@jtl-software/create-cloud-app 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,10 +1,17 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as p2 from "@clack/prompts";
-import pc2 from "picocolors";
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
 
-// src/register.ts
+// 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";
 import crypto from "crypto";
@@ -12,7 +19,6 @@ import fs from "fs";
 import http from "http";
 import os from "os";
 import path from "path";
-import { parseArgs } from "util";
 import pc from "picocolors";
 var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
 var CALLBACK_PORT = 9876;
@@ -21,6 +27,7 @@ var DEFAULT_SCOPE = "openid offline_access";
 var DEFAULT_API_HOST = "https://api.jtl-cloud.com";
 var DEFAULT_AUTH_HOST = "https://auth.jtl-cloud.com";
 var DEFAULT_HUB_HOST = "https://hub.jtl-cloud.com";
+var DEFAULT_PARTNER_HOST = "https://partner.jtl-cloud.com";
 var CLIENT_IDS_BY_AUTH_HOST = {
   "auth.jtl-cloud.com": "b6aca875-c9a3-4010-9fd7-7f8d2e0b0333",
   "auth.dev.jtl-cloud.com": "9c230937-6a52-48d6-9a39-e97edd8ef511",
@@ -50,152 +57,6 @@ function generatePkce() {
   );
   return { verifier, challenge };
 }
-function parseEnv(content) {
-  const result = {};
-  for (const line of content.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eq = trimmed.indexOf("=");
-    if (eq === -1) continue;
-    const key = trimmed.slice(0, eq).trim();
-    let value = trimmed.slice(eq + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    result[key] = value;
-  }
-  return result;
-}
-function pickFirstLocaleEntry(entries) {
-  if (!entries || typeof entries !== "object") return void 0;
-  const keys = Object.keys(entries);
-  if (!keys.length) return void 0;
-  return entries[keys[0]];
-}
-function summarizeManifest(manifest) {
-  const m = manifest.manifest ?? {};
-  const listing = manifest.listing ?? {};
-  const nameEntry = pickFirstLocaleEntry(listing.name);
-  const descEntry = pickFirstLocaleEntry(listing.description);
-  return {
-    name: nameEntry?.short ?? nameEntry?.full ?? m.technicalName ?? "(unnamed)",
-    technicalName: m.technicalName ?? "(unset)",
-    version: m.version ?? "(unset)",
-    description: descEntry?.short ?? descEntry?.full
-  };
-}
-function readEnvFile(filePath) {
-  if (!fs.existsSync(filePath)) return {};
-  return parseEnv(fs.readFileSync(filePath, "utf-8"));
-}
-function upsertEnv(filePath, updates) {
-  const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
-  const lines = existing.split(/\r?\n/);
-  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
-  const remaining = new Map(Object.entries(updates));
-  const next = lines.map((line) => {
-    const eq = line.indexOf("=");
-    if (eq === -1) return line;
-    const key = line.slice(0, eq).trim();
-    if (remaining.has(key)) {
-      const value = remaining.get(key);
-      remaining.delete(key);
-      return `${key}=${value}`;
-    }
-    return line;
-  });
-  for (const [key, value] of remaining) {
-    next.push(`${key}=${value}`);
-  }
-  fs.writeFileSync(filePath, next.join("\n") + "\n");
-}
-function findDotnetProject(backendDir) {
-  if (!fs.existsSync(backendDir)) return null;
-  for (const entry of fs.readdirSync(backendDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const exampleFile = path.join(
-      backendDir,
-      entry.name,
-      "appsettings.Local.json.example"
-    );
-    const csproj = path.join(backendDir, entry.name, `${entry.name}.csproj`);
-    if (fs.existsSync(exampleFile) || fs.existsSync(csproj)) {
-      return path.join(backendDir, entry.name);
-    }
-  }
-  return null;
-}
-function detectBackend(root) {
-  const backendDir = path.join(root, "packages", "backend");
-  const envFile = path.join(backendDir, ".env");
-  const envExample = path.join(backendDir, ".env.example");
-  if (fs.existsSync(envFile) || fs.existsSync(envExample)) {
-    return { kind: "node", envFile };
-  }
-  const dotnetDir = findDotnetProject(backendDir);
-  if (dotnetDir) {
-    return {
-      kind: "dotnet",
-      settingsFile: path.join(dotnetDir, "appsettings.Local.json")
-    };
-  }
-  return { kind: "node", envFile: path.join(root, ".env") };
-}
-function readExistingCredentials(backend) {
-  if (backend.kind === "node") {
-    const values = readEnvFile(backend.envFile);
-    return { clientId: values.CLIENT_ID, clientSecret: values.CLIENT_SECRET };
-  }
-  if (!fs.existsSync(backend.settingsFile)) return {};
-  try {
-    const settings = JSON.parse(fs.readFileSync(backend.settingsFile, "utf-8"));
-    return {
-      clientId: settings?.JtlPlatform?.ClientId,
-      clientSecret: settings?.JtlPlatform?.ClientSecret
-    };
-  } catch {
-    return {};
-  }
-}
-function writeBackendCredentials(backend, clientId, clientSecret) {
-  if (backend.kind === "node") {
-    upsertEnv(backend.envFile, {
-      CLIENT_ID: clientId,
-      CLIENT_SECRET: clientSecret
-    });
-    return backend.envFile;
-  }
-  let settings = {};
-  if (fs.existsSync(backend.settingsFile)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(backend.settingsFile, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-  settings.JtlPlatform = {
-    ...settings.JtlPlatform ?? {},
-    ClientId: clientId,
-    ClientSecret: clientSecret
-  };
-  fs.writeFileSync(
-    backend.settingsFile,
-    JSON.stringify(settings, null, 2) + "\n"
-  );
-  return backend.settingsFile;
-}
-function readManifest(manifestPath) {
-  if (!fs.existsSync(manifestPath)) {
-    bail(
-      `manifest.json not found at ${manifestPath}. Run this from the project root.`
-    );
-  }
-  try {
-    return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-  } catch (err) {
-    bail(`manifest.json is not valid JSON: ${err.message}`);
-  }
-}
 function readTokenCache() {
   const file = tokenCacheFile();
   if (!fs.existsSync(file)) return {};
@@ -385,18 +246,18 @@ async function postTokenRequest(authBaseUrl, body) {
     },
     body: body.toString()
   });
-  const text2 = await res.text();
+  const text3 = await res.text();
   if (!res.ok) {
-    throw new Error(`token endpoint returned ${res.status}: ${text2}`);
+    throw new Error(`token endpoint returned ${res.status}: ${text3}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(text2);
+    parsed = JSON.parse(text3);
   } catch {
-    throw new Error(`token endpoint returned non-JSON: ${text2}`);
+    throw new Error(`token endpoint returned non-JSON: ${text3}`);
   }
   if (!parsed.access_token) {
-    throw new Error(`token endpoint response missing access_token: ${text2}`);
+    throw new Error(`token endpoint response missing access_token: ${text3}`);
   }
   return parsed;
 }
@@ -423,16 +284,16 @@ async function refreshAccessToken(authBaseUrl, clientId, refreshToken) {
   );
 }
 async function acquireAccessToken(opts) {
-  const { auth, clientId, scope, reauth, spinner: spinner3, captureOptions } = opts;
+  const { auth, clientId, scope, reauth, spinner: spinner4, captureOptions } = opts;
   const now = Math.floor(Date.now() / 1e3);
   const cached = reauth ? null : getCachedToken(auth, clientId, scope);
   if (cached && cached.expires_at > now + TOKEN_EXPIRY_MARGIN_S) {
-    spinner3?.start("Using cached session");
-    spinner3?.stop("Signed in (cached)");
+    spinner4?.start("Using cached session");
+    spinner4?.stop("Signed in (cached)");
     return cached.access_token;
   }
   if (cached?.refresh_token) {
-    spinner3?.start("Refreshing session");
+    spinner4?.start("Refreshing session");
     try {
       const refreshed = await refreshAccessToken(
         auth,
@@ -443,10 +304,10 @@ async function acquireAccessToken(opts) {
         auth,
         makeCachedToken(clientId, refreshed, cached.refresh_token, scope)
       );
-      spinner3?.stop("Signed in (refreshed)");
+      spinner4?.stop("Signed in (refreshed)");
       return refreshed.access_token;
     } catch {
-      spinner3?.stop("Refresh failed, opening browser");
+      spinner4?.stop("Refresh failed, opening browser");
     }
   }
   const pkce = generatePkce();
@@ -460,7 +321,7 @@ async function acquireAccessToken(opts) {
   authorizeUrl.searchParams.set("code_challenge", pkce.challenge);
   authorizeUrl.searchParams.set("code_challenge_method", "S256");
   authorizeUrl.searchParams.set("prompt", "login");
-  spinner3?.start("Waiting for browser login");
+  spinner4?.start("Waiting for browser login");
   try {
     const { code, verifier } = await captureAuthCode(
       authorizeUrl,
@@ -468,24 +329,24 @@ async function acquireAccessToken(opts) {
       pkce.verifier,
       captureOptions
     );
-    spinner3?.message("Exchanging authorization code");
+    spinner4?.message("Exchanging authorization code");
     const tokens = await exchangeCodeForToken(auth, clientId, code, verifier);
     saveCachedToken(auth, makeCachedToken(clientId, tokens, void 0, scope));
-    spinner3?.stop("Signed in");
+    spinner4?.stop("Signed in");
     return tokens.access_token;
   } catch (err) {
-    spinner3?.stop("Login failed");
+    spinner4?.stop("Login failed");
     throw err;
   }
 }
 async function apiCall(url, init) {
   const res = await fetch(url, init);
-  const text2 = await res.text();
+  const text3 = await res.text();
   let body;
   try {
-    body = text2 ? JSON.parse(text2) : {};
+    body = text3 ? JSON.parse(text3) : {};
   } catch {
-    body = text2;
+    body = text3;
   }
   if (!res.ok) {
     const detail = typeof body === "string" ? body : JSON.stringify(body);
@@ -506,31 +367,6 @@ async function fetchTenants(apiBaseUrl, jwt) {
   }
   return tenants;
 }
-async function listTenantApps(apiBaseUrl, jwt, tenantId) {
-  const res = await apiCall(
-    `${apiBaseUrl}/app-service/tenants/apps?onlyAppsOfTenant=true&returnAll=true`,
-    {
-      headers: {
-        Authorization: `Bearer ${jwt}`,
-        "X-Tenant-Id": tenantId,
-        Accept: "application/json"
-      }
-    }
-  );
-  const items = Array.isArray(res) ? res : res.items ?? [];
-  return items.map((entry) => {
-    const id = entry.appId ?? entry.app?.id;
-    const technicalName = entry.app?.technicalName;
-    if (!id || !technicalName) return null;
-    return {
-      id,
-      technicalName,
-      clientId: entry.app?.clientId,
-      provisioningStatus: entry.app?.activeVersion?.provisioningStatus,
-      isInstalled: entry.isInstalled
-    };
-  }).filter((a) => a !== null);
-}
 function validateHost(input, flag) {
   let url;
   try {
@@ -541,7 +377,279 @@ function validateHost(input, flag) {
   if (!/^https?:$/.test(url.protocol)) {
     bail(`--${flag} must use http(s): ${input}`);
   }
-  return `${url.protocol}//${url.host}`;
+  return `${url.protocol}//${url.host}`;
+}
+var COMMON_ARG_OPTIONS = {
+  "api-host": { type: "string" },
+  "auth-host": { type: "string" },
+  "hub-host": { type: "string" },
+  "partner-host": { type: "string" },
+  "client-id": { type: "string" },
+  scope: { type: "string" },
+  reauth: { type: "boolean" },
+  yes: { type: "boolean", short: "y" },
+  tenant: { type: "string" }
+};
+function resolveCommonOptions(values) {
+  const api = values["api-host"] ? validateHost(values["api-host"], "api-host") : DEFAULT_API_HOST;
+  const auth = values["auth-host"] ? validateHost(values["auth-host"], "auth-host") : DEFAULT_AUTH_HOST;
+  const hub = values["hub-host"] ? validateHost(values["hub-host"], "hub-host") : DEFAULT_HUB_HOST;
+  const partner = values["partner-host"] ? validateHost(values["partner-host"], "partner-host") : DEFAULT_PARTNER_HOST;
+  const clientIdArg = values["client-id"];
+  const clientId = clientIdArg ?? CLIENT_IDS_BY_AUTH_HOST[new URL(auth).hostname] ?? "";
+  if (!clientId) {
+    bail(
+      `no OAuth client_id registered for ${auth}. Pass --client-id <id> or add an entry to CLIENT_IDS_BY_AUTH_HOST.`
+    );
+  }
+  return {
+    api,
+    auth,
+    hub,
+    partner,
+    clientId,
+    scope: values.scope ?? DEFAULT_SCOPE,
+    reauth: values.reauth ?? false,
+    yes: values.yes ?? false,
+    tenant: values.tenant
+  };
+}
+function ensureContinue(value) {
+  if (p.isCancel(value)) {
+    bail("Cancelled.");
+  }
+  return value;
+}
+async function selectTenant(tenants, opts) {
+  if (tenants.length === 0) {
+    bail(
+      "your account has no tenants. Create one on the Partner Portal first."
+    );
+  }
+  if (opts.tenant) {
+    const needle = opts.tenant.toLowerCase();
+    const matches = tenants.filter(
+      (t) => t.id === opts.tenant || t.slug.toLowerCase() === needle
+    );
+    if (matches.length === 0) {
+      bail(`no tenant matched --tenant "${opts.tenant}"`);
+    }
+    if (matches.length > 1) {
+      bail(
+        `--tenant "${opts.tenant}" matched ${matches.length} tenants \u2014 be more specific`
+      );
+    }
+    return matches[0];
+  }
+  if (tenants.length === 1) {
+    return tenants[0];
+  }
+  if (opts.yes) {
+    bail(
+      `multiple tenants available; pass --tenant <id|slug> in non-interactive mode`
+    );
+  }
+  const tenantId = ensureContinue(
+    await p.select({
+      message: "Select a tenant",
+      options: tenants.map((t) => ({
+        value: t.id,
+        label: t.name,
+        hint: t.slug
+      }))
+    })
+  );
+  return tenants.find((t) => t.id === tenantId);
+}
+async function confirmAction(opts, message, defaultValue) {
+  if (opts.yes) return true;
+  return ensureContinue(
+    await p.confirm({ message, initialValue: defaultValue })
+  );
+}
+function buildHubInstallUrl(hubHost, tenantSlug, appId) {
+  return `${hubHost}/${tenantSlug}/admin/app-overview/manage/${appId}/grants`;
+}
+function buildHubAppOverviewUrl(hubHost, tenantSlug) {
+  return `${hubHost}/${tenantSlug}/admin/app-overview?tab=development-apps`;
+}
+function buildPartnerPortalPublishUrl(partnerHost, tenantSlug, publisherId) {
+  return `${partnerHost}/${tenantSlug}/${publisherId}/apps/publish`;
+}
+function terminalLink(url, text3 = url) {
+  const OSC = "\x1B]";
+  const ST = "\x1B\\";
+  return `${OSC}8;;${url}${ST}${text3}${OSC}8;;${ST}`;
+}
+function printHubLink(hubHost, tenantSlug, appId, isInstalled) {
+  if (isInstalled) {
+    const url = buildHubAppOverviewUrl(hubHost, tenantSlug);
+    p.note(pc.cyan(terminalLink(url)), "Already installed \u2014 open in Hub");
+  } else {
+    const url = buildHubInstallUrl(hubHost, tenantSlug, appId);
+    p.note(pc.cyan(terminalLink(url)), "Install in Hub");
+  }
+}
+
+// src/register.ts
+import * as p2 from "@clack/prompts";
+import fs2 from "fs";
+import path2 from "path";
+import { parseArgs } from "util";
+import pc2 from "picocolors";
+function parseEnv(content) {
+  const result = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function summarizeManifest(manifest) {
+  return {
+    technicalName: manifest.technicalName ?? "(unset)",
+    version: manifest.version ?? "(unset)"
+  };
+}
+function readEnvFile(filePath) {
+  if (!fs2.existsSync(filePath)) return {};
+  return parseEnv(fs2.readFileSync(filePath, "utf-8"));
+}
+function upsertEnv(filePath, updates) {
+  const existing = fs2.existsSync(filePath) ? fs2.readFileSync(filePath, "utf-8") : "";
+  const lines = existing.split(/\r?\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const remaining = new Map(Object.entries(updates));
+  const next = lines.map((line) => {
+    const eq = line.indexOf("=");
+    if (eq === -1) return line;
+    const key = line.slice(0, eq).trim();
+    if (remaining.has(key)) {
+      const value = remaining.get(key);
+      remaining.delete(key);
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  for (const [key, value] of remaining) {
+    next.push(`${key}=${value}`);
+  }
+  fs2.writeFileSync(filePath, next.join("\n") + "\n");
+}
+function findDotnetProject(backendDir) {
+  if (!fs2.existsSync(backendDir)) return null;
+  for (const entry of fs2.readdirSync(backendDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const exampleFile = path2.join(
+      backendDir,
+      entry.name,
+      "appsettings.Local.json.example"
+    );
+    const csproj = path2.join(backendDir, entry.name, `${entry.name}.csproj`);
+    if (fs2.existsSync(exampleFile) || fs2.existsSync(csproj)) {
+      return path2.join(backendDir, entry.name);
+    }
+  }
+  return null;
+}
+function detectBackend(root) {
+  const backendDir = path2.join(root, "packages", "backend");
+  const envFile = path2.join(backendDir, ".env");
+  const envExample = path2.join(backendDir, ".env.example");
+  if (fs2.existsSync(envFile) || fs2.existsSync(envExample)) {
+    return { kind: "node", envFile };
+  }
+  const dotnetDir = findDotnetProject(backendDir);
+  if (dotnetDir) {
+    return {
+      kind: "dotnet",
+      settingsFile: path2.join(dotnetDir, "appsettings.Local.json")
+    };
+  }
+  return { kind: "node", envFile: path2.join(root, ".env") };
+}
+function readExistingCredentials(backend) {
+  if (backend.kind === "node") {
+    const values = readEnvFile(backend.envFile);
+    return { clientId: values.CLIENT_ID, clientSecret: values.CLIENT_SECRET };
+  }
+  if (!fs2.existsSync(backend.settingsFile)) return {};
+  try {
+    const settings = JSON.parse(fs2.readFileSync(backend.settingsFile, "utf-8"));
+    return {
+      clientId: settings?.JtlPlatform?.ClientId,
+      clientSecret: settings?.JtlPlatform?.ClientSecret
+    };
+  } catch {
+    return {};
+  }
+}
+function writeBackendCredentials(backend, clientId, clientSecret) {
+  if (backend.kind === "node") {
+    upsertEnv(backend.envFile, {
+      CLIENT_ID: clientId,
+      CLIENT_SECRET: clientSecret
+    });
+    return backend.envFile;
+  }
+  let settings = {};
+  if (fs2.existsSync(backend.settingsFile)) {
+    try {
+      settings = JSON.parse(fs2.readFileSync(backend.settingsFile, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  settings.JtlPlatform = {
+    ...settings.JtlPlatform ?? {},
+    ClientId: clientId,
+    ClientSecret: clientSecret
+  };
+  fs2.writeFileSync(
+    backend.settingsFile,
+    JSON.stringify(settings, null, 2) + "\n"
+  );
+  return backend.settingsFile;
+}
+function readManifest(appJsonPath) {
+  const dir = path2.dirname(appJsonPath);
+  const legacyPath = path2.join(dir, "manifest.json");
+  let filePath;
+  if (fs2.existsSync(appJsonPath)) {
+    filePath = appJsonPath;
+  } else if (fs2.existsSync(legacyPath)) {
+    p2.log.warn(
+      "manifest.json is deprecated. Rename it to app.json. See the doc for more details: \nhttps://developer.jtl-software.com/guides/cloud-apps/app-manifest."
+    );
+    filePath = legacyPath;
+  } else {
+    bail(
+      `app.json not found at ${appJsonPath}. Run this from the project root.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch (err) {
+    bail(
+      `${path2.basename(filePath)} is not valid JSON: ${err.message}`
+    );
+  }
+  if (parsed && typeof parsed === "object" && "manifest" in parsed && typeof parsed.manifest === "object") {
+    p2.log.warn(
+      "manifest.json uses the old combined format. Split it into app.json (version, technicalName, lifecycle, capabilities) and listing.json (defaultLocale, distributionType, name, ...). See the doc for more details:  \nhttps://developer.jtl-software.com/guides/cloud-apps/app-manifest."
+    );
+    return parsed.manifest;
+  }
+  return parsed;
 }
 function parseCollisionAction(input) {
   if (input === "overwrite" || input === "print" || input === "cancel") {
@@ -557,14 +665,7 @@ function resolveOptions(args) {
     parsed = parseArgs({
       args,
       options: {
-        "api-host": { type: "string" },
-        "auth-host": { type: "string" },
-        "hub-host": { type: "string" },
-        "client-id": { type: "string" },
-        scope: { type: "string" },
-        reauth: { type: "boolean" },
-        yes: { type: "boolean", short: "y" },
-        tenant: { type: "string" },
+        ...COMMON_ARG_OPTIONS,
         "existing-app-id": { type: "string" },
         new: { type: "boolean" },
         "on-collision": { type: "string" }
@@ -575,16 +676,7 @@ function resolveOptions(args) {
   } catch (err) {
     bail(err.message);
   }
-  const api = parsed.values["api-host"] ? validateHost(parsed.values["api-host"], "api-host") : DEFAULT_API_HOST;
-  const auth = parsed.values["auth-host"] ? validateHost(parsed.values["auth-host"], "auth-host") : DEFAULT_AUTH_HOST;
-  const hub = parsed.values["hub-host"] ? validateHost(parsed.values["hub-host"], "hub-host") : DEFAULT_HUB_HOST;
-  const clientIdArg = parsed.values["client-id"];
-  const clientId = clientIdArg ?? CLIENT_IDS_BY_AUTH_HOST[new URL(auth).hostname] ?? "";
-  if (!clientId) {
-    bail(
-      `no OAuth client_id registered for ${auth}. Pass --client-id <id> or add an entry to CLIENT_IDS_BY_AUTH_HOST.`
-    );
-  }
+  const common = resolveCommonOptions(parsed.values);
   const existingAppId = parsed.values["existing-app-id"];
   const forceNew = parsed.values.new ?? false;
   if (existingAppId && forceNew) {
@@ -593,66 +685,12 @@ function resolveOptions(args) {
   const onCollisionRaw = parsed.values["on-collision"];
   const onCollision = onCollisionRaw ? parseCollisionAction(onCollisionRaw) : void 0;
   return {
-    api,
-    auth,
-    hub,
-    clientId,
-    scope: parsed.values.scope ?? DEFAULT_SCOPE,
-    reauth: parsed.values.reauth ?? false,
-    yes: parsed.values.yes ?? false,
-    tenant: parsed.values.tenant,
+    ...common,
     existingAppId,
     forceNew,
     onCollision
   };
 }
-function ensureContinue(value) {
-  if (p.isCancel(value)) {
-    bail("Cancelled.");
-  }
-  return value;
-}
-async function selectTenant(tenants, opts) {
-  if (tenants.length === 0) {
-    bail(
-      "your account has no tenants. Create one on the Partner Portal first."
-    );
-  }
-  if (opts.tenant) {
-    const needle = opts.tenant.toLowerCase();
-    const matches = tenants.filter(
-      (t) => t.id === opts.tenant || t.slug.toLowerCase() === needle
-    );
-    if (matches.length === 0) {
-      bail(`no tenant matched --tenant "${opts.tenant}"`);
-    }
-    if (matches.length > 1) {
-      bail(
-        `--tenant "${opts.tenant}" matched ${matches.length} tenants \u2014 be more specific`
-      );
-    }
-    return matches[0];
-  }
-  if (tenants.length === 1) {
-    return tenants[0];
-  }
-  if (opts.yes) {
-    bail(
-      `multiple tenants available; pass --tenant <id|slug> in non-interactive mode`
-    );
-  }
-  const tenantId = ensureContinue(
-    await p.select({
-      message: "Register the app in which tenant?",
-      options: tenants.map((t) => ({
-        value: t.id,
-        label: t.name,
-        hint: t.slug
-      }))
-    })
-  );
-  return tenants.find((t) => t.id === tenantId);
-}
 async function selectExistingOrNew(matches, opts) {
   if (opts.existingAppId) {
     const match = matches.find((a) => a.id === opts.existingAppId);
@@ -672,7 +710,7 @@ async function selectExistingOrNew(matches, opts) {
   }
   const CREATE_NEW = "__create_new__";
   const choice = ensureContinue(
-    await p.select({
+    await p2.select({
       message: "Update an existing app or create a new one?",
       options: [
         ...matches.map((a) => ({
@@ -687,12 +725,6 @@ async function selectExistingOrNew(matches, opts) {
   if (choice === CREATE_NEW) return null;
   return matches.find((a) => a.id === choice);
 }
-async function confirmAction(opts, message, defaultValue) {
-  if (opts.yes) return true;
-  return ensureContinue(
-    await p.confirm({ message, initialValue: defaultValue })
-  );
-}
 async function resolveCollision(targetLabel, credentialPair, opts) {
   if (opts.onCollision) return opts.onCollision;
   if (opts.yes) {
@@ -701,7 +733,7 @@ async function resolveCollision(targetLabel, credentialPair, opts) {
     );
   }
   return ensureContinue(
-    await p.select({
+    await p2.select({
       message: `${targetLabel} already has ${credentialPair}. What now?`,
       options: [
         { value: "overwrite", label: "Overwrite the file" },
@@ -711,6 +743,31 @@ async function resolveCollision(targetLabel, credentialPair, opts) {
     })
   );
 }
+async function listTenantApps(apiBaseUrl, jwt, tenantId) {
+  const res = await apiCall(
+    `${apiBaseUrl}/app-service/tenants/apps?onlyAppsOfTenant=true&returnAll=true`,
+    {
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "X-Tenant-Id": tenantId,
+        Accept: "application/json"
+      }
+    }
+  );
+  const items = Array.isArray(res) ? res : res.items ?? [];
+  return items.map((entry) => {
+    const id = entry.id;
+    const technicalName = entry.technicalName;
+    if (!id || !technicalName) return null;
+    return {
+      id,
+      technicalName,
+      clientId: entry.clientId,
+      provisioningStatus: entry.activeVersion?.provisioningStatus,
+      isInstalled: entry.isInstalled
+    };
+  }).filter((a) => a !== null);
+}
 async function updateAppManifest(apiBaseUrl, jwt, tenantId, appId, manifest) {
   await apiCall(`${apiBaseUrl}/app-service/store/apps/${appId}/manifest`, {
     method: "PUT",
@@ -719,7 +776,7 @@ async function updateAppManifest(apiBaseUrl, jwt, tenantId, appId, manifest) {
       "Content-Type": "application/json",
       "X-Tenant-Id": tenantId
     },
-    body: JSON.stringify({ manifest: manifest.manifest, tcAccepted: true })
+    body: JSON.stringify({ manifest, tcAccepted: true })
   });
 }
 async function createDraftApp(apiBaseUrl, jwt, tenantId, manifest) {
@@ -733,17 +790,17 @@ async function createDraftApp(apiBaseUrl, jwt, tenantId, manifest) {
         "X-Tenant-Id": tenantId
       },
       body: JSON.stringify({
-        manifest: manifest.manifest,
+        manifest,
         tcAccepted: true
       })
     }
   );
-  if (!created.appId) {
+  if (!created.id) {
     throw new Error(
-      `/store/apps did not return appId: ${JSON.stringify(created)}`
+      `/store/apps did not return id: ${JSON.stringify(created)}`
     );
   }
-  return created.appId;
+  return created.id;
 }
 async function provisionApp(apiBaseUrl, jwt, tenantId, appId) {
   const provisioned = await apiCall(
@@ -758,35 +815,15 @@ async function provisionApp(apiBaseUrl, jwt, tenantId, appId) {
       body: JSON.stringify({ appId })
     }
   );
-  const clientId = provisioned.app?.clientId;
+  const clientId = provisioned.clientId;
   const clientSecret = provisioned.clientSecret;
   if (!clientId || !clientSecret) {
     throw new Error(
-      `provision response missing app.clientId or clientSecret: ${JSON.stringify(provisioned)}`
+      `provision response missing clientId or clientSecret: ${JSON.stringify(provisioned)}`
     );
   }
   return { clientId, clientSecret };
 }
-function buildHubInstallUrl(hubHost, tenantSlug, appId) {
-  return `${hubHost}/${tenantSlug}/admin/app-overview/manage/${appId}/grants`;
-}
-function buildHubAppOverviewUrl(hubHost, tenantSlug) {
-  return `${hubHost}/${tenantSlug}/admin/app-overview?tab=development-apps`;
-}
-function terminalLink(url, text2 = url) {
-  const OSC = "\x1B]";
-  const ST = "\x1B\\";
-  return `${OSC}8;;${url}${ST}${text2}${OSC}8;;${ST}`;
-}
-function printHubLink(hubHost, tenantSlug, appId, isInstalled) {
-  if (isInstalled) {
-    const url = buildHubAppOverviewUrl(hubHost, tenantSlug);
-    p.note(pc.cyan(terminalLink(url)), "Already installed \u2014 open in Hub");
-  } else {
-    const url = buildHubInstallUrl(hubHost, tenantSlug, appId);
-    p.note(pc.cyan(terminalLink(url)), "Install in Hub");
-  }
-}
 function credentialLabels(backend) {
   if (backend.kind === "node") {
     return {
@@ -803,7 +840,7 @@ function credentialLabels(backend) {
 }
 async function persistCredentials(backend, clientId, clientSecret, root, opts, context) {
   const targetPath = backend.kind === "node" ? backend.envFile : backend.settingsFile;
-  const relPath = path.relative(root, targetPath) || targetPath;
+  const relPath = path2.relative(root, targetPath) || targetPath;
   const labels = credentialLabels(backend);
   const existing = readExistingCredentials(backend);
   const collision = !!(existing.clientId && existing.clientSecret);
@@ -814,8 +851,8 @@ async function persistCredentials(backend, clientId, clientSecret, root, opts, c
   if (action === "cancel") bail("Cancelled.");
   if (action === "print") {
     console.log();
-    console.log(pc.cyan(labels.id) + "     = " + clientId);
-    console.log(pc.cyan(labels.secret) + " = " + clientSecret);
+    console.log(pc2.cyan(labels.id) + "     = " + clientId);
+    console.log(pc2.cyan(labels.secret) + " = " + clientSecret);
     console.log();
     printHubLink(
       context.hub,
@@ -823,7 +860,7 @@ async function persistCredentials(backend, clientId, clientSecret, root, opts, c
       context.appId,
       context.isInstalled
     );
-    p.outro(pc.green("Done. Credentials printed above; file left untouched."));
+    p2.outro(pc2.green("Done. Credentials printed above; file left untouched."));
     return;
   }
   const written = writeBackendCredentials(backend, clientId, clientSecret);
@@ -833,32 +870,29 @@ async function persistCredentials(backend, clientId, clientSecret, root, opts, c
     context.appId,
     context.isInstalled
   );
-  p.outro(
-    pc.green(
-      `Done. Wrote ${labels.pair} to ${pc.cyan(path.relative(root, written) || written)}.`
+  p2.outro(
+    pc2.green(
+      `Done. Wrote ${labels.pair} to ${pc2.cyan(path2.relative(root, written) || written)}.`
     )
   );
 }
 async function register(argv = [], runOpts = {}) {
   const root = runOpts.cwd ?? process.cwd();
-  const manifestPath = path.join(root, "manifest.json");
   console.log();
-  p.intro(pc.bgCyan(pc.black(" register cloud app ")));
+  p2.intro(pc2.bgCyan(pc2.black(" register cloud app ")));
   const opts = resolveOptions(argv);
-  const manifest = readManifest(manifestPath);
-  const summary = summarizeManifest(manifest);
   const backend = detectBackend(root);
-  p.note(
+  p2.note(
     [
-      `${pc.dim("API")}        ${opts.api}`,
-      `${pc.dim("Auth")}       ${opts.auth}`,
-      `${pc.dim("Hub")}        ${opts.hub}`,
-      `${pc.dim("Client ID")}  ${opts.clientId}`,
-      `${pc.dim("Scope")}      ${opts.scope}`
+      `${pc2.dim("API")}        ${opts.api}`,
+      `${pc2.dim("Auth")}       ${opts.auth}`,
+      `${pc2.dim("Hub")}        ${opts.hub}`,
+      `${pc2.dim("Client ID")}  ${opts.clientId}`,
+      `${pc2.dim("Scope")}      ${opts.scope}`
     ].join("\n"),
     "Target"
   );
-  const spinner3 = p.spinner();
+  const spinner4 = p2.spinner();
   let jwt;
   try {
     jwt = await acquireAccessToken({
@@ -866,56 +900,56 @@ async function register(argv = [], runOpts = {}) {
       clientId: opts.clientId,
       scope: opts.scope,
       reauth: opts.reauth,
-      spinner: spinner3,
+      spinner: spinner4,
       captureOptions: runOpts.captureOptions
     });
   } catch (err) {
     bail(err.message);
   }
-  spinner3.start("Fetching tenants");
+  spinner4.start("Fetching tenants");
   let tenants;
   try {
     tenants = await fetchTenants(opts.api, jwt);
-    spinner3.stop(
+    spinner4.stop(
       `Found ${tenants.length} tenant${tenants.length === 1 ? "" : "s"}`
     );
   } catch (err) {
-    spinner3.stop("Failed to fetch tenants");
+    spinner4.stop("Failed to fetch tenants");
     bail(err.message);
   }
   const tenant = await selectTenant(tenants, opts);
-  spinner3.start("Looking for apps matching this manifest");
+  const manifest = readManifest(path2.join(root, "app.json"));
+  const summary = summarizeManifest(manifest);
+  spinner4.start("Looking for apps matching this manifest");
   let matches;
   try {
     const apps = await listTenantApps(opts.api, jwt, tenant.id);
     matches = apps.filter((a) => a.technicalName === summary.technicalName);
-    spinner3.stop(
-      `Found ${matches.length} app${matches.length === 1 ? "" : "s"} with technical name ${pc.cyan(summary.technicalName)}`
+    spinner4.stop(
+      `Found ${matches.length} app${matches.length === 1 ? "" : "s"} with technical name ${pc2.cyan(summary.technicalName)}`
     );
   } catch (err) {
-    spinner3.stop("Failed to look up tenant apps");
+    spinner4.stop("Failed to look up tenant apps");
     bail(err.message);
   }
   const existing = await selectExistingOrNew(matches, opts);
   const reviewLines = [
-    `${pc.dim("App name")}        ${summary.name}`,
-    `${pc.dim("Technical name")}  ${summary.technicalName}`,
-    `${pc.dim("Version")}         ${summary.version}`,
-    summary.description ? `${pc.dim("Description")}     ${summary.description}` : null,
-    `${pc.dim("Tenant")}          ${tenant.name} (${tenant.slug})`,
-    existing ? `${pc.dim("Updating")}        ${existing.technicalName} (${existing.id}) [${existing.provisioningStatus ?? "?"}]` : `${pc.dim("Action")}          create new`
+    `${pc2.dim("Technical name")}  ${summary.technicalName}`,
+    `${pc2.dim("Version")}         ${summary.version}`,
+    `${pc2.dim("Tenant")}          ${tenant.name} (${tenant.slug})`,
+    existing ? `${pc2.dim("Updating")}        ${existing.technicalName} (${existing.id}) [${existing.provisioningStatus ?? "?"}]` : `${pc2.dim("Action")}          create new`
   ].filter(Boolean);
-  p.note(reviewLines.join("\n"), "Review");
-  const confirmMessage = existing ? `Update app "${existing.technicalName}" in tenant "${tenant.name}"?` : `Create app "${summary.name}" in tenant "${tenant.name}"?`;
+  p2.note(reviewLines.join("\n"), "Review");
+  const confirmMessage = existing ? `Update app "${existing.technicalName}" in tenant "${tenant.name}"?` : `Create app "${summary.technicalName}" in tenant "${tenant.name}"?`;
   const confirm2 = await confirmAction(opts, confirmMessage, existing !== null);
   if (!confirm2) bail("Cancelled.");
   if (existing) {
-    spinner3.start("Updating manifest");
+    spinner4.start("Updating manifest");
     try {
       await updateAppManifest(opts.api, jwt, tenant.id, existing.id, manifest);
-      spinner3.stop("Manifest updated");
+      spinner4.stop("Manifest updated");
     } catch (err) {
-      spinner3.stop("Failed to update manifest");
+      spinner4.stop("Failed to update manifest");
       bail(err.message);
     }
     printHubLink(
@@ -930,33 +964,33 @@ async function register(argv = [], runOpts = {}) {
       const localCreds = readExistingCredentials(backend);
       const hasLocalCreds = !!(localCreds.clientId && localCreds.clientSecret);
       if (!hasLocalCreds) {
-        p.outro(
-          pc.yellow(
+        p2.outro(
+          pc2.yellow(
             `Manifest updated. Your backend config is missing ${labels.pair} \u2014 they can't be recovered. Re-create the app to get a fresh secret.`
           )
         );
         return;
       }
-      p.outro(
-        pc.green(
-          `Manifest updated. Existing ${labels.pair} in ${pc.cyan(path.relative(root, envFile))} kept as-is.`
+      p2.outro(
+        pc2.green(
+          `Manifest updated. Existing ${labels.pair} in ${pc2.cyan(path2.relative(root, envFile))} kept as-is.`
         )
       );
     } else {
-      p.outro(pc.green("Manifest updated."));
+      p2.outro(pc2.green("Manifest updated."));
     }
     return;
   }
-  spinner3.start("Creating draft app");
+  spinner4.start("Creating draft app");
   let appId;
   try {
     appId = await createDraftApp(opts.api, jwt, tenant.id, manifest);
-    spinner3.stop(`Created app ${pc.cyan(appId)}`);
+    spinner4.stop(`Created app ${pc2.cyan(appId)}`);
   } catch (err) {
-    spinner3.stop("Failed to create app");
+    spinner4.stop("Failed to create app");
     bail(err.message);
   }
-  spinner3.start("Provisioning app");
+  spinner4.start("Provisioning app");
   let clientId;
   let clientSecret;
   try {
@@ -966,9 +1000,9 @@ async function register(argv = [], runOpts = {}) {
       tenant.id,
       appId
     ));
-    spinner3.stop("Provisioned");
+    spinner4.stop("Provisioned");
   } catch (err) {
-    spinner3.stop("Failed to provision app");
+    spinner4.stop("Failed to provision app");
     bail(err.message);
   }
   await persistCredentials(backend, clientId, clientSecret, root, opts, {
@@ -980,10 +1014,275 @@ async function register(argv = [], runOpts = {}) {
   });
 }
 
+// src/listing.ts
+function pickFirstLocaleEntry(entries) {
+  if (!entries || typeof entries !== "object") return void 0;
+  const keys = Object.keys(entries);
+  if (!keys.length) return void 0;
+  return entries[keys[0]];
+}
+function summarizeListing(listing2) {
+  const nameEntry = pickFirstLocaleEntry(listing2.name);
+  return {
+    name: nameEntry?.short ?? nameEntry?.full ?? "(unnamed)",
+    distributionType: listing2.distributionType ?? "(unset)"
+  };
+}
+function readListing(listingPath) {
+  if (!fs3.existsSync(listingPath)) {
+    bail(
+      `listing.json not found at ${listingPath}. Run this from the project root.`
+    );
+  }
+  try {
+    return JSON.parse(fs3.readFileSync(listingPath, "utf-8"));
+  } catch (err) {
+    bail(`listing.json is not valid JSON: ${err.message}`);
+  }
+}
+function writeListing(listingPath, listing2) {
+  fs3.writeFileSync(listingPath, JSON.stringify(listing2, null, 2) + "\n");
+}
+function readTechnicalName(root) {
+  const manifestPath = path3.join(root, "app.json");
+  const manifest = readManifest(manifestPath);
+  if (!manifest.technicalName) {
+    bail(
+      `app.json at ${manifestPath} has no technicalName \u2014 run \`npm run register\` first.`
+    );
+  }
+  return manifest.technicalName;
+}
+async function resolveAppId(apiBaseUrl, jwt, tenantId, technicalName) {
+  const apps = await listTenantApps(apiBaseUrl, jwt, tenantId);
+  const matches = apps.filter(
+    (a) => a.technicalName === technicalName
+  );
+  if (matches.length === 0) {
+    bail(
+      `No app with technicalName "${technicalName}" found in this tenant \u2014 run \`npm run register\` first.`
+    );
+  }
+  if (matches.length > 1) {
+    bail(
+      `${matches.length} apps with technicalName "${technicalName}" found in this tenant \u2014 resolve the duplicate in the Partner Portal before pushing a listing.`
+    );
+  }
+  return matches[0].id;
+}
+function resolveListingOptions(args) {
+  let parsed;
+  try {
+    parsed = parseArgs2({
+      args,
+      options: { ...COMMON_ARG_OPTIONS },
+      strict: true,
+      allowPositionals: false
+    });
+  } catch (err) {
+    bail(err.message);
+  }
+  return resolveCommonOptions(parsed.values);
+}
+async function createAppListing(apiBaseUrl, jwt, tenantId, appId, listing2) {
+  const created = await apiCall(
+    `${apiBaseUrl}/app-service/app-listings`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "Content-Type": "application/json",
+        "X-Tenant-Id": tenantId
+      },
+      body: JSON.stringify({
+        appId,
+        defaultLocale: listing2.defaultLocale,
+        name: listing2.name
+      })
+    }
+  );
+  if (!created.slug) {
+    throw new Error(
+      `/app-listings did not return a slug: ${JSON.stringify(created)}`
+    );
+  }
+  return { slug: created.slug, publisherId: created.publisherId };
+}
+async function updateAppListing(apiBaseUrl, jwt, tenantId, slug, appId, listing2) {
+  await apiCall(
+    `${apiBaseUrl}/app-service/app-listings/${encodeURIComponent(slug)}`,
+    {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "Content-Type": "application/json",
+        "X-Tenant-Id": tenantId
+      },
+      body: JSON.stringify({ ...listing2, appId })
+    }
+  );
+}
+async function resolveDistributionType(existing, opts) {
+  const fallback = existing === "PUBLIC" ? "PUBLIC" : "PRIVATE";
+  if (opts.yes) return fallback;
+  return ensureContinue(
+    await p3.select({
+      message: "Distribution type",
+      initialValue: fallback,
+      options: [
+        {
+          value: "PRIVATE",
+          label: "Private",
+          hint: "shared with merchants via activation codes, not listed in the App Store"
+        },
+        {
+          value: "PUBLIC",
+          label: "Public",
+          hint: "listed in the App Store, goes through review"
+        }
+      ]
+    })
+  );
+}
+async function resolveDefaultLocale(existing, opts) {
+  const fallback = existing ?? "de-DE";
+  if (opts.yes) return fallback;
+  return ensureContinue(
+    await p3.text({
+      message: "Default locale",
+      initialValue: fallback,
+      validate: (value) => {
+        if (!value) return "Default locale is required";
+      }
+    })
+  );
+}
+async function listing(argv = [], runOpts = {}) {
+  const root = runOpts.cwd ?? process.cwd();
+  const listingPath = path3.join(root, "listing.json");
+  console.log();
+  p3.intro(pc3.bgCyan(pc3.black(" push app listing ")));
+  const opts = resolveListingOptions(argv);
+  const technicalName = readTechnicalName(root);
+  const listingData = readListing(listingPath);
+  p3.note(
+    [
+      `${pc3.dim("API")}      ${opts.api}`,
+      `${pc3.dim("Auth")}     ${opts.auth}`,
+      `${pc3.dim("Hub")}      ${opts.hub}`,
+      `${pc3.dim("Partner")}  ${opts.partner}`
+    ].join("\n"),
+    "Target"
+  );
+  const spinner4 = p3.spinner();
+  let jwt;
+  try {
+    jwt = await acquireAccessToken({
+      auth: opts.auth,
+      clientId: opts.clientId,
+      scope: opts.scope,
+      reauth: opts.reauth,
+      spinner: spinner4,
+      captureOptions: runOpts.captureOptions
+    });
+  } catch (err) {
+    bail(err.message);
+  }
+  spinner4.start("Fetching tenants");
+  let tenants;
+  try {
+    tenants = await fetchTenants(opts.api, jwt);
+    spinner4.stop(
+      `Found ${tenants.length} tenant${tenants.length === 1 ? "" : "s"}`
+    );
+  } catch (err) {
+    spinner4.stop("Failed to fetch tenants");
+    bail(err.message);
+  }
+  const tenant = await selectTenant(tenants, opts);
+  listingData.distributionType = await resolveDistributionType(
+    listingData.distributionType,
+    opts
+  );
+  listingData.defaultLocale = await resolveDefaultLocale(
+    listingData.defaultLocale,
+    opts
+  );
+  writeListing(listingPath, listingData);
+  const summary = summarizeListing(listingData);
+  if (listingData.distributionType === "PUBLIC" && !listingData.pricing?.subscriptionTiers?.length) {
+    bail(
+      `listing.json has distributionType "PUBLIC" but no pricing.subscriptionTiers \u2014 public listings require at least one tier. Add one, or set distributionType to "PRIVATE" if this app isn't ready for App Store review yet.`
+    );
+  }
+  spinner4.start("Looking up the registered app");
+  let appId;
+  try {
+    appId = await resolveAppId(opts.api, jwt, tenant.id, technicalName);
+    spinner4.stop(`Found app ${pc3.cyan(appId)}`);
+  } catch (err) {
+    spinner4.stop("Failed to look up the app");
+    bail(err.message);
+  }
+  const reviewLines = [
+    `${pc3.dim("Technical name")}  ${technicalName}`,
+    `${pc3.dim("App ID")}          ${appId}`,
+    `${pc3.dim("Listing name")}    ${summary.name}`,
+    `${pc3.dim("Distribution")}    ${summary.distributionType}`,
+    `${pc3.dim("Tenant")}          ${tenant.name} (${tenant.slug})`
+  ].join("\n");
+  p3.note(reviewLines, "Review");
+  const confirm2 = await confirmAction(
+    opts,
+    `Push listing for "${technicalName}" in tenant "${tenant.name}"?`,
+    true
+  );
+  if (!confirm2) bail("Cancelled.");
+  spinner4.start("Creating listing");
+  let slug;
+  let publisherId;
+  try {
+    ({ slug, publisherId } = await createAppListing(
+      opts.api,
+      jwt,
+      tenant.id,
+      appId,
+      listingData
+    ));
+    spinner4.stop(`Listing created (${pc3.cyan(slug)})`);
+  } catch (err) {
+    spinner4.stop("Failed to create listing");
+    const message = err.message;
+    if (/AppListingAlreadyExists/.test(message)) {
+      bail(
+        `App "${technicalName}" already has a listing. This CLI can't update an existing listing yet (no confirmed lookup for its slug) \u2014 edit it in the Partner Portal's "Publish apps" section instead: ${opts.partner}`
+      );
+    }
+    bail(message);
+  }
+  spinner4.start("Pushing listing details");
+  try {
+    await updateAppListing(opts.api, jwt, tenant.id, slug, appId, listingData);
+    spinner4.stop("Listing updated");
+  } catch (err) {
+    spinner4.stop("Failed to push listing details");
+    bail(err.message);
+  }
+  const hubUrl = buildHubAppOverviewUrl(opts.hub, tenant.slug);
+  p3.note(pc3.cyan(terminalLink(hubUrl)), "View in Hub");
+  const publishUrl = buildPartnerPortalPublishUrl(
+    opts.partner,
+    tenant.slug,
+    publisherId
+  );
+  p3.note(pc3.cyan(terminalLink(publishUrl)), "Manage in Partner Portal");
+  p3.outro(pc3.green("Done. Listing pushed."));
+}
+
 // src/scaffold.ts
 import crypto2 from "crypto";
-import fs2 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function toPascalCase(kebab) {
   return kebab.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
@@ -1042,30 +1341,30 @@ function transformPackageJson(content, appName, templateType, replacements) {
   return result + "\n";
 }
 function copyDir(src, dest, replacements, templateType, appName) {
-  fs2.mkdirSync(dest, { recursive: true });
-  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path2.join(src, entry.name);
+  fs4.mkdirSync(dest, { recursive: true });
+  for (const entry of fs4.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path4.join(src, entry.name);
     let destName = entry.name;
     if (destName.startsWith("_git")) {
       destName = `.${destName.slice(1)}`;
     }
     destName = applyPlaceholders(destName, replacements);
-    const destPath = path2.join(dest, destName);
+    const destPath = path4.join(dest, destName);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath, replacements);
     } else if (entry.name === "package.json" && templateType && appName) {
-      const content = fs2.readFileSync(srcPath, "utf-8");
-      fs2.writeFileSync(
+      const content = fs4.readFileSync(srcPath, "utf-8");
+      fs4.writeFileSync(
         destPath,
         transformPackageJson(content, appName, templateType, replacements)
       );
     } else {
-      const ext = path2.extname(entry.name).toLowerCase();
+      const ext = path4.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) {
-        fs2.copyFileSync(srcPath, destPath);
+        fs4.copyFileSync(srcPath, destPath);
       } else {
-        const content = fs2.readFileSync(srcPath, "utf-8");
-        fs2.writeFileSync(destPath, applyPlaceholders(content, replacements));
+        const content = fs4.readFileSync(srcPath, "utf-8");
+        fs4.writeFileSync(destPath, applyPlaceholders(content, replacements));
       }
     }
   }
@@ -1086,14 +1385,14 @@ async function scaffold({
   shared,
   targetDir: customTargetDir
 }) {
-  const targetDir = customTargetDir ?? path2.resolve(process.cwd(), appName);
+  const targetDir = customTargetDir ?? path4.resolve(process.cwd(), appName);
   const baseReplacements = buildPlaceholders({ appName, description });
-  if (fs2.existsSync(targetDir)) {
+  if (fs4.existsSync(targetDir)) {
     throw new Error(`Directory "${appName}" already exists`);
   }
-  fs2.mkdirSync(targetDir, { recursive: true });
+  fs4.mkdirSync(targetDir, { recursive: true });
   copyDir(shared.dir, targetDir, baseReplacements);
-  const frontendDest = path2.join(targetDir, "packages", "frontend");
+  const frontendDest = path4.join(targetDir, "packages", "frontend");
   const frontendReplacements = buildReplacements(baseReplacements, frontend);
   copyDir(
     frontend.dir,
@@ -1102,7 +1401,7 @@ async function scaffold({
     frontend.meta.type,
     appName
   );
-  const backendDest = path2.join(targetDir, "packages", "backend");
+  const backendDest = path4.join(targetDir, "packages", "backend");
   const backendReplacements = buildReplacements(baseReplacements, backend);
   copyDir(
     backend.dir,
@@ -1114,8 +1413,8 @@ async function scaffold({
   const runtimeVersions = backend.meta.runtimeVersions ?? {};
   if (Object.keys(runtimeVersions).length > 0) {
     const toolVersions = Object.entries(runtimeVersions).map(([tool, version]) => `${tool} ${version}`).join("\n");
-    fs2.writeFileSync(
-      path2.join(targetDir, ".tool-versions"),
+    fs4.writeFileSync(
+      path4.join(targetDir, ".tool-versions"),
       toolVersions + "\n"
     );
   }
@@ -1132,39 +1431,40 @@ async function scaffold({
       build: "turbo build",
       lint: "turbo lint",
       test: "turbo test",
-      register: "npx -y @jtl-software/create-cloud-app@latest register"
+      register: "npx -y @jtl-software/create-cloud-app@latest register",
+      listing: "npx -y @jtl-software/create-cloud-app@latest listing"
     },
     packageManager: "npm@10.8.2",
     devDependencies: {
       turbo: "^2.5.5"
     }
   };
-  fs2.writeFileSync(
-    path2.join(targetDir, "package.json"),
+  fs4.writeFileSync(
+    path4.join(targetDir, "package.json"),
     JSON.stringify(rootPackageJson, null, 2) + "\n"
   );
 }
 
 // src/templates.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 function discoverTemplates() {
   const cliPkgPath = require2.resolve("@jtl-software/create-cloud-app/package.json");
-  const cliPkg = JSON.parse(fs3.readFileSync(cliPkgPath, "utf-8"));
+  const cliPkg = JSON.parse(fs5.readFileSync(cliPkgPath, "utf-8"));
   const deps = cliPkg.dependencies ?? {};
   const templates = [];
   for (const packageName of Object.keys(deps)) {
     if (!packageName.startsWith("@jtl-software/cloud-app-template-")) continue;
     try {
       const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-      const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf-8"));
       const meta = pkg.cloudAppTemplate;
       if (!meta?.type) continue;
       templates.push({
         packageName,
-        dir: path3.dirname(pkgJsonPath),
+        dir: path5.dirname(pkgJsonPath),
         meta
       });
     } catch {
@@ -1176,21 +1476,29 @@ function getTemplatesByType(templates, type) {
   return templates.filter((t) => t.meta.type === type);
 }
 
+// src/posthog.ts
+import { PostHog } from "posthog-node";
+var TOKEN = "phc_SkFAxTIa4RUQxotci1Ftdw7xefZK2Ax0LEIGcl8zuD2";
+var client = TOKEN ? new PostHog(TOKEN, { host: "https://e.jtl-cloud.com" }) : null;
+async function shutdownPostHog() {
+  await client?.shutdown();
+}
+
 // src/index.ts
 async function runScaffold() {
   console.log();
-  p2.intro(pc2.bgCyan(pc2.black(" create-cloud-app ")));
+  p4.intro(pc4.bgCyan(pc4.black(" create-cloud-app ")));
   const templates = discoverTemplates();
   const backends = getTemplatesByType(templates, "backend");
   const frontends = getTemplatesByType(templates, "frontend");
   const shared = templates.find((t) => t.meta.type === "shared");
   if (!backends.length || !frontends.length || !shared) {
-    p2.cancel("No templates found. Ensure template packages are installed.");
+    p4.cancel("No templates found. Ensure template packages are installed.");
     process.exit(1);
   }
-  const answers = await p2.group(
+  const answers = await p4.group(
     {
-      appName: () => p2.text({
+      appName: () => p4.text({
         message: "App name",
         placeholder: "my-jtl-app",
         validate: (value) => {
@@ -1199,11 +1507,11 @@ async function runScaffold() {
             return "Use lowercase letters, numbers, and hyphens only";
         }
       }),
-      description: () => p2.text({
+      description: () => p4.text({
         message: "Description",
         placeholder: "A JTL Platform app"
       }),
-      backend: () => p2.select({
+      backend: () => p4.select({
         message: "Backend",
         options: backends.map((t) => ({
           value: t.packageName,
@@ -1211,7 +1519,7 @@ async function runScaffold() {
           hint: t.meta.hint
         }))
       }),
-      frontend: () => p2.select({
+      frontend: () => p4.select({
         message: "Frontend",
         options: frontends.map((t) => ({
           value: t.packageName,
@@ -1222,7 +1530,7 @@ async function runScaffold() {
     },
     {
       onCancel: () => {
-        p2.cancel("Cancelled.");
+        p4.cancel("Cancelled.");
         process.exit(0);
       }
     }
@@ -1233,7 +1541,7 @@ async function runScaffold() {
   const selectedFrontend = templates.find(
     (t) => t.packageName === answers.frontend
   );
-  const s = p2.spinner();
+  const s = p4.spinner();
   s.start("Scaffolding project");
   await scaffold({
     appName: answers.appName,
@@ -1243,25 +1551,31 @@ async function runScaffold() {
     shared
   });
   s.stop("Project scaffolded");
-  p2.note(
+  p4.note(
     [
-      `${pc2.cyan("cd")} ${answers.appName}`,
-      `${pc2.cyan("npm install")}`,
-      `${pc2.cyan("npm run register")}`,
-      `${pc2.cyan("npm run dev")}`
+      `${pc4.cyan("cd")} ${answers.appName}`,
+      `${pc4.cyan("npm install")}`,
+      `${pc4.cyan("npm run register")}`,
+      `${pc4.cyan("npm run dev")}`,
+      `${pc4.cyan("npm run listing")} ${pc4.dim("(once you're ready to publish)")}`
     ].join("\n"),
     "Next steps"
   );
-  p2.outro(pc2.green("Done! Happy building."));
+  p4.outro(pc4.green("Done! Happy building."));
 }
 async function main() {
   if (process.argv[2] === "register") {
     await register(process.argv.slice(3));
     return;
   }
+  if (process.argv[2] === "listing") {
+    await listing(process.argv.slice(3));
+    return;
+  }
   await runScaffold();
 }
-main().catch((err) => {
+main().then(() => shutdownPostHog()).catch(async (err) => {
+  await shutdownPostHog();
   if (err instanceof BailError) {
     process.exit(1);
   }