@bluealba/platform-cli 0.3.1-feature-platform-cli-228 → 0.3.1-feature-platform-cli-229

package/dist/index.js

@@ -1299,273 +1299,17 @@ async function createUiModule(params, logger) {
 }
 
 // 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"
-};
+import { spawn as spawn3 } from "child_process";
+import { access as access7 } from "fs/promises";
+import { join as join24, resolve as resolve5 } from "path";
 
 // src/commands/local-scripts/docker-compose-orchestrator.ts
-import { spawn as spawn2 } from "child_process";
-import { access as access6 } from "fs/promises";
-import { join as join23 } from "path";
+import { spawn } from "child_process";
+import { access as access5 } from "fs/promises";
+import { join as join22 } from "path";
 function runDockerCompose(args2, logger, rootDir, signal) {
   return new Promise((resolvePromise) => {
-    const child = spawn2("docker", ["compose", ...args2], {
+    const child = spawn("docker", ["compose", ...args2], {
       shell: false,
       stdio: ["ignore", "pipe", "pipe"],
       cwd: rootDir
@@ -1609,7 +1353,7 @@ function runDockerCompose(args2, logger, rootDir, signal) {
 }
 function captureDockerCompose(args2, rootDir) {
   return new Promise((resolvePromise, reject) => {
-    const child = spawn2("docker", ["compose", ...args2], {
+    const child = spawn("docker", ["compose", ...args2], {
       shell: false,
       stdio: ["ignore", "pipe", "pipe"],
       cwd: rootDir
@@ -1628,15 +1372,15 @@ function captureDockerCompose(args2, rootDir) {
 async function getAppComposePaths(localDir, platformName, manifest) {
   const results = [];
   for (const app of manifest.applications) {
-    const prefixedPath = join23(localDir, `${platformName}-${app.name}-docker-compose.yml`);
-    const unprefixedPath = join23(localDir, `${app.name}-docker-compose.yml`);
+    const prefixedPath = join22(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixedPath = join22(localDir, `${app.name}-docker-compose.yml`);
     let resolved = null;
     try {
-      await access6(prefixedPath);
+      await access5(prefixedPath);
       resolved = prefixedPath;
     } catch {
       try {
-        await access6(unprefixedPath);
+        await access5(unprefixedPath);
         resolved = unprefixedPath;
       } catch {
       }
@@ -1650,18 +1394,18 @@ async function getAppComposePaths(localDir, platformName, manifest) {
 async function buildFullComposeArgs(layout, manifest, logger) {
   const { coreDirName, localDir } = layout;
   const platformName = manifest.product.name;
-  const prefixedCoreCompose = join23(localDir, `${coreDirName}-docker-compose.yml`);
-  const unprefixedCoreCompose = join23(localDir, "core-docker-compose.yml");
+  const prefixedCoreCompose = join22(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCoreCompose = join22(localDir, "core-docker-compose.yml");
   let coreComposePath;
   try {
-    await access6(prefixedCoreCompose);
+    await access5(prefixedCoreCompose);
     coreComposePath = prefixedCoreCompose;
   } catch {
     coreComposePath = unprefixedCoreCompose;
   }
   const fileArgs = [
     "-f",
-    join23(localDir, "platform-docker-compose.yml"),
+    join22(localDir, "platform-docker-compose.yml"),
     "-f",
     coreComposePath
   ];
@@ -1681,16 +1425,16 @@ async function buildSelectedComposeFiles(layout, selectedManifest, includeCore)
   const platformName = selectedManifest.product.name;
   const files = [];
   if (includeCore) {
-    const prefixedCoreCompose = join23(localDir, `${coreDirName}-docker-compose.yml`);
-    const unprefixedCoreCompose = join23(localDir, "core-docker-compose.yml");
+    const prefixedCoreCompose = join22(localDir, `${coreDirName}-docker-compose.yml`);
+    const unprefixedCoreCompose = join22(localDir, "core-docker-compose.yml");
     let coreComposePath;
     try {
-      await access6(prefixedCoreCompose);
+      await access5(prefixedCoreCompose);
       coreComposePath = prefixedCoreCompose;
     } catch {
       coreComposePath = unprefixedCoreCompose;
     }
-    files.push(join23(localDir, "platform-docker-compose.yml"), coreComposePath);
+    files.push(join22(localDir, "platform-docker-compose.yml"), coreComposePath);
   }
   const appEntries = await getAppComposePaths(localDir, platformName, selectedManifest);
   for (const { composePath } of appEntries) {
@@ -1720,14 +1464,21 @@ async function getServicesFromComposeFiles(selectedFiles, allFiles, rootDir) {
   const allOutput = await captureDockerCompose([...allFileArgs, "config", "--services"], rootDir);
   const allServices = new Set(allOutput.split("\n").map((s) => s.trim()).filter(Boolean));
   const contextFileArgs = contextFiles.flatMap((f) => ["-f", f]);
-  const contextOutput = await captureDockerCompose([...contextFileArgs, "config", "--services"], rootDir);
-  const contextServices = new Set(contextOutput.split("\n").map((s) => s.trim()).filter(Boolean));
+  let contextServices;
+  try {
+    const contextOutput = await captureDockerCompose([...contextFileArgs, "config", "--services"], rootDir);
+    contextServices = new Set(contextOutput.split("\n").map((s) => s.trim()).filter(Boolean));
+  } catch {
+    const selectedFileArgs = selectedFiles.flatMap((f) => ["-f", f]);
+    const fallbackOutput = await captureDockerCompose([...selectedFileArgs, "config", "--services"], rootDir);
+    return fallbackOutput.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
   return [...allServices].filter((s) => !contextServices.has(s));
 }
 async function startEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join23(localDir, ".env");
+  const envFile = join22(localDir, ".env");
   const isSelective = fullManifest !== void 0;
   const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
   const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
@@ -1749,7 +1500,7 @@ async function startEnvironment(layout, manifest, logger, signal, includeCore =
 async function stopEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join23(localDir, ".env");
+  const envFile = join22(localDir, ".env");
   const isSelective = fullManifest !== void 0;
   const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
   const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
@@ -1771,7 +1522,7 @@ async function stopEnvironment(layout, manifest, logger, signal, includeCore = t
 async function destroyEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join23(localDir, ".env");
+  const envFile = join22(localDir, ".env");
   const isSelective = fullManifest !== void 0;
   const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
   const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
@@ -1795,12 +1546,12 @@ async function destroyEnvironment(layout, manifest, logger, signal, includeCore
 }
 
 // src/commands/local-scripts/npm-orchestrator.ts
-import { spawn as spawn3 } from "child_process";
-import { access as access7 } from "fs/promises";
-import { resolve as resolve5, join as join24 } from "path";
+import { spawn as spawn2 } from "child_process";
+import { access as access6 } from "fs/promises";
+import { resolve as resolve4, join as join23 } from "path";
 function runCommand(command, args2, workDir, logger, signal) {
   return new Promise((resolvePromise) => {
-    const child = spawn3(command, args2, {
+    const child = spawn2(command, args2, {
       cwd: workDir,
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1833,164 +1584,517 @@ function runCommand(command, args2, workDir, logger, signal) {
       } else if (code !== 0) {
         logger.log(`Command "${command} ${args2.join(" ")}" exited with code ${code}.`);
       }
-      resolvePromise();
-    });
-    child.on("error", (err) => {
-      signal?.removeEventListener("abort", onAbort);
-      logger.log(`Failed to run "${command} ${args2.join(" ")}": ${err.message}`);
-      resolvePromise();
+      resolvePromise();
+    });
+    child.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      logger.log(`Failed to run "${command} ${args2.join(" ")}": ${err.message}`);
+      resolvePromise();
+    });
+  });
+}
+async function dirExists(dirPath) {
+  try {
+    await access6(dirPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installDependencies(layout, manifest, logger, signal, includeCore = true) {
+  const { coreDir, coreDirName } = layout;
+  const appDirs = [];
+  for (const app of manifest.applications) {
+    const appDir = resolve4(join23(coreDir), app.localPath);
+    if (!await dirExists(appDir)) {
+      logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping install.`);
+      continue;
+    }
+    appDirs.push({ name: app.name, dir: appDir });
+  }
+  const targets = includeCore ? [{ name: coreDirName, dir: coreDir }, ...appDirs] : appDirs;
+  logger.log(`Installing dependencies in parallel: ${targets.map((t) => t.name).join(", ")}...`);
+  await Promise.all(
+    targets.map(
+      ({ name, dir }) => runCommand("npm", ["install"], dir, logger, signal).then(() => {
+        logger.log(`\u2713 ${name} install done`);
+      })
+    )
+  );
+}
+async function buildAll(layout, manifest, logger, signal, includeCore = true) {
+  const { coreDir, coreDirName } = layout;
+  if (includeCore) {
+    logger.log(`Building ${coreDirName}/...`);
+    await runCommand("npx", ["turbo", "build"], coreDir, logger, signal);
+    if (signal?.aborted) return;
+  }
+  const appDirs = [];
+  for (const app of manifest.applications) {
+    const appDir = resolve4(join23(coreDir), app.localPath);
+    if (!await dirExists(appDir)) {
+      logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping build.`);
+      continue;
+    }
+    appDirs.push({ name: app.name, dir: appDir });
+  }
+  if (appDirs.length === 0) return;
+  logger.log(`Building apps in parallel: ${appDirs.map((a) => a.name).join(", ")}...`);
+  await Promise.all(
+    appDirs.map(
+      ({ name, dir }) => runCommand("npm", ["run", "build"], dir, logger, signal).then(() => {
+        logger.log(`\u2713 ${name} build done`);
+      })
+    )
+  );
+}
+
+// src/commands/local-scripts/local-script.command.ts
+var INSTALL_COMMAND_NAME = "install";
+var BUILD_COMMAND_NAME = "build";
+var START_COMMAND_NAME = "start";
+var STOP_COMMAND_NAME = "stop";
+var DESTROY_COMMAND_NAME = "destroy";
+var CORE_APP_NAME = "core";
+var installCommand = {
+  name: INSTALL_COMMAND_NAME,
+  description: "Install dependencies in the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var buildCommand = {
+  name: BUILD_COMMAND_NAME,
+  description: "Build the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var startCommand = {
+  name: START_COMMAND_NAME,
+  description: "Start the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var stopCommand = {
+  name: STOP_COMMAND_NAME,
+  description: "Stop the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var destroyCommand = {
+  name: DESTROY_COMMAND_NAME,
+  description: "Destroy the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var localScriptCommands = [
+  installCommand,
+  buildCommand,
+  startCommand,
+  stopCommand,
+  destroyCommand
+];
+async function runLocalScript(scriptName, logger, signal, appNames) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    logger.log(`Error: Cannot run "${scriptName}" \u2014 no platform initialized in this directory.`);
+    return;
+  }
+  const { rootDir, coreDirName } = layout;
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  let includeCore = true;
+  const fullManifest = manifest;
+  let isSelective = false;
+  if (appNames && appNames.length > 0) {
+    isSelective = true;
+    includeCore = appNames.includes(CORE_APP_NAME);
+    const appNamesWithoutCore = appNames.filter((n) => n !== CORE_APP_NAME);
+    const nameSet = new Set(appNamesWithoutCore);
+    const unknown = appNamesWithoutCore.filter((n) => !manifest.applications.some((a) => a.name === n));
+    if (unknown.length > 0) {
+      logger.log(`Warning: Unknown application(s): ${unknown.join(", ")} \u2014 ignoring.`);
+    }
+    const filtered = manifest.applications.filter((a) => nameSet.has(a.name));
+    if (!includeCore && filtered.length === 0) {
+      logger.log("No matching applications found. Nothing to do.");
+      return;
+    }
+    manifest = { ...manifest, applications: filtered };
+  }
+  switch (scriptName) {
+    case START_COMMAND_NAME:
+      await startEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
+      break;
+    case STOP_COMMAND_NAME:
+      await stopEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
+      break;
+    case DESTROY_COMMAND_NAME:
+      await destroyEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
+      break;
+    case INSTALL_COMMAND_NAME:
+      await installDependencies(layout, manifest, logger, signal, includeCore);
+      break;
+    case BUILD_COMMAND_NAME:
+      await buildAll(layout, manifest, logger, signal, includeCore);
+      break;
+    default:
+      logger.log(`Error: Unknown script "${scriptName}".`);
+  }
+}
+
+// src/commands/status/status-checks.ts
+function spawnCapture(cmd, args2, cwd5) {
+  return new Promise((resolvePromise) => {
+    const child = spawn3(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 access7(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: join24(layout.coreDir, "node_modules"),
+    exists: await pathExists(join24(layout.coreDir, "node_modules"))
+  };
+  results.push(coreCheck);
+  for (const app of manifest.applications) {
+    const appDir = resolve5(layout.coreDir, app.localPath);
+    const nodeModulesPath = join24(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 = join24(layout.coreDir, ".turbo");
+  results.push({
+    name: layout.coreDirName,
+    path: coreTurboPath,
+    exists: await pathExists(coreTurboPath)
+  });
+  for (const app of manifest.applications) {
+    const appDir = resolve5(layout.coreDir, app.localPath);
+    const appTurboPath = join24(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 = [join24(localDir, "platform-docker-compose.yml")];
+  const prefixedCore = join24(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCore = join24(localDir, "core-docker-compose.yml");
+  files.push(await pathExists(prefixedCore) ? prefixedCore : unprefixedCore);
+  for (const app of manifest.applications) {
+    const prefixed = join24(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixed = join24(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
+  }));
 }
-async function dirExists(dirPath) {
-  try {
-    await access7(dirPath);
-    return true;
-  } catch {
-    return false;
+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 computeNextStepInfo(result) {
+  if (!result.lifecycle.initialized) {
+    return { step: "init", appNames: [], allApps: true };
+  }
+  if (!result.lifecycle.installed) {
+    const failing = result.lifecycle.installedDetails.filter((d) => !d.exists).map((d) => d.name === result.coreDirName ? CORE_APP_NAME : d.name);
+    const allApps = failing.length === result.lifecycle.installedDetails.length;
+    return { step: "install", appNames: failing, allApps };
+  }
+  if (!result.lifecycle.built) {
+    const failing = result.lifecycle.builtDetails.filter((d) => !d.exists).map((d) => d.name === result.coreDirName ? CORE_APP_NAME : d.name);
+    const allApps = failing.length === result.lifecycle.builtDetails.length;
+    return { step: "build", appNames: failing, allApps };
   }
+  if (!result.lifecycle.running) {
+    const failing = result.containersByApp.filter((g) => !g.allRunning).map((g) => g.appName);
+    const allApps = failing.length === result.containersByApp.length;
+    return { step: "start", appNames: failing, allApps };
+  }
+  return { step: null, appNames: [], allApps: true };
 }
-async function installDependencies(layout, manifest, logger, signal, includeCore = true) {
-  const { coreDir, coreDirName } = layout;
-  const appDirs = [];
+async function getServicesForComposeFiles(selectedFiles, allFiles, rootDir) {
+  const selectedSet = new Set(selectedFiles);
+  const contextFiles = allFiles.filter((f) => !selectedSet.has(f));
+  if (contextFiles.length === 0) {
+    const fileArgs = selectedFiles.flatMap((f) => ["-f", f]);
+    const { stdout } = await spawnCapture("docker", ["compose", ...fileArgs, "config", "--services"], rootDir);
+    return stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  const allFileArgs = allFiles.flatMap((f) => ["-f", f]);
+  const { stdout: allOut } = await spawnCapture("docker", ["compose", ...allFileArgs, "config", "--services"], rootDir);
+  const allServices = new Set(allOut.split("\n").map((s) => s.trim()).filter(Boolean));
+  const contextFileArgs = contextFiles.flatMap((f) => ["-f", f]);
+  const { stdout: ctxOut } = await spawnCapture("docker", ["compose", ...contextFileArgs, "config", "--services"], rootDir);
+  const contextServices = new Set(ctxOut.split("\n").map((s) => s.trim()).filter(Boolean));
+  return [...allServices].filter((s) => !contextServices.has(s));
+}
+async function checkContainersPerApp(layout, manifest, allContainers) {
+  const { localDir, coreDirName, rootDir } = layout;
+  const platformName = manifest.product.name;
+  const prefixedCore = join24(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCore = join24(localDir, "core-docker-compose.yml");
+  const coreComposePath = await pathExists(prefixedCore) ? prefixedCore : unprefixedCore;
+  const platformComposePath = join24(localDir, "platform-docker-compose.yml");
+  const allFiles = [platformComposePath, coreComposePath];
+  const appComposeMap = /* @__PURE__ */ new Map();
   for (const app of manifest.applications) {
-    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;
+    const prefixed = join24(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixed = join24(localDir, `${app.name}-docker-compose.yml`);
+    if (await pathExists(prefixed)) {
+      appComposeMap.set(app.name, prefixed);
+      allFiles.push(prefixed);
+    } else if (await pathExists(unprefixed)) {
+      appComposeMap.set(app.name, unprefixed);
+      allFiles.push(unprefixed);
     }
-    appDirs.push({ name: app.name, dir: appDir });
   }
-  const targets = includeCore ? [{ name: coreDirName, dir: coreDir }, ...appDirs] : appDirs;
-  logger.log(`Installing dependencies in parallel: ${targets.map((t) => t.name).join(", ")}...`);
-  await Promise.all(
-    targets.map(
-      ({ name, dir }) => runCommand("npm", ["install"], dir, logger, signal).then(() => {
-        logger.log(`\u2713 ${name} install done`);
-      })
-    )
+  const containerByName = new Map(allContainers.map((c) => [c.name, c]));
+  const coreFiles = [platformComposePath, coreComposePath];
+  const { stdout: coreOut } = await spawnCapture(
+    "docker",
+    ["compose", ...coreFiles.flatMap((f) => ["-f", f]), "config", "--services"],
+    rootDir
   );
-}
-async function buildAll(layout, manifest, logger, signal, includeCore = true) {
-  const { coreDir, coreDirName } = layout;
-  if (includeCore) {
-    logger.log(`Building ${coreDirName}/...`);
-    await runCommand("npx", ["turbo", "build"], coreDir, logger, signal);
-    if (signal?.aborted) return;
-  }
-  const appDirs = [];
+  const coreServiceNames = coreOut.split("\n").map((s) => s.trim()).filter(Boolean);
+  const appServicesMap = /* @__PURE__ */ new Map();
   for (const app of manifest.applications) {
-    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;
+    const appComposePath = appComposeMap.get(app.name);
+    if (!appComposePath) continue;
+    try {
+      const appServices = await getServicesForComposeFiles([appComposePath], allFiles, rootDir);
+      appServicesMap.set(app.name, appServices);
+    } catch {
     }
-    appDirs.push({ name: app.name, dir: appDir });
   }
-  if (appDirs.length === 0) return;
-  logger.log(`Building apps in parallel: ${appDirs.map((a) => a.name).join(", ")}...`);
-  await Promise.all(
-    appDirs.map(
-      ({ name, dir }) => runCommand("npm", ["run", "build"], dir, logger, signal).then(() => {
-        logger.log(`\u2713 ${name} build done`);
-      })
-    )
-  );
+  const groups = [];
+  const coreContainers = coreServiceNames.map((s) => containerByName.get(s) ?? { name: s, state: "not started", ports: "" });
+  groups.push({
+    appName: CORE_APP_NAME,
+    containers: coreContainers,
+    allRunning: coreContainers.length > 0 && coreContainers.every((c) => c.state === "running")
+  });
+  for (const app of manifest.applications) {
+    const appServices = appServicesMap.get(app.name);
+    if (!appServices) continue;
+    const appContainers = appServices.map((s) => containerByName.get(s) ?? { name: s, state: "not started", ports: "" });
+    groups.push({
+      appName: app.name,
+      containers: appContainers,
+      allRunning: appContainers.length > 0 && appContainers.every((c) => c.state === "running")
+    });
+  }
+  return groups;
 }
-
-// src/commands/local-scripts/local-script.command.ts
-var INSTALL_COMMAND_NAME = "install";
-var BUILD_COMMAND_NAME = "build";
-var START_COMMAND_NAME = "start";
-var STOP_COMMAND_NAME = "stop";
-var DESTROY_COMMAND_NAME = "destroy";
-var CORE_APP_NAME = "core";
-var installCommand = {
-  name: INSTALL_COMMAND_NAME,
-  description: "Install dependencies in the local dev environment",
-  hidden: (ctx) => !ctx.platformInitialized
-};
-var buildCommand = {
-  name: BUILD_COMMAND_NAME,
-  description: "Build the local dev environment",
-  hidden: (ctx) => !ctx.platformInitialized
-};
-var startCommand = {
-  name: START_COMMAND_NAME,
-  description: "Start the local dev environment",
-  hidden: (ctx) => !ctx.platformInitialized
-};
-var stopCommand = {
-  name: STOP_COMMAND_NAME,
-  description: "Stop the local dev environment",
-  hidden: (ctx) => !ctx.platformInitialized
-};
-var destroyCommand = {
-  name: DESTROY_COMMAND_NAME,
-  description: "Destroy the local dev environment",
-  hidden: (ctx) => !ctx.platformInitialized
-};
-var localScriptCommands = [
-  installCommand,
-  buildCommand,
-  startCommand,
-  stopCommand,
-  destroyCommand
-];
-async function runLocalScript(scriptName, logger, signal, appNames) {
+async function gatherStatus() {
   const layout = await findPlatformLayout();
+  const [nodeCheck, dockerCheck] = await Promise.all([checkNodeVersion(), checkDocker()]);
+  const prerequisites = [nodeCheck, dockerCheck];
   if (!layout) {
-    logger.log(`Error: Cannot run "${scriptName}" \u2014 no platform initialized in this directory.`);
-    return;
+    return {
+      projectInfo: null,
+      prerequisites,
+      lifecycle: {
+        initialized: false,
+        installed: false,
+        installedDetails: [],
+        built: false,
+        builtDetails: [],
+        running: false
+      },
+      containers: [],
+      containersByApp: [],
+      coreDirName: null
+    };
   }
-  const { rootDir, coreDirName } = layout;
   let manifest;
   try {
-    manifest = await readManifest(rootDir, coreDirName);
-  } catch (err) {
-    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
-    return;
-  }
-  let includeCore = true;
-  const fullManifest = manifest;
-  let isSelective = false;
-  if (appNames && appNames.length > 0) {
-    isSelective = true;
-    includeCore = appNames.includes(CORE_APP_NAME);
-    const appNamesWithoutCore = appNames.filter((n) => n !== CORE_APP_NAME);
-    const nameSet = new Set(appNamesWithoutCore);
-    const unknown = appNamesWithoutCore.filter((n) => !manifest.applications.some((a) => a.name === n));
-    if (unknown.length > 0) {
-      logger.log(`Warning: Unknown application(s): ${unknown.join(", ")} \u2014 ignoring.`);
-    }
-    const filtered = manifest.applications.filter((a) => nameSet.has(a.name));
-    if (!includeCore && filtered.length === 0) {
-      logger.log("No matching applications found. Nothing to do.");
-      return;
-    }
-    manifest = { ...manifest, applications: filtered };
-  }
-  switch (scriptName) {
-    case START_COMMAND_NAME:
-      await startEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
-      break;
-    case STOP_COMMAND_NAME:
-      await stopEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
-      break;
-    case DESTROY_COMMAND_NAME:
-      await destroyEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
-      break;
-    case INSTALL_COMMAND_NAME:
-      await installDependencies(layout, manifest, logger, signal, includeCore);
-      break;
-    case BUILD_COMMAND_NAME:
-      await buildAll(layout, manifest, logger, signal, includeCore);
-      break;
-    default:
-      logger.log(`Error: Unknown script "${scriptName}".`);
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  } catch {
+    return {
+      projectInfo: null,
+      prerequisites,
+      lifecycle: {
+        initialized: true,
+        installed: false,
+        installedDetails: [],
+        built: false,
+        builtDetails: [],
+        running: false
+      },
+      containers: [],
+      containersByApp: [],
+      coreDirName: layout.coreDirName
+    };
   }
+  const [installedDetails, builtDetails, containers] = await Promise.all([
+    checkInstalled(layout, manifest),
+    checkBuilt(layout, manifest),
+    checkContainers(layout, manifest)
+  ]);
+  const containersByApp = await checkContainersPerApp(layout, manifest, containers);
+  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,
+    containersByApp,
+    coreDirName: layout.coreDirName
+  };
 }
 
+// src/commands/status/status.command.ts
+var STATUS_COMMAND_NAME = "status";
+var statusCommand = {
+  name: STATUS_COMMAND_NAME,
+  description: "Show platform status and health checks",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -2328,24 +2432,29 @@ async function statusUiController(ctx) {
     for (const line of formatStatusLines(result)) {
       ctx.log(line);
     }
-    const next = computeNextStep(result);
-    if (next === null) {
+    const { step, appNames, allApps } = computeNextStepInfo(result);
+    if (step === 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") {
+    if (step === "init") {
+      const shouldRun = await ctx.confirm(`Next step: "init". Run it now?`, true);
+      if (!shouldRun) return;
       await initUiController(ctx);
     } else {
-      await localScriptService(next, ctx, ctx.signal);
+      const appListStr = allApps ? "all apps" : appNames.join(", ");
+      const shouldRun = await ctx.confirm(`Run ${step} for ${appListStr}?`, true);
+      if (!shouldRun) return;
+      await localScriptService(step, ctx, ctx.signal, allApps ? void 0 : appNames);
     }
     const resultAfter = await statusService();
-    const nextAfter = computeNextStep(resultAfter);
-    if (nextAfter === next) {
+    const nextAfter = computeNextStepInfo(resultAfter);
+    const sameStep = nextAfter.step === step;
+    const noProgress = sameStep && (allApps ? nextAfter.allApps : appNames.some((a) => nextAfter.appNames.includes(a)));
+    if (noProgress) {
       ctx.log("");
-      ctx.log(`"${next}" did not complete successfully. Check the output above for errors.`);
+      ctx.log(`"${step}" did not complete successfully. Check the output above for errors.`);
       return;
     }
   }
@@ -2953,10 +3062,14 @@ var statusCliController = async (_args) => {
   for (const line of lines) {
     console.log(line);
   }
-  const next = computeNextStep(result);
-  if (next !== null) {
+  const { step, appNames, allApps } = computeNextStepInfo(result);
+  if (step !== null) {
     console.log("");
-    console.log(`Hint: Run "platform ${next}" to continue.`);
+    if (step === "init" || allApps) {
+      console.log(`Hint: Run "platform ${step}" to continue.`);
+    } else {
+      console.log(`Hint: Run "platform ${step} ${appNames.join(" ")}" to continue.`);
+    }
     process.exit(1);
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluealba/platform-cli",
-  "version": "0.3.1-feature-platform-cli-228",
+  "version": "0.3.1-feature-platform-cli-229",
   "description": "Blue Alba Platform CLI",
   "license": "PolyForm-Noncommercial-1.0.0",
   "type": "module",