@bluealba/platform-cli 0.3.0 → 0.3.1-feature-platform-cli-prefix-221

package/dist/index.js

@@ -6,7 +6,7 @@ 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 Text6, useApp, useInput } from "ink";
+import { Box as Box4, Text as Text7, useApp, useInput } from "ink";
 
 // src/components/prompt.tsx
 import { Box, Text } from "ink";
@@ -54,53 +54,76 @@ var CommandPalette = React.memo(function CommandPalette2({ commands, selectedInd
 });
 
 // src/components/scrollback-history.tsx
-import { Static, Text as Text4 } from "ink";
+import { Static, Text as Text5 } from "ink";
 
 // src/components/welcome-banner.tsx
+import React3 from "react";
+import { Box as Box3, Text as Text4 } from "ink";
+
+// src/components/working-directory.tsx
 import React2 from "react";
-import { Box as Box3, Text as Text3 } from "ink";
+import { Text as Text3 } from "ink";
+import { cwd } from "process";
+import { homedir } from "os";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function shortenPath(fullPath) {
+  const home = homedir();
+  return fullPath.startsWith(home) ? `~${fullPath.slice(home.length)}` : fullPath;
+}
+var WorkingDirectory = React2.memo(function WorkingDirectory2() {
+  const dir = shortenPath(cwd());
+  return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    "  ",
+    /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "cwd:" }),
+    " ",
+    dir
+  ] });
+});
+
+// src/components/welcome-banner.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var ASCII_ART = [
   "|---.  .---|",
   "|    \\/    |",
   "|    /\\    |",
   "|---'  '---|"
 ];
-var WelcomeBanner = React2.memo(function WelcomeBanner2({ version: version2 }) {
-  return /* @__PURE__ */ jsxs3(Box3, { borderStyle: "round", flexDirection: "column", paddingX: 1, paddingY: 1, children: [
-    /* @__PURE__ */ jsxs3(Text3, { bold: true, color: "cyan", children: [
+var WelcomeBanner = React3.memo(function WelcomeBanner2({ version: version2 }) {
+  return /* @__PURE__ */ jsxs4(Box3, { borderStyle: "round", flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "cyan", children: [
       "Blue Alba Platform CLI v",
       version2
     ] }),
-    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginRight: 2, children: ASCII_ART.map((line, i) => /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: line }, i)) }),
-      /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", justifyContent: "center", marginRight: 2, children: [
-        /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Welcome to the" }),
-        /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Blue Alba Platform!" })
+    /* @__PURE__ */ jsxs4(Box3, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", marginRight: 2, children: ASCII_ART.map((line, i) => /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: line }, i)) }),
+      /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", justifyContent: "center", marginRight: 2, children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Welcome to the" }),
+        /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Blue Alba Platform!" })
       ] }),
-      /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: ASCII_ART.map((_, i) => /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2502" }, i)) }),
-      /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 2, children: [
-        /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: "Tips for getting started" }),
-        /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", children: ASCII_ART.map((_, i) => /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2502" }, i)) }),
+      /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginLeft: 2, children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Tips for getting started" }),
+        /* @__PURE__ */ jsxs4(Text4, { children: [
           "Run ",
-          /* @__PURE__ */ jsx3(Text3, { color: "green", children: "/init" }),
+          /* @__PURE__ */ jsx4(Text4, { color: "green", children: "/init" }),
           " to start building a platform"
         ] })
       ] })
-    ] })
+    ] }),
+    /* @__PURE__ */ jsx4(WorkingDirectory, {})
   ] });
 });
 
 // src/components/scrollback-history.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
 function ScrollbackHistory({ items, version: version2 }) {
-  return /* @__PURE__ */ jsx4(Static, { items, children: (item) => item.kind === "banner" ? /* @__PURE__ */ jsx4(WelcomeBanner, { version: version2 }, item.id) : /* @__PURE__ */ jsx4(Text4, { children: item.line }, item.id) });
+  return /* @__PURE__ */ jsx5(Static, { items, children: (item) => item.kind === "banner" ? /* @__PURE__ */ jsx5(WelcomeBanner, { version: version2 }, item.id) : /* @__PURE__ */ jsx5(Text5, { children: item.line }, item.id) });
 }
 
 // src/components/spinner.tsx
 import { useState, useEffect } from "react";
-import { Text as Text5 } from "ink";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var INTERVAL_MS = 80;
 function Spinner({ label }) {
@@ -111,12 +134,12 @@ function Spinner({ label }) {
     }, INTERVAL_MS);
     return () => clearInterval(id);
   }, []);
-  return /* @__PURE__ */ jsxs4(Text5, { children: [
-    /* @__PURE__ */ jsxs4(Text5, { color: "cyan", children: [
+  return /* @__PURE__ */ jsxs5(Text6, { children: [
+    /* @__PURE__ */ jsxs5(Text6, { color: "cyan", children: [
       FRAMES[frame],
       " "
     ] }),
-    label && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: label })
+    label && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: label })
   ] });
 }
 
@@ -124,8 +147,7 @@ function Spinner({ label }) {
 import { Fzf } from "fzf";
 
 // src/commands/create-application/create-application.command.ts
-import { join as join10 } from "path";
-import { cwd as cwd2 } from "process";
+import { join as join11, resolve } from "path";
 import { mkdir as mkdir2 } from "fs/promises";
 
 // src/commands/create-application/scaffold-application-monorepo.ts
@@ -290,8 +312,8 @@ var nestjsServiceModuleTemplateDir = join6(
   "templates",
   "nestjs-service-module-template"
 );
-async function scaffoldNestjsService(serviceDir, organizationName, applicationName, applicationDisplayName, serviceBaseDir, logger) {
-  const serviceName = `${applicationName}-service`;
+async function scaffoldNestjsService(serviceDir, organizationName, platformName, applicationName, applicationDisplayName, serviceBaseDir, logger) {
+  const serviceName = `${platformName}-${applicationName}-service`;
   const serviceDisplayName = `${applicationDisplayName} Service`;
   logger.log(`Creating NestJS service "${serviceName}"...`);
   await applyTemplate(
@@ -322,33 +344,35 @@ async function addModuleEntry(bootstrapServiceDir, applicationName, entry, logge
 }
 
 // src/commands/create-application/module-entry-builders.ts
-function buildServiceModuleEntry(organizationName, applicationName, applicationDisplayName) {
+function buildServiceModuleEntry(organizationName, platformName, applicationName, applicationDisplayName) {
+  const serviceName = `${platformName}-${applicationName}-service`;
   return {
-    name: `@${organizationName}/${applicationName}-service`,
+    name: `@${organizationName}/${serviceName}`,
     displayName: `${applicationDisplayName} Service`,
     type: "service",
-    baseUrl: `/${applicationName}-service`,
+    baseUrl: `/${serviceName}`,
     service: {
-      host: `${applicationName}-service`,
+      host: serviceName,
       port: 80
     },
     dependsOn: []
   };
 }
-function buildUiModuleEntry(organizationName, applicationName, applicationDisplayName) {
+function buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName) {
+  const uiName = `${platformName}-${applicationName}-ui`;
   return {
-    name: `@${organizationName}/${applicationName}-ui`,
+    name: `@${organizationName}/${uiName}`,
     displayName: applicationDisplayName,
     type: "app",
-    baseUrl: `/${applicationName}-ui`,
+    baseUrl: `/${uiName}`,
     service: {
-      host: `${applicationName}-ui`,
+      host: uiName,
       port: 80
     },
     ui: {
       route: `/${applicationName}`,
       mountAtSelector: "#pae-shell-ui-content",
-      bundleFile: `${organizationName}-${applicationName}-ui.js`,
+      bundleFile: `${organizationName}-${uiName}.js`,
       customProps: {}
     },
     dependsOn: [`@bluealba/pae-shell-ui`]
@@ -357,10 +381,11 @@ function buildUiModuleEntry(organizationName, applicationName, applicationDispla
 
 // src/commands/create-application/create-docker-compose.ts
 import { writeFile as writeFile3 } from "fs/promises";
-function buildBootstrapBlock(applicationName) {
-  return `  ${applicationName}-bootstrap-service:
+function buildBootstrapBlock(platformName, applicationName) {
+  const bootstrapName = `${platformName}-${applicationName}-bootstrap-service`;
+  return `  ${bootstrapName}:
     build:
-      context: ../${applicationName}/services/${applicationName}-bootstrap-service
+      context: ../../${platformName}-${applicationName}/services/${bootstrapName}
       dockerfile: Dockerfile.development
     environment:
       - NODE_TLS_REJECT_UNAUTHORIZED=0
@@ -370,27 +395,29 @@ function buildBootstrapBlock(applicationName) {
       - GATEWAY_SERVICE_URL=\${PAE_GATEWAY_URL}
       - SERVICE_ACCESS_SECRET=\${PAE_GATEWAY_SERVICE_ACCESS_SECRET}
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
     depends_on:
       pae-nestjs-gateway-service:
         condition: service_healthy
 `;
 }
-function buildUiBlock(applicationName, uiPort) {
-  return `  ${applicationName}-ui:
+function buildUiBlock(platformName, applicationName, uiPort) {
+  const uiName = `${platformName}-${applicationName}-ui`;
+  return `  ${uiName}:
     build:
-      context: ../${applicationName}/ui/${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${uiPort}:80
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
 }
-function buildBackendBlock(applicationName, servicePort) {
-  return `  ${applicationName}-service:
+function buildBackendBlock(platformName, applicationName, servicePort) {
+  const serviceName = `${platformName}-${applicationName}-service`;
+  return `  ${serviceName}:
     build:
-      context: ../${applicationName}/services/${applicationName}-service
+      context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -399,18 +426,18 @@ function buildBackendBlock(applicationName, servicePort) {
     environment:
       - GATEWAY_URL=\${PAE_GATEWAY_URL}
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
 }
-async function createDockerCompose(dockerComposePath, applicationName, hasUserInterface, hasBackendService, uiPort, servicePort, logger) {
-  const blocks = ["services:\n", buildBootstrapBlock(applicationName)];
+async function createDockerCompose(dockerComposePath, applicationName, platformName, hasUserInterface, hasBackendService, uiPort, servicePort, logger) {
+  const blocks = ["services:\n", buildBootstrapBlock(platformName, applicationName)];
   if (hasUserInterface) {
-    blocks.push(buildUiBlock(applicationName, uiPort));
+    blocks.push(buildUiBlock(platformName, applicationName, uiPort));
   }
   if (hasBackendService) {
-    blocks.push(buildBackendBlock(applicationName, servicePort));
+    blocks.push(buildBackendBlock(platformName, applicationName, servicePort));
   }
-  const content = blocks.join("\n");
+  const content = blocks.join("\n") + "\n";
   try {
     await writeFile3(dockerComposePath, content, "utf-8");
     logger.log(`Created docker-compose: ${dockerComposePath}`);
@@ -420,32 +447,17 @@ async function createDockerCompose(dockerComposePath, applicationName, hasUserIn
   }
 }
 
-// src/commands/create-application/update-root-docker-compose.ts
-import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
-async function updateRootDockerCompose(rootDockerComposePath, applicationName, logger) {
-  try {
-    const existing = await readFile3(rootDockerComposePath, "utf-8");
-    const includeLine = `  - path: ./${applicationName}-docker-compose.yml
-`;
-    await writeFile4(rootDockerComposePath, existing + includeLine, "utf-8");
-    logger.log(`Updated root docker-compose: ${rootDockerComposePath}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    logger.log(`Warning: Could not update root docker-compose \u2014 ${message}`);
-  }
-}
-
 // src/commands/create-application/port-allocator.ts
 import { join as join8 } from "path";
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
 async function getNextAvailablePort(localDir) {
   const allPorts = [];
   try {
     const files = await readdir2(localDir);
-    const dockerComposeFiles = files.filter((f) => f.endsWith("-docker-compose.yml"));
-    for (const file of dockerComposeFiles) {
+    const ymlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+    for (const file of ymlFiles) {
       try {
-        const content = await readFile4(join8(localDir, file), "utf-8");
+        const content = await readFile3(join8(localDir, file), "utf-8");
         const regex = /^\s*-\s*"?(\d+):\d+"?\s*$/gm;
         let match;
         while ((match = regex.exec(content)) !== null) {
@@ -464,18 +476,95 @@ function formatError(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/utils/platform-check.ts
-import { access } from "fs/promises";
-import { join as join9 } from "path";
-import { cwd } from "process";
-async function isPlatformInitialized() {
+// src/utils/platform-layout.ts
+import { access, readdir as readdir3 } from "fs/promises";
+import { join as join9, dirname as dirname7 } from "path";
+import { cwd as cwd2 } from "process";
+async function findCoreDirIn(dir) {
+  let entries;
   try {
-    await access(join9(cwd(), "core"));
-    await access(join9(cwd(), "local"));
-    return true;
+    entries = await readdir3(dir, { withFileTypes: true });
   } catch {
-    return false;
+    return null;
   }
+  const dirs = entries.filter((e) => e.isDirectory());
+  for (const entry of dirs) {
+    if (entry.name.endsWith("-core")) {
+      try {
+        await access(join9(dir, entry.name, "product.manifest.json"));
+        return entry.name;
+      } catch {
+      }
+    }
+  }
+  const coreEntry = dirs.find((e) => e.name === "core");
+  if (coreEntry) {
+    try {
+      await access(join9(dir, "core", "product.manifest.json"));
+      return "core";
+    } catch {
+    }
+  }
+  return null;
+}
+async function findPlatformLayout(startDir = cwd2()) {
+  let dir = startDir;
+  while (true) {
+    const coreDirName = await findCoreDirIn(dir);
+    if (coreDirName) {
+      const coreDir = join9(dir, coreDirName);
+      return {
+        rootDir: dir,
+        coreDir,
+        coreDirName,
+        localDir: join9(coreDir, "local")
+      };
+    }
+    const parent = dirname7(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+// src/utils/platform-check.ts
+async function isPlatformInitialized() {
+  return await findPlatformLayout() !== null;
+}
+
+// src/utils/manifest.ts
+import { readFile as readFile4, writeFile as writeFile4, access as access2 } from "fs/promises";
+import { join as join10 } from "path";
+import { cwd as cwd3 } from "process";
+function manifestPath(rootDir, coreDirName = "core") {
+  return join10(rootDir, coreDirName, "product.manifest.json");
+}
+async function readManifest(rootDir = cwd3(), coreDirName = "core") {
+  const content = await readFile4(manifestPath(rootDir, coreDirName), "utf-8");
+  return JSON.parse(content);
+}
+async function writeManifest(manifest, rootDir = cwd3(), coreDirName = "core") {
+  await writeFile4(manifestPath(rootDir, coreDirName), JSON.stringify(manifest, null, 2), "utf-8");
+}
+function createInitialManifest(params) {
+  const { organizationName, platformName, platformDisplayName } = params;
+  return {
+    version: "1",
+    product: {
+      name: platformName,
+      displayName: platformDisplayName,
+      organization: organizationName,
+      scope: `@${organizationName}`
+    },
+    applications: []
+  };
+}
+function addApplicationToManifest(manifest, app) {
+  return {
+    ...manifest,
+    applications: [...manifest.applications, app]
+  };
 }
 
 // src/commands/create-application/create-application.command.ts
@@ -486,22 +575,30 @@ var createApplicationCommand = {
 };
 async function createApplication(params, logger) {
   const {
-    organizationName,
-    platformName,
     applicationName,
     applicationDisplayName,
     applicationDescription,
     hasUserInterface,
     hasBackendService
   } = params;
-  if (!await isPlatformInitialized()) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
     return;
   }
-  const rootDir = cwd2();
-  const applicationDir = join10(rootDir, applicationName);
-  const bootstrapServiceDir = join10(applicationDir, "services", `${applicationName}-bootstrap-service`);
-  const localDir = join10(rootDir, "local");
+  const { rootDir, coreDirName, localDir } = layout;
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  const { organization: organizationName, name: platformName } = manifest.product;
+  const localPath = `../${platformName}-${applicationName}`;
+  const applicationDir = resolve(join11(rootDir, coreDirName), localPath);
+  const bootstrapServiceName = `${platformName}-${applicationName}-bootstrap-service`;
+  const bootstrapServiceDir = join11(applicationDir, "services", bootstrapServiceName);
   logger.log(`Creating application monorepo "${applicationName}"...`);
   try {
     await scaffoldApplicationMonorepo(applicationDir, organizationName, platformName, applicationName, logger);
@@ -509,12 +606,12 @@ async function createApplication(params, logger) {
     logger.log(`Error: Could not scaffold application monorepo \u2014 ${formatError(err)}`);
     return;
   }
-  await mkdir2(join10(applicationDir, "services"), { recursive: true });
-  await mkdir2(join10(applicationDir, "ui"), { recursive: true });
-  logger.log(`Creating bootstrap service "${applicationName}-bootstrap-service"...`);
-  const bootstrapServiceDir_var = `${applicationName}/services`;
+  await mkdir2(join11(applicationDir, "services"), { recursive: true });
+  await mkdir2(join11(applicationDir, "ui"), { recursive: true });
+  logger.log(`Creating bootstrap service "${bootstrapServiceName}"...`);
+  const bootstrapServiceBaseDir = `${platformName}-${applicationName}/services`;
   try {
-    await scaffoldBootstrap(bootstrapServiceDir, organizationName, applicationName, bootstrapServiceDir_var, logger);
+    await scaffoldBootstrap(bootstrapServiceDir, organizationName, `${platformName}-${applicationName}`, bootstrapServiceBaseDir, logger);
   } catch (err) {
     logger.log(`Error: Could not scaffold bootstrap service \u2014 ${formatError(err)}`);
     return;
@@ -530,7 +627,7 @@ async function createApplication(params, logger) {
     await addModuleEntry(
       bootstrapServiceDir,
       applicationName,
-      buildUiModuleEntry(organizationName, applicationName, applicationDisplayName),
+      buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName),
       logger
     );
   }
@@ -538,13 +635,14 @@ async function createApplication(params, logger) {
     await addModuleEntry(
       bootstrapServiceDir,
       applicationName,
-      buildServiceModuleEntry(organizationName, applicationName, applicationDisplayName),
+      buildServiceModuleEntry(organizationName, platformName, applicationName, applicationDisplayName),
       logger
     );
   }
   if (hasUserInterface) {
-    const uiDir = join10(applicationDir, "ui", `${applicationName}-ui`);
-    const uiBaseDir = `${applicationName}/ui`;
+    const uiName = `${platformName}-${applicationName}-ui`;
+    const uiDir = join11(applicationDir, "ui", uiName);
+    const uiBaseDir = `${platformName}-${applicationName}/ui`;
     try {
       await scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
     } catch (err) {
@@ -553,36 +651,49 @@ async function createApplication(params, logger) {
     }
   }
   if (hasBackendService) {
-    const serviceDir = join10(applicationDir, "services", `${applicationName}-service`);
-    const serviceBaseDir = `${applicationName}/services`;
+    const serviceName = `${platformName}-${applicationName}-service`;
+    const serviceDir = join11(applicationDir, "services", serviceName);
+    const serviceBaseDir = `${platformName}-${applicationName}/services`;
     try {
-      await scaffoldNestjsService(serviceDir, organizationName, applicationName, applicationDisplayName, serviceBaseDir, logger);
+      await scaffoldNestjsService(serviceDir, organizationName, platformName, applicationName, applicationDisplayName, serviceBaseDir, logger);
     } catch (err) {
       logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
       return;
     }
   }
-  const dockerComposePath = join10(localDir, `${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join11(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const basePort = await getNextAvailablePort(localDir);
   const uiPort = hasUserInterface ? basePort : 0;
   const servicePort = hasBackendService ? hasUserInterface ? basePort + 1 : basePort : 0;
   await createDockerCompose(
     dockerComposePath,
     applicationName,
+    platformName,
     hasUserInterface,
     hasBackendService,
     uiPort,
     servicePort,
     logger
   );
-  const rootDockerComposePath = join10(localDir, "docker-compose.yml");
-  await updateRootDockerCompose(rootDockerComposePath, applicationName, logger);
+  const updatedManifest = addApplicationToManifest(manifest, {
+    name: applicationName,
+    displayName: applicationDisplayName,
+    description: applicationDescription,
+    localPath,
+    repository: null
+  });
+  try {
+    await writeManifest(updatedManifest, rootDir, coreDirName);
+    logger.log(`Updated product manifest with application "${applicationName}".`);
+  } catch (err) {
+    logger.log(`Warning: Could not update product manifest \u2014 ${formatError(err)}`);
+  }
   logger.log(`Done! Application "${applicationName}" created at ${applicationDir}`);
 }
 
 // src/commands/init/init.command.ts
-import { join as join16 } from "path";
-import { cwd as cwd3 } from "process";
+import { join as join17 } from "path";
+import { cwd as cwd4 } from "process";
 
 // src/utils/string.ts
 function camelize(name) {
@@ -591,9 +702,9 @@ function camelize(name) {
 
 // src/commands/init/scaffold-platform.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { join as join11, dirname as dirname7 } from "path";
-var templateDir = join11(
-  dirname7(fileURLToPath6(import.meta.url)),
+import { join as join12, dirname as dirname8 } from "path";
+var templateDir = join12(
+  dirname8(fileURLToPath6(import.meta.url)),
   "..",
   "templates",
   "platform-init-template"
@@ -604,9 +715,9 @@ async function scaffoldPlatform(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-platform-bootstrap.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { join as join12, dirname as dirname8 } from "path";
-var templateDir2 = join12(
-  dirname8(fileURLToPath7(import.meta.url)),
+import { join as join13, dirname as dirname9 } from "path";
+var templateDir2 = join13(
+  dirname9(fileURLToPath7(import.meta.url)),
   "..",
   "templates",
   "bootstrap-service-template"
@@ -617,9 +728,9 @@ async function scaffoldPlatformBootstrap(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-customization-ui.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { join as join13, dirname as dirname9 } from "path";
-var templateDir3 = join13(
-  dirname9(fileURLToPath8(import.meta.url)),
+import { join as join14, dirname as dirname10 } from "path";
+var templateDir3 = join14(
+  dirname10(fileURLToPath8(import.meta.url)),
   "..",
   "templates",
   "customization-ui-module-template"
@@ -629,19 +740,20 @@ async function scaffoldCustomizationUi(outputDir, variables, logger) {
 }
 
 // src/commands/init/register-customization-module.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-async function registerCustomizationModule(bootstrapServiceDir, organizationName, logger) {
-  const modulesJsonPath = join14(bootstrapServiceDir, "src", "data", "platform", "modules.json");
+async function registerCustomizationModule(bootstrapServiceDir, organizationName, logger, platformName = "platform") {
+  const modulesJsonPath = join15(bootstrapServiceDir, "src", "data", "platform", "modules.json");
+  const customizationUiName = `${platformName}-customization-ui`;
   const entry = {
-    name: `@${organizationName}/platform-customization-ui`,
+    name: `@${organizationName}/${customizationUiName}`,
     displayName: "Platform Customization UI",
     type: "app",
-    baseUrl: "/platform-customization-ui",
-    service: { host: "platform-customization-ui", port: 80 },
+    baseUrl: `/${customizationUiName}`,
+    service: { host: customizationUiName, port: 80 },
     ui: {
       route: "/",
-      bundleFile: "platform-customization-ui.js",
+      bundleFile: `${customizationUiName}.js`,
       isPlatformCustomization: true,
       customProps: {}
     },
@@ -655,7 +767,7 @@ async function registerCustomizationModule(bootstrapServiceDir, organizationName
 
 // src/commands/init/generate-local-env.ts
 import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/utils/random.ts
 import { randomBytes } from "crypto";
@@ -664,10 +776,10 @@ function generateRandomSecret() {
 }
 
 // src/commands/init/generate-local-env.ts
-async function generateLocalEnv(outputDir, logger) {
-  const examplePath = join15(outputDir, "local", ".env.example");
-  const envPath = join15(outputDir, "local", ".env");
-  logger.log("Generating local/.env with random secrets...");
+async function generateLocalEnv(outputDir, logger, coreDirName = "core") {
+  const examplePath = join16(outputDir, coreDirName, "local", ".env.example");
+  const envPath = join16(outputDir, coreDirName, "local", ".env");
+  logger.log(`Generating ${coreDirName}/local/.env with random secrets...`);
   const content = await readFile6(examplePath, "utf-8");
   const result = content.replace(/^(PAE_AUTH_JWT_SECRET|PAE_GATEWAY_SERVICE_ACCESS_SECRET|PAE_DB_PASSWORD)=$/gm, (_, key) => {
     return `${key}=${generateRandomSecret()}`;
@@ -688,15 +800,18 @@ async function init(params, logger) {
   }
   const { organizationName, platformName, platformDisplayName } = params;
   const platformTitle = camelize(platformName);
-  const outputDir = cwd3();
+  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 variables = {
     organizationName,
     platformName,
     platformTitle,
     platformDisplayName,
-    bootstrapName: "platform",
-    bootstrapServiceDir: "core/services"
+    bootstrapName: platformName,
+    bootstrapServiceDir: `${coreDirName}/services`
   };
   try {
     await scaffoldPlatform(outputDir, variables, logger);
@@ -705,14 +820,22 @@ async function init(params, logger) {
     return;
   }
   try {
-    await generateLocalEnv(outputDir, logger);
+    await generateLocalEnv(outputDir, logger, coreDirName);
   } catch (err) {
-    logger.log(`Error: Could not generate local/.env \u2014 ${formatError(err)}`);
+    logger.log(`Error: Could not generate ${coreDirName}/local/.env \u2014 ${formatError(err)}`);
+    return;
+  }
+  try {
+    const manifest = createInitialManifest({ organizationName, platformName, platformDisplayName });
+    await writeManifest(manifest, outputDir, coreDirName);
+    logger.log(`Created product manifest: ${coreDirName}/product.manifest.json`);
+  } catch (err) {
+    logger.log(`Error: Could not write product manifest \u2014 ${formatError(err)}`);
     return;
   }
   try {
     await scaffoldPlatformBootstrap(
-      join16(outputDir, "core", "services", "platform-bootstrap-service"),
+      join17(outputDir, coreDirName, "services", bootstrapServiceName),
       variables,
       logger
     );
@@ -722,7 +845,7 @@ async function init(params, logger) {
   }
   try {
     await scaffoldCustomizationUi(
-      join16(outputDir, "core", "ui", "platform-customization-ui"),
+      join17(outputDir, coreDirName, "ui", customizationUiName),
       variables,
       logger
     );
@@ -732,9 +855,10 @@ async function init(params, logger) {
   }
   try {
     await registerCustomizationModule(
-      join16(outputDir, "core", "services", "platform-bootstrap-service"),
+      join17(outputDir, coreDirName, "services", bootstrapServiceName),
       organizationName,
-      logger
+      logger,
+      platformName
     );
   } catch (err) {
     logger.log(`Error: Could not register customization module \u2014 ${formatError(err)}`);
@@ -744,8 +868,7 @@ async function init(params, logger) {
 }
 
 // src/commands/configure-idp/configure-idp.command.ts
-import { join as join17 } from "path";
-import { cwd as cwd4 } from "process";
+import { join as join18 } from "path";
 import { fetch as undiciFetch, Agent } from "undici";
 
 // src/utils/env-reader.ts
@@ -823,11 +946,12 @@ var configureIdpCommand = {
   description: "Configure an Identity Provider (IDP) in the gateway"
 };
 async function configureIdp(params, logger) {
-  if (!await isPlatformInitialized()) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const envPath = join17(cwd4(), "local", ".env");
+  const envPath = join18(layout.localDir, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -838,11 +962,11 @@ async function configureIdp(params, logger) {
   const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
   const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
   if (!gatewayUrl) {
-    logger.log("Error: PAE_GATEWAY_HOST_URL is not set in local/.env");
+    logger.log("Error: PAE_GATEWAY_HOST_URL is not set in core/local/.env");
     return;
   }
   if (!accessSecret) {
-    logger.log("Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in local/.env");
+    logger.log("Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in core/local/.env");
     return;
   }
   const provider = idpProviderRegistry.get(params.providerType);
@@ -879,15 +1003,14 @@ async function configureIdp(params, logger) {
 }
 
 // src/commands/create-service-module/create-service-module.command.ts
-import { join as join19 } from "path";
-import { cwd as cwd5 } from "process";
-import { access as access2, readFile as readFile9 } from "fs/promises";
+import { join as join20, resolve as resolve2 } from "path";
+import { access as access3 } from "fs/promises";
 
 // src/commands/create-service-module/scaffold-service-module.ts
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { join as join18, dirname as dirname10 } from "path";
-var nestjsServiceModuleTemplateDir2 = join18(
-  dirname10(fileURLToPath9(import.meta.url)),
+import { join as join19, dirname as dirname11 } from "path";
+var nestjsServiceModuleTemplateDir2 = join19(
+  dirname11(fileURLToPath9(import.meta.url)),
   "..",
   "templates",
   "nestjs-service-module-template"
@@ -922,11 +1045,11 @@ function buildCustomServiceModuleEntry(organizationName, serviceName, serviceDis
 
 // src/commands/create-service-module/append-docker-compose.ts
 import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-async function appendServiceToDockerCompose(dockerComposePath, serviceName, applicationName, port, logger) {
+async function appendServiceToDockerCompose(dockerComposePath, serviceName, platformName, applicationName, port, logger) {
   const block = `
   ${serviceName}:
     build:
-      context: ../${applicationName}/services/${serviceName}
+      context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -935,7 +1058,7 @@ async function appendServiceToDockerCompose(dockerComposePath, serviceName, appl
     environment:
       - GATEWAY_URL=\${PAE_GATEWAY_URL}
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
   try {
     const existing = await readFile8(dockerComposePath, "utf-8");
@@ -955,41 +1078,41 @@ var createServiceModuleCommand = {
 };
 async function createServiceModule(params, logger) {
   const { applicationName, serviceName, serviceDisplayName } = params;
-  if (!await isPlatformInitialized()) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
-  const rootDir = cwd5();
-  const applicationDir = join19(rootDir, applicationName);
+  const { rootDir, coreDirName, localDir } = layout;
+  let manifest;
   try {
-    await access2(applicationDir);
+    manifest = await readManifest(rootDir, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  const { organization: organizationName, name: platformName } = manifest.product;
+  const appEntry = manifest.applications.find((a) => a.name === applicationName);
+  if (!appEntry) {
+    logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
+    return;
+  }
+  const applicationDir = resolve2(join20(rootDir, coreDirName), appEntry.localPath);
+  try {
+    await access3(applicationDir);
   } catch {
     logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
-  const fullServiceName = `${serviceName}-service`;
-  const serviceDir = join19(applicationDir, "services", fullServiceName);
+  const fullServiceName = `${platformName}-${serviceName}-service`;
+  const serviceDir = join20(applicationDir, "services", fullServiceName);
   try {
-    await access2(serviceDir);
+    await access3(serviceDir);
     logger.log(`Error: A service named "${fullServiceName}" already exists in application "${applicationName}".`);
     return;
   } catch {
   }
-  let organizationName;
-  try {
-    const corePackageJson = JSON.parse(
-      await readFile9(join19(rootDir, "core", "package.json"), "utf-8")
-    );
-    const scopeMatch = corePackageJson.name.match(/^@([^/]+)\//);
-    organizationName = scopeMatch?.[1];
-    if (!organizationName) {
-      throw new Error(`Could not parse organization from package name: "${corePackageJson.name}"`);
-    }
-  } catch (err) {
-    logger.log(`Error: Could not read core/package.json \u2014 ${formatError(err)}`);
-    return;
-  }
-  const serviceBaseDir = `${applicationName}/services`;
+  const serviceBaseDir = `${platformName}-${applicationName}/services`;
   try {
     await scaffoldServiceModule(
       serviceDir,
@@ -1003,36 +1126,35 @@ async function createServiceModule(params, logger) {
     logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
     return;
   }
-  const bootstrapServiceDir = join19(applicationDir, "services", `${applicationName}-bootstrap-service`);
+  const bootstrapServiceDir = join20(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
   const moduleEntry = buildCustomServiceModuleEntry(organizationName, fullServiceName, serviceDisplayName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
-  const localDir = join19(rootDir, "local");
-  const dockerComposePath = join19(localDir, `${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join20(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const port = await getNextAvailablePort(localDir);
-  await appendServiceToDockerCompose(dockerComposePath, fullServiceName, applicationName, port, logger);
+  await appendServiceToDockerCompose(dockerComposePath, fullServiceName, platformName, applicationName, port, logger);
   logger.log(`Done! Service module "${fullServiceName}" added to application "${applicationName}".`);
 }
 
 // src/commands/create-ui-module/create-ui-module.command.ts
-import { join as join20 } from "path";
-import { cwd as cwd6 } from "process";
-import { access as access3, readdir as readdir3, readFile as readFile11 } from "fs/promises";
+import { join as join21, resolve as resolve3 } from "path";
+import { access as access4, readdir as readdir4 } from "fs/promises";
 
 // src/commands/create-ui-module/append-ui-docker-compose.ts
-import { readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
-async function appendUiToDockerCompose(dockerComposePath, applicationName, port, logger) {
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger) {
+  const uiName = `${platformName}-${applicationName}-ui`;
   const block = `
-  ${applicationName}-ui:
+  ${uiName}:
     build:
-      context: ../${applicationName}/ui/${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${port}:80
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
   try {
-    const existing = await readFile10(dockerComposePath, "utf-8");
+    const existing = await readFile9(dockerComposePath, "utf-8");
     await writeFile8(dockerComposePath, existing + block, "utf-8");
     logger.log(`Updated docker-compose: ${dockerComposePath}`);
   } catch (err) {
@@ -1049,21 +1171,35 @@ var createUiModuleCommand = {
 };
 async function createUiModule(params, logger) {
   const { applicationName, applicationDisplayName } = params;
-  if (!await isPlatformInitialized()) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
-  const rootDir = cwd6();
-  const applicationDir = join20(rootDir, applicationName);
+  const { rootDir, coreDirName, localDir } = layout;
+  let manifest;
   try {
-    await access3(applicationDir);
+    manifest = await readManifest(rootDir, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  const { organization: organizationName, name: platformName } = manifest.product;
+  const appEntry = manifest.applications.find((a) => a.name === applicationName);
+  if (!appEntry) {
+    logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
+    return;
+  }
+  const applicationDir = resolve3(join21(rootDir, coreDirName), appEntry.localPath);
+  try {
+    await access4(applicationDir);
   } catch {
     logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
-  const uiDir = join20(applicationDir, "ui");
+  const uiDir = join21(applicationDir, "ui");
   try {
-    const uiEntries = await readdir3(uiDir);
+    const uiEntries = await readdir4(uiDir);
     const existingUiModules = uiEntries.filter((e) => e !== ".gitkeep");
     if (existingUiModules.length > 0) {
       logger.log(`Error: Currently we support only one UI module per application. Application "${applicationName}" already has a UI module.`);
@@ -1071,39 +1207,22 @@ async function createUiModule(params, logger) {
     }
   } catch {
   }
-  let organizationName;
-  let platformName;
-  try {
-    const corePackageJson = JSON.parse(
-      await readFile11(join20(rootDir, "core", "package.json"), "utf-8")
-    );
-    const scopeMatch = corePackageJson.name.match(/^@([^/]+)\//);
-    organizationName = scopeMatch?.[1];
-    const rawName = corePackageJson.name.replace(/^@[^/]+\//, "").replace(/-core$/, "");
-    platformName = rawName;
-    if (!organizationName || !platformName) {
-      throw new Error(`Could not parse organization/platform from package name: "${corePackageJson.name}"`);
-    }
-  } catch (err) {
-    logger.log(`Error: Could not read core/package.json \u2014 ${formatError(err)}`);
-    return;
-  }
-  const uiOutputDir = join20(uiDir, `${applicationName}-ui`);
-  const uiBaseDir = `${applicationName}/ui`;
+  const uiName = `${platformName}-${applicationName}-ui`;
+  const uiOutputDir = join21(uiDir, uiName);
+  const uiBaseDir = `${platformName}-${applicationName}/ui`;
   try {
     await scaffoldUiModule(uiOutputDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
   } catch (err) {
     logger.log(`Error: Could not scaffold UI module \u2014 ${formatError(err)}`);
     return;
   }
-  const bootstrapServiceDir = join20(applicationDir, "services", `${applicationName}-bootstrap-service`);
-  const moduleEntry = buildUiModuleEntry(organizationName, applicationName, applicationDisplayName);
+  const bootstrapServiceDir = join21(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
+  const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
-  const localDir = join20(rootDir, "local");
-  const dockerComposePath = join20(localDir, `${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join21(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const port = await getNextAvailablePort(localDir);
-  await appendUiToDockerCompose(dockerComposePath, applicationName, port, logger);
-  logger.log(`Done! UI module "${applicationName}-ui" added to application "${applicationName}".`);
+  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger);
+  logger.log(`Done! UI module "${uiName}" added to application "${applicationName}".`);
 }
 
 // src/commands/registry.ts
@@ -1145,11 +1264,6 @@ var APP_STATE = {
 // src/hooks/use-command-runner.ts
 import { useState as useState2, useCallback, useRef } from "react";
 
-// src/controllers/ui/create-application.ui-controller.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join21 } from "path";
-import { cwd as cwd7 } from "process";
-
 // src/services/create-application.service.ts
 async function createApplicationService(params, logger) {
   await createApplication(params, logger);
@@ -1161,24 +1275,6 @@ async function createApplicationUiController(ctx) {
     ctx.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
     return;
   }
-  let organizationName;
-  let platformName;
-  try {
-    const corePackageJson = JSON.parse(
-      await readFile12(join21(cwd7(), "core", "package.json"), "utf-8")
-    );
-    const scopeMatch = corePackageJson.name.match(/^@([^/]+)\//);
-    organizationName = scopeMatch?.[1];
-    const rawName = corePackageJson.name.replace(/^@[^/]+\//, "").replace(/-core$/, "");
-    platformName = rawName;
-    if (!organizationName || !platformName) {
-      throw new Error(`Could not parse organization/platform from package name: "${corePackageJson.name}"`);
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    ctx.log(`Error: Could not read core/package.json \u2014 ${message}`);
-    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.`);
@@ -1198,8 +1294,6 @@ async function createApplicationUiController(ctx) {
   }
   await createApplicationService(
     {
-      organizationName,
-      platformName,
       applicationName,
       applicationDisplayName,
       applicationDescription,
@@ -1333,7 +1427,7 @@ function useCommandRunner({ appendStaticItem, setState }) {
     abortControllerRef.current = null;
     promptResolveRef.current = null;
   }, []);
-  const runCommand = useCallback(
+  const runCommand2 = useCallback(
     (cmd) => {
       const controller = new AbortController();
       abortControllerRef.current = controller;
@@ -1347,14 +1441,14 @@ function useCommandRunner({ appendStaticItem, setState }) {
           }
         },
         prompt(message) {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve5, reject) => {
             if (controller.signal.aborted) {
               reject(new DOMException("Aborted", "AbortError"));
               return;
             }
             setPromptMessage(message);
             setPromptValue("");
-            promptResolveRef.current = resolve;
+            promptResolveRef.current = resolve5;
             setState(APP_STATE.PROMPTING);
             controller.signal.addEventListener(
               "abort",
@@ -1386,15 +1480,15 @@ function useCommandRunner({ appendStaticItem, setState }) {
   );
   const handlePromptSubmit = useCallback(
     (value) => {
-      const resolve = promptResolveRef.current;
+      const resolve5 = promptResolveRef.current;
       promptResolveRef.current = null;
       setState(APP_STATE.EXECUTING);
-      resolve?.(value);
+      resolve5?.(value);
     },
     [setState]
   );
   return {
-    runCommand,
+    runCommand: runCommand2,
     handlePromptSubmit,
     abortExecution,
     promptMessage,
@@ -1404,7 +1498,7 @@ function useCommandRunner({ appendStaticItem, setState }) {
 }
 
 // src/app.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 function App() {
@@ -1416,7 +1510,7 @@ function App() {
   const appendStaticItem = useCallback2((item) => {
     setStaticItems((prev) => [...prev, item]);
   }, []);
-  const { runCommand, handlePromptSubmit, abortExecution, promptMessage, promptValue, setPromptValue } = useCommandRunner({ appendStaticItem, setState });
+  const { runCommand: runCommand2, handlePromptSubmit, abortExecution, promptMessage, promptValue, setPromptValue } = useCommandRunner({ appendStaticItem, setState });
   const query = inputValue.startsWith("/") ? inputValue.slice(1) : "";
   const filteredCommands = registry.search(query);
   useInput(
@@ -1448,7 +1542,7 @@ function App() {
           const cmd = filteredCommands[selectedIndex];
           if (cmd) {
             setInputValue("");
-            runCommand(cmd);
+            runCommand2(cmd);
           }
           return;
         }
@@ -1484,24 +1578,24 @@ function App() {
       if (!value.startsWith("/")) return;
       const name = value.slice(1).trim();
       const cmd = registry.get(name);
-      if (cmd) runCommand(cmd);
+      if (cmd) runCommand2(cmd);
     },
-    [runCommand]
+    [runCommand2]
   );
   function renderActiveArea() {
     switch (state) {
       case APP_STATE.EXECUTING:
-        return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "row", gap: 1, children: [
-          /* @__PURE__ */ jsx6(Spinner, { label: "Running\u2026" }),
-          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "(esc to cancel)" })
+        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__ */ jsxs5(Box4, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: promptMessage }),
-          /* @__PURE__ */ jsx6(Prompt, { value: promptValue, onChange: setPromptValue, onSubmit: handlePromptSubmit })
+        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__ */ jsx6(
+        return /* @__PURE__ */ jsx7(
           Prompt,
           {
             value: inputValue,
@@ -1514,17 +1608,14 @@ function App() {
         );
     }
   }
-  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx6(ScrollbackHistory, { items: staticItems, version }),
+  return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(ScrollbackHistory, { items: staticItems, version }),
     renderActiveArea(),
-    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx6(CommandPalette, { commands: filteredCommands, selectedIndex })
+    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx7(CommandPalette, { commands: filteredCommands, selectedIndex })
   ] });
 }
 
 // src/controllers/cli/create-application.cli-controller.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join22 } from "path";
-import { cwd as cwd8 } from "process";
 async function createApplicationCliController(args2) {
   if (!await isPlatformInitialized()) {
     console.error("Error: Cannot create an application \u2014 no platform initialized in this directory.");
@@ -1545,28 +1636,8 @@ async function createApplicationCliController(args2) {
     console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
     process.exit(1);
   }
-  let organizationName;
-  let platformName;
-  try {
-    const corePackageJson = JSON.parse(
-      await readFile13(join22(cwd8(), "core", "package.json"), "utf-8")
-    );
-    const scopeMatch = corePackageJson.name.match(/^@([^/]+)\//);
-    organizationName = scopeMatch?.[1];
-    const rawName = corePackageJson.name.replace(/^@[^/]+\//, "").replace(/-core$/, "");
-    platformName = rawName;
-    if (!organizationName || !platformName) {
-      throw new Error(`Could not parse organization/platform from package name: "${corePackageJson.name}"`);
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error: Could not read core/package.json \u2014 ${message}`);
-    process.exit(1);
-  }
   await createApplicationService(
     {
-      organizationName,
-      platformName,
       applicationName,
       applicationDisplayName,
       applicationDescription,
@@ -1623,22 +1694,187 @@ async function configureIdpCliController(args2) {
   await configureIdpService({ providerType, name, issuer, clientId, clientSecret, extras }, logger);
 }
 
-// src/utils/run-npm-script.ts
+// src/commands/local-scripts/docker-compose-orchestrator.ts
 import { spawn } from "child_process";
-import { access as access4 } from "fs/promises";
-import { join as join23 } from "path";
-async function runNpmScript(scriptName, logger, signal) {
-  const localDir = join23(process.cwd(), "local");
+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 = spawn("docker", ["compose", ...args2], {
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: rootDir
+    });
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (signal) {
+      if (signal.aborted) {
+        child.kill("SIGTERM");
+        resolvePromise();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout.on("data", (data) => {
+      for (const line of data.toString().split("\n")) {
+        if (line.trim()) logger.log(line);
+      }
+    });
+    child.stderr.on("data", (data) => {
+      for (const line of data.toString().split("\n")) {
+        if (line.trim()) logger.log(line);
+      }
+    });
+    child.on("close", (code, sig) => {
+      signal?.removeEventListener("abort", onAbort);
+      if (sig === "SIGTERM" || signal?.aborted) {
+        logger.log("Command cancelled.");
+      } else if (code !== 0) {
+        logger.log(`docker compose exited with code ${code}.`);
+      }
+      resolvePromise();
+    });
+    child.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      logger.log(`Failed to run docker compose: ${err.message}`);
+      resolvePromise();
+    });
+  });
+}
+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`);
+    let resolved = null;
+    try {
+      await access5(prefixedPath);
+      resolved = prefixedPath;
+    } catch {
+      try {
+        await access5(unprefixedPath);
+        resolved = unprefixedPath;
+      } catch {
+      }
+    }
+    if (resolved) {
+      results.push({ composePath: resolved, appName: app.name });
+    }
+  }
+  return results;
+}
+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");
+  let coreComposePath;
   try {
-    await access4(localDir);
+    await access5(prefixedCoreCompose);
+    coreComposePath = prefixedCoreCompose;
   } catch {
-    logger.log(`Error: "local/" directory not found. Run "platform init" first.`);
-    return;
+    coreComposePath = unprefixedCoreCompose;
+  }
+  const fileArgs = [
+    "-f",
+    join22(localDir, "platform-docker-compose.yml"),
+    "-f",
+    coreComposePath
+  ];
+  const appEntries = await getAppComposePaths(localDir, platformName, manifest);
+  for (const { composePath } of appEntries) {
+    fileArgs.push("-f", composePath);
+  }
+  for (const app of manifest.applications) {
+    if (!appEntries.find((e) => e.appName === app.name)) {
+      logger.log(`Warning: No docker-compose found for application "${app.name}" in ${coreDirName}/local/ \u2014 skipping.`);
+    }
   }
-  return new Promise((resolve) => {
-    const child = spawn("npm", ["run", scriptName], {
-      cwd: localDir,
-      shell: true,
+  return fileArgs;
+}
+async function startEnvironment(layout, manifest, logger, signal) {
+  const { rootDir, localDir } = layout;
+  const platformName = manifest.product.name;
+  const envFile = join22(localDir, ".env");
+  const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
+  logger.log("Starting environment...");
+  await runDockerCompose(
+    [
+      "-p",
+      `${platformName}-platform`,
+      "--project-directory",
+      localDir,
+      "--env-file",
+      envFile,
+      ...fileArgs,
+      "up",
+      "-d",
+      "--build",
+      "--remove-orphans"
+    ],
+    logger,
+    rootDir,
+    signal
+  );
+}
+async function stopEnvironment(layout, manifest, logger, signal) {
+  const { rootDir, localDir } = layout;
+  const platformName = manifest.product.name;
+  const envFile = join22(localDir, ".env");
+  const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
+  logger.log("Stopping environment...");
+  await runDockerCompose(
+    [
+      "-p",
+      `${platformName}-platform`,
+      "--project-directory",
+      localDir,
+      "--env-file",
+      envFile,
+      ...fileArgs,
+      "down"
+    ],
+    logger,
+    rootDir,
+    signal
+  );
+}
+async function destroyEnvironment(layout, manifest, logger, signal) {
+  const { rootDir, localDir } = layout;
+  const platformName = manifest.product.name;
+  const envFile = join22(localDir, ".env");
+  const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
+  logger.log("Destroying environment...");
+  await runDockerCompose(
+    [
+      "-p",
+      `${platformName}-platform`,
+      "--project-directory",
+      localDir,
+      "--env-file",
+      envFile,
+      ...fileArgs,
+      "down",
+      "-v",
+      "--rmi",
+      "all"
+    ],
+    logger,
+    rootDir,
+    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";
+function runCommand(command, args2, workDir, logger, signal) {
+  return new Promise((resolvePromise) => {
+    const child = spawn2(command, args2, {
+      cwd: workDir,
+      shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
     const onAbort = () => {
@@ -1647,7 +1883,7 @@ async function runNpmScript(scriptName, logger, signal) {
     if (signal) {
       if (signal.aborted) {
         child.kill("SIGTERM");
-        resolve();
+        resolvePromise();
         return;
       }
       signal.addEventListener("abort", onAbort, { once: true });
@@ -1665,19 +1901,72 @@ async function runNpmScript(scriptName, logger, signal) {
     child.on("close", (code, sig) => {
       signal?.removeEventListener("abort", onAbort);
       if (sig === "SIGTERM" || signal?.aborted) {
-        logger.log(`Command cancelled.`);
+        logger.log("Command cancelled.");
       } else if (code !== 0) {
-        logger.log(`Command "npm run ${scriptName}" exited with code ${code}.`);
+        logger.log(`Command "${command} ${args2.join(" ")}" exited with code ${code}.`);
       }
-      resolve();
+      resolvePromise();
     });
     child.on("error", (err) => {
       signal?.removeEventListener("abort", onAbort);
-      logger.log(`Failed to run "npm run ${scriptName}": ${err.message}`);
-      resolve();
+      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) {
+  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 = [{ name: coreDirName, dir: coreDir }, ...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) {
+  const { coreDir, coreDirName } = layout;
+  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";
@@ -1686,7 +1975,38 @@ var START_COMMAND_NAME = "start";
 var STOP_COMMAND_NAME = "stop";
 var DESTROY_COMMAND_NAME = "destroy";
 async function runLocalScript(scriptName, logger, signal) {
-  await runNpmScript(scriptName, logger, signal);
+  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;
+  }
+  switch (scriptName) {
+    case START_COMMAND_NAME:
+      await startEnvironment(layout, manifest, logger, signal);
+      break;
+    case STOP_COMMAND_NAME:
+      await stopEnvironment(layout, manifest, logger, signal);
+      break;
+    case DESTROY_COMMAND_NAME:
+      await destroyEnvironment(layout, manifest, logger, signal);
+      break;
+    case INSTALL_COMMAND_NAME:
+      await installDependencies(layout, manifest, logger, signal);
+      break;
+    case BUILD_COMMAND_NAME:
+      await buildAll(layout, manifest, logger, signal);
+      break;
+    default:
+      logger.log(`Error: Unknown script "${scriptName}".`);
+  }
 }
 
 // src/services/local-script.service.ts
@@ -1812,10 +2132,10 @@ function parseKeyValueArgs(args2) {
 }
 
 // src/index.tsx
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { jsx as jsx8 } from "react/jsx-runtime";
 var args = process.argv.slice(2);
 if (args.length === 0) {
-  render(/* @__PURE__ */ jsx7(App, {}));
+  render(/* @__PURE__ */ jsx8(App, {}));
 } else {
   const commandName = args[0];
   const params = parseKeyValueArgs(args.slice(1));