@bluealba/platform-cli 0.2.1 → 0.3.1

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 Box5, Text as Text7, useApp, useInput } from "ink";
 
 // src/components/prompt.tsx
 import { Box, Text } from "ink";
@@ -54,54 +54,71 @@ 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 Box4, Text as Text4 } from "ink";
+
+// src/components/working-directory.tsx
 import React2 from "react";
+import os from "os";
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var WorkingDirectory = React2.memo(function WorkingDirectory2() {
+  const cwd7 = process.cwd();
+  const home = os.homedir();
+  const displayPath = cwd7.startsWith(home) ? "~" + cwd7.slice(home.length) : cwd7;
+  return /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 2, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, dimColor: true, children: "Working Dir: " }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: displayPath })
+  ] });
+});
+
+// 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(Box4, { 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(Box4, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginRight: 2, children: ASCII_ART.map((line, i) => /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: line }, i)) }),
+      /* @__PURE__ */ jsxs4(Box4, { 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(Box4, { flexDirection: "column", children: ASCII_ART.map((_, i) => /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2502" }, i)) }),
+      /* @__PURE__ */ jsxs4(Box4, { 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(Box4, { marginTop: 1, children: /* @__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 }) {
@@ -112,12 +129,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 })
   ] });
 }
 
@@ -270,7 +287,7 @@ var reactUiModuleTemplateDir = join5(
   "react-ui-module-template"
 );
 async function scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger) {
-  logger.log(`Creating UI module "${applicationName}-ui"...`);
+  logger.log(`Creating UI module "${platformName}-${applicationName}-ui"...`);
   await applyTemplate(
     {
       templateDir: reactUiModuleTemplateDir,
@@ -291,8 +308,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(
@@ -323,33 +340,33 @@ 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) {
   return {
-    name: `@${organizationName}/${applicationName}-service`,
+    name: `@${organizationName}/${platformName}-${applicationName}-service`,
     displayName: `${applicationDisplayName} Service`,
     type: "service",
-    baseUrl: `/${applicationName}-service`,
+    baseUrl: `/${platformName}-${applicationName}-service`,
     service: {
-      host: `${applicationName}-service`,
+      host: `${platformName}-${applicationName}-service`,
       port: 80
     },
     dependsOn: []
   };
 }
-function buildUiModuleEntry(organizationName, applicationName, applicationDisplayName) {
+function buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName) {
   return {
-    name: `@${organizationName}/${applicationName}-ui`,
+    name: `@${organizationName}/${platformName}-${applicationName}-ui`,
     displayName: applicationDisplayName,
     type: "app",
-    baseUrl: `/${applicationName}-ui`,
+    baseUrl: `/${platformName}-${applicationName}-ui`,
     service: {
-      host: `${applicationName}-ui`,
+      host: `${platformName}-${applicationName}-ui`,
       port: 80
     },
     ui: {
       route: `/${applicationName}`,
       mountAtSelector: "#pae-shell-ui-content",
-      bundleFile: `${organizationName}-${applicationName}-ui.js`,
+      bundleFile: `${organizationName}-${platformName}-${applicationName}-ui.js`,
       customProps: {}
     },
     dependsOn: [`@bluealba/pae-shell-ui`]
@@ -358,14 +375,14 @@ function buildUiModuleEntry(organizationName, applicationName, applicationDispla
 
 // src/commands/create-application/create-docker-compose.ts
 import { writeFile as writeFile3 } from "fs/promises";
-function buildBootstrapBlock(applicationName) {
-  return `  ${applicationName}-bootstrap-service:
+function buildBootstrapBlock(platformName, applicationName) {
+  return `  ${platformName}-${applicationName}-bootstrap-service:
     build:
-      context: ../${applicationName}/services/${applicationName}-bootstrap-service
+      context: ../${platformName}-${applicationName}/services/${platformName}-${applicationName}-bootstrap-service
       dockerfile: Dockerfile.development
     environment:
       - NODE_TLS_REJECT_UNAUTHORIZED=0
-      - SERVICE_ACCESS_NAME=${applicationName}-bootstrap
+      - SERVICE_ACCESS_NAME=${platformName}-${applicationName}-bootstrap
       - WAIT_TIME=5000
       - SYNC_STRATEGY=\${PAE_BOOTSTRAP_SYNC_STRATEGY}
       - GATEWAY_SERVICE_URL=\${PAE_GATEWAY_URL}
@@ -377,10 +394,10 @@ function buildBootstrapBlock(applicationName) {
         condition: service_healthy
 `;
 }
-function buildUiBlock(applicationName, uiPort) {
-  return `  ${applicationName}-ui:
+function buildUiBlock(platformName, applicationName, uiPort) {
+  return `  ${platformName}-${applicationName}-ui:
     build:
-      context: ../${applicationName}/ui/${applicationName}-ui
+      context: ../${platformName}-${applicationName}/ui/${platformName}-${applicationName}-ui
       dockerfile: Dockerfile.development
     ports:
       - ${uiPort}:80
@@ -388,10 +405,10 @@ function buildUiBlock(applicationName, uiPort) {
       - \${PWD}/../:/app/out
 `;
 }
-function buildBackendBlock(applicationName, servicePort) {
-  return `  ${applicationName}-service:
+function buildBackendBlock(platformName, applicationName, servicePort) {
+  return `  ${platformName}-${applicationName}-service:
     build:
-      context: ../${applicationName}/services/${applicationName}-service
+      context: ../${platformName}-${applicationName}/services/${platformName}-${applicationName}-service
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -403,13 +420,13 @@ function buildBackendBlock(applicationName, servicePort) {
       - \${PWD}/../:/app/out
 `;
 }
-async function createDockerCompose(dockerComposePath, applicationName, hasUserInterface, hasBackendService, uiPort, servicePort, logger) {
-  const blocks = ["services:\n", buildBootstrapBlock(applicationName)];
+async function createDockerCompose(dockerComposePath, platformName, applicationName, 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");
   try {
@@ -423,10 +440,10 @@ 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) {
+async function updateRootDockerCompose(rootDockerComposePath, platformName, applicationName, logger) {
   try {
     const existing = await readFile3(rootDockerComposePath, "utf-8");
-    const includeLine = `  - path: ./${applicationName}-docker-compose.yml
+    const includeLine = `  - path: ./${platformName}-${applicationName}-docker-compose.yml
 `;
     await writeFile4(rootDockerComposePath, existing + includeLine, "utf-8");
     logger.log(`Updated root docker-compose: ${rootDockerComposePath}`);
@@ -466,13 +483,34 @@ function formatError(err) {
 }
 
 // src/utils/platform-check.ts
-import { access } from "fs/promises";
+import { access, readdir as readdir3, readFile as readFile5 } from "fs/promises";
 import { join as join9 } from "path";
 import { cwd } from "process";
+async function findCoreDirName(dir) {
+  const entries = await readdir3(dir, { withFileTypes: true });
+  const coreEntry = entries.find((e) => e.isDirectory() && e.name.endsWith("-core"));
+  return coreEntry?.name ?? null;
+}
+async function readPlatformManifest(dir) {
+  const baseDir = dir ?? cwd();
+  const coreDirName = await findCoreDirName(baseDir);
+  if (!coreDirName) {
+    throw new Error("No *-core directory found \u2014 platform not initialized in this directory.");
+  }
+  const platformName = coreDirName.replace(/-core$/, "");
+  const pkgJson = JSON.parse(await readFile5(join9(baseDir, coreDirName, "package.json"), "utf-8"));
+  const scopeMatch = pkgJson.name.match(/^@([^/]+)\//);
+  if (!scopeMatch) {
+    throw new Error(`Could not parse organization from package name: "${pkgJson.name}"`);
+  }
+  return { platformName, organizationName: scopeMatch[1] };
+}
 async function isPlatformInitialized() {
   try {
-    await access(join9(cwd(), "core"));
-    await access(join9(cwd(), "local"));
+    const coreDirName = await findCoreDirName(cwd());
+    if (!coreDirName) return false;
+    const platformName = coreDirName.replace(/-core$/, "");
+    await access(join9(cwd(), `${platformName}-local`));
     return true;
   } catch {
     return false;
@@ -500,10 +538,10 @@ async function createApplication(params, logger) {
     return;
   }
   const rootDir = cwd2();
-  const applicationDir = join10(rootDir, applicationName);
-  const bootstrapServiceDir = join10(applicationDir, "services", `${applicationName}-bootstrap-service`);
-  const localDir = join10(rootDir, "local");
-  logger.log(`Creating application monorepo "${applicationName}"...`);
+  const applicationDir = join10(rootDir, `${platformName}-${applicationName}`);
+  const bootstrapServiceDir = join10(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
+  const localDir = join10(rootDir, `${platformName}-local`);
+  logger.log(`Creating application monorepo "${platformName}-${applicationName}"...`);
   try {
     await scaffoldApplicationMonorepo(applicationDir, organizationName, platformName, applicationName, logger);
   } catch (err) {
@@ -512,10 +550,10 @@ async function createApplication(params, logger) {
   }
   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`;
+  logger.log(`Creating bootstrap service "${platformName}-${applicationName}-bootstrap-service"...`);
+  const bootstrapServiceDir_var = `${platformName}-${applicationName}/services`;
   try {
-    await scaffoldBootstrap(bootstrapServiceDir, organizationName, applicationName, bootstrapServiceDir_var, logger);
+    await scaffoldBootstrap(bootstrapServiceDir, organizationName, `${platformName}-${applicationName}`, bootstrapServiceDir_var, logger);
   } catch (err) {
     logger.log(`Error: Could not scaffold bootstrap service \u2014 ${formatError(err)}`);
     return;
@@ -531,7 +569,7 @@ async function createApplication(params, logger) {
     await addModuleEntry(
       bootstrapServiceDir,
       applicationName,
-      buildUiModuleEntry(organizationName, applicationName, applicationDisplayName),
+      buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName),
       logger
     );
   }
@@ -539,13 +577,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 uiBaseDir = `${applicationName}/ui`;
+    const uiDir = join10(applicationDir, "ui", `${platformName}-${applicationName}-ui`);
+    const uiBaseDir = `${platformName}-${applicationName}/ui`;
     try {
       await scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
     } catch (err) {
@@ -554,21 +592,22 @@ async function createApplication(params, logger) {
     }
   }
   if (hasBackendService) {
-    const serviceDir = join10(applicationDir, "services", `${applicationName}-service`);
-    const serviceBaseDir = `${applicationName}/services`;
+    const serviceDir = join10(applicationDir, "services", `${platformName}-${applicationName}-service`);
+    const serviceBaseDir = `${platformName}-${applicationName}/services`;
     try {
-      await scaffoldNestjsService(serviceDir, organizationName, applicationName, applicationDisplayName, serviceBaseDir, logger);
+      await scaffoldNestjsService(serviceDir, organizationName, platformName, applicationName, applicationDisplayName, serviceBaseDir, logger);
     } catch (err) {
       logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
       return;
     }
   }
-  const dockerComposePath = join10(localDir, `${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join10(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const basePort = await getNextAvailablePort(localDir);
   const uiPort = hasUserInterface ? basePort : 0;
   const servicePort = hasBackendService ? hasUserInterface ? basePort + 1 : basePort : 0;
   await createDockerCompose(
     dockerComposePath,
+    platformName,
     applicationName,
     hasUserInterface,
     hasBackendService,
@@ -577,8 +616,8 @@ async function createApplication(params, logger) {
     logger
   );
   const rootDockerComposePath = join10(localDir, "docker-compose.yml");
-  await updateRootDockerCompose(rootDockerComposePath, applicationName, logger);
-  logger.log(`Done! Application "${applicationName}" created at ${applicationDir}`);
+  await updateRootDockerCompose(rootDockerComposePath, platformName, applicationName, logger);
+  logger.log(`Done! Application "${platformName}-${applicationName}" created at ${applicationDir}`);
 }
 
 // src/commands/init/init.command.ts
@@ -631,31 +670,31 @@ async function scaffoldCustomizationUi(outputDir, variables, logger) {
 
 // src/commands/init/register-customization-module.ts
 import { join as join14 } from "path";
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-async function registerCustomizationModule(bootstrapServiceDir, organizationName, logger) {
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+async function registerCustomizationModule(bootstrapServiceDir, organizationName, platformName, logger) {
   const modulesJsonPath = join14(bootstrapServiceDir, "src", "data", "platform", "modules.json");
   const entry = {
-    name: `@${organizationName}/platform-customization-ui`,
+    name: `@${organizationName}/${platformName}-customization-ui`,
     displayName: "Platform Customization UI",
     type: "app",
-    baseUrl: "/platform-customization-ui",
-    service: { host: "platform-customization-ui", port: 80 },
+    baseUrl: `/${platformName}-customization-ui`,
+    service: { host: `${platformName}-customization-ui`, port: 80 },
     ui: {
       route: "/",
-      bundleFile: "platform-customization-ui.js",
+      bundleFile: `${platformName}-customization-ui.js`,
       isPlatformCustomization: true,
       customProps: {}
     },
     dependsOn: []
   };
-  const existing = JSON.parse(await readFile5(modulesJsonPath, "utf-8"));
+  const existing = JSON.parse(await readFile6(modulesJsonPath, "utf-8"));
   existing.push(entry);
   await writeFile5(modulesJsonPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
   logger.log(`Registered customization module in ${modulesJsonPath}`);
 }
 
 // src/commands/init/generate-local-env.ts
-import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
 import { join as join15 } from "path";
 
 // src/utils/random.ts
@@ -665,11 +704,11 @@ function generateRandomSecret() {
 }
 
 // src/commands/init/generate-local-env.ts
-async function generateLocalEnv(outputDir, logger) {
-  const examplePath = join15(outputDir, "local", ".env.example");
-  const envPath = join15(outputDir, "local", ".env");
-  logger.log("Generating local/.env with random secrets...");
-  const content = await readFile6(examplePath, "utf-8");
+async function generateLocalEnv(outputDir, platformName, logger) {
+  const examplePath = join15(outputDir, `${platformName}-local`, ".env.example");
+  const envPath = join15(outputDir, `${platformName}-local`, ".env");
+  logger.log(`Generating ${platformName}-local/.env with random secrets...`);
+  const content = await readFile7(examplePath, "utf-8");
   const result = content.replace(/^(PAE_AUTH_JWT_SECRET|PAE_GATEWAY_SERVICE_ACCESS_SECRET|PAE_DB_PASSWORD)=$/gm, (_, key) => {
     return `${key}=${generateRandomSecret()}`;
   });
@@ -696,8 +735,8 @@ async function init(params, logger) {
     platformName,
     platformTitle,
     platformDisplayName,
-    bootstrapName: "platform",
-    bootstrapServiceDir: "core/services"
+    bootstrapName: platformName,
+    bootstrapServiceDir: `${platformName}-core/services`
   };
   try {
     await scaffoldPlatform(outputDir, variables, logger);
@@ -706,14 +745,14 @@ async function init(params, logger) {
     return;
   }
   try {
-    await generateLocalEnv(outputDir, logger);
+    await generateLocalEnv(outputDir, platformName, logger);
   } catch (err) {
-    logger.log(`Error: Could not generate local/.env \u2014 ${formatError(err)}`);
+    logger.log(`Error: Could not generate ${platformName}-local/.env \u2014 ${formatError(err)}`);
     return;
   }
   try {
     await scaffoldPlatformBootstrap(
-      join16(outputDir, "core", "services", "platform-bootstrap-service"),
+      join16(outputDir, `${platformName}-core`, "services", `${platformName}-bootstrap-service`),
       variables,
       logger
     );
@@ -723,7 +762,7 @@ async function init(params, logger) {
   }
   try {
     await scaffoldCustomizationUi(
-      join16(outputDir, "core", "ui", "platform-customization-ui"),
+      join16(outputDir, `${platformName}-core`, "ui", `${platformName}-customization-ui`),
       variables,
       logger
     );
@@ -733,8 +772,9 @@ async function init(params, logger) {
   }
   try {
     await registerCustomizationModule(
-      join16(outputDir, "core", "services", "platform-bootstrap-service"),
+      join16(outputDir, `${platformName}-core`, "services", `${platformName}-bootstrap-service`),
       organizationName,
+      platformName,
       logger
     );
   } catch (err) {
@@ -750,11 +790,11 @@ import { cwd as cwd4 } from "process";
 import { fetch as undiciFetch, Agent } from "undici";
 
 // src/utils/env-reader.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 async function readEnvFile(filePath) {
   let content;
   try {
-    content = await readFile7(filePath, "utf-8");
+    content = await readFile8(filePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(`.env file not found at ${filePath}`);
@@ -828,7 +868,8 @@ async function configureIdp(params, logger) {
     logger.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const envPath = join17(cwd4(), "local", ".env");
+  const { platformName } = await readPlatformManifest();
+  const envPath = join17(cwd4(), `${platformName}-local`, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -839,11 +880,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 ${platformName}-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 ${platformName}-local/.env`);
     return;
   }
   const provider = idpProviderRegistry.get(params.providerType);
@@ -879,6 +920,223 @@ 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 } from "path";
+import { cwd as cwd5 } from "process";
+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 dirname10 } from "path";
+var nestjsServiceModuleTemplateDir2 = join18(
+  dirname10(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 readFile9, 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 readFile9(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;
+  if (!await isPlatformInitialized()) {
+    logger.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
+    return;
+  }
+  const rootDir = cwd5();
+  let organizationName;
+  let platformName;
+  try {
+    const manifest = await readPlatformManifest(rootDir);
+    organizationName = manifest.organizationName;
+    platformName = manifest.platformName;
+  } catch (err) {
+    logger.log(`Error: Could not read .platform.json \u2014 ${formatError(err)}`);
+    return;
+  }
+  const applicationDir = join19(rootDir, `${platformName}-${applicationName}`);
+  try {
+    await access2(applicationDir);
+  } catch {
+    logger.log(`Error: The specified application "${platformName}-${applicationName}" does not exist in the platform.`);
+    return;
+  }
+  const fullServiceName = `${platformName}-${serviceName}-service`;
+  const serviceDir = join19(applicationDir, "services", fullServiceName);
+  try {
+    await access2(serviceDir);
+    logger.log(`Error: A service named "${fullServiceName}" already exists in application "${platformName}-${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", `${platformName}-${applicationName}-bootstrap-service`);
+  const moduleEntry = buildCustomServiceModuleEntry(organizationName, fullServiceName, serviceDisplayName);
+  await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
+  const localDir = join19(rootDir, `${platformName}-local`);
+  const dockerComposePath = join19(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 "${platformName}-${applicationName}".`);
+}
+
+// src/commands/create-ui-module/create-ui-module.command.ts
+import { join as join20 } from "path";
+import { cwd as cwd6 } from "process";
+import { access as access3, readdir as readdir4 } from "fs/promises";
+
+// src/commands/create-ui-module/append-ui-docker-compose.ts
+import { readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger) {
+  const block = `
+  ${platformName}-${applicationName}-ui:
+    build:
+      context: ../${platformName}-${applicationName}/ui/${platformName}-${applicationName}-ui
+      dockerfile: Dockerfile.development
+    ports:
+      - ${port}:80
+    volumes:
+      - \${PWD}/../:/app/out
+`;
+  try {
+    const existing = await readFile10(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;
+  if (!await isPlatformInitialized()) {
+    logger.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
+    return;
+  }
+  const rootDir = cwd6();
+  let organizationName;
+  let platformName;
+  try {
+    const manifest = await readPlatformManifest(rootDir);
+    organizationName = manifest.organizationName;
+    platformName = manifest.platformName;
+  } catch (err) {
+    logger.log(`Error: Could not read .platform.json \u2014 ${formatError(err)}`);
+    return;
+  }
+  const applicationDir = join20(rootDir, `${platformName}-${applicationName}`);
+  try {
+    await access3(applicationDir);
+  } catch {
+    logger.log(`Error: The specified application "${platformName}-${applicationName}" does not exist in the platform.`);
+    return;
+  }
+  const uiDir = join20(applicationDir, "ui");
+  try {
+    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 "${platformName}-${applicationName}" already has a UI module.`);
+      return;
+    }
+  } catch {
+  }
+  const uiOutputDir = join20(uiDir, `${platformName}-${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", `${platformName}-${applicationName}-bootstrap-service`);
+  const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName);
+  await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
+  const localDir = join20(rootDir, `${platformName}-local`);
+  const dockerComposePath = join20(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const port = await getNextAvailablePort(localDir);
+  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger);
+  logger.log(`Done! UI module "${platformName}-${applicationName}-ui" added to application "${platformName}-${applicationName}".`);
+}
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -904,6 +1162,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 = {
@@ -916,11 +1176,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 join18 } from "path";
-import { cwd as cwd5 } from "process";
-
 // src/services/create-application.service.ts
 async function createApplicationService(params, logger) {
   await createApplication(params, logger);
@@ -935,19 +1190,12 @@ async function createApplicationUiController(ctx) {
   let organizationName;
   let platformName;
   try {
-    const corePackageJson = JSON.parse(
-      await readFile8(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}"`);
-    }
+    const manifest = await readPlatformManifest();
+    organizationName = manifest.organizationName;
+    platformName = manifest.platformName;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    ctx.log(`Error: Could not read core/package.json \u2014 ${message}`);
+    ctx.log(`Error: Could not read .platform.json \u2014 ${message}`);
     return;
   }
   const applicationName = await ctx.prompt("Application name:");
@@ -1018,7 +1266,7 @@ async function configureIdpUiController(ctx) {
     return;
   }
   const provider = providers[index];
-  const name = await ctx.prompt("Provider name:");
+  const name = provider.type;
   const issuer = await ctx.prompt("Issuer URL:");
   const clientId = await ctx.prompt("Client ID:");
   const clientSecret = await ctx.prompt("Client Secret:");
@@ -1032,11 +1280,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
@@ -1122,7 +1423,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() {
@@ -1209,17 +1510,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(Box5, { 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(Box5, { 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,
@@ -1232,17 +1533,14 @@ function App() {
         );
     }
   }
-  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx6(ScrollbackHistory, { items: staticItems, version }),
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(ScrollbackHistory, { items: staticItems, version }),
     renderActiveArea(),
-    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx6(CommandPalette, { commands: filteredCommands, selectedIndex })
+    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx7(CommandPalette, { commands: filteredCommands, selectedIndex })
   ] });
 }
 
 // src/controllers/cli/create-application.cli-controller.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join19 } from "path";
-import { cwd as cwd6 } from "process";
 async function createApplicationCliController(args2) {
   if (!await isPlatformInitialized()) {
     console.error("Error: Cannot create an application \u2014 no platform initialized in this directory.");
@@ -1266,19 +1564,12 @@ async function createApplicationCliController(args2) {
   let organizationName;
   let platformName;
   try {
-    const corePackageJson = JSON.parse(
-      await readFile9(join19(cwd6(), "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}"`);
-    }
+    const manifest = await readPlatformManifest();
+    organizationName = manifest.organizationName;
+    platformName = manifest.platformName;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error: Could not read core/package.json \u2014 ${message}`);
+    console.error(`Error: Could not read .platform.json \u2014 ${message}`);
     process.exit(1);
   }
   await createApplicationService(
@@ -1319,9 +1610,9 @@ async function configureIdpCliController(args2) {
     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");
+  const { providerType, issuer, clientId, clientSecret } = args2;
+  if (!providerType || !issuer || !clientId || !clientSecret) {
+    logger.log("Error: Missing required arguments: providerType, issuer, clientId, clientSecret");
     process.exit(1);
   }
   const provider = idpProviderRegistry.get(providerType);
@@ -1338,19 +1629,22 @@ async function configureIdpCliController(args2) {
     }
     extras[field.key] = value;
   }
+  const name = providerType;
   await configureIdpService({ providerType, name, issuer, clientId, clientSecret, extras }, logger);
 }
 
 // src/utils/run-npm-script.ts
 import { spawn } from "child_process";
-import { access as access2 } from "fs/promises";
-import { join as join20 } from "path";
+import { access as access4 } from "fs/promises";
+import { join as join21 } from "path";
 async function runNpmScript(scriptName, logger, signal) {
-  const localDir = join20(process.cwd(), "local");
+  let localDir;
   try {
-    await access2(localDir);
+    const { platformName } = await readPlatformManifest();
+    localDir = join21(process.cwd(), `${platformName}-local`);
+    await access4(localDir);
   } catch {
-    logger.log(`Error: "local/" directory not found. Run "platform init" first.`);
+    logger.log(`Error: No initialized platform found in this directory. Run "platform init" first.`);
     return;
   }
   return new Promise((resolve) => {
@@ -1455,11 +1749,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)],
@@ -1482,10 +1824,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));