Restructure repository into output workspace

output/scripts/new_app.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+import argparse
+import datetime as dt
+import json
+import pathlib
+import shutil
+from typing import Dict, Iterable, List, Sequence
+
+try:
+    import jinja2
+except ModuleNotFoundError as exc:  # pragma: no cover - guidance for local execution
+    raise SystemExit(
+        "Jinja2 is required. Run this script via './output/run/dev.sh python output/scripts/new_app.py ...' so dependencies are provided by the devtools container."
+    ) from exc
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+REPO_ROOT = ROOT.parent
+DEFAULT_BASE_IMAGE = "cloudron/base:5.0.0"
+DEFAULT_BUILDER_IMAGE = "cloudron/base:5.0.0"
+
+
+def load_catalog(path: pathlib.Path) -> List[Dict[str, object]]:
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def build_app_id(slug: str) -> str:
+    import re
+
+    normalized = slug.lower()
+    normalized = re.sub(r"[^a-z0-9]+", ".", normalized)
+    normalized = re.sub(r"\.\.+", ".", normalized).strip(".")
+    if not normalized:
+        raise ValueError(f"Unable to derive Cloudron app id from slug '{slug}'")
+    return f"com.knel.{normalized}"
+
+
+def ensure_clean_destination(app_dir: pathlib.Path, force: bool) -> None:
+    if app_dir.exists():
+        if not force:
+            raise FileExistsError(
+                f"Destination {app_dir} already exists. Use --force to overwrite or remove it manually."
+            )
+        shutil.rmtree(app_dir)
+    app_dir.mkdir(parents=True, exist_ok=True)
+
+
+def render_templates(template_dir: pathlib.Path, destination: pathlib.Path, context: Dict[str, object]) -> None:
+    env = jinja2.Environment(
+        loader=jinja2.FileSystemLoader(str(template_dir)),
+        keep_trailing_newline=True,
+        autoescape=False,
+    )
+
+    for source in template_dir.rglob("*"):
+        if source.is_dir():
+            continue
+        relative = source.relative_to(template_dir)
+        target = destination / relative
+
+        if source.suffix == ".j2":
+            rendered_path = target.with_suffix("")
+            rendered_path.parent.mkdir(parents=True, exist_ok=True)
+            template = env.get_template(str(relative))
+            rendered_path.write_text(template.render(**context), encoding="utf-8")
+        else:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source, target)
+
+    for relpath in ("start.sh", "test/smoke.sh"):
+        path = destination / relpath
+        if path.exists():
+            path.chmod(path.stat().st_mode | 0o111)
+
+
+def build_context(entry: Dict[str, object]) -> Dict[str, object]:
+    generated_at = dt.datetime.utcnow().replace(microsecond=0).isoformat() + "Z"
+    tags = entry.get("tags") or ["custom", "known-element"]
+    website = entry.get("website") or entry.get("repo", "").rstrip(".git")
+    http_port = int(entry.get("httpPort", 3000))
+    base_image = entry.get("baseImage", DEFAULT_BASE_IMAGE)
+    builder_image = entry.get("builderImage", DEFAULT_BUILDER_IMAGE)
+    additional_repos = entry.get("additionalRepos", [])
+
+    return {
+        "app_id": build_app_id(entry["slug"]),
+        "app_slug": entry["slug"],
+        "app_title": entry["title"],
+        "app_repo": entry["repo"],
+        "app_issue": entry.get("issue", ""),
+        "app_website": website,
+        "app_tags": json.dumps(tags),
+        "http_port": http_port,
+        "base_image": base_image,
+        "builder_image": builder_image,
+        "generated_at": generated_at,
+        "additional_repos_json": json.dumps(additional_repos, indent=2),
+        "default_app_version": entry.get("defaultVersion", "latest"),
+    }
+
+
+def render_app(entry: Dict[str, object], template_dir: pathlib.Path, apps_dir: pathlib.Path, force: bool) -> pathlib.Path:
+    app_dir = apps_dir / entry["slug"]
+    ensure_clean_destination(app_dir, force)
+    context = build_context(entry)
+    render_templates(template_dir, app_dir, context)
+    return app_dir
+
+
+def iter_entries(catalog: Sequence[Dict[str, object]], slugs: Iterable[str] | None) -> Iterable[Dict[str, object]]:
+    if slugs is None:
+        yield from catalog
+        return
+
+    slug_set = set(slugs)
+    for entry in catalog:
+        if entry["slug"] in slug_set:
+            yield entry
+            slug_set.remove(entry["slug"])
+
+    if slug_set:
+        missing = ", ".join(sorted(slug_set))
+        raise SystemExit(f"Unknown slug(s): {missing}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Scaffold Cloudron app packages from catalog entries")
+    parser.add_argument("--slug", action="append", dest="slugs", help="Generate scaffold for the provided slug (repeatable)")
+    parser.add_argument("--catalog", default=str(ROOT / "apps" / "catalog.json"), help="Path to catalog JSON")
+    parser.add_argument("--template", default=str(ROOT / "templates" / "cloudron-app"), help="Template directory")
+    parser.add_argument("--apps-dir", default=str(ROOT / "apps"), help="Destination apps directory")
+    parser.add_argument("--force", action="store_true", help="Overwrite existing app directory")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    catalog = load_catalog(pathlib.Path(args.catalog))
+    template_dir = pathlib.Path(args.template)
+    apps_dir = pathlib.Path(args.apps_dir)
+    apps_dir.mkdir(parents=True, exist_ok=True)
+
+    for entry in iter_entries(catalog, args.slugs):
+        app_dir = render_app(entry, template_dir, apps_dir, args.force)
+        print(f"Created {app_dir.relative_to(ROOT)}")
+
+
+if __name__ == "__main__":
+    main()