@bluealba/platform-cli 0.3.1-feature-platform-cli-223 → 0.3.1-feature-platform-cli-225

package/dist/index.js

@@ -5,8 +5,8 @@ import { render } from "ink";
 
 // src/app.tsx
 import { createRequire } from "module";
-import { useState as useState3, useCallback as useCallback2 } from "react";
-import { Box as Box4, Text as Text7, useApp, useInput } from "ink";
+import { useState as useState3, useCallback as useCallback2, useEffect as useEffect2 } from "react";
+import { Box as Box6, Text as Text9, useApp, useInput } from "ink";
 
 // src/components/prompt.tsx
 import { Box, Text } from "ink";
@@ -143,6 +143,31 @@ function Spinner({ label }) {
   ] });
 }
 
+// src/components/select-list.tsx
+import React4 from "react";
+import { Box as Box4, Text as Text7 } from "ink";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var SelectList = React4.memo(function SelectList2({ options, selectedIndex }) {
+  if (options.length === 0) {
+    return /* @__PURE__ */ jsx7(Box4, { paddingLeft: 2, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No options available" }) });
+  }
+  return /* @__PURE__ */ jsx7(Box4, { flexDirection: "column", paddingLeft: 2, children: options.map((opt, i) => {
+    const isSelected = i === selectedIndex;
+    return /* @__PURE__ */ jsx7(Box4, { children: /* @__PURE__ */ jsx7(Text7, { color: "cyan", bold: isSelected, inverse: isSelected, children: opt.label }) }, opt.value);
+  }) });
+});
+
+// src/components/confirm-prompt.tsx
+import { Box as Box5, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function ConfirmPrompt({ value }) {
+  return /* @__PURE__ */ jsxs6(Box5, { gap: 2, paddingLeft: 2, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: value, inverse: value, children: "Yes" }),
+    /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: !value, inverse: !value, children: "No" }),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "(\u2190/\u2192 to toggle, Enter to confirm)" })
+  ] });
+}
+
 // src/commands/registry.ts
 import { Fzf } from "fzf";
 
@@ -254,7 +279,12 @@ async function scaffoldBootstrap(bootstrapServiceDir, organizationName, bootstra
     {
       templateDir: bootstrapTemplateDir,
       outputDir: bootstrapServiceDir,
-      variables: { organizationName, bootstrapName, bootstrapServiceDir: bootstrapServiceDir_var },
+      variables: {
+        organizationName,
+        bootstrapName,
+        bootstrapServiceName: `${bootstrapName}-bootstrap-service`,
+        bootstrapServiceDir: bootstrapServiceDir_var
+      },
       exclude: ["src/data/shared-libraries.json", "src/data/platform/modules-config.json"]
     },
     (message) => logger.log(message)
@@ -358,8 +388,8 @@ function buildServiceModuleEntry(organizationName, platformName, applicationName
     dependsOn: []
   };
 }
-function buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName) {
-  const uiName = `${platformName}-${applicationName}-ui`;
+function buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName, uiNameOverride) {
+  const uiName = uiNameOverride ?? `${platformName}-${applicationName}-ui`;
   return {
     name: `@${organizationName}/${uiName}`,
     displayName: applicationDisplayName,
@@ -791,7 +821,8 @@ async function generateLocalEnv(outputDir, logger, coreDirName = "core") {
 var INIT_COMMAND_NAME = "init";
 var initCommand = {
   name: INIT_COMMAND_NAME,
-  description: "Initialize a new platform"
+  description: "Initialize a new platform",
+  hidden: ({ platformInitialized }) => platformInitialized
 };
 async function init(params, logger) {
   if (await isPlatformInitialized()) {
@@ -803,14 +834,18 @@ async function init(params, logger) {
   const outputDir = cwd4();
   logger.log(`Initializing ${platformTitle} platform for @${organizationName}...`);
   const coreDirName = `${platformName}-core`;
-  const bootstrapServiceName = `${platformName}-bootstrap-service`;
-  const customizationUiName = `${platformName}-customization-ui`;
+  const bootstrapSuffix = params.bootstrapServiceSuffix ?? "bootstrap-service";
+  const customizationUiSuffix = params.customizationUiSuffix ?? "customization-ui";
+  const bootstrapServiceName = `${platformName}-${bootstrapSuffix}`;
+  const customizationUiName = `${platformName}-${customizationUiSuffix}`;
   const variables = {
     organizationName,
     platformName,
     platformTitle,
     platformDisplayName,
     bootstrapName: platformName,
+    bootstrapServiceName,
+    customizationUiName,
     bootstrapServiceDir: `${coreDirName}/services`
   };
   try {
@@ -1077,7 +1112,7 @@ var createServiceModuleCommand = {
   description: "Add a new service module to an existing application"
 };
 async function createServiceModule(params, logger) {
-  const { applicationName, serviceName, serviceDisplayName } = params;
+  const { applicationName, serviceName, serviceDisplayName, serviceNameSuffix } = params;
   const layout = await findPlatformLayout();
   if (!layout) {
     logger.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
@@ -1104,7 +1139,8 @@ async function createServiceModule(params, logger) {
     logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
-  const fullServiceName = `${platformName}-${serviceName}-service`;
+  const suffix = serviceNameSuffix === void 0 ? "service" : serviceNameSuffix;
+  const fullServiceName = suffix ? `${platformName}-${serviceName}-${suffix}` : `${platformName}-${serviceName}`;
   const serviceDir = join20(applicationDir, "services", fullServiceName);
   try {
     await access3(serviceDir);
@@ -1141,8 +1177,8 @@ import { access as access4, readdir as readdir4 } from "fs/promises";
 
 // src/commands/create-ui-module/append-ui-docker-compose.ts
 import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
-async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger) {
-  const uiName = `${platformName}-${applicationName}-ui`;
+async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger, uiNameOverride) {
+  const uiName = uiNameOverride ?? `${platformName}-${applicationName}-ui`;
   const block = `
   ${uiName}:
     build:
@@ -1170,7 +1206,7 @@ var createUiModuleCommand = {
   description: "Add a UI module to an existing application"
 };
 async function createUiModule(params, logger) {
-  const { applicationName, applicationDisplayName } = params;
+  const { applicationName, applicationDisplayName, uiModuleSuffix } = params;
   const layout = await findPlatformLayout();
   if (!layout) {
     logger.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
@@ -1207,7 +1243,8 @@ async function createUiModule(params, logger) {
     }
   } catch {
   }
-  const uiName = `${platformName}-${applicationName}-ui`;
+  const uiSuffix = uiModuleSuffix === void 0 ? "ui" : uiModuleSuffix;
+  const uiName = uiSuffix ? `${platformName}-${applicationName}-${uiSuffix}` : `${platformName}-${applicationName}`;
   const uiOutputDir = join21(uiDir, uiName);
   const uiBaseDir = `${platformName}-${applicationName}/ui`;
   try {
@@ -1217,14 +1254,275 @@ async function createUiModule(params, logger) {
     return;
   }
   const bootstrapServiceDir = join21(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
-  const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName);
+  const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName, uiName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
   const dockerComposePath = join21(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const port = await getNextAvailablePort(localDir);
-  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger);
+  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger, uiName);
   logger.log(`Done! UI module "${uiName}" added to application "${applicationName}".`);
 }
 
+// src/commands/status/status-checks.ts
+import { spawn } from "child_process";
+import { access as access5 } from "fs/promises";
+import { join as join22, resolve as resolve4 } from "path";
+function spawnCapture(cmd, args2, cwd5) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(cmd, args2, {
+      cwd: cwd5,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? 1, stdout, stderr });
+    });
+    child.on("error", () => {
+      resolvePromise({ code: 1, stdout, stderr });
+    });
+  });
+}
+async function pathExists(p) {
+  try {
+    await access5(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkNodeVersion() {
+  const { code, stdout } = await spawnCapture("node", ["--version"]);
+  if (code !== 0 || !stdout.trim()) {
+    return { name: "Node.js", available: false, version: null, versionOk: false, detail: "not found in PATH" };
+  }
+  const version2 = stdout.trim();
+  const match = version2.match(/^v(\d+)/);
+  const major = match ? parseInt(match[1], 10) : 0;
+  const versionOk = major >= 22;
+  return {
+    name: "Node.js",
+    available: true,
+    version: version2,
+    versionOk,
+    detail: versionOk ? void 0 : `>=22 required, found ${version2}`
+  };
+}
+async function checkDocker() {
+  const { code, stdout } = await spawnCapture("docker", ["info", "--format", "{{.ServerVersion}}"]);
+  if (code === 0 && stdout.trim()) {
+    return { name: "Docker", available: true, version: stdout.trim(), versionOk: true };
+  }
+  const { code: vCode, stdout: vOut } = await spawnCapture("docker", ["--version"]);
+  if (vCode === 0 && vOut.trim()) {
+    return {
+      name: "Docker",
+      available: false,
+      version: null,
+      versionOk: false,
+      detail: "installed but daemon is not running"
+    };
+  }
+  return { name: "Docker", available: false, version: null, versionOk: false, detail: "not found in PATH" };
+}
+async function checkInstalled(layout, manifest) {
+  const results = [];
+  const coreCheck = {
+    name: layout.coreDirName,
+    path: join22(layout.coreDir, "node_modules"),
+    exists: await pathExists(join22(layout.coreDir, "node_modules"))
+  };
+  results.push(coreCheck);
+  for (const app of manifest.applications) {
+    const appDir = resolve4(layout.coreDir, app.localPath);
+    const nodeModulesPath = join22(appDir, "node_modules");
+    results.push({
+      name: app.name,
+      path: nodeModulesPath,
+      exists: await pathExists(nodeModulesPath)
+    });
+  }
+  return results;
+}
+async function checkBuilt(layout, manifest) {
+  const results = [];
+  const coreTurboPath = join22(layout.coreDir, ".turbo");
+  results.push({
+    name: layout.coreDirName,
+    path: coreTurboPath,
+    exists: await pathExists(coreTurboPath)
+  });
+  for (const app of manifest.applications) {
+    const appDir = resolve4(layout.coreDir, app.localPath);
+    const appTurboPath = join22(appDir, ".turbo");
+    results.push({
+      name: app.name,
+      path: appTurboPath,
+      exists: await pathExists(appTurboPath)
+    });
+  }
+  return results;
+}
+async function resolveComposeFiles(layout, manifest) {
+  const { localDir, coreDirName } = layout;
+  const platformName = manifest.product.name;
+  const files = [join22(localDir, "platform-docker-compose.yml")];
+  const prefixedCore = join22(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCore = join22(localDir, "core-docker-compose.yml");
+  files.push(await pathExists(prefixedCore) ? prefixedCore : unprefixedCore);
+  for (const app of manifest.applications) {
+    const prefixed = join22(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixed = join22(localDir, `${app.name}-docker-compose.yml`);
+    if (await pathExists(prefixed)) files.push(prefixed);
+    else if (await pathExists(unprefixed)) files.push(unprefixed);
+  }
+  return files;
+}
+async function checkContainers(layout, manifest) {
+  const platformName = manifest.product.name;
+  const projectName = `${platformName}-platform`;
+  const composeFiles = await resolveComposeFiles(layout, manifest);
+  const fileArgs = composeFiles.flatMap((f) => ["-f", f]);
+  const { code: cfgCode, stdout: cfgOut } = await spawnCapture(
+    "docker",
+    ["compose", "-p", projectName, ...fileArgs, "config", "--services"],
+    layout.rootDir
+  );
+  const expectedServices = cfgCode === 0 ? cfgOut.trim().split("\n").map((s) => s.trim()).filter(Boolean) : [];
+  const { stdout: psOut } = await spawnCapture(
+    "docker",
+    ["compose", "-p", projectName, ...fileArgs, "ps", "--format", "json"],
+    layout.rootDir
+  );
+  const runningByService = /* @__PURE__ */ new Map();
+  for (const line of psOut.trim().split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      const service = String(obj["Service"] ?? obj["Name"] ?? "");
+      if (service) {
+        runningByService.set(service, {
+          state: String(obj["State"] ?? "unknown").toLowerCase(),
+          ports: String(obj["Publishers"] ? formatPublishers(obj["Publishers"]) : obj["Ports"] ?? "")
+        });
+      }
+    } catch {
+    }
+  }
+  if (expectedServices.length > 0) {
+    return expectedServices.map((service) => {
+      const actual = runningByService.get(service);
+      return {
+        name: service,
+        state: actual ? actual.state : "not started",
+        ports: actual ? actual.ports : ""
+      };
+    });
+  }
+  return Array.from(runningByService.entries()).map(([name, info]) => ({
+    name,
+    ...info
+  }));
+}
+function formatPublishers(publishers) {
+  if (!Array.isArray(publishers)) return "";
+  return publishers.map((p) => {
+    if (typeof p !== "object" || p === null) return "";
+    const pub = p;
+    const host = pub["URL"] ?? "0.0.0.0";
+    const published = pub["PublishedPort"];
+    const target = pub["TargetPort"];
+    const proto = pub["Protocol"] ?? "tcp";
+    if (!published || !target) return "";
+    return `${host}:${published}->${target}/${proto}`;
+  }).filter(Boolean).join(", ");
+}
+function computeNextStep(result) {
+  if (!result.lifecycle.initialized) return "init";
+  if (!result.lifecycle.installed) return "install";
+  if (!result.lifecycle.built) return "build";
+  if (!result.lifecycle.running) return "start";
+  return null;
+}
+async function gatherStatus() {
+  const layout = await findPlatformLayout();
+  const [nodeCheck, dockerCheck] = await Promise.all([checkNodeVersion(), checkDocker()]);
+  const prerequisites = [nodeCheck, dockerCheck];
+  if (!layout) {
+    return {
+      projectInfo: null,
+      prerequisites,
+      lifecycle: {
+        initialized: false,
+        installed: false,
+        installedDetails: [],
+        built: false,
+        builtDetails: [],
+        running: false
+      },
+      containers: []
+    };
+  }
+  let manifest;
+  try {
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  } catch {
+    return {
+      projectInfo: null,
+      prerequisites,
+      lifecycle: {
+        initialized: true,
+        installed: false,
+        installedDetails: [],
+        built: false,
+        builtDetails: [],
+        running: false
+      },
+      containers: []
+    };
+  }
+  const [installedDetails, builtDetails, containers] = await Promise.all([
+    checkInstalled(layout, manifest),
+    checkBuilt(layout, manifest),
+    checkContainers(layout, manifest)
+  ]);
+  const projectInfo = {
+    productName: manifest.product.name,
+    displayName: manifest.product.displayName,
+    organization: manifest.product.organization,
+    scope: manifest.product.scope,
+    applicationCount: manifest.applications.length,
+    applicationNames: manifest.applications.map((a) => a.name)
+  };
+  return {
+    projectInfo,
+    prerequisites,
+    lifecycle: {
+      initialized: true,
+      installed: installedDetails.every((d) => d.exists),
+      installedDetails,
+      built: builtDetails.every((d) => d.exists),
+      builtDetails,
+      running: containers.length > 0 && containers.every((c) => c.state === "running")
+    },
+    containers
+  };
+}
+
+// src/commands/status/status.command.ts
+var STATUS_COMMAND_NAME = "status";
+var statusCommand = {
+  name: STATUS_COMMAND_NAME,
+  description: "Show platform status and health checks"
+};
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -1245,6 +1543,14 @@ var CommandRegistry = class {
     });
     return fzf.find(query).map((result) => result.item);
   }
+  searchVisible(query, visibilityCtx) {
+    const visible = this.getAll().filter((cmd) => !cmd.hidden?.(visibilityCtx));
+    if (!query) return visible;
+    const fzf = new Fzf(visible, {
+      selector: (cmd) => `${cmd.name} ${cmd.description}`
+    });
+    return fzf.find(query).map((result) => result.item);
+  }
 };
 var registry = new CommandRegistry();
 registry.register(createApplicationCommand);
@@ -1252,6 +1558,7 @@ registry.register(initCommand);
 registry.register(configureIdpCommand);
 registry.register(createServiceModuleCommand);
 registry.register(createUiModuleCommand);
+registry.register(statusCommand);
 
 // src/app-state.ts
 var APP_STATE = {
@@ -1282,23 +1589,15 @@ async function createApplicationUiController(ctx) {
   }
   const applicationDisplayName = await ctx.prompt("Application display name:");
   const applicationDescription = await ctx.prompt("Application description:");
-  const hasUserInterfaceAnswer = await ctx.prompt("Does this application have a user interface? (yes/no):");
-  if (hasUserInterfaceAnswer !== "yes" && hasUserInterfaceAnswer !== "no") {
-    ctx.log(`Error: Please answer "yes" or "no".`);
-    return;
-  }
-  const hasBackendServiceAnswer = await ctx.prompt("Does this application have a backend service? (yes/no):");
-  if (hasBackendServiceAnswer !== "yes" && hasBackendServiceAnswer !== "no") {
-    ctx.log(`Error: Please answer "yes" or "no".`);
-    return;
-  }
+  const hasUserInterface = await ctx.confirm("Does this application have a user interface?");
+  const hasBackendService = await ctx.confirm("Does this application have a backend service?");
   await createApplicationService(
     {
       applicationName,
       applicationDisplayName,
       applicationDescription,
-      hasUserInterface: hasUserInterfaceAnswer === "yes",
-      hasBackendService: hasBackendServiceAnswer === "yes"
+      hasUserInterface,
+      hasBackendService
     },
     ctx
   );
@@ -1318,7 +1617,32 @@ async function initUiController(ctx) {
   const organizationName = await ctx.prompt("Organization name:");
   const platformName = await ctx.prompt("Platform name:");
   const platformDisplayName = await ctx.prompt("Platform display name:");
-  await initService({ organizationName, platformName, platformDisplayName }, ctx);
+  const defaultBootstrapSuffix = "bootstrap-service";
+  const defaultCustomizationUiSuffix = "customization-ui";
+  ctx.log(`Default artifact names:`);
+  ctx.log(`  Bootstrap service: ${platformName}-${defaultBootstrapSuffix}`);
+  ctx.log(`  Customization UI:  ${platformName}-${defaultCustomizationUiSuffix}`);
+  const customize = await ctx.confirm("Customize artifact names?", false);
+  let bootstrapServiceSuffix = defaultBootstrapSuffix;
+  let customizationUiSuffix = defaultCustomizationUiSuffix;
+  if (customize) {
+    const bsSuffix = await ctx.prompt(`Bootstrap service suffix (${platformName}-...):`, defaultBootstrapSuffix);
+    if (!/^[a-z0-9-]+$/.test(bsSuffix)) {
+      ctx.log(`Error: Suffix "${bsSuffix}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+      return;
+    }
+    bootstrapServiceSuffix = bsSuffix;
+    const cuiSuffix = await ctx.prompt(`Customization UI suffix (${platformName}-...):`, defaultCustomizationUiSuffix);
+    if (!/^[a-z0-9-]+$/.test(cuiSuffix)) {
+      ctx.log(`Error: Suffix "${cuiSuffix}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+      return;
+    }
+    customizationUiSuffix = cuiSuffix;
+  }
+  await initService(
+    { organizationName, platformName, platformDisplayName, bootstrapServiceSuffix, customizationUiSuffix },
+    ctx
+  );
 }
 
 // src/services/configure-idp.service.ts
@@ -1333,14 +1657,11 @@ async function configureIdpUiController(ctx) {
     return;
   }
   const providers = getAllProviders();
-  const options = providers.map((p, i) => `${i + 1}: ${p.displayName}`).join(", ");
-  const selectionInput = await ctx.prompt(`Select IDP type (${options}):`);
-  const index = parseInt(selectionInput.trim(), 10) - 1;
-  if (isNaN(index) || index < 0 || index >= providers.length) {
-    ctx.log(`Error: Invalid selection "${selectionInput}"`);
-    return;
-  }
-  const provider = providers[index];
+  const providerType = await ctx.select(
+    "Select IDP type:",
+    providers.map((p) => ({ label: p.displayName, value: p.type }))
+  );
+  const provider = providers.find((p) => p.type === providerType);
   const name = await ctx.prompt("Provider name:");
   const issuer = await ctx.prompt("Issuer URL:");
   const clientId = await ctx.prompt("Client ID:");
@@ -1366,19 +1687,38 @@ async function createServiceModuleUiController(ctx) {
     ctx.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
-  const applicationName = await ctx.prompt("Application name:");
-  if (!/^[a-z0-9-]+$/.test(applicationName)) {
-    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    ctx.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
+  let manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  if (manifest.applications.length === 0) {
+    ctx.log("No applications found in this platform.");
+    const createFirst = await ctx.confirm("Would you like to create an application first?");
+    if (!createFirst) return;
+    await createApplicationUiController(ctx);
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+    if (manifest.applications.length === 0) {
+      ctx.log("Error: No applications available after creation attempt.");
+      return;
+    }
+  }
+  const applicationName = await ctx.select(
+    "Select application:",
+    manifest.applications.map((a) => ({ label: `${a.name} \u2014 ${a.displayName}`, value: a.name }))
+  );
   const serviceName = await ctx.prompt("Service name:");
   if (!/^[a-z0-9-]+$/.test(serviceName)) {
     ctx.log(`Error: Service name "${serviceName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
     return;
   }
+  const platformName = manifest.product.name;
+  const includeSuffix = await ctx.confirm(`Include "-service" suffix? (${platformName}-${serviceName}-service)`, true);
+  const serviceNameSuffix = includeSuffix ? "service" : null;
   const serviceDisplayName = await ctx.prompt("Service display name:");
   await createServiceModuleService(
-    { applicationName, serviceName, serviceDisplayName },
+    { applicationName, serviceName, serviceDisplayName, serviceNameSuffix },
     ctx
   );
 }
@@ -1394,313 +1734,124 @@ async function createUiModuleUiController(ctx) {
     ctx.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
-  const applicationName = await ctx.prompt("Application name:");
-  if (!/^[a-z0-9-]+$/.test(applicationName)) {
-    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    ctx.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
+  let manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  if (manifest.applications.length === 0) {
+    ctx.log("No applications found in this platform.");
+    const createFirst = await ctx.confirm("Would you like to create an application first?");
+    if (!createFirst) return;
+    await createApplicationUiController(ctx);
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+    if (manifest.applications.length === 0) {
+      ctx.log("Error: No applications available after creation attempt.");
+      return;
+    }
+  }
+  const applicationName = await ctx.select(
+    "Select application:",
+    manifest.applications.map((a) => ({ label: `${a.name} \u2014 ${a.displayName}`, value: a.name }))
+  );
+  const platformName = manifest.product.name;
+  const includeSuffix = await ctx.confirm(`Include "-ui" suffix? (${platformName}-${applicationName}-ui)`, true);
+  const uiModuleSuffix = includeSuffix ? "ui" : null;
   const applicationDisplayName = await ctx.prompt("Application display name:");
   await createUiModuleService(
-    { applicationName, applicationDisplayName },
+    { applicationName, applicationDisplayName, uiModuleSuffix },
     ctx
   );
 }
 
-// src/controllers/ui/registry.ts
-var uiControllers = /* @__PURE__ */ new Map([
-  [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
-  [INIT_COMMAND_NAME, initUiController],
-  [CONFIGURE_IDP_COMMAND_NAME, configureIdpUiController],
-  [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleUiController],
-  [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleUiController]
-]);
+// src/services/status.service.ts
+async function statusService() {
+  return gatherStatus();
+}
+
+// src/utils/theme.ts
+import chalk from "chalk";
+var theme = {
+  prompt: chalk.green,
+  commandName: chalk.cyan,
+  commandDescription: chalk.gray,
+  selected: chalk.bgBlue.white,
+  output: chalk.white,
+  muted: chalk.dim,
+  error: chalk.red,
+  success: chalk.green,
+  warning: chalk.yellow,
+  info: chalk.cyan,
+  section: chalk.bold.white,
+  label: chalk.dim
+};
 
-// src/hooks/use-command-runner.ts
-function useCommandRunner({ appendStaticItem, setState }) {
-  const outputCountRef = useRef(0);
-  const abortControllerRef = useRef(null);
-  const promptResolveRef = useRef(null);
-  const [promptMessage, setPromptMessage] = useState2("");
-  const [promptValue, setPromptValue] = useState2("");
-  const abortExecution = useCallback(() => {
-    abortControllerRef.current?.abort();
-    abortControllerRef.current = null;
-    promptResolveRef.current = null;
-  }, []);
-  const runCommand2 = useCallback(
-    (cmd) => {
-      const controller = new AbortController();
-      abortControllerRef.current = controller;
-      setState(APP_STATE.EXECUTING);
-      const ctx = {
-        signal: controller.signal,
-        log(message) {
-          if (!controller.signal.aborted) {
-            const id = `output-${outputCountRef.current++}`;
-            appendStaticItem({ kind: "output", id, line: message });
-          }
-        },
-        prompt(message) {
-          return new Promise((resolve5, reject) => {
-            if (controller.signal.aborted) {
-              reject(new DOMException("Aborted", "AbortError"));
-              return;
-            }
-            setPromptMessage(message);
-            setPromptValue("");
-            promptResolveRef.current = resolve5;
-            setState(APP_STATE.PROMPTING);
-            controller.signal.addEventListener(
-              "abort",
-              () => reject(new DOMException("Aborted", "AbortError")),
-              { once: true }
-            );
-          });
-        }
-      };
-      const uiController = uiControllers.get(cmd.name);
-      if (!uiController) {
-        const id = `output-${outputCountRef.current++}`;
-        appendStaticItem({ kind: "output", id, line: `Error: No controller found for "${cmd.name}"` });
-        setState(APP_STATE.IDLE);
-        return;
+// src/commands/status/status-formatter.ts
+var CHECK = theme.success("\u2713");
+var CROSS = theme.error("\u2717");
+function tick(ok) {
+  return ok ? CHECK : CROSS;
+}
+function formatStatusLines(result) {
+  const lines = [];
+  if (result.projectInfo) {
+    const p = result.projectInfo;
+    lines.push(theme.info("\u25B8 ") + theme.section(p.displayName) + theme.label(` (${p.productName})`));
+    lines.push(theme.label("  Organization: ") + p.organization + theme.label(` (${p.scope})`));
+    const appList = p.applicationNames.length > 0 ? p.applicationNames.join(", ") : "(none)";
+    lines.push(theme.label("  Applications: ") + `${p.applicationCount} \u2014 ` + appList);
+    lines.push("");
+  }
+  lines.push(theme.section("Prerequisites"));
+  for (const pre of result.prerequisites) {
+    const ok = pre.available && pre.versionOk;
+    const versionStr = pre.version ? theme.label(` ${pre.version}`) : "";
+    const detailStr = pre.detail ? theme.warning(` \u2014 ${pre.detail}`) : "";
+    lines.push(`  ${tick(ok)} ${pre.name}${versionStr}${detailStr}`);
+  }
+  lines.push("");
+  lines.push(theme.section("Lifecycle"));
+  lines.push(`  ${tick(result.lifecycle.initialized)} Platform initialized`);
+  const installed = result.lifecycle.installed;
+  lines.push(`  ${tick(installed)} Dependencies installed`);
+  if (!installed && result.lifecycle.installedDetails.length > 0) {
+    for (const d of result.lifecycle.installedDetails) {
+      if (!d.exists) {
+        lines.push(`    ${CROSS} ${theme.label(d.name)} ${theme.warning("(missing node_modules/)")}`);
       }
-      uiController(ctx).then(() => {
-        if (!controller.signal.aborted) {
-          setState(APP_STATE.IDLE);
-        }
-      }).catch((err) => {
-        if (controller.signal.aborted) return;
-        const id = `output-${outputCountRef.current++}`;
-        appendStaticItem({ kind: "output", id, line: `Error: ${formatError(err)}` });
-        setState(APP_STATE.IDLE);
-      });
-    },
-    [appendStaticItem, setState]
-  );
-  const handlePromptSubmit = useCallback(
-    (value) => {
-      const resolve5 = promptResolveRef.current;
-      promptResolveRef.current = null;
-      setState(APP_STATE.EXECUTING);
-      resolve5?.(value);
-    },
-    [setState]
-  );
-  return {
-    runCommand: runCommand2,
-    handlePromptSubmit,
-    abortExecution,
-    promptMessage,
-    promptValue,
-    setPromptValue
-  };
-}
-
-// src/app.tsx
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
-function App() {
-  const { exit } = useApp();
-  const [state, setState] = useState3(APP_STATE.IDLE);
-  const [inputValue, setInputValue] = useState3("");
-  const [selectedIndex, setSelectedIndex] = useState3(0);
-  const [staticItems, setStaticItems] = useState3([{ kind: "banner", id: "banner" }]);
-  const appendStaticItem = useCallback2((item) => {
-    setStaticItems((prev) => [...prev, item]);
-  }, []);
-  const { runCommand: runCommand2, handlePromptSubmit, abortExecution, promptMessage, promptValue, setPromptValue } = useCommandRunner({ appendStaticItem, setState });
-  const query = inputValue.startsWith("/") ? inputValue.slice(1) : "";
-  const filteredCommands = registry.search(query);
-  useInput(
-    (input, key) => {
-      if (key.ctrl && input === "c") {
-        exit();
-        return;
-      }
-      if ((state === APP_STATE.EXECUTING || state === APP_STATE.PROMPTING) && key.escape) {
-        abortExecution();
-        setState(APP_STATE.IDLE);
-        return;
-      }
-      if (state === APP_STATE.PALETTE) {
-        if (key.escape) {
-          setState(APP_STATE.IDLE);
-          setInputValue("");
-          return;
-        }
-        if (key.upArrow) {
-          setSelectedIndex((prev) => Math.max(0, prev - 1));
-          return;
-        }
-        if (key.downArrow) {
-          setSelectedIndex((prev) => Math.min(filteredCommands.length - 1, prev + 1));
-          return;
-        }
-        if (key.return) {
-          const cmd = filteredCommands[selectedIndex];
-          if (cmd) {
-            setInputValue("");
-            runCommand2(cmd);
-          }
-          return;
-        }
-        if (key.backspace || key.delete) {
-          setInputValue((prev) => {
-            const next = prev.slice(0, -1);
-            if (!next.startsWith("/")) {
-              setState(APP_STATE.IDLE);
-              return "";
-            }
-            return next;
-          });
-          setSelectedIndex(0);
-          return;
-        }
-        if (input && !key.ctrl && !key.meta) {
-          setInputValue((prev) => prev + input);
-          setSelectedIndex(0);
-        }
-      }
-    },
-    { isActive: true }
-  );
-  const handleIdleInputChange = useCallback2((value) => {
-    setInputValue(value);
-    if (value.startsWith("/")) {
-      setState(APP_STATE.PALETTE);
-      setSelectedIndex(0);
-    }
-  }, []);
-  const handleIdleSubmit = useCallback2(
-    (value) => {
-      if (!value.startsWith("/")) return;
-      const name = value.slice(1).trim();
-      const cmd = registry.get(name);
-      if (cmd) runCommand2(cmd);
-    },
-    [runCommand2]
-  );
-  function renderActiveArea() {
-    switch (state) {
-      case APP_STATE.EXECUTING:
-        return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "row", gap: 1, children: [
-          /* @__PURE__ */ jsx7(Spinner, { label: "Running\u2026" }),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "(esc to cancel)" })
-        ] });
-      case APP_STATE.PROMPTING:
-        return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: promptMessage }),
-          /* @__PURE__ */ jsx7(Prompt, { value: promptValue, onChange: setPromptValue, onSubmit: handlePromptSubmit })
-        ] });
-      default:
-        return /* @__PURE__ */ jsx7(
-          Prompt,
-          {
-            value: inputValue,
-            onChange: state === APP_STATE.IDLE ? handleIdleInputChange : () => {
-            },
-            onSubmit: state === APP_STATE.IDLE ? handleIdleSubmit : () => {
-            },
-            disabled: state === APP_STATE.PALETTE
-          }
-        );
-    }
-  }
-  return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx7(ScrollbackHistory, { items: staticItems, version }),
-    renderActiveArea(),
-    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx7(CommandPalette, { commands: filteredCommands, selectedIndex })
-  ] });
-}
-
-// src/controllers/cli/create-application.cli-controller.ts
-async function createApplicationCliController(args2) {
-  if (!await isPlatformInitialized()) {
-    console.error("Error: Cannot create an application \u2014 no platform initialized in this directory.");
-    process.exit(1);
-  }
-  const {
-    applicationName,
-    applicationDisplayName,
-    applicationDescription,
-    hasUserInterface,
-    hasBackendService
-  } = args2;
-  if (!applicationName || !applicationDisplayName || !applicationDescription) {
-    console.error("Error: applicationName, applicationDisplayName, and applicationDescription are required.");
-    process.exit(1);
-  }
-  if (!/^[a-z0-9-]+$/.test(applicationName)) {
-    console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
-    process.exit(1);
-  }
-  await createApplicationService(
-    {
-      applicationName,
-      applicationDisplayName,
-      applicationDescription,
-      hasUserInterface: hasUserInterface === "yes",
-      hasBackendService: hasBackendService === "yes"
-    },
-    { log: console.log }
-  );
-}
-
-// src/controllers/cli/init.cli-controller.ts
-async function initCliController(args2) {
-  if (await isPlatformInitialized()) {
-    console.error("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
-    process.exit(1);
-  }
-  const { organizationName, platformName, platformDisplayName } = args2;
-  if (!organizationName || !platformName || !platformDisplayName) {
-    console.error("Error: organizationName, platformName, and platformDisplayName are required.");
-    process.exit(1);
-  }
-  await initService(
-    { organizationName, platformName, platformDisplayName },
-    { log: console.log }
-  );
-}
-
-// src/controllers/cli/configure-idp.cli-controller.ts
-async function configureIdpCliController(args2) {
-  const logger = { log: console.log };
-  if (!await isPlatformInitialized()) {
-    console.error("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
-    process.exit(1);
-  }
-  const { providerType, name, issuer, clientId, clientSecret } = args2;
-  if (!providerType || !name || !issuer || !clientId || !clientSecret) {
-    logger.log("Error: Missing required arguments: providerType, name, issuer, clientId, clientSecret");
-    process.exit(1);
-  }
-  const provider = idpProviderRegistry.get(providerType);
-  if (!provider) {
-    logger.log(`Error: Unknown IDP type "${providerType}"`);
-    process.exit(1);
-  }
-  const extras = {};
-  for (const field of provider.fields) {
-    const value = args2[field.key];
-    if (!value) {
-      logger.log(`Error: Missing required argument for ${providerType}: ${field.key}`);
-      process.exit(1);
-    }
-    extras[field.key] = value;
-  }
-  await configureIdpService({ providerType, name, issuer, clientId, clientSecret, extras }, logger);
+    }
+  }
+  const built = result.lifecycle.built;
+  lines.push(`  ${tick(built)} Build completed`);
+  if (!built && result.lifecycle.builtDetails.length > 0) {
+    for (const d of result.lifecycle.builtDetails) {
+      if (!d.exists) {
+        lines.push(`    ${CROSS} ${theme.label(d.name)} ${theme.warning("(missing .turbo/)")}`);
+      }
+    }
+  }
+  lines.push(`  ${tick(result.lifecycle.running)} Environment running`);
+  if (result.containers.length > 0) {
+    lines.push("");
+    lines.push(theme.section("Containers"));
+    for (const c of result.containers) {
+      const ok = c.state === "running";
+      const stateStr = ok ? theme.success(c.state) : c.state === "not started" ? theme.label(c.state) : theme.error(c.state);
+      const ports = c.ports ? theme.label(`   ${c.ports}`) : "";
+      lines.push(`  ${tick(ok)} ${c.name.padEnd(35)} ${stateStr}${ports}`);
+    }
+  }
+  return lines;
 }
 
 // src/commands/local-scripts/docker-compose-orchestrator.ts
-import { spawn } from "child_process";
-import { access as access5 } from "fs/promises";
-import { join as join22 } from "path";
+import { spawn as spawn2 } from "child_process";
+import { access as access6 } from "fs/promises";
+import { join as join23 } from "path";
 function runDockerCompose(args2, logger, rootDir, signal) {
   return new Promise((resolvePromise) => {
-    const child = spawn("docker", ["compose", ...args2], {
+    const child = spawn2("docker", ["compose", ...args2], {
       shell: false,
       stdio: ["ignore", "pipe", "pipe"],
       cwd: rootDir
@@ -1745,15 +1896,15 @@ function runDockerCompose(args2, logger, rootDir, signal) {
 async function getAppComposePaths(localDir, platformName, manifest) {
   const results = [];
   for (const app of manifest.applications) {
-    const prefixedPath = join22(localDir, `${platformName}-${app.name}-docker-compose.yml`);
-    const unprefixedPath = join22(localDir, `${app.name}-docker-compose.yml`);
+    const prefixedPath = join23(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixedPath = join23(localDir, `${app.name}-docker-compose.yml`);
     let resolved = null;
     try {
-      await access5(prefixedPath);
+      await access6(prefixedPath);
       resolved = prefixedPath;
     } catch {
       try {
-        await access5(unprefixedPath);
+        await access6(unprefixedPath);
         resolved = unprefixedPath;
       } catch {
       }
@@ -1767,18 +1918,18 @@ async function getAppComposePaths(localDir, platformName, manifest) {
 async function buildAllComposeArgs(layout, manifest, logger) {
   const { rootDir, coreDirName, localDir } = layout;
   const platformName = manifest.product.name;
-  const prefixedCoreCompose = join22(localDir, `${coreDirName}-docker-compose.yml`);
-  const unprefixedCoreCompose = join22(localDir, "core-docker-compose.yml");
+  const prefixedCoreCompose = join23(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCoreCompose = join23(localDir, "core-docker-compose.yml");
   let coreComposePath;
   try {
-    await access5(prefixedCoreCompose);
+    await access6(prefixedCoreCompose);
     coreComposePath = prefixedCoreCompose;
   } catch {
     coreComposePath = unprefixedCoreCompose;
   }
   const fileArgs = [
     "-f",
-    join22(localDir, "platform-docker-compose.yml"),
+    join23(localDir, "platform-docker-compose.yml"),
     "-f",
     coreComposePath
   ];
@@ -1796,7 +1947,7 @@ async function buildAllComposeArgs(layout, manifest, logger) {
 async function startEnvironment(layout, manifest, logger, signal) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join22(localDir, ".env");
+  const envFile = join23(localDir, ".env");
   const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
   logger.log("Starting environment...");
   await runDockerCompose(
@@ -1821,7 +1972,7 @@ async function startEnvironment(layout, manifest, logger, signal) {
 async function stopEnvironment(layout, manifest, logger, signal) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join22(localDir, ".env");
+  const envFile = join23(localDir, ".env");
   const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
   logger.log("Stopping environment...");
   await runDockerCompose(
@@ -1843,7 +1994,7 @@ async function stopEnvironment(layout, manifest, logger, signal) {
 async function destroyEnvironment(layout, manifest, logger, signal) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join22(localDir, ".env");
+  const envFile = join23(localDir, ".env");
   const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
   logger.log("Destroying environment...");
   await runDockerCompose(
@@ -1867,12 +2018,12 @@ async function destroyEnvironment(layout, manifest, logger, signal) {
 }
 
 // src/commands/local-scripts/npm-orchestrator.ts
-import { spawn as spawn2 } from "child_process";
-import { access as access6 } from "fs/promises";
-import { resolve as resolve4, join as join23 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { access as access7 } from "fs/promises";
+import { resolve as resolve5, join as join24 } from "path";
 function runCommand(command, args2, workDir, logger, signal) {
   return new Promise((resolvePromise) => {
-    const child = spawn2(command, args2, {
+    const child = spawn3(command, args2, {
       cwd: workDir,
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1916,7 +2067,7 @@ function runCommand(command, args2, workDir, logger, signal) {
 }
 async function dirExists(dirPath) {
   try {
-    await access6(dirPath);
+    await access7(dirPath);
     return true;
   } catch {
     return false;
@@ -1926,7 +2077,7 @@ async function installDependencies(layout, manifest, logger, signal) {
   const { coreDir, coreDirName } = layout;
   const appDirs = [];
   for (const app of manifest.applications) {
-    const appDir = resolve4(join23(coreDir), app.localPath);
+    const appDir = resolve5(join24(coreDir), app.localPath);
     if (!await dirExists(appDir)) {
       logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping install.`);
       continue;
@@ -1950,7 +2101,7 @@ async function buildAll(layout, manifest, logger, signal) {
   if (signal?.aborted) return;
   const appDirs = [];
   for (const app of manifest.applications) {
-    const appDir = resolve4(join23(coreDir), app.localPath);
+    const appDir = resolve5(join24(coreDir), app.localPath);
     if (!await dirExists(appDir)) {
       logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping build.`);
       continue;
@@ -2014,6 +2165,431 @@ async function localScriptService(scriptName, logger, signal) {
   await runLocalScript(scriptName, logger, signal);
 }
 
+// src/controllers/ui/status.ui-controller.ts
+async function statusUiController(ctx) {
+  while (true) {
+    const result = await statusService();
+    for (const line of formatStatusLines(result)) {
+      ctx.log(line);
+    }
+    const next = computeNextStep(result);
+    if (next === null) {
+      ctx.log("");
+      ctx.log("All checks passed!");
+      return;
+    }
+    const shouldRun = await ctx.confirm(`Next step: "${next}". Run it now?`, true);
+    if (!shouldRun) return;
+    if (next === "init") {
+      await initUiController(ctx);
+    } else {
+      await localScriptService(next, ctx, ctx.signal);
+    }
+    const resultAfter = await statusService();
+    const nextAfter = computeNextStep(resultAfter);
+    if (nextAfter === next) {
+      ctx.log("");
+      ctx.log(`"${next}" did not complete successfully. Check the output above for errors.`);
+      return;
+    }
+  }
+}
+
+// src/controllers/ui/registry.ts
+var uiControllers = /* @__PURE__ */ new Map([
+  [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
+  [INIT_COMMAND_NAME, initUiController],
+  [CONFIGURE_IDP_COMMAND_NAME, configureIdpUiController],
+  [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleUiController],
+  [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleUiController],
+  [STATUS_COMMAND_NAME, statusUiController]
+]);
+
+// src/hooks/use-command-runner.ts
+function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
+  const outputCountRef = useRef(0);
+  const abortControllerRef = useRef(null);
+  const promptResolveRef = useRef(null);
+  const [promptMessage, setPromptMessage] = useState2("");
+  const [promptValue, setPromptValue] = useState2("");
+  const [promptMode, setPromptMode] = useState2({ kind: "text" });
+  const [selectIndex, setSelectIndex] = useState2(0);
+  const [confirmValue, setConfirmValue] = useState2(true);
+  const abortExecution = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    promptResolveRef.current = null;
+    setPromptMode({ kind: "text" });
+  }, []);
+  const runCommand2 = useCallback(
+    (cmd) => {
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState(APP_STATE.EXECUTING);
+      const ctx = {
+        signal: controller.signal,
+        log(message) {
+          if (!controller.signal.aborted) {
+            const id = `output-${outputCountRef.current++}`;
+            appendStaticItem({ kind: "output", id, line: message });
+          }
+        },
+        prompt(message, defaultValue) {
+          return new Promise((resolve6, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptValue(defaultValue ?? "");
+            setPromptMode({ kind: "text" });
+            promptResolveRef.current = resolve6;
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        },
+        select(message, options) {
+          return new Promise((resolve6, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptMode({ kind: "select", options });
+            setSelectIndex(0);
+            promptResolveRef.current = resolve6;
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        },
+        confirm(message, defaultValue) {
+          return new Promise((resolve6, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptMode({ kind: "confirm" });
+            setConfirmValue(defaultValue ?? true);
+            promptResolveRef.current = (value) => resolve6(value === "true");
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        }
+      };
+      const uiController = uiControllers.get(cmd.name);
+      if (!uiController) {
+        const id = `output-${outputCountRef.current++}`;
+        appendStaticItem({ kind: "output", id, line: `Error: No controller found for "${cmd.name}"` });
+        setState(APP_STATE.IDLE);
+        return;
+      }
+      uiController(ctx).then(() => {
+        if (!controller.signal.aborted) {
+          setState(APP_STATE.IDLE);
+          onCommandComplete?.();
+        }
+      }).catch((err) => {
+        if (controller.signal.aborted) return;
+        const id = `output-${outputCountRef.current++}`;
+        appendStaticItem({ kind: "output", id, line: `Error: ${formatError(err)}` });
+        setState(APP_STATE.IDLE);
+        onCommandComplete?.();
+      });
+    },
+    [appendStaticItem, setState, onCommandComplete]
+  );
+  const handlePromptSubmit = useCallback(
+    (value) => {
+      const resolve6 = promptResolveRef.current;
+      promptResolveRef.current = null;
+      setPromptMode({ kind: "text" });
+      setState(APP_STATE.EXECUTING);
+      resolve6?.(value);
+    },
+    [setState]
+  );
+  return {
+    runCommand: runCommand2,
+    handlePromptSubmit,
+    abortExecution,
+    promptMessage,
+    promptValue,
+    setPromptValue,
+    promptMode,
+    selectIndex,
+    setSelectIndex,
+    confirmValue,
+    setConfirmValue
+  };
+}
+
+// src/app.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+function App() {
+  const { exit } = useApp();
+  const [state, setState] = useState3(APP_STATE.IDLE);
+  const [inputValue, setInputValue] = useState3("");
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [staticItems, setStaticItems] = useState3([{ kind: "banner", id: "banner" }]);
+  const [platformInitialized, setPlatformInitialized] = useState3(false);
+  useEffect2(() => {
+    isPlatformInitialized().then(setPlatformInitialized).catch(() => {
+    });
+  }, []);
+  const appendStaticItem = useCallback2((item) => {
+    setStaticItems((prev) => [...prev, item]);
+  }, []);
+  const handleCommandComplete = useCallback2(() => {
+    isPlatformInitialized().then(setPlatformInitialized).catch(() => {
+    });
+  }, []);
+  const {
+    runCommand: runCommand2,
+    handlePromptSubmit,
+    abortExecution,
+    promptMessage,
+    promptValue,
+    setPromptValue,
+    promptMode,
+    selectIndex,
+    setSelectIndex,
+    confirmValue,
+    setConfirmValue
+  } = useCommandRunner({ appendStaticItem, setState, onCommandComplete: handleCommandComplete });
+  const query = inputValue.startsWith("/") ? inputValue.slice(1) : "";
+  const filteredCommands = registry.searchVisible(query, { platformInitialized });
+  useInput(
+    (input, key) => {
+      if (key.ctrl && input === "c") {
+        exit();
+        return;
+      }
+      if ((state === APP_STATE.EXECUTING || state === APP_STATE.PROMPTING) && key.escape) {
+        abortExecution();
+        setState(APP_STATE.IDLE);
+        return;
+      }
+      if (state === APP_STATE.PROMPTING) {
+        if (promptMode.kind === "select") {
+          if (key.upArrow) {
+            setSelectIndex((prev) => Math.max(0, prev - 1));
+            return;
+          }
+          if (key.downArrow) {
+            setSelectIndex((prev) => Math.min(promptMode.options.length - 1, prev + 1));
+            return;
+          }
+          if (key.return) {
+            const selected = promptMode.options[selectIndex];
+            if (selected) handlePromptSubmit(selected.value);
+            return;
+          }
+          return;
+        }
+        if (promptMode.kind === "confirm") {
+          if (key.leftArrow || key.upArrow) {
+            setConfirmValue(true);
+            return;
+          }
+          if (key.rightArrow || key.downArrow) {
+            setConfirmValue(false);
+            return;
+          }
+          if (key.return) {
+            handlePromptSubmit(confirmValue ? "true" : "false");
+            return;
+          }
+          return;
+        }
+        return;
+      }
+      if (state === APP_STATE.PALETTE) {
+        if (key.escape) {
+          setState(APP_STATE.IDLE);
+          setInputValue("");
+          return;
+        }
+        if (key.upArrow) {
+          setSelectedIndex((prev) => Math.max(0, prev - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelectedIndex((prev) => Math.min(filteredCommands.length - 1, prev + 1));
+          return;
+        }
+        if (key.return) {
+          const cmd = filteredCommands[selectedIndex];
+          if (cmd) {
+            setInputValue("");
+            runCommand2(cmd);
+          }
+          return;
+        }
+        if (key.backspace || key.delete) {
+          setInputValue((prev) => {
+            const next = prev.slice(0, -1);
+            if (!next.startsWith("/")) {
+              setState(APP_STATE.IDLE);
+              return "";
+            }
+            return next;
+          });
+          setSelectedIndex(0);
+          return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+          setInputValue((prev) => prev + input);
+          setSelectedIndex(0);
+        }
+      }
+    },
+    { isActive: true }
+  );
+  const handleIdleInputChange = useCallback2((value) => {
+    setInputValue(value);
+    if (value.startsWith("/")) {
+      setState(APP_STATE.PALETTE);
+      setSelectedIndex(0);
+    }
+  }, []);
+  const handleIdleSubmit = useCallback2(
+    (value) => {
+      if (!value.startsWith("/")) return;
+      const name = value.slice(1).trim();
+      const cmd = registry.get(name);
+      if (cmd) runCommand2(cmd);
+    },
+    [runCommand2]
+  );
+  function renderActiveArea() {
+    switch (state) {
+      case APP_STATE.EXECUTING:
+        return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "row", gap: 1, children: [
+          /* @__PURE__ */ jsx9(Spinner, { label: "Running\u2026" }),
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "(esc to cancel)" })
+        ] });
+      case APP_STATE.PROMPTING:
+        return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx9(Text9, { color: "cyan", children: promptMessage }),
+          promptMode.kind === "select" && /* @__PURE__ */ jsx9(SelectList, { options: promptMode.options, selectedIndex: selectIndex }),
+          promptMode.kind === "confirm" && /* @__PURE__ */ jsx9(ConfirmPrompt, { value: confirmValue }),
+          promptMode.kind === "text" && /* @__PURE__ */ jsx9(Prompt, { value: promptValue, onChange: setPromptValue, onSubmit: handlePromptSubmit })
+        ] });
+      default:
+        return /* @__PURE__ */ jsx9(
+          Prompt,
+          {
+            value: inputValue,
+            onChange: state === APP_STATE.IDLE ? handleIdleInputChange : () => {
+            },
+            onSubmit: state === APP_STATE.IDLE ? handleIdleSubmit : () => {
+            },
+            disabled: state === APP_STATE.PALETTE
+          }
+        );
+    }
+  }
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(ScrollbackHistory, { items: staticItems, version }),
+    renderActiveArea(),
+    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx9(CommandPalette, { commands: filteredCommands, selectedIndex })
+  ] });
+}
+
+// src/controllers/cli/create-application.cli-controller.ts
+async function createApplicationCliController(args2) {
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot create an application \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
+  const {
+    applicationName,
+    applicationDisplayName,
+    applicationDescription,
+    hasUserInterface,
+    hasBackendService
+  } = args2;
+  if (!applicationName || !applicationDisplayName || !applicationDescription) {
+    console.error("Error: applicationName, applicationDisplayName, and applicationDescription are required.");
+    process.exit(1);
+  }
+  if (!/^[a-z0-9-]+$/.test(applicationName)) {
+    console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    process.exit(1);
+  }
+  await createApplicationService(
+    {
+      applicationName,
+      applicationDisplayName,
+      applicationDescription,
+      hasUserInterface: hasUserInterface === "yes",
+      hasBackendService: hasBackendService === "yes"
+    },
+    { log: console.log }
+  );
+}
+
+// src/controllers/cli/init.cli-controller.ts
+async function initCliController(args2) {
+  if (await isPlatformInitialized()) {
+    console.error("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
+    process.exit(1);
+  }
+  const { organizationName, platformName, platformDisplayName, bootstrapServiceSuffix, customizationUiSuffix } = args2;
+  if (!organizationName || !platformName || !platformDisplayName) {
+    console.error("Error: organizationName, platformName, and platformDisplayName are required.");
+    process.exit(1);
+  }
+  await initService(
+    { organizationName, platformName, platformDisplayName, bootstrapServiceSuffix, customizationUiSuffix },
+    { log: console.log }
+  );
+}
+
+// src/controllers/cli/configure-idp.cli-controller.ts
+async function configureIdpCliController(args2) {
+  const logger = { log: console.log };
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
+  const { providerType, name, issuer, clientId, clientSecret } = args2;
+  if (!providerType || !name || !issuer || !clientId || !clientSecret) {
+    logger.log("Error: Missing required arguments: providerType, name, issuer, clientId, clientSecret");
+    process.exit(1);
+  }
+  const provider = idpProviderRegistry.get(providerType);
+  if (!provider) {
+    logger.log(`Error: Unknown IDP type "${providerType}"`);
+    process.exit(1);
+  }
+  const extras = {};
+  for (const field of provider.fields) {
+    const value = args2[field.key];
+    if (!value) {
+      logger.log(`Error: Missing required argument for ${providerType}: ${field.key}`);
+      process.exit(1);
+    }
+    extras[field.key] = value;
+  }
+  await configureIdpService({ providerType, name, issuer, clientId, clientSecret, extras }, logger);
+}
+
 // src/utils/cli-spinner.ts
 var FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var INTERVAL_MS2 = 80;
@@ -2103,6 +2679,21 @@ async function createUiModuleCliController(args2) {
   );
 }
 
+// src/controllers/cli/status.cli-controller.ts
+var statusCliController = async (_args) => {
+  const result = await statusService();
+  const lines = formatStatusLines(result);
+  for (const line of lines) {
+    console.log(line);
+  }
+  const next = computeNextStep(result);
+  if (next !== null) {
+    console.log("");
+    console.log(`Hint: Run "platform ${next}" to continue.`);
+    process.exit(1);
+  }
+};
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
@@ -2110,6 +2701,7 @@ var cliControllers = /* @__PURE__ */ new Map([
   [CONFIGURE_IDP_COMMAND_NAME, configureIdpCliController],
   [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleCliController],
   [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleCliController],
+  [STATUS_COMMAND_NAME, statusCliController],
   [INSTALL_COMMAND_NAME, createLocalScriptCliController(INSTALL_COMMAND_NAME)],
   [BUILD_COMMAND_NAME, createLocalScriptCliController(BUILD_COMMAND_NAME)],
   [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],
@@ -2132,10 +2724,10 @@ function parseKeyValueArgs(args2) {
 }
 
 // src/index.tsx
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx10 } from "react/jsx-runtime";
 var args = process.argv.slice(2);
 if (args.length === 0) {
-  render(/* @__PURE__ */ jsx8(App, {}));
+  render(/* @__PURE__ */ jsx10(App, {}));
 } else {
   const commandName = args[0];
   const params = parseKeyValueArgs(args.slice(1));