@bluealba/platform-cli 0.3.0-feature-platform-cli-222 → 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,7 +147,7 @@ function Spinner({ label }) {
 import { Fzf } from "fzf";
 
 // src/commands/create-application/create-application.command.ts
-import { join as join10, resolve } from "path";
+import { join as join11, resolve } from "path";
 import { mkdir as mkdir2 } from "fs/promises";
 
 // src/commands/create-application/scaffold-application-monorepo.ts
@@ -289,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(
@@ -321,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,9 +382,10 @@ function buildUiModuleEntry(organizationName, applicationName, applicationDispla
 // src/commands/create-application/create-docker-compose.ts
 import { writeFile as writeFile3 } from "fs/promises";
 function buildBootstrapBlock(platformName, applicationName) {
-  return `  ${applicationName}-bootstrap-service:
+  const bootstrapName = `${platformName}-${applicationName}-bootstrap-service`;
+  return `  ${bootstrapName}:
     build:
-      context: ../../${platformName}-${applicationName}/services/${applicationName}-bootstrap-service
+      context: ../../${platformName}-${applicationName}/services/${bootstrapName}
       dockerfile: Dockerfile.development
     environment:
       - NODE_TLS_REJECT_UNAUTHORIZED=0
@@ -376,9 +402,10 @@ function buildBootstrapBlock(platformName, applicationName) {
 `;
 }
 function buildUiBlock(platformName, applicationName, uiPort) {
-  return `  ${applicationName}-ui:
+  const uiName = `${platformName}-${applicationName}-ui`;
+  return `  ${uiName}:
     build:
-      context: ../../${platformName}-${applicationName}/ui/${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${uiPort}:80
@@ -387,9 +414,10 @@ function buildUiBlock(platformName, applicationName, uiPort) {
 `;
 }
 function buildBackendBlock(platformName, applicationName, servicePort) {
-  return `  ${applicationName}-service:
+  const serviceName = `${platformName}-${applicationName}-service`;
+  return `  ${serviceName}:
     build:
-      context: ../../${platformName}-${applicationName}/services/${applicationName}-service
+      context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -422,9 +450,8 @@ async function createDockerCompose(dockerComposePath, applicationName, platformN
 // src/commands/create-application/port-allocator.ts
 import { join as join8 } from "path";
 import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-async function getNextAvailablePort(rootDir) {
+async function getNextAvailablePort(localDir) {
   const allPorts = [];
-  const localDir = join8(rootDir, "core", "local");
   try {
     const files = await readdir2(localDir);
     const ymlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
@@ -449,32 +476,76 @@ function formatError(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/utils/platform-check.ts
+// 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";
-import { dirname as dirname7 } from "path";
+async function findCoreDirIn(dir) {
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    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 } from "fs/promises";
-import { join as join9 } from "path";
-import { cwd } from "process";
-var MANIFEST_RELATIVE_PATH = join9("core", "product.manifest.json");
-function manifestPath(rootDir) {
-  return join9(rootDir, MANIFEST_RELATIVE_PATH);
+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 = cwd()) {
-  const content = await readFile4(manifestPath(rootDir), "utf-8");
+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 = cwd()) {
-  await writeFile4(manifestPath(rootDir), JSON.stringify(manifest, null, 2), "utf-8");
-}
-async function manifestExists(rootDir = cwd()) {
-  try {
-    await access(manifestPath(rootDir));
-    return true;
-  } catch {
-    return false;
-  }
+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;
@@ -496,24 +567,6 @@ function addApplicationToManifest(manifest, app) {
   };
 }
 
-// src/utils/platform-check.ts
-async function findRootDir(startDir = cwd2()) {
-  let dir = startDir;
-  while (true) {
-    if (await manifestExists(dir)) {
-      return dir;
-    }
-    const parent = dirname7(dir);
-    if (parent === dir) {
-      return null;
-    }
-    dir = parent;
-  }
-}
-async function isPlatformInitialized() {
-  return await findRootDir() !== null;
-}
-
 // src/commands/create-application/create-application.command.ts
 var CREATE_APPLICATION_COMMAND_NAME = "create-application";
 var createApplicationCommand = {
@@ -528,22 +581,24 @@ async function createApplication(params, logger) {
     hasUserInterface,
     hasBackendService
   } = params;
-  const rootDir = await findRootDir();
-  if (!rootDir) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
     return;
   }
+  const { rootDir, coreDirName, localDir } = layout;
   let manifest;
   try {
-    manifest = await readManifest(rootDir);
+    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(join10(rootDir, "core"), localPath);
-  const bootstrapServiceDir = join10(applicationDir, "services", `${applicationName}-bootstrap-service`);
+  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);
@@ -551,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 = `${platformName}-${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;
@@ -572,7 +627,7 @@ async function createApplication(params, logger) {
     await addModuleEntry(
       bootstrapServiceDir,
       applicationName,
-      buildUiModuleEntry(organizationName, applicationName, applicationDisplayName),
+      buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName),
       logger
     );
   }
@@ -580,12 +635,13 @@ 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 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);
@@ -595,17 +651,18 @@ async function createApplication(params, logger) {
     }
   }
   if (hasBackendService) {
-    const serviceDir = join10(applicationDir, "services", `${applicationName}-service`);
+    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(rootDir, "core", "local", `${applicationName}-docker-compose.yml`);
-  const basePort = await getNextAvailablePort(rootDir);
+  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(
@@ -626,7 +683,7 @@ async function createApplication(params, logger) {
     repository: null
   });
   try {
-    await writeManifest(updatedManifest, rootDir);
+    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)}`);
@@ -635,8 +692,8 @@ async function createApplication(params, logger) {
 }
 
 // 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) {
@@ -645,8 +702,8 @@ function camelize(name) {
 
 // src/commands/init/scaffold-platform.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { join as join11, dirname as dirname8 } from "path";
-var templateDir = join11(
+import { join as join12, dirname as dirname8 } from "path";
+var templateDir = join12(
   dirname8(fileURLToPath6(import.meta.url)),
   "..",
   "templates",
@@ -658,8 +715,8 @@ 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 dirname9 } from "path";
-var templateDir2 = join12(
+import { join as join13, dirname as dirname9 } from "path";
+var templateDir2 = join13(
   dirname9(fileURLToPath7(import.meta.url)),
   "..",
   "templates",
@@ -671,8 +728,8 @@ 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 dirname10 } from "path";
-var templateDir3 = join13(
+import { join as join14, dirname as dirname10 } from "path";
+var templateDir3 = join14(
   dirname10(fileURLToPath8(import.meta.url)),
   "..",
   "templates",
@@ -683,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: {}
     },
@@ -709,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";
@@ -718,10 +776,10 @@ function generateRandomSecret() {
 }
 
 // src/commands/init/generate-local-env.ts
-async function generateLocalEnv(outputDir, logger) {
-  const examplePath = join15(outputDir, "core", "local", ".env.example");
-  const envPath = join15(outputDir, "core", "local", ".env");
-  logger.log("Generating core/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()}`;
@@ -742,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);
@@ -759,22 +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 core/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);
-    logger.log("Created product manifest: core/product.manifest.json");
+    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
     );
@@ -784,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
     );
@@ -794,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)}`);
@@ -806,7 +868,7 @@ async function init(params, logger) {
 }
 
 // src/commands/configure-idp/configure-idp.command.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { fetch as undiciFetch, Agent } from "undici";
 
 // src/utils/env-reader.ts
@@ -884,12 +946,12 @@ var configureIdpCommand = {
   description: "Configure an Identity Provider (IDP) in the gateway"
 };
 async function configureIdp(params, logger) {
-  const rootDir = await findRootDir();
-  if (!rootDir) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const envPath = join17(rootDir, "core", "local", ".env");
+  const envPath = join18(layout.localDir, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -941,13 +1003,13 @@ async function configureIdp(params, logger) {
 }
 
 // src/commands/create-service-module/create-service-module.command.ts
-import { join as join19, resolve as resolve2 } from "path";
-import { access as access2 } 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 dirname11 } from "path";
-var nestjsServiceModuleTemplateDir2 = join18(
+import { join as join19, dirname as dirname11 } from "path";
+var nestjsServiceModuleTemplateDir2 = join19(
   dirname11(fileURLToPath9(import.meta.url)),
   "..",
   "templates",
@@ -1016,14 +1078,15 @@ var createServiceModuleCommand = {
 };
 async function createServiceModule(params, logger) {
   const { applicationName, serviceName, serviceDisplayName } = params;
-  const rootDir = await findRootDir();
-  if (!rootDir) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
+  const { rootDir, coreDirName, localDir } = layout;
   let manifest;
   try {
-    manifest = await readManifest(rootDir);
+    manifest = await readManifest(rootDir, coreDirName);
   } catch (err) {
     logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
     return;
@@ -1034,17 +1097,17 @@ async function createServiceModule(params, logger) {
     logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
     return;
   }
-  const applicationDir = resolve2(join19(rootDir, "core"), appEntry.localPath);
+  const applicationDir = resolve2(join20(rootDir, coreDirName), appEntry.localPath);
   try {
-    await access2(applicationDir);
+    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 {
@@ -1063,26 +1126,27 @@ 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 dockerComposePath = join19(rootDir, "core", "local", `${applicationName}-docker-compose.yml`);
-  const port = await getNextAvailablePort(rootDir);
+  const dockerComposePath = join20(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const port = await getNextAvailablePort(localDir);
   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, resolve as resolve3 } from "path";
-import { access as access3, readdir as readdir3 } 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 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: ../../${platformName}-${applicationName}/ui/${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${port}:80
@@ -1107,14 +1171,15 @@ var createUiModuleCommand = {
 };
 async function createUiModule(params, logger) {
   const { applicationName, applicationDisplayName } = params;
-  const rootDir = await findRootDir();
-  if (!rootDir) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
+  const { rootDir, coreDirName, localDir } = layout;
   let manifest;
   try {
-    manifest = await readManifest(rootDir);
+    manifest = await readManifest(rootDir, coreDirName);
   } catch (err) {
     logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
     return;
@@ -1125,16 +1190,16 @@ async function createUiModule(params, logger) {
     logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
     return;
   }
-  const applicationDir = resolve3(join20(rootDir, "core"), appEntry.localPath);
+  const applicationDir = resolve3(join21(rootDir, coreDirName), appEntry.localPath);
   try {
-    await access3(applicationDir);
+    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.`);
@@ -1142,7 +1207,8 @@ async function createUiModule(params, logger) {
     }
   } catch {
   }
-  const uiOutputDir = join20(uiDir, `${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);
@@ -1150,13 +1216,13 @@ async function createUiModule(params, logger) {
     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 dockerComposePath = join20(rootDir, "core", "local", `${applicationName}-docker-compose.yml`);
-  const port = await getNextAvailablePort(rootDir);
+  const dockerComposePath = join21(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const port = await getNextAvailablePort(localDir);
   await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger);
-  logger.log(`Done! UI module "${applicationName}-ui" added to application "${applicationName}".`);
+  logger.log(`Done! UI module "${uiName}" added to application "${applicationName}".`);
 }
 
 // src/commands/registry.ts
@@ -1432,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() {
@@ -1519,17 +1585,17 @@ function App() {
   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,
@@ -1542,10 +1608,10 @@ 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 })
   ] });
 }
 
@@ -1630,8 +1696,8 @@ async function configureIdpCliController(args2) {
 
 // src/commands/local-scripts/docker-compose-orchestrator.ts
 import { spawn } from "child_process";
-import { access as access4 } from "fs/promises";
-import { join as join21 } from "path";
+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], {
@@ -1676,42 +1742,62 @@ function runDockerCompose(args2, logger, rootDir, signal) {
     });
   });
 }
-async function getAppComposePaths(rootDir, manifest) {
+async function getAppComposePaths(localDir, platformName, manifest) {
   const results = [];
   for (const app of manifest.applications) {
-    const composePath = join21(rootDir, "core", "local", `${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 access4(composePath);
-      results.push({ composePath, appName: app.name });
+      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(rootDir, manifest, logger) {
-  const localDir = join21(rootDir, "core", "local");
+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 access5(prefixedCoreCompose);
+    coreComposePath = prefixedCoreCompose;
+  } catch {
+    coreComposePath = unprefixedCoreCompose;
+  }
   const fileArgs = [
     "-f",
-    join21(localDir, "platform-docker-compose.yml"),
+    join22(localDir, "platform-docker-compose.yml"),
     "-f",
-    join21(localDir, "core-docker-compose.yml")
+    coreComposePath
   ];
-  const appEntries = await getAppComposePaths(rootDir, manifest);
-  for (const { composePath, appName } of appEntries) {
+  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 core/local/ \u2014 skipping.`);
+      logger.log(`Warning: No docker-compose found for application "${app.name}" in ${coreDirName}/local/ \u2014 skipping.`);
     }
   }
   return fileArgs;
 }
-async function startEnvironment(rootDir, manifest, logger, signal) {
+async function startEnvironment(layout, manifest, logger, signal) {
+  const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join21(rootDir, "core", "local", ".env");
-  const fileArgs = await buildAllComposeArgs(rootDir, manifest, logger);
-  const localDir = join21(rootDir, "core", "local");
+  const envFile = join22(localDir, ".env");
+  const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
   logger.log("Starting environment...");
   await runDockerCompose(
     [
@@ -1732,11 +1818,11 @@ async function startEnvironment(rootDir, manifest, logger, signal) {
     signal
   );
 }
-async function stopEnvironment(rootDir, manifest, logger, signal) {
+async function stopEnvironment(layout, manifest, logger, signal) {
+  const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join21(rootDir, "core", "local", ".env");
-  const fileArgs = await buildAllComposeArgs(rootDir, manifest, logger);
-  const localDir = join21(rootDir, "core", "local");
+  const envFile = join22(localDir, ".env");
+  const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
   logger.log("Stopping environment...");
   await runDockerCompose(
     [
@@ -1754,11 +1840,11 @@ async function stopEnvironment(rootDir, manifest, logger, signal) {
     signal
   );
 }
-async function destroyEnvironment(rootDir, manifest, logger, signal) {
+async function destroyEnvironment(layout, manifest, logger, signal) {
+  const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join21(rootDir, "core", "local", ".env");
-  const fileArgs = await buildAllComposeArgs(rootDir, manifest, logger);
-  const localDir = join21(rootDir, "core", "local");
+  const envFile = join22(localDir, ".env");
+  const fileArgs = await buildAllComposeArgs(layout, manifest, logger);
   logger.log("Destroying environment...");
   await runDockerCompose(
     [
@@ -1782,8 +1868,8 @@ async function destroyEnvironment(rootDir, manifest, logger, signal) {
 
 // src/commands/local-scripts/npm-orchestrator.ts
 import { spawn as spawn2 } from "child_process";
-import { access as access5 } from "fs/promises";
-import { join as join22, resolve as resolve4 } from "path";
+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, {
@@ -1830,24 +1916,24 @@ function runCommand(command, args2, workDir, logger, signal) {
 }
 async function dirExists(dirPath) {
   try {
-    await access5(dirPath);
+    await access6(dirPath);
     return true;
   } catch {
     return false;
   }
 }
-async function installDependencies(rootDir, manifest, logger, signal) {
-  const coreDir = join22(rootDir, "core");
+async function installDependencies(layout, manifest, logger, signal) {
+  const { coreDir, coreDirName } = layout;
   const appDirs = [];
   for (const app of manifest.applications) {
-    const appDir = resolve4(join22(rootDir, "core"), app.localPath);
+    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: "core", dir: coreDir }, ...appDirs];
+  const targets = [{ name: coreDirName, dir: coreDir }, ...appDirs];
   logger.log(`Installing dependencies in parallel: ${targets.map((t) => t.name).join(", ")}...`);
   await Promise.all(
     targets.map(
@@ -1857,14 +1943,14 @@ async function installDependencies(rootDir, manifest, logger, signal) {
     )
   );
 }
-async function buildAll(rootDir, manifest, logger, signal) {
-  const coreDir = join22(rootDir, "core");
-  logger.log("Building core/...");
+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(join22(rootDir, "core"), app.localPath);
+    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;
@@ -1889,33 +1975,34 @@ var START_COMMAND_NAME = "start";
 var STOP_COMMAND_NAME = "stop";
 var DESTROY_COMMAND_NAME = "destroy";
 async function runLocalScript(scriptName, logger, signal) {
-  const rootDir = await findRootDir();
-  if (!rootDir) {
+  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);
+    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(rootDir, manifest, logger, signal);
+      await startEnvironment(layout, manifest, logger, signal);
       break;
     case STOP_COMMAND_NAME:
-      await stopEnvironment(rootDir, manifest, logger, signal);
+      await stopEnvironment(layout, manifest, logger, signal);
       break;
     case DESTROY_COMMAND_NAME:
-      await destroyEnvironment(rootDir, manifest, logger, signal);
+      await destroyEnvironment(layout, manifest, logger, signal);
       break;
     case INSTALL_COMMAND_NAME:
-      await installDependencies(rootDir, manifest, logger, signal);
+      await installDependencies(layout, manifest, logger, signal);
       break;
     case BUILD_COMMAND_NAME:
-      await buildAll(rootDir, manifest, logger, signal);
+      await buildAll(layout, manifest, logger, signal);
       break;
     default:
       logger.log(`Error: Unknown script "${scriptName}".`);
@@ -2045,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));