@jtl-software/create-cloud-app 0.8.3 → 0.9.0

package/README.md

@@ -16,6 +16,30 @@ The CLI has three entry points:
 
 Registration and listing are two independent resources on two independent files. `register` must happen first — `listing` pushes against the app that `register` created and will fail with a clear error if it hasn't run yet.
 
+### Help and version
+
+Every command documents its flags:
+
+```bash
+npx @jtl-software/create-cloud-app --help           # overview + scaffold flags
+npx @jtl-software/create-cloud-app help register    # same as `register --help`
+npx @jtl-software/create-cloud-app listing --help
+npx @jtl-software/create-cloud-app --version
+```
+
+### Running without a terminal (AI agents, scripts)
+
+Every prompt has a matching flag. When stdin is not a terminal, the CLI never prompts. Instead it exits with code 1 and names the flags to pass. Pass `--yes` to get the same behavior in a terminal.
+
+```bash
+npx @jtl-software/create-cloud-app --name my-app --frontend react --backend node --yes
+cd my-app && npm install
+npm run register -- --yes --tenant my-tenant --new --on-collision overwrite
+npm run listing -- --yes --tenant my-tenant --distribution-type PRIVATE
+```
+
+`register` and `listing` still need a browser sign-in the first time. After that the cached token is reused and refreshed.
+
 ### `npm create @jtl-software/cloud-app@latest`
 
 Scaffold a new app interactively.
@@ -28,7 +52,7 @@ You'll be prompted for:
 
 - **App name**: directory name, package name, and manifest identifier
 - **Description**: placed in the listing
-- **Backend**: Node.js (Express + TypeScript) or .NET (ASP.NET Core + FastEndpoints)
+- **Backend**: Node.js (Express + TypeScript), .NET (ASP.NET Core + FastEndpoints) or PHP (Slim 4)
 - **Frontend**: React (Vite + Tailwind + JTL Platform UI)
 
 Then:
@@ -40,6 +64,20 @@ npm run register
 npm run dev
 ```
 
+Pass any of these flags to skip the matching prompt:
+
+| Flag                                  | Description                                                        |
+| ------------------------------------- | ------------------------------------------------------------------ |
+| `--name <app-name>`                   | App name and directory. Lowercase letters, numbers and hyphens.    |
+| `--description <text>`                | Short description. Default `A JTL Platform app`.                   |
+| `--frontend <react\|none>`            | Frontend stack, or `none`.                                         |
+| `--backend <node\|dotnet\|php\|none>` | Backend stack, or `none`. Pick at least one frontend or backend.   |
+| `--yes`, `-y`                         | Never prompt. `--name`, `--frontend` and `--backend` are required. |
+
+```bash
+npm create @jtl-software/cloud-app@latest -- --name my-app --frontend react --backend node --yes
+```
+
 Pass `--legacy` to scaffold the backend for the legacy Ory M2M flow instead of the Zitadel service account (compat testing only, node backend only):
 
 ```bash
@@ -75,14 +113,16 @@ Flags:
 | `--api-host <url>`                          | API host. Default `https://api.jtl-cloud.com`.                                                                                                                                                       |
 | `--auth-host <url>`                         | OAuth host. Default `https://id.jtl-cloud.com`. The CLI picks the matching client ID for the known prod/QA/dev hosts.                                                                                |
 | `--hub-host <url>`                          | Hub host (used in printed links). Default `https://hub.jtl-cloud.com`.                                                                                                                               |
+| `--partner-host <url>`                      | Partner Portal host (used in printed links). Default `https://partner.jtl-cloud.com`.                                                                                                                |
 | `--client-id <id>`                          | Override the OAuth client ID. Only needed for custom auth hosts.                                                                                                                                     |
-| `--scope <scope>`                           | OAuth scope. Default `openid offline_access`.                                                                                                                                                        |
+| `--scope <scope>`                           | OAuth scope. The default depends on `--auth-host`.                                                                                                                                                   |
 | `--reauth`                                  | Skip the cached token and open the browser again. Useful after switching accounts.                                                                                                                   |
-| `--yes`, `-y`                               | Non-interactive mode. Auto-confirms prompts and fails if any choice is ambiguous (e.g. multiple tenants match). Required for CI.                                                                     |
+| `--yes`, `-y`                               | Non-interactive mode. Auto-confirms prompts and fails if any choice is ambiguous (e.g. multiple tenants match). Required for CI and whenever stdin is not a terminal.                                |
 | `--tenant <id-or-slug>`                     | Select a tenant by ID or slug (case-insensitive).                                                                                                                                                    |
 | `--existing-app-id <id>`                    | Update the app with this ID instead of prompting. Errors if it doesn't match this manifest's technical name.                                                                                         |
 | `--new`                                     | Force-create a new app even if a matching one exists. Mutually exclusive with `--existing-app-id`.                                                                                                   |
 | `--on-collision <overwrite\|print\|cancel>` | What to do when an existing credentials file would be overwritten during provisioning. `print` writes the secret to stdout instead of the file. Required in `--yes` mode if a collision is possible. |
+| `--app-service-path <path>`                 | App service path segment, for testing a branch deployment (e.g. `app-service-1317`). Default `app-service`.                                                                                          |
 
 Tokens are cached under `~/.config/jtl-cli/tokens.json` (mode `0600`). Override the path with the `JTL_CLI_TOKEN_CACHE_FILE` environment variable.
 
@@ -96,7 +136,10 @@ npx @jtl-software/create-cloud-app listing
 
 Like `register`, it's interactive by default: OAuth login, then a tenant prompt. It also asks two questions about the listing itself — distribution type (`PUBLIC`/`PRIVATE`) and default locale — pre-filled from whatever's already in `listing.json` and written back there once answered, so re-running `listing` later remembers your choice. Unlike `register`, there's no create-vs-update choice or local credential file to write — a listing is always pushed against the app `register` already created, keyed by `technicalName`. If no registered app matches, the command fails with a message telling you to run `register` first.
 
-Flags: `--api-host`, `--auth-host`, `--hub-host`, `--client-id`, `--scope`, `--reauth`, `--yes`/`-y`, `--tenant` — same meaning as the equivalent `register` flags above. There's no `--existing-app-id`, `--new`, or `--on-collision` since listing has nothing to disambiguate or overwrite locally.
+Flags: `--api-host`, `--auth-host`, `--hub-host`, `--partner-host`, `--client-id`, `--scope`, `--reauth`, `--yes`/`-y`, `--tenant`. They mean the same as the `register` flags above. There's no `--existing-app-id`, `--new`, or `--on-collision` since listing has nothing to disambiguate or overwrite locally. Two flags answer the listing questions without a prompt and write the value to `listing.json`:
+
+- `--distribution-type <PUBLIC|PRIVATE>`
+- `--default-locale <locale>`, e.g. `de-DE`
 
 ## CI usage: keep your deployed app.json and listing.json in sync with the repo
 

package/dist/index.js

@@ -2,15 +2,10 @@
 
 // src/index.ts
 import * as p4 from "@clack/prompts";
+import fs7 from "fs";
+import path7 from "path";
 import pc4 from "picocolors";
 
-// src/listing.ts
-import * as p3 from "@clack/prompts";
-import fs3 from "fs";
-import path3 from "path";
-import { parseArgs as parseArgs2 } from "util";
-import pc3 from "picocolors";
-
 // src/platform-client.ts
 import * as p from "@clack/prompts";
 import { spawn } from "child_process";
@@ -528,6 +523,12 @@ function resolveCommonOptions(values) {
     tenant: values.tenant
   };
 }
+function requireTerminalOrYes(opts, isTTY = Boolean(process.stdin.isTTY)) {
+  if (opts.yes || isTTY) return;
+  bail(
+    "no terminal to prompt in. Pass --yes (plus --tenant and the command's other flags) to run without prompts. Run with --help for the flags."
+  );
+}
 function ensureContinue(value) {
   if (p.isCancel(value)) {
     bail("Cancelled.");
@@ -605,6 +606,191 @@ function printHubLink(hubHost, tenantSlug, appId, isInstalled) {
   }
 }
 
+// src/help.ts
+var BIN = "create-cloud-app";
+var GLOBAL_FLAGS = [
+  { flag: "-h, --help", description: "Show help for the command." },
+  { flag: "-v, --version", description: "Print the CLI version." }
+];
+var COMMON_FLAGS = [
+  {
+    flag: "-y, --yes",
+    description: "Non-interactive: auto-confirm, and fail with a hint instead of prompting when a choice is ambiguous. Required when stdin is not a terminal."
+  },
+  {
+    flag: "--tenant <id|slug>",
+    description: "Tenant to use (case-insensitive slug). Needed with --yes when the account has more than one tenant."
+  },
+  {
+    flag: "--reauth",
+    description: "Ignore the cached token and sign in again in the browser."
+  },
+  {
+    flag: "--api-host <url>",
+    description: `API host. Default ${DEFAULT_API_HOST}.`
+  },
+  {
+    flag: "--auth-host <url>",
+    description: `OAuth host. Default ${DEFAULT_AUTH_HOST}.`
+  },
+  {
+    flag: "--hub-host <url>",
+    description: `Hub host for printed links. Default ${DEFAULT_HUB_HOST}.`
+  },
+  {
+    flag: "--partner-host <url>",
+    description: `Partner Portal host for printed links. Default ${DEFAULT_PARTNER_HOST}.`
+  },
+  {
+    flag: "--client-id <id>",
+    description: "OAuth client id. Only needed for an unknown --auth-host."
+  },
+  {
+    flag: "--scope <scope>",
+    description: "OAuth scope. Default depends on --auth-host."
+  }
+];
+var AUTH_NOTE = "Sign-in opens a browser once; the token is cached in ~/.config/jtl-cli/tokens.json (override with JTL_CLI_TOKEN_CACHE_FILE).";
+var COMMANDS = {
+  scaffold: {
+    name: "scaffold",
+    usage: `${BIN} [options]`,
+    summary: "Scaffold a new app project (default when no command is given).",
+    description: "Creates ./<name> with app.json, listing.json and the chosen frontend/backend. Prompts for any value not passed as a flag. With --yes, or when stdin is not a terminal, it never prompts: --name, --frontend and --backend are then required.",
+    flags: [
+      {
+        flag: "--name <app-name>",
+        description: "App name and directory. Lowercase letters, numbers and hyphens."
+      },
+      {
+        flag: "--description <text>",
+        description: 'Short description. Default "A JTL Platform app".'
+      },
+      {
+        flag: "--frontend <react|none>",
+        description: "Frontend stack, or none."
+      },
+      {
+        flag: "--backend <node|dotnet|php|none>",
+        description: "Backend stack, or none. Pick at least one of frontend and backend."
+      },
+      {
+        flag: "--legacy",
+        description: "Scaffold the node backend for the legacy Ory M2M flow (compat testing only)."
+      },
+      {
+        flag: "-y, --yes",
+        description: "Never prompt; fail on missing flags instead."
+      }
+    ],
+    examples: [
+      `${BIN} --name my-app --frontend react --backend node --yes`,
+      `npm create @jtl-software/cloud-app@latest -- --name my-app --frontend react --backend none --yes`
+    ]
+  },
+  register: {
+    name: "register",
+    usage: `${BIN} register [options]`,
+    summary: "Register or update app.json with the JTL Cloud and write credentials.",
+    description: `Run from the project root. Reads app.json, creates or updates the app in the chosen tenant, and writes its credentials to the backend and frontend config. ${AUTH_NOTE}`,
+    flags: [
+      ...COMMON_FLAGS,
+      {
+        flag: "--existing-app-id <id>",
+        description: "Update this app instead of asking. Must match app.json's technicalName."
+      },
+      {
+        flag: "--new",
+        description: "Create a new app even if one matches. Excludes --existing-app-id."
+      },
+      {
+        flag: "--on-collision <overwrite|print|cancel>",
+        description: "What to do when a credentials file already has values. Needed with --yes when that can happen."
+      },
+      {
+        flag: "--app-service-path <path>",
+        description: "App service path segment, for branch deployments. Default app-service."
+      }
+    ],
+    examples: [
+      `${BIN} register --yes --tenant my-tenant --new --on-collision overwrite`,
+      `${BIN} register --yes --tenant my-tenant --existing-app-id <app-id>`
+    ]
+  },
+  listing: {
+    name: "listing",
+    usage: `${BIN} listing [options]`,
+    summary: "Push listing.json as the app's store listing.",
+    description: `Run from the project root after register. Reads listing.json and the technicalName from app.json. With --yes, the distribution type and default locale are taken from listing.json (or the flags below). ${AUTH_NOTE}`,
+    flags: [
+      ...COMMON_FLAGS,
+      {
+        flag: "--distribution-type <PUBLIC|PRIVATE>",
+        description: "Set distributionType in listing.json instead of asking."
+      },
+      {
+        flag: "--default-locale <locale>",
+        description: "Set defaultLocale in listing.json instead of asking, e.g. de-DE."
+      }
+    ],
+    examples: [
+      `${BIN} listing --yes --tenant my-tenant --distribution-type PRIVATE`
+    ]
+  }
+};
+function flagTable(flags) {
+  const width = Math.max(...flags.map((f) => f.flag.length));
+  return flags.map((f) => `  ${f.flag.padEnd(width)}  ${f.description}`);
+}
+function renderOverview(version) {
+  const commands = Object.values(COMMANDS);
+  const width = Math.max(...commands.map((c) => c.name.length));
+  return [
+    `${BIN} ${version}: create, register and publish JTL Platform cloud apps.`,
+    "",
+    "Usage:",
+    `  ${BIN} [command] [options]`,
+    "",
+    "Commands:",
+    ...commands.map(
+      (c) => `  ${(c.name === "scaffold" ? "(none)" : c.name).padEnd(width)}  ${c.summary}`
+    ),
+    `  ${"help".padEnd(width)}  Show help for a command, e.g. \`${BIN} help register\`.`,
+    "",
+    "Options:",
+    ...flagTable(GLOBAL_FLAGS),
+    "",
+    `Run \`${BIN} <command> --help\` for the command's flags.`,
+    "Every prompt has a matching flag. register and listing still need a one-time browser sign-in.",
+    ""
+  ].join("\n");
+}
+function renderCommandHelp(name) {
+  const c = COMMANDS[name];
+  return [
+    c.summary,
+    "",
+    "Usage:",
+    `  ${c.usage}`,
+    "",
+    c.description,
+    "",
+    "Options:",
+    ...flagTable([...c.flags, GLOBAL_FLAGS[0]]),
+    "",
+    "Examples:",
+    ...c.examples.map((e) => `  ${e}`),
+    ""
+  ].join("\n");
+}
+
+// src/listing.ts
+import * as p3 from "@clack/prompts";
+import fs3 from "fs";
+import path3 from "path";
+import { parseArgs as parseArgs2 } from "util";
+import pc3 from "picocolors";
+
 // src/register.ts
 import * as p2 from "@clack/prompts";
 import fs2 from "fs";
@@ -884,23 +1070,24 @@ function parseCollisionAction(input) {
     `--on-collision must be one of: overwrite, print, cancel (got "${input}")`
   );
 }
+var REGISTER_ARG_OPTIONS = {
+  ...COMMON_ARG_OPTIONS,
+  "existing-app-id": { type: "string" },
+  new: { type: "boolean" },
+  "on-collision": { type: "string" },
+  "app-service-path": { type: "string" }
+};
 function resolveOptions(args) {
   let parsed;
   try {
     parsed = parseArgs({
       args,
-      options: {
-        ...COMMON_ARG_OPTIONS,
-        "existing-app-id": { type: "string" },
-        new: { type: "boolean" },
-        "on-collision": { type: "string" },
-        "app-service-path": { type: "string" }
-      },
+      options: REGISTER_ARG_OPTIONS,
       strict: true,
       allowPositionals: false
     });
   } catch (err) {
-    bail(err.message);
+    bail(`${err.message}. Run with --help for usage.`);
   }
   const common = resolveCommonOptions(parsed.values);
   const existingAppId = parsed.values["existing-app-id"];
@@ -1199,6 +1386,7 @@ async function register(argv = [], runOpts = {}) {
   console.log();
   p2.intro(pc2.bgCyan(pc2.black(" register cloud app ")));
   const opts = resolveOptions(argv);
+  requireTerminalOrYes(opts);
   const backend = detectBackend(root);
   p2.note(
     [
@@ -1517,19 +1705,36 @@ async function resolveAppId(apiBaseUrl, jwt, tenantId, technicalName) {
   }
   return matches[0].id;
 }
+var LISTING_ARG_OPTIONS = {
+  ...COMMON_ARG_OPTIONS,
+  "distribution-type": { type: "string" },
+  "default-locale": { type: "string" }
+};
 function resolveListingOptions(args) {
   let parsed;
   try {
     parsed = parseArgs2({
       args,
-      options: { ...COMMON_ARG_OPTIONS },
+      options: LISTING_ARG_OPTIONS,
       strict: true,
       allowPositionals: false
     });
   } catch (err) {
-    bail(err.message);
+    bail(`${err.message}. Run with --help for usage.`);
+  }
+  const distributionType = parsed.values["distribution-type"]?.toUpperCase();
+  if (distributionType !== void 0 && distributionType !== "PUBLIC" && distributionType !== "PRIVATE") {
+    bail(
+      `--distribution-type must be PUBLIC or PRIVATE (got "${parsed.values["distribution-type"]}")`
+    );
   }
-  return resolveCommonOptions(parsed.values);
+  const defaultLocale = parsed.values["default-locale"];
+  if (defaultLocale === "") bail("--default-locale must not be empty");
+  return {
+    ...resolveCommonOptions(parsed.values),
+    distributionType,
+    defaultLocale
+  };
 }
 async function createAppListing(apiBaseUrl, jwt, tenantId, appId, listing2) {
   const created = await apiCall(
@@ -1610,6 +1815,7 @@ async function listing(argv = [], runOpts = {}) {
   console.log();
   p3.intro(pc3.bgCyan(pc3.black(" push app listing ")));
   const opts = resolveListingOptions(argv);
+  requireTerminalOrYes(opts);
   const technicalName = readTechnicalName(root);
   const listingData = readListing(listingPath);
   p3.note(
@@ -1648,14 +1854,8 @@ async function listing(argv = [], runOpts = {}) {
     bail(err.message);
   }
   const tenant = await selectTenant(tenants, opts);
-  listingData.distributionType = await resolveDistributionType(
-    listingData.distributionType,
-    opts
-  );
-  listingData.defaultLocale = await resolveDefaultLocale(
-    listingData.defaultLocale,
-    opts
-  );
+  listingData.distributionType = opts.distributionType ?? await resolveDistributionType(listingData.distributionType, opts);
+  listingData.defaultLocale = opts.defaultLocale ?? await resolveDefaultLocale(listingData.defaultLocale, opts);
   writeListing(listingPath, listingData);
   const summary = summarizeListing(listingData);
   if (listingData.distributionType === "PUBLIC" && !listingData.pricing?.subscriptionTiers?.length) {
@@ -2019,6 +2219,82 @@ async function scaffold({
   );
 }
 
+// src/scaffold-args.ts
+import { parseArgs as parseArgs3 } from "util";
+var SCAFFOLD_ARG_OPTIONS = {
+  name: { type: "string" },
+  description: { type: "string" },
+  frontend: { type: "string" },
+  backend: { type: "string" },
+  legacy: { type: "boolean" },
+  yes: { type: "boolean", short: "y" }
+};
+var NONE = "none";
+function validateAppName(value) {
+  if (!value) return "App name is required";
+  if (!/^[a-z0-9-]+$/.test(value))
+    return "Use lowercase letters, numbers, and hyphens only";
+}
+function stackChoices(templates) {
+  return [...templates.map(templateTech), NONE];
+}
+function pickTemplate(flag, value, templates) {
+  if (value === void 0) return void 0;
+  if (value === NONE) return null;
+  const match = templates.find((t) => templateTech(t) === value);
+  if (!match) {
+    bail(
+      `--${flag} must be one of: ${stackChoices(templates).join(", ")} (got "${value}")`
+    );
+  }
+  return match;
+}
+function resolveScaffoldArgs(args, templates, isTTY = Boolean(process.stdin.isTTY)) {
+  let parsed;
+  try {
+    parsed = parseArgs3({
+      args,
+      options: SCAFFOLD_ARG_OPTIONS,
+      strict: true,
+      allowPositionals: false
+    });
+  } catch (err) {
+    bail(`${err.message}. Run with --help for usage.`);
+  }
+  const v = parsed.values;
+  if (v.name !== void 0) {
+    const invalid = validateAppName(v.name);
+    if (invalid) bail(`--name: ${invalid}`);
+  }
+  const result = {
+    name: v.name,
+    description: v.description,
+    frontend: pickTemplate("frontend", v.frontend, templates.frontends),
+    backend: pickTemplate("backend", v.backend, templates.backends),
+    legacy: v.legacy ?? false,
+    nonInteractive: Boolean(v.yes) || !isTTY
+  };
+  if (result.nonInteractive) {
+    const missing = [
+      result.name === void 0 && "--name <app-name>",
+      result.frontend === void 0 && `--frontend <${stackChoices(templates.frontends).join("|")}>`,
+      result.backend === void 0 && `--backend <${stackChoices(templates.backends).join("|")}>`
+    ].filter(Boolean);
+    if (missing.length) {
+      bail(
+        `missing ${missing.join(", ")}. Without a terminal (or with --yes) these must be passed as flags.`
+      );
+    }
+  }
+  if (result.frontend === null && result.backend === null) {
+    bail("Pick at least a frontend or a backend.");
+  }
+  if (result.legacy && result.backend && templateTech(result.backend) !== "node") {
+    bail("--legacy is only supported for the node backend.");
+  }
+  return result;
+}
+
 // src/templates.ts
 import fs5 from "fs";
 import path5 from "path";
@@ -2057,7 +2333,7 @@ import os2 from "os";
 import path6 from "path";
 import { PostHog } from "posthog-node";
 var TOKEN = "phc_SkFAxTIa4RUQxotci1Ftdw7xefZK2Ax0LEIGcl8zuD2";
-var CLI_VERSION = "0.8.3";
+var CLI_VERSION = "0.9.0";
 var client = TOKEN ? new PostHog(TOKEN, { host: "https://e.jtl-cloud.com" }) : null;
 function telemetryDisabledByEnv() {
   const dnt = process.env.DO_NOT_TRACK;
@@ -2125,7 +2401,7 @@ async function shutdownPostHog() {
 }
 
 // src/index.ts
-var NONE = "__none__";
+var NONE2 = "__none__";
 function scaffoldChoice(backend, frontend, legacy) {
   const hasBackend = Boolean(backend);
   const hasFrontend = Boolean(frontend);
@@ -2148,14 +2424,14 @@ function templateSelectOptions(templates) {
 function halfSelectOptions(templates, noneHint) {
   return [
     ...templateSelectOptions(templates),
-    { value: NONE, label: "None", hint: noneHint }
+    { value: NONE2, label: "None", hint: noneHint }
   ];
 }
 function cancelScaffold() {
   p4.cancel("Cancelled.");
   process.exit(0);
 }
-async function runScaffold() {
+async function runScaffold(argv) {
   console.log();
   p4.intro(pc4.bgCyan(pc4.black(" create-cloud-app ")));
   const templates = discoverTemplates();
@@ -2166,23 +2442,23 @@ async function runScaffold() {
     p4.cancel("No templates found. Ensure template packages are installed.");
     process.exit(1);
   }
+  const args = resolveScaffoldArgs(argv, { frontends, backends });
   const answers = await p4.group(
     {
-      appName: () => p4.text({
+      appName: () => args.name !== void 0 ? Promise.resolve(args.name) : p4.text({
         message: "App name",
         placeholder: "my-jtl-app",
-        validate: (value) => {
-          if (!value) return "App name is required";
-          if (!/^[a-z0-9-]+$/.test(value))
-            return "Use lowercase letters, numbers, and hyphens only";
-        }
+        validate: validateAppName
       }),
-      description: () => p4.text({ message: "Description", placeholder: "A JTL Platform app" }),
-      frontend: () => p4.select({
+      description: () => args.description !== void 0 || args.nonInteractive ? Promise.resolve(args.description ?? "") : p4.text({
+        message: "Description",
+        placeholder: "A JTL Platform app"
+      }),
+      frontend: () => args.frontend !== void 0 ? Promise.resolve(args.frontend?.packageName ?? NONE2) : p4.select({
         message: "Frontend (adds a public client for browser login)",
         options: halfSelectOptions(frontends, "no frontend")
       }),
-      backend: () => p4.select({
+      backend: () => args.backend !== void 0 ? Promise.resolve(args.backend?.packageName ?? NONE2) : p4.select({
         message: "Backend (adds a service account for the JTL API)",
         options: halfSelectOptions(backends, "no backend")
       })
@@ -2196,13 +2472,14 @@ async function runScaffold() {
     (t) => t.packageName === answers.backend
   );
   if (!selectedFrontend && !selectedBackend) {
-    p4.cancel("Pick at least a frontend or a backend.");
-    process.exit(1);
+    bail("Pick at least a frontend or a backend.");
   }
-  const legacy = process.argv.includes("--legacy");
+  const legacy = args.legacy;
   if (legacy && selectedBackend && templateTech(selectedBackend) !== "node") {
-    p4.cancel("--legacy is only supported for the node backend.");
-    process.exit(1);
+    bail("--legacy is only supported for the node backend.");
+  }
+  if (fs7.existsSync(path7.resolve(process.cwd(), answers.appName))) {
+    bail(`Directory "${answers.appName}" already exists.`);
   }
   const s = p4.spinner();
   s.start("Scaffolding project");
@@ -2235,7 +2512,10 @@ async function runScaffold() {
   }
   printNextSteps(answers.appName);
   p4.outro(pc4.green("Done! Happy building."));
-  return scaffoldChoice(selectedBackend, selectedFrontend, legacy);
+  return {
+    ...scaffoldChoice(selectedBackend, selectedFrontend, legacy),
+    non_interactive: args.nonInteractive
+  };
 }
 function printNextSteps(appName) {
   p4.note(
@@ -2249,17 +2529,49 @@ function printNextSteps(appName) {
     "Next steps"
   );
 }
+var SUBCOMMANDS = ["register", "listing"];
+function handleMeta(argv) {
+  const [first, second] = argv;
+  if (first === "-v" || first === "--version") {
+    console.log(CLI_VERSION);
+    return true;
+  }
+  if (first === "help") {
+    if (second === void 0) console.log(renderOverview(CLI_VERSION));
+    else if (second === "scaffold" || isSubcommand(second))
+      console.log(renderCommandHelp(second));
+    else
+      bail(`unknown command "${second}". Run \`${BIN} --help\` for the list.`);
+    return true;
+  }
+  if (first !== void 0 && !first.startsWith("-") && !isSubcommand(first)) {
+    bail(`unknown command "${first}". Run \`${BIN} --help\` for the list.`);
+  }
+  if (argv.includes("-h") || argv.includes("--help")) {
+    console.log(
+      isSubcommand(first) ? renderCommandHelp(first) : `${renderOverview(CLI_VERSION)}
+${renderCommandHelp("scaffold")}`
+    );
+    return true;
+  }
+  return false;
+}
+function isSubcommand(arg) {
+  return SUBCOMMANDS.includes(arg);
+}
 async function main() {
-  const command = process.argv[2] === "register" ? "register" : process.argv[2] === "listing" ? "listing" : "scaffold";
+  const argv = process.argv.slice(2);
+  if (handleMeta(argv)) return;
+  const command = isSubcommand(argv[0]) ? argv[0] : "scaffold";
   const startedAt = Date.now();
   try {
     let detail = {};
     if (command === "register") {
-      detail = await register(process.argv.slice(3));
+      detail = await register(argv.slice(1));
     } else if (command === "listing") {
-      await listing(process.argv.slice(3));
+      await listing(argv.slice(1));
     } else {
-      detail = await runScaffold();
+      detail = await runScaffold(argv);
     }
     captureCommand(command, {
       success: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtl-software/create-cloud-app",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "type": "module",
   "description": "CLI tool for scaffolding JTL Platform cloud apps",
   "bin": {