@bluealba/platform-cli 0.2.0 → 0.3.0-feature-platform-cli-211

package/dist/index.js

@@ -61,11 +61,10 @@ import React2 from "react";
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } 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: [
@@ -125,8 +124,7 @@ function Spinner({ label }) {
 import { Fzf } from "fzf";
 
 // src/commands/create-application/create-application.command.ts
-import { join as join9 } from "path";
-import { cwd } from "process";
+import { join as join10, resolve } from "path";
 import { mkdir as mkdir2 } from "fs/promises";
 
 // src/commands/create-application/scaffold-application-monorepo.ts
@@ -358,10 +356,10 @@ function buildUiModuleEntry(organizationName, applicationName, applicationDispla
 
 // src/commands/create-application/create-docker-compose.ts
 import { writeFile as writeFile3 } from "fs/promises";
-function buildBootstrapBlock(applicationName) {
+function buildBootstrapBlock(platformName, applicationName) {
   return `  ${applicationName}-bootstrap-service:
     build:
-      context: ../${applicationName}/services/${applicationName}-bootstrap-service
+      context: ../../${platformName}-${applicationName}/services/${applicationName}-bootstrap-service
       dockerfile: Dockerfile.development
     environment:
       - NODE_TLS_REJECT_UNAUTHORIZED=0
@@ -371,27 +369,27 @@ 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) {
+function buildUiBlock(platformName, applicationName, uiPort) {
   return `  ${applicationName}-ui:
     build:
-      context: ../${applicationName}/ui/${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${applicationName}-ui
       dockerfile: Dockerfile.development
     ports:
       - ${uiPort}:80
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
 }
-function buildBackendBlock(applicationName, servicePort) {
+function buildBackendBlock(platformName, applicationName, servicePort) {
   return `  ${applicationName}-service:
     build:
-      context: ../${applicationName}/services/${applicationName}-service
+      context: ../../${platformName}-${applicationName}/services/${applicationName}-service
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -400,18 +398,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}`);
@@ -421,32 +419,18 @@ 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";
-async function getNextAvailablePort(localDir) {
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+async function getNextAvailablePort(rootDir) {
   const allPorts = [];
+  const localDir = join8(rootDir, "core", "local");
   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) {
@@ -465,6 +449,71 @@ function formatError(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
+// src/utils/platform-check.ts
+import { cwd as cwd2 } from "process";
+import { dirname as dirname7 } from "path";
+
+// 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);
+}
+async function readManifest(rootDir = cwd()) {
+  const content = await readFile4(manifestPath(rootDir), "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;
+  }
+}
+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/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 = {
@@ -473,18 +522,28 @@ var createApplicationCommand = {
 };
 async function createApplication(params, logger) {
   const {
-    organizationName,
-    platformName,
     applicationName,
     applicationDisplayName,
     applicationDescription,
     hasUserInterface,
     hasBackendService
   } = params;
-  const rootDir = cwd();
-  const applicationDir = join9(rootDir, applicationName);
-  const bootstrapServiceDir = join9(applicationDir, "services", `${applicationName}-bootstrap-service`);
-  const localDir = join9(rootDir, "local");
+  const rootDir = await findRootDir();
+  if (!rootDir) {
+    logger.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
+    return;
+  }
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir);
+  } 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`);
   logger.log(`Creating application monorepo "${applicationName}"...`);
   try {
     await scaffoldApplicationMonorepo(applicationDir, organizationName, platformName, applicationName, logger);
@@ -492,10 +551,10 @@ async function createApplication(params, logger) {
     logger.log(`Error: Could not scaffold application monorepo \u2014 ${formatError(err)}`);
     return;
   }
-  await mkdir2(join9(applicationDir, "services"), { recursive: true });
-  await mkdir2(join9(applicationDir, "ui"), { recursive: true });
+  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`;
+  const bootstrapServiceDir_var = `${platformName}-${applicationName}/services`;
   try {
     await scaffoldBootstrap(bootstrapServiceDir, organizationName, applicationName, bootstrapServiceDir_var, logger);
   } catch (err) {
@@ -526,8 +585,8 @@ async function createApplication(params, logger) {
     );
   }
   if (hasUserInterface) {
-    const uiDir = join9(applicationDir, "ui", `${applicationName}-ui`);
-    const uiBaseDir = `${applicationName}/ui`;
+    const uiDir = join10(applicationDir, "ui", `${applicationName}-ui`);
+    const uiBaseDir = `${platformName}-${applicationName}/ui`;
     try {
       await scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
     } catch (err) {
@@ -536,8 +595,8 @@ async function createApplication(params, logger) {
     }
   }
   if (hasBackendService) {
-    const serviceDir = join9(applicationDir, "services", `${applicationName}-service`);
-    const serviceBaseDir = `${applicationName}/services`;
+    const serviceDir = join10(applicationDir, "services", `${applicationName}-service`);
+    const serviceBaseDir = `${platformName}-${applicationName}/services`;
     try {
       await scaffoldNestjsService(serviceDir, organizationName, applicationName, applicationDisplayName, serviceBaseDir, logger);
     } catch (err) {
@@ -545,27 +604,39 @@ async function createApplication(params, logger) {
       return;
     }
   }
-  const dockerComposePath = join9(localDir, `${applicationName}-docker-compose.yml`);
-  const basePort = await getNextAvailablePort(localDir);
+  const dockerComposePath = join10(rootDir, "core", "local", `${applicationName}-docker-compose.yml`);
+  const basePort = await getNextAvailablePort(rootDir);
   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 = join9(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);
+    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 join15 } from "path";
-import { cwd as cwd2 } from "process";
+import { join as join16 } from "path";
+import { cwd as cwd3 } from "process";
 
 // src/utils/string.ts
 function camelize(name) {
@@ -574,9 +645,9 @@ function camelize(name) {
 
 // src/commands/init/scaffold-platform.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { join as join10, dirname as dirname7 } from "path";
-var templateDir = join10(
-  dirname7(fileURLToPath6(import.meta.url)),
+import { join as join11, dirname as dirname8 } from "path";
+var templateDir = join11(
+  dirname8(fileURLToPath6(import.meta.url)),
   "..",
   "templates",
   "platform-init-template"
@@ -587,9 +658,9 @@ async function scaffoldPlatform(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-platform-bootstrap.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { join as join11, dirname as dirname8 } from "path";
-var templateDir2 = join11(
-  dirname8(fileURLToPath7(import.meta.url)),
+import { join as join12, dirname as dirname9 } from "path";
+var templateDir2 = join12(
+  dirname9(fileURLToPath7(import.meta.url)),
   "..",
   "templates",
   "bootstrap-service-template"
@@ -600,9 +671,9 @@ async function scaffoldPlatformBootstrap(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-customization-ui.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { join as join12, dirname as dirname9 } from "path";
-var templateDir3 = join12(
-  dirname9(fileURLToPath8(import.meta.url)),
+import { join as join13, dirname as dirname10 } from "path";
+var templateDir3 = join13(
+  dirname10(fileURLToPath8(import.meta.url)),
   "..",
   "templates",
   "customization-ui-module-template"
@@ -612,10 +683,10 @@ async function scaffoldCustomizationUi(outputDir, variables, logger) {
 }
 
 // src/commands/init/register-customization-module.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 async function registerCustomizationModule(bootstrapServiceDir, organizationName, logger) {
-  const modulesJsonPath = join13(bootstrapServiceDir, "src", "data", "platform", "modules.json");
+  const modulesJsonPath = join14(bootstrapServiceDir, "src", "data", "platform", "modules.json");
   const entry = {
     name: `@${organizationName}/platform-customization-ui`,
     displayName: "Platform Customization UI",
@@ -638,7 +709,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 join14 } from "path";
+import { join as join15 } from "path";
 
 // src/utils/random.ts
 import { randomBytes } from "crypto";
@@ -648,9 +719,9 @@ function generateRandomSecret() {
 
 // src/commands/init/generate-local-env.ts
 async function generateLocalEnv(outputDir, logger) {
-  const examplePath = join14(outputDir, "local", ".env.example");
-  const envPath = join14(outputDir, "local", ".env");
-  logger.log("Generating local/.env with random secrets...");
+  const examplePath = join15(outputDir, "core", "local", ".env.example");
+  const envPath = join15(outputDir, "core", "local", ".env");
+  logger.log("Generating core/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()}`;
@@ -665,9 +736,13 @@ var initCommand = {
   description: "Initialize a new platform"
 };
 async function init(params, logger) {
+  if (await isPlatformInitialized()) {
+    logger.log("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
+    return;
+  }
   const { organizationName, platformName, platformDisplayName } = params;
   const platformTitle = camelize(platformName);
-  const outputDir = cwd2();
+  const outputDir = cwd3();
   logger.log(`Initializing ${platformTitle} platform for @${organizationName}...`);
   const variables = {
     organizationName,
@@ -686,12 +761,20 @@ async function init(params, logger) {
   try {
     await generateLocalEnv(outputDir, logger);
   } catch (err) {
-    logger.log(`Error: Could not generate local/.env \u2014 ${formatError(err)}`);
+    logger.log(`Error: Could not generate core/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");
+  } catch (err) {
+    logger.log(`Error: Could not write product manifest \u2014 ${formatError(err)}`);
     return;
   }
   try {
     await scaffoldPlatformBootstrap(
-      join15(outputDir, "core", "services", "platform-bootstrap-service"),
+      join16(outputDir, "core", "services", "platform-bootstrap-service"),
       variables,
       logger
     );
@@ -701,7 +784,7 @@ async function init(params, logger) {
   }
   try {
     await scaffoldCustomizationUi(
-      join15(outputDir, "core", "ui", "platform-customization-ui"),
+      join16(outputDir, "core", "ui", "platform-customization-ui"),
       variables,
       logger
     );
@@ -711,7 +794,7 @@ async function init(params, logger) {
   }
   try {
     await registerCustomizationModule(
-      join15(outputDir, "core", "services", "platform-bootstrap-service"),
+      join16(outputDir, "core", "services", "platform-bootstrap-service"),
       organizationName,
       logger
     );
@@ -723,8 +806,7 @@ async function init(params, logger) {
 }
 
 // src/commands/configure-idp/configure-idp.command.ts
-import { join as join16 } from "path";
-import { cwd as cwd3 } from "process";
+import { join as join17 } from "path";
 import { fetch as undiciFetch, Agent } from "undici";
 
 // src/utils/env-reader.ts
@@ -802,7 +884,12 @@ var configureIdpCommand = {
   description: "Configure an Identity Provider (IDP) in the gateway"
 };
 async function configureIdp(params, logger) {
-  const envPath = join16(cwd3(), "local", ".env");
+  const rootDir = await findRootDir();
+  if (!rootDir) {
+    logger.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
+    return;
+  }
+  const envPath = join17(rootDir, "core", "local", ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -813,11 +900,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);
@@ -853,6 +940,225 @@ async function configureIdp(params, logger) {
   logger.log(`IDP provider "${params.name}" configured successfully.`);
 }
 
+// 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";
+
+// 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(
+  dirname11(fileURLToPath9(import.meta.url)),
+  "..",
+  "templates",
+  "nestjs-service-module-template"
+);
+async function scaffoldServiceModule(serviceDir, organizationName, serviceName, serviceDisplayName, serviceBaseDir, logger) {
+  logger.log(`Creating NestJS service "${serviceName}"...`);
+  await applyTemplate(
+    {
+      templateDir: nestjsServiceModuleTemplateDir2,
+      outputDir: serviceDir,
+      variables: { organizationName, serviceName, serviceDisplayName, serviceBaseDir }
+    },
+    (message) => logger.log(message)
+  );
+  logger.log(`Done! Service output: ${serviceDir}`);
+}
+
+// src/commands/create-service-module/service-module-entry-builder.ts
+function buildCustomServiceModuleEntry(organizationName, serviceName, serviceDisplayName) {
+  return {
+    name: `@${organizationName}/${serviceName}`,
+    displayName: serviceDisplayName,
+    type: "service",
+    baseUrl: `/${serviceName}`,
+    service: {
+      host: serviceName,
+      port: 80
+    },
+    dependsOn: []
+  };
+}
+
+// src/commands/create-service-module/append-docker-compose.ts
+import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+async function appendServiceToDockerCompose(dockerComposePath, serviceName, platformName, applicationName, port, logger) {
+  const block = `
+  ${serviceName}:
+    build:
+      context: ../../${platformName}-${applicationName}/services/${serviceName}
+      dockerfile: Dockerfile.development
+      args:
+        - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
+    ports:
+      - ${port}:80
+    environment:
+      - GATEWAY_URL=\${PAE_GATEWAY_URL}
+    volumes:
+      - \${PWD}/:/app/out
+`;
+  try {
+    const existing = await readFile8(dockerComposePath, "utf-8");
+    await writeFile7(dockerComposePath, existing + block, "utf-8");
+    logger.log(`Updated docker-compose: ${dockerComposePath}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`Warning: Could not update docker-compose \u2014 ${message}`);
+  }
+}
+
+// src/commands/create-service-module/create-service-module.command.ts
+var CREATE_SERVICE_MODULE_COMMAND_NAME = "create-service-module";
+var createServiceModuleCommand = {
+  name: CREATE_SERVICE_MODULE_COMMAND_NAME,
+  description: "Add a new service module to an existing application"
+};
+async function createServiceModule(params, logger) {
+  const { applicationName, serviceName, serviceDisplayName } = params;
+  const rootDir = await findRootDir();
+  if (!rootDir) {
+    logger.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
+    return;
+  }
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir);
+  } 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(join19(rootDir, "core"), appEntry.localPath);
+  try {
+    await access2(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);
+  try {
+    await access2(serviceDir);
+    logger.log(`Error: A service named "${fullServiceName}" already exists in application "${applicationName}".`);
+    return;
+  } catch {
+  }
+  const serviceBaseDir = `${platformName}-${applicationName}/services`;
+  try {
+    await scaffoldServiceModule(
+      serviceDir,
+      organizationName,
+      fullServiceName,
+      serviceDisplayName,
+      serviceBaseDir,
+      logger
+    );
+  } catch (err) {
+    logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
+    return;
+  }
+  const bootstrapServiceDir = join19(applicationDir, "services", `${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);
+  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";
+
+// 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 block = `
+  ${applicationName}-ui:
+    build:
+      context: ../../${platformName}-${applicationName}/ui/${applicationName}-ui
+      dockerfile: Dockerfile.development
+    ports:
+      - ${port}:80
+    volumes:
+      - \${PWD}/:/app/out
+`;
+  try {
+    const existing = await readFile9(dockerComposePath, "utf-8");
+    await writeFile8(dockerComposePath, existing + block, "utf-8");
+    logger.log(`Updated docker-compose: ${dockerComposePath}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`Warning: Could not update docker-compose \u2014 ${message}`);
+  }
+}
+
+// src/commands/create-ui-module/create-ui-module.command.ts
+var CREATE_UI_MODULE_COMMAND_NAME = "create-ui-module";
+var createUiModuleCommand = {
+  name: CREATE_UI_MODULE_COMMAND_NAME,
+  description: "Add a UI module to an existing application"
+};
+async function createUiModule(params, logger) {
+  const { applicationName, applicationDisplayName } = params;
+  const rootDir = await findRootDir();
+  if (!rootDir) {
+    logger.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
+    return;
+  }
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir);
+  } 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(join20(rootDir, "core"), appEntry.localPath);
+  try {
+    await access3(applicationDir);
+  } catch {
+    logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
+    return;
+  }
+  const uiDir = join20(applicationDir, "ui");
+  try {
+    const uiEntries = await readdir3(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.`);
+      return;
+    }
+  } catch {
+  }
+  const uiOutputDir = join20(uiDir, `${applicationName}-ui`);
+  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);
+  await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
+  const dockerComposePath = join20(rootDir, "core", "local", `${applicationName}-docker-compose.yml`);
+  const port = await getNextAvailablePort(rootDir);
+  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger);
+  logger.log(`Done! UI module "${applicationName}-ui" added to application "${applicationName}".`);
+}
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -878,6 +1184,8 @@ var registry = new CommandRegistry();
 registry.register(createApplicationCommand);
 registry.register(initCommand);
 registry.register(configureIdpCommand);
+registry.register(createServiceModuleCommand);
+registry.register(createUiModuleCommand);
 
 // src/app-state.ts
 var APP_STATE = {
@@ -890,11 +1198,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 readFile8 } from "fs/promises";
-import { join as join17 } from "path";
-import { cwd as cwd4 } from "process";
-
 // src/services/create-application.service.ts
 async function createApplicationService(params, logger) {
   await createApplication(params, logger);
@@ -902,22 +1205,8 @@ async function createApplicationService(params, logger) {
 
 // src/controllers/ui/create-application.ui-controller.ts
 async function createApplicationUiController(ctx) {
-  let organizationName;
-  let platformName;
-  try {
-    const corePackageJson = JSON.parse(
-      await readFile8(join17(cwd4(), "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}`);
+  if (!await isPlatformInitialized()) {
+    ctx.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
     return;
   }
   const applicationName = await ctx.prompt("Application name:");
@@ -939,8 +1228,6 @@ async function createApplicationUiController(ctx) {
   }
   await createApplicationService(
     {
-      organizationName,
-      platformName,
       applicationName,
       applicationDisplayName,
       applicationDescription,
@@ -958,6 +1245,10 @@ async function initService(params, logger) {
 
 // src/controllers/ui/init.ui-controller.ts
 async function initUiController(ctx) {
+  if (await isPlatformInitialized()) {
+    ctx.log("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
+    return;
+  }
   const organizationName = await ctx.prompt("Organization name:");
   const platformName = await ctx.prompt("Platform name:");
   const platformDisplayName = await ctx.prompt("Platform display name:");
@@ -971,6 +1262,10 @@ async function configureIdpService(params, logger) {
 
 // src/controllers/ui/configure-idp.ui-controller.ts
 async function configureIdpUiController(ctx) {
+  if (!await isPlatformInitialized()) {
+    ctx.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
+    return;
+  }
   const providers = getAllProviders();
   const options = providers.map((p, i) => `${i + 1}: ${p.displayName}`).join(", ");
   const selectionInput = await ctx.prompt(`Select IDP type (${options}):`);
@@ -994,11 +1289,64 @@ async function configureIdpUiController(ctx) {
   );
 }
 
+// src/services/create-service-module.service.ts
+async function createServiceModuleService(params, logger) {
+  await createServiceModule(params, logger);
+}
+
+// src/controllers/ui/create-service-module.ui-controller.ts
+async function createServiceModuleUiController(ctx) {
+  if (!await isPlatformInitialized()) {
+    ctx.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
+    return;
+  }
+  const applicationName = await ctx.prompt("Application name:");
+  if (!/^[a-z0-9-]+$/.test(applicationName)) {
+    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    return;
+  }
+  const serviceName = await ctx.prompt("Service name:");
+  if (!/^[a-z0-9-]+$/.test(serviceName)) {
+    ctx.log(`Error: Service name "${serviceName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    return;
+  }
+  const serviceDisplayName = await ctx.prompt("Service display name:");
+  await createServiceModuleService(
+    { applicationName, serviceName, serviceDisplayName },
+    ctx
+  );
+}
+
+// src/services/create-ui-module.service.ts
+async function createUiModuleService(params, logger) {
+  await createUiModule(params, logger);
+}
+
+// src/controllers/ui/create-ui-module.ui-controller.ts
+async function createUiModuleUiController(ctx) {
+  if (!await isPlatformInitialized()) {
+    ctx.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
+    return;
+  }
+  const applicationName = await ctx.prompt("Application name:");
+  if (!/^[a-z0-9-]+$/.test(applicationName)) {
+    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    return;
+  }
+  const applicationDisplayName = await ctx.prompt("Application display name:");
+  await createUiModuleService(
+    { applicationName, applicationDisplayName },
+    ctx
+  );
+}
+
 // src/controllers/ui/registry.ts
 var uiControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
   [INIT_COMMAND_NAME, initUiController],
-  [CONFIGURE_IDP_COMMAND_NAME, configureIdpUiController]
+  [CONFIGURE_IDP_COMMAND_NAME, configureIdpUiController],
+  [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleUiController],
+  [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleUiController]
 ]);
 
 // src/hooks/use-command-runner.ts
@@ -1013,7 +1361,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;
@@ -1027,14 +1375,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",
@@ -1066,15 +1414,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,
@@ -1096,7 +1444,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(
@@ -1128,7 +1476,7 @@ function App() {
           const cmd = filteredCommands[selectedIndex];
           if (cmd) {
             setInputValue("");
-            runCommand(cmd);
+            runCommand2(cmd);
           }
           return;
         }
@@ -1164,9 +1512,9 @@ 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) {
@@ -1202,10 +1550,11 @@ function App() {
 }
 
 // src/controllers/cli/create-application.cli-controller.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join18 } from "path";
-import { cwd as cwd5 } from "process";
 async function createApplicationCliController(args2) {
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot create an application \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
   const {
     applicationName,
     applicationDisplayName,
@@ -1221,28 +1570,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 readFile9(join18(cwd5(), "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,
@@ -1255,6 +1584,10 @@ async function createApplicationCliController(args2) {
 
 // src/controllers/cli/init.cli-controller.ts
 async function initCliController(args2) {
+  if (await isPlatformInitialized()) {
+    console.error("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
+    process.exit(1);
+  }
   const { organizationName, platformName, platformDisplayName } = args2;
   if (!organizationName || !platformName || !platformDisplayName) {
     console.error("Error: organizationName, platformName, and platformDisplayName are required.");
@@ -1269,6 +1602,10 @@ async function initCliController(args2) {
 // src/controllers/cli/configure-idp.cli-controller.ts
 async function configureIdpCliController(args2) {
   const logger = { log: console.log };
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
   const { providerType, name, issuer, clientId, clientSecret } = args2;
   if (!providerType || !name || !issuer || !clientId || !clientSecret) {
     logger.log("Error: Missing required arguments: providerType, name, issuer, clientId, clientSecret");
@@ -1291,22 +1628,167 @@ 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 } from "fs/promises";
-import { join as join19 } from "path";
-async function runNpmScript(scriptName, logger, signal) {
-  const localDir = join19(process.cwd(), "local");
-  try {
-    await access(localDir);
-  } catch {
-    logger.log(`Error: "local/" directory not found. Run "platform init" first.`);
-    return;
+import { access as access4 } from "fs/promises";
+import { join as join21 } 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(rootDir, manifest) {
+  const results = [];
+  for (const app of manifest.applications) {
+    const composePath = join21(rootDir, "core", "local", `${app.name}-docker-compose.yml`);
+    try {
+      await access4(composePath);
+      results.push({ composePath, appName: app.name });
+    } catch {
+    }
+  }
+  return results;
+}
+async function buildAllComposeArgs(rootDir, manifest, logger) {
+  const localDir = join21(rootDir, "core", "local");
+  const fileArgs = [
+    "-f",
+    join21(localDir, "platform-docker-compose.yml"),
+    "-f",
+    join21(localDir, "core-docker-compose.yml")
+  ];
+  const appEntries = await getAppComposePaths(rootDir, manifest);
+  for (const { composePath, appName } of appEntries) {
+    fileArgs.push("-f", composePath);
   }
-  return new Promise((resolve) => {
-    const child = spawn("npm", ["run", scriptName], {
-      cwd: localDir,
-      shell: true,
+  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.`);
+    }
+  }
+  return fileArgs;
+}
+async function startEnvironment(rootDir, manifest, logger, signal) {
+  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");
+  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(rootDir, manifest, logger, signal) {
+  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");
+  logger.log("Stopping environment...");
+  await runDockerCompose(
+    [
+      "-p",
+      `${platformName}-platform`,
+      "--project-directory",
+      localDir,
+      "--env-file",
+      envFile,
+      ...fileArgs,
+      "down"
+    ],
+    logger,
+    rootDir,
+    signal
+  );
+}
+async function destroyEnvironment(rootDir, manifest, logger, signal) {
+  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");
+  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 access5 } from "fs/promises";
+import { join as join22, resolve as resolve4 } 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 = () => {
@@ -1315,7 +1797,7 @@ async function runNpmScript(scriptName, logger, signal) {
     if (signal) {
       if (signal.aborted) {
         child.kill("SIGTERM");
-        resolve();
+        resolvePromise();
         return;
       }
       signal.addEventListener("abort", onAbort, { once: true });
@@ -1333,19 +1815,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 access5(dirPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installDependencies(rootDir, manifest, logger, signal) {
+  const coreDir = join22(rootDir, "core");
+  const appDirs = [];
+  for (const app of manifest.applications) {
+    const appDir = resolve4(join22(rootDir, "core"), 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];
+  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(rootDir, manifest, logger, signal) {
+  const coreDir = join22(rootDir, "core");
+  logger.log("Building core/...");
+  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);
+    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";
@@ -1354,7 +1889,37 @@ 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 rootDir = await findRootDir();
+  if (!rootDir) {
+    logger.log(`Error: Cannot run "${scriptName}" \u2014 no platform initialized in this directory.`);
+    return;
+  }
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir);
+  } 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);
+      break;
+    case STOP_COMMAND_NAME:
+      await stopEnvironment(rootDir, manifest, logger, signal);
+      break;
+    case DESTROY_COMMAND_NAME:
+      await destroyEnvironment(rootDir, manifest, logger, signal);
+      break;
+    case INSTALL_COMMAND_NAME:
+      await installDependencies(rootDir, manifest, logger, signal);
+      break;
+    case BUILD_COMMAND_NAME:
+      await buildAll(rootDir, manifest, logger, signal);
+      break;
+    default:
+      logger.log(`Error: Unknown script "${scriptName}".`);
+  }
 }
 
 // src/services/local-script.service.ts
@@ -1405,11 +1970,59 @@ function createLocalScriptCliController(scriptName) {
   };
 }
 
+// src/controllers/cli/create-service-module.cli-controller.ts
+async function createServiceModuleCliController(args2) {
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
+  const { applicationName, serviceName, serviceDisplayName } = args2;
+  if (!applicationName || !serviceName || !serviceDisplayName) {
+    console.error("Error: applicationName, serviceName, and serviceDisplayName are required.");
+    process.exit(1);
+  }
+  if (!/^[a-z0-9-]+$/.test(applicationName)) {
+    console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    process.exit(1);
+  }
+  if (!/^[a-z0-9-]+$/.test(serviceName)) {
+    console.error(`Error: Service name "${serviceName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    process.exit(1);
+  }
+  await createServiceModuleService(
+    { applicationName, serviceName, serviceDisplayName },
+    { log: console.log }
+  );
+}
+
+// src/controllers/cli/create-ui-module.cli-controller.ts
+async function createUiModuleCliController(args2) {
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
+  const { applicationName, applicationDisplayName } = args2;
+  if (!applicationName || !applicationDisplayName) {
+    console.error("Error: applicationName and applicationDisplayName are required.");
+    process.exit(1);
+  }
+  if (!/^[a-z0-9-]+$/.test(applicationName)) {
+    console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    process.exit(1);
+  }
+  await createUiModuleService(
+    { applicationName, applicationDisplayName },
+    { log: console.log }
+  );
+}
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
   [INIT_COMMAND_NAME, initCliController],
   [CONFIGURE_IDP_COMMAND_NAME, configureIdpCliController],
+  [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleCliController],
+  [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleCliController],
   [INSTALL_COMMAND_NAME, createLocalScriptCliController(INSTALL_COMMAND_NAME)],
   [BUILD_COMMAND_NAME, createLocalScriptCliController(BUILD_COMMAND_NAME)],
   [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],