@bluealba/platform-cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1448 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+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";
+
+// src/components/prompt.tsx
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Prompt({ value, onChange, onSubmit, disabled = false }) {
+  const width = process.stdout.columns || 80;
+  const separator = "\u2500".repeat(width);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: separator }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "green", children: "> " }),
+      disabled ? /* @__PURE__ */ jsx(Text, { children: value }) : /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value,
+          onChange,
+          onSubmit,
+          placeholder: "Type / to browse commands..."
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: separator })
+  ] });
+}
+
+// src/components/command-palette.tsx
+import React from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var CommandPalette = React.memo(function CommandPalette2({ commands, selectedIndex }) {
+  if (commands.length === 0) {
+    return /* @__PURE__ */ jsx2(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "No commands found" }) });
+  }
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: commands.map((cmd, i) => {
+    const isSelected = i === selectedIndex;
+    return /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "cyan", bold: isSelected, inverse: isSelected, children: [
+        "/",
+        cmd.name
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "white" : "gray", children: cmd.description })
+    ] }, cmd.name);
+  }) });
+});
+
+// src/components/scrollback-history.tsx
+import { Static, Text as Text4 } from "ink";
+
+// src/components/welcome-banner.tsx
+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: [
+    /* @__PURE__ */ jsxs3(Text3, { 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__ */ 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: [
+          "Run ",
+          /* @__PURE__ */ jsx3(Text3, { color: "green", children: "/init" }),
+          " to start building a platform"
+        ] })
+      ] })
+    ] })
+  ] });
+});
+
+// src/components/scrollback-history.tsx
+import { jsx as jsx4 } 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) });
+}
+
+// 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";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS = 80;
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => {
+      setFrame((prev) => (prev + 1) % FRAMES.length);
+    }, INTERVAL_MS);
+    return () => clearInterval(id);
+  }, []);
+  return /* @__PURE__ */ jsxs4(Text5, { children: [
+    /* @__PURE__ */ jsxs4(Text5, { color: "cyan", children: [
+      FRAMES[frame],
+      " "
+    ] }),
+    label && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: label })
+  ] });
+}
+
+// src/commands/registry.ts
+import { Fzf } from "fzf";
+
+// src/commands/create-application/create-application.command.ts
+import { join as join9 } from "path";
+import { cwd } from "process";
+import { mkdir as mkdir2 } from "fs/promises";
+
+// src/commands/create-application/scaffold-application-monorepo.ts
+import { fileURLToPath } from "url";
+import { join as join2, dirname as dirname2 } from "path";
+
+// src/utils/template-engine.ts
+import { readdir, readFile, writeFile, mkdir, copyFile, stat, chmod } from "fs/promises";
+import { join, dirname, extname } from "path";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pem",
+  ".crt",
+  ".key",
+  ".p12",
+  ".pfx",
+  ".der",
+  ".bin",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot"
+]);
+function applyVariables(text, variables) {
+  let result = text;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function isBinary(filePath) {
+  return BINARY_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+async function walk(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await walk(fullPath);
+      files.push(...nested);
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function applyTemplate(config, onProgress) {
+  const { templateDir: templateDir4, outputDir, variables, exclude = [] } = config;
+  const files = await walk(templateDir4);
+  for (const srcPath of files) {
+    const relativePath = srcPath.slice(templateDir4.length + 1);
+    if (relativePath.endsWith(".gitkeep")) continue;
+    if (exclude.includes(relativePath)) continue;
+    const transformedRelative = applyVariables(relativePath, variables);
+    const destPath = join(outputDir, transformedRelative);
+    await mkdir(dirname(destPath), { recursive: true });
+    if (isBinary(srcPath)) {
+      await copyFile(srcPath, destPath);
+    } else {
+      const content = await readFile(srcPath, "utf8");
+      const transformed = applyVariables(content, variables);
+      await writeFile(destPath, transformed, "utf8");
+      const { mode } = await stat(srcPath);
+      await chmod(destPath, mode);
+    }
+    onProgress?.(`  created ${transformedRelative}`);
+  }
+}
+
+// src/commands/create-application/scaffold-application-monorepo.ts
+var applicationMonorepoTemplateDir = join2(
+  dirname2(fileURLToPath(import.meta.url)),
+  "..",
+  "templates",
+  "application-monorepo-template"
+);
+async function scaffoldApplicationMonorepo(outputDir, organizationName, platformName, applicationName, logger) {
+  await applyTemplate(
+    {
+      templateDir: applicationMonorepoTemplateDir,
+      outputDir,
+      variables: { organizationName, platformName, applicationName }
+    },
+    (message) => logger.log(message)
+  );
+}
+
+// src/commands/create-application/scaffold-bootstrap.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join3, dirname as dirname3 } from "path";
+var bootstrapTemplateDir = join3(
+  dirname3(fileURLToPath2(import.meta.url)),
+  "..",
+  "templates",
+  "bootstrap-service-template"
+);
+async function scaffoldBootstrap(bootstrapServiceDir, organizationName, bootstrapName, bootstrapServiceDir_var, logger) {
+  await applyTemplate(
+    {
+      templateDir: bootstrapTemplateDir,
+      outputDir: bootstrapServiceDir,
+      variables: { organizationName, bootstrapName, bootstrapServiceDir: bootstrapServiceDir_var },
+      exclude: ["src/data/shared-libraries.json", "src/data/platform/modules-config.json"]
+    },
+    (message) => logger.log(message)
+  );
+}
+
+// src/commands/create-application/scaffold-application-data.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { join as join4, dirname as dirname4 } from "path";
+var applicationTemplateDir = join4(
+  dirname4(fileURLToPath3(import.meta.url)),
+  "..",
+  "templates",
+  "application-data-template"
+);
+async function scaffoldApplicationData(bootstrapServiceDir, applicationName, applicationDisplayName, applicationDescription, logger) {
+  await applyTemplate(
+    {
+      templateDir: applicationTemplateDir,
+      outputDir: join4(bootstrapServiceDir, "src", "data"),
+      variables: { applicationName, applicationDisplayName, applicationDescription }
+    },
+    (message) => logger.log(message)
+  );
+}
+
+// src/commands/create-application/scaffold-ui-module.ts
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { join as join5, dirname as dirname5 } from "path";
+var reactUiModuleTemplateDir = join5(
+  dirname5(fileURLToPath4(import.meta.url)),
+  "..",
+  "templates",
+  "react-ui-module-template"
+);
+async function scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger) {
+  logger.log(`Creating UI module "${applicationName}-ui"...`);
+  await applyTemplate(
+    {
+      templateDir: reactUiModuleTemplateDir,
+      outputDir: uiDir,
+      variables: { organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir }
+    },
+    (message) => logger.log(message)
+  );
+  logger.log(`Done! UI output: ${uiDir}`);
+}
+
+// src/commands/create-application/scaffold-nestjs-service.ts
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { join as join6, dirname as dirname6 } from "path";
+var nestjsServiceModuleTemplateDir = join6(
+  dirname6(fileURLToPath5(import.meta.url)),
+  "..",
+  "templates",
+  "nestjs-service-module-template"
+);
+async function scaffoldNestjsService(serviceDir, organizationName, applicationName, applicationDisplayName, serviceBaseDir, logger) {
+  const serviceName = `${applicationName}-service`;
+  const serviceDisplayName = `${applicationDisplayName} Service`;
+  logger.log(`Creating NestJS service "${serviceName}"...`);
+  await applyTemplate(
+    {
+      templateDir: nestjsServiceModuleTemplateDir,
+      outputDir: serviceDir,
+      variables: { organizationName, serviceName, serviceDisplayName, serviceBaseDir }
+    },
+    (message) => logger.log(message)
+  );
+  logger.log(`Done! Service output: ${serviceDir}`);
+}
+
+// src/commands/create-application/update-modules-json.ts
+import { join as join7 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+async function addModuleEntry(bootstrapServiceDir, applicationName, entry, logger) {
+  const modulesJsonPath = join7(bootstrapServiceDir, "src", "data", applicationName, "modules.json");
+  try {
+    const modules = JSON.parse(await readFile2(modulesJsonPath, "utf-8"));
+    modules.push(entry);
+    await writeFile2(modulesJsonPath, JSON.stringify(modules, null, 2) + "\n", "utf-8");
+    logger.log(`Updated modules.json: ${modulesJsonPath}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`Warning: Could not update modules.json \u2014 ${message}`);
+  }
+}
+
+// src/commands/create-application/module-entry-builders.ts
+function buildServiceModuleEntry(organizationName, applicationName, applicationDisplayName) {
+  return {
+    name: `@${organizationName}/${applicationName}-service`,
+    displayName: `${applicationDisplayName} Service`,
+    type: "service",
+    baseUrl: `/${applicationName}-service`,
+    service: {
+      host: `${applicationName}-service`,
+      port: 80
+    },
+    dependsOn: []
+  };
+}
+function buildUiModuleEntry(organizationName, applicationName, applicationDisplayName) {
+  return {
+    name: `@${organizationName}/${applicationName}-ui`,
+    displayName: applicationDisplayName,
+    type: "app",
+    baseUrl: `/${applicationName}-ui`,
+    service: {
+      host: `${applicationName}-ui`,
+      port: 80
+    },
+    ui: {
+      route: `/${applicationName}`,
+      mountAtSelector: "#pae-shell-ui-content",
+      bundleFile: `${organizationName}-${applicationName}-ui.js`,
+      customProps: {}
+    },
+    dependsOn: [`@bluealba/pae-shell-ui`]
+  };
+}
+
+// src/commands/create-application/create-docker-compose.ts
+import { writeFile as writeFile3 } from "fs/promises";
+function buildBootstrapBlock(applicationName) {
+  return `  ${applicationName}-bootstrap-service:
+    build:
+      context: ../${applicationName}/services/${applicationName}-bootstrap-service
+      dockerfile: Dockerfile.development
+    environment:
+      - NODE_TLS_REJECT_UNAUTHORIZED=0
+      - SERVICE_ACCESS_NAME=${applicationName}-bootstrap
+      - WAIT_TIME=5000
+      - SYNC_STRATEGY=\${PAE_BOOTSTRAP_SYNC_STRATEGY}
+      - GATEWAY_SERVICE_URL=\${PAE_GATEWAY_URL}
+      - SERVICE_ACCESS_SECRET=\${PAE_GATEWAY_SERVICE_ACCESS_SECRET}
+    volumes:
+      - \${PWD}/../:/app/out
+    depends_on:
+      pae-nestjs-gateway-service:
+        condition: service_healthy
+`;
+}
+function buildUiBlock(applicationName, uiPort) {
+  return `  ${applicationName}-ui:
+    build:
+      context: ../${applicationName}/ui/${applicationName}-ui
+      dockerfile: Dockerfile.development
+    ports:
+      - ${uiPort}:80
+    volumes:
+      - \${PWD}/../:/app/out
+`;
+}
+function buildBackendBlock(applicationName, servicePort) {
+  return `  ${applicationName}-service:
+    build:
+      context: ../${applicationName}/services/${applicationName}-service
+      dockerfile: Dockerfile.development
+      args:
+        - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
+    ports:
+      - ${servicePort}:80
+    environment:
+      - GATEWAY_URL=\${PAE_GATEWAY_URL}
+    volumes:
+      - \${PWD}/../:/app/out
+`;
+}
+async function createDockerCompose(dockerComposePath, applicationName, hasUserInterface, hasBackendService, uiPort, servicePort, logger) {
+  const blocks = ["services:\n", buildBootstrapBlock(applicationName)];
+  if (hasUserInterface) {
+    blocks.push(buildUiBlock(applicationName, uiPort));
+  }
+  if (hasBackendService) {
+    blocks.push(buildBackendBlock(applicationName, servicePort));
+  }
+  const content = blocks.join("\n");
+  try {
+    await writeFile3(dockerComposePath, content, "utf-8");
+    logger.log(`Created docker-compose: ${dockerComposePath}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`Warning: Could not create docker-compose \u2014 ${message}`);
+  }
+}
+
+// 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) {
+  const allPorts = [];
+  try {
+    const files = await readdir2(localDir);
+    const dockerComposeFiles = files.filter((f) => f.endsWith("-docker-compose.yml"));
+    for (const file of dockerComposeFiles) {
+      try {
+        const content = await readFile4(join8(localDir, file), "utf-8");
+        const regex = /^\s*-\s*"?(\d+):\d+"?\s*$/gm;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          allPorts.push(parseInt(match[1], 10));
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return allPorts.length > 0 ? Math.max(...allPorts) + 1 : 9e3;
+}
+
+// src/utils/error.ts
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/commands/create-application/create-application.command.ts
+var CREATE_APPLICATION_COMMAND_NAME = "create-application";
+var createApplicationCommand = {
+  name: CREATE_APPLICATION_COMMAND_NAME,
+  description: "Create an application in a platform"
+};
+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");
+  logger.log(`Creating application monorepo "${applicationName}"...`);
+  try {
+    await scaffoldApplicationMonorepo(applicationDir, organizationName, platformName, applicationName, logger);
+  } catch (err) {
+    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 });
+  logger.log(`Creating bootstrap service "${applicationName}-bootstrap-service"...`);
+  const bootstrapServiceDir_var = `${applicationName}/services`;
+  try {
+    await scaffoldBootstrap(bootstrapServiceDir, organizationName, applicationName, bootstrapServiceDir_var, logger);
+  } catch (err) {
+    logger.log(`Error: Could not scaffold bootstrap service \u2014 ${formatError(err)}`);
+    return;
+  }
+  logger.log(`Adding application data "${applicationName}"...`);
+  try {
+    await scaffoldApplicationData(bootstrapServiceDir, applicationName, applicationDisplayName, applicationDescription, logger);
+  } catch (err) {
+    logger.log(`Error: Could not scaffold application data \u2014 ${formatError(err)}`);
+    return;
+  }
+  if (hasUserInterface) {
+    await addModuleEntry(
+      bootstrapServiceDir,
+      applicationName,
+      buildUiModuleEntry(organizationName, applicationName, applicationDisplayName),
+      logger
+    );
+  }
+  if (hasBackendService) {
+    await addModuleEntry(
+      bootstrapServiceDir,
+      applicationName,
+      buildServiceModuleEntry(organizationName, applicationName, applicationDisplayName),
+      logger
+    );
+  }
+  if (hasUserInterface) {
+    const uiDir = join9(applicationDir, "ui", `${applicationName}-ui`);
+    const uiBaseDir = `${applicationName}/ui`;
+    try {
+      await scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
+    } catch (err) {
+      logger.log(`Error: Could not scaffold UI module \u2014 ${formatError(err)}`);
+      return;
+    }
+  }
+  if (hasBackendService) {
+    const serviceDir = join9(applicationDir, "services", `${applicationName}-service`);
+    const serviceBaseDir = `${applicationName}/services`;
+    try {
+      await scaffoldNestjsService(serviceDir, organizationName, applicationName, applicationDisplayName, serviceBaseDir, logger);
+    } catch (err) {
+      logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
+      return;
+    }
+  }
+  const dockerComposePath = join9(localDir, `${applicationName}-docker-compose.yml`);
+  const basePort = await getNextAvailablePort(localDir);
+  const uiPort = hasUserInterface ? basePort : 0;
+  const servicePort = hasBackendService ? hasUserInterface ? basePort + 1 : basePort : 0;
+  await createDockerCompose(
+    dockerComposePath,
+    applicationName,
+    hasUserInterface,
+    hasBackendService,
+    uiPort,
+    servicePort,
+    logger
+  );
+  const rootDockerComposePath = join9(localDir, "docker-compose.yml");
+  await updateRootDockerCompose(rootDockerComposePath, applicationName, logger);
+  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";
+
+// src/utils/string.ts
+function camelize(name) {
+  return name.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+
+// 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)),
+  "..",
+  "templates",
+  "platform-init-template"
+);
+async function scaffoldPlatform(outputDir, variables, logger) {
+  await applyTemplate({ templateDir, outputDir, variables }, (message) => logger.log(message));
+}
+
+// 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)),
+  "..",
+  "templates",
+  "bootstrap-service-template"
+);
+async function scaffoldPlatformBootstrap(outputDir, variables, logger) {
+  await applyTemplate({ templateDir: templateDir2, outputDir, variables }, (message) => logger.log(message));
+}
+
+// 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)),
+  "..",
+  "templates",
+  "customization-ui-module-template"
+);
+async function scaffoldCustomizationUi(outputDir, variables, logger) {
+  await applyTemplate({ templateDir: templateDir3, outputDir, variables }, (message) => logger.log(message));
+}
+
+// src/commands/init/register-customization-module.ts
+import { join as join13 } 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 entry = {
+    name: `@${organizationName}/platform-customization-ui`,
+    displayName: "Platform Customization UI",
+    type: "app",
+    baseUrl: "/platform-customization-ui",
+    service: { host: "platform-customization-ui", port: 80 },
+    ui: {
+      route: "/",
+      bundleFile: "platform-customization-ui.js",
+      isPlatformCustomization: true,
+      customProps: {}
+    },
+    dependsOn: []
+  };
+  const existing = JSON.parse(await readFile5(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 { join as join14 } from "path";
+
+// src/utils/random.ts
+import { randomBytes } from "crypto";
+function generateRandomSecret() {
+  return randomBytes(32).toString("hex");
+}
+
+// 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 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()}`;
+  });
+  await writeFile6(envPath, result, "utf-8");
+}
+
+// src/commands/init/init.command.ts
+var INIT_COMMAND_NAME = "init";
+var initCommand = {
+  name: INIT_COMMAND_NAME,
+  description: "Initialize a new platform"
+};
+async function init(params, logger) {
+  const { organizationName, platformName, platformDisplayName } = params;
+  const platformTitle = camelize(platformName);
+  const outputDir = cwd2();
+  logger.log(`Initializing ${platformTitle} platform for @${organizationName}...`);
+  const variables = {
+    organizationName,
+    platformName,
+    platformTitle,
+    platformDisplayName,
+    bootstrapName: "platform",
+    bootstrapServiceDir: "core/services"
+  };
+  try {
+    await scaffoldPlatform(outputDir, variables, logger);
+  } catch (err) {
+    logger.log(`Error: Could not initialize platform \u2014 ${formatError(err)}`);
+    return;
+  }
+  try {
+    await generateLocalEnv(outputDir, logger);
+  } catch (err) {
+    logger.log(`Error: Could not generate local/.env \u2014 ${formatError(err)}`);
+    return;
+  }
+  try {
+    await scaffoldPlatformBootstrap(
+      join15(outputDir, "core", "services", "platform-bootstrap-service"),
+      variables,
+      logger
+    );
+  } catch (err) {
+    logger.log(`Error: Could not generate bootstrap service \u2014 ${formatError(err)}`);
+    return;
+  }
+  try {
+    await scaffoldCustomizationUi(
+      join15(outputDir, "core", "ui", "platform-customization-ui"),
+      variables,
+      logger
+    );
+  } catch (err) {
+    logger.log(`Error: Could not generate customization UI module \u2014 ${formatError(err)}`);
+    return;
+  }
+  try {
+    await registerCustomizationModule(
+      join15(outputDir, "core", "services", "platform-bootstrap-service"),
+      organizationName,
+      logger
+    );
+  } catch (err) {
+    logger.log(`Error: Could not register customization module \u2014 ${formatError(err)}`);
+    return;
+  }
+  logger.log(`Done! Output: ${outputDir}`);
+}
+
+// src/commands/configure-idp/configure-idp.command.ts
+import { join as join16 } from "path";
+import { cwd as cwd3 } from "process";
+import { fetch as undiciFetch, Agent } from "undici";
+
+// src/utils/env-reader.ts
+import { readFile as readFile7 } from "fs/promises";
+async function readEnvFile(filePath) {
+  let content;
+  try {
+    content = await readFile7(filePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`.env file not found at ${filePath}`);
+    }
+    throw error;
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result.set(key, value);
+  }
+  return result;
+}
+
+// src/commands/configure-idp/idp-provider-registry.ts
+var oktaProvider = {
+  type: "okta",
+  displayName: "Okta",
+  fields: [],
+  buildPayload(params) {
+    return {
+      type: "okta",
+      name: params.name,
+      issuer: params.issuer,
+      clientId: params.clientId,
+      clientSecret: params.clientSecret
+    };
+  }
+};
+var entraIdProvider = {
+  type: "entra-id",
+  displayName: "Entra ID",
+  fields: [{ key: "tenantId", prompt: "Tenant ID:" }],
+  buildPayload(params) {
+    return {
+      type: "entra-id",
+      name: params.name,
+      issuer: params.issuer,
+      clientId: params.clientId,
+      clientSecret: params.clientSecret,
+      extras: {
+        tenantId: params.extras?.tenantId ?? ""
+      }
+    };
+  }
+};
+var idpProviderRegistry = /* @__PURE__ */ new Map([
+  [oktaProvider.type, oktaProvider],
+  [entraIdProvider.type, entraIdProvider]
+]);
+function getAllProviders() {
+  return Array.from(idpProviderRegistry.values());
+}
+
+// src/commands/configure-idp/configure-idp.command.ts
+var CONFIGURE_IDP_COMMAND_NAME = "configure-idp";
+var configureIdpCommand = {
+  name: CONFIGURE_IDP_COMMAND_NAME,
+  description: "Configure an Identity Provider (IDP) in the gateway"
+};
+async function configureIdp(params, logger) {
+  const envPath = join16(cwd3(), "local", ".env");
+  let env;
+  try {
+    env = await readEnvFile(envPath);
+  } catch (error) {
+    logger.log(`Error: ${error.message}`);
+    return;
+  }
+  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");
+    return;
+  }
+  if (!accessSecret) {
+    logger.log("Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in local/.env");
+    return;
+  }
+  const provider = idpProviderRegistry.get(params.providerType);
+  if (!provider) {
+    logger.log(`Error: Unknown IDP type "${params.providerType}"`);
+    return;
+  }
+  const payload = provider.buildPayload(params);
+  const agent = new Agent({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch(`${gatewayUrl}/_/providers`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        Authorization: `Bearer ${accessSecret}`
+      },
+      body: JSON.stringify(payload),
+      dispatcher: agent
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return;
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return;
+  }
+  logger.log(`IDP provider "${params.name}" configured successfully.`);
+}
+
+// src/commands/registry.ts
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  getAll() {
+    return Array.from(this.commands.values());
+  }
+  search(query) {
+    const all = this.getAll();
+    if (!query) return all;
+    const fzf = new Fzf(all, {
+      selector: (cmd) => `${cmd.name} ${cmd.description}`
+    });
+    return fzf.find(query).map((result) => result.item);
+  }
+};
+var registry = new CommandRegistry();
+registry.register(createApplicationCommand);
+registry.register(initCommand);
+registry.register(configureIdpCommand);
+
+// src/app-state.ts
+var APP_STATE = {
+  IDLE: "idle",
+  PALETTE: "palette",
+  EXECUTING: "executing",
+  PROMPTING: "prompting"
+};
+
+// 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);
+}
+
+// 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}`);
+    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:");
+  const applicationDescription = await ctx.prompt("Application description:");
+  const hasUserInterfaceAnswer = await ctx.prompt("Does this application have a user interface? (yes/no):");
+  if (hasUserInterfaceAnswer !== "yes" && hasUserInterfaceAnswer !== "no") {
+    ctx.log(`Error: Please answer "yes" or "no".`);
+    return;
+  }
+  const hasBackendServiceAnswer = await ctx.prompt("Does this application have a backend service? (yes/no):");
+  if (hasBackendServiceAnswer !== "yes" && hasBackendServiceAnswer !== "no") {
+    ctx.log(`Error: Please answer "yes" or "no".`);
+    return;
+  }
+  await createApplicationService(
+    {
+      organizationName,
+      platformName,
+      applicationName,
+      applicationDisplayName,
+      applicationDescription,
+      hasUserInterface: hasUserInterfaceAnswer === "yes",
+      hasBackendService: hasBackendServiceAnswer === "yes"
+    },
+    ctx
+  );
+}
+
+// src/services/init.service.ts
+async function initService(params, logger) {
+  await init(params, logger);
+}
+
+// src/controllers/ui/init.ui-controller.ts
+async function initUiController(ctx) {
+  const organizationName = await ctx.prompt("Organization name:");
+  const platformName = await ctx.prompt("Platform name:");
+  const platformDisplayName = await ctx.prompt("Platform display name:");
+  await initService({ organizationName, platformName, platformDisplayName }, ctx);
+}
+
+// src/services/configure-idp.service.ts
+async function configureIdpService(params, logger) {
+  await configureIdp(params, logger);
+}
+
+// src/controllers/ui/configure-idp.ui-controller.ts
+async function configureIdpUiController(ctx) {
+  const providers = getAllProviders();
+  const options = providers.map((p, i) => `${i + 1}: ${p.displayName}`).join(", ");
+  const selectionInput = await ctx.prompt(`Select IDP type (${options}):`);
+  const index = parseInt(selectionInput.trim(), 10) - 1;
+  if (isNaN(index) || index < 0 || index >= providers.length) {
+    ctx.log(`Error: Invalid selection "${selectionInput}"`);
+    return;
+  }
+  const provider = providers[index];
+  const name = await ctx.prompt("Provider name:");
+  const issuer = await ctx.prompt("Issuer URL:");
+  const clientId = await ctx.prompt("Client ID:");
+  const clientSecret = await ctx.prompt("Client Secret:");
+  const extras = {};
+  for (const field of provider.fields) {
+    extras[field.key] = await ctx.prompt(field.prompt);
+  }
+  await configureIdpService(
+    { providerType: provider.type, name, issuer, clientId, clientSecret, extras },
+    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]
+]);
+
+// src/hooks/use-command-runner.ts
+function useCommandRunner({ appendStaticItem, setState }) {
+  const outputCountRef = useRef(0);
+  const abortControllerRef = useRef(null);
+  const promptResolveRef = useRef(null);
+  const [promptMessage, setPromptMessage] = useState2("");
+  const [promptValue, setPromptValue] = useState2("");
+  const abortExecution = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    promptResolveRef.current = null;
+  }, []);
+  const runCommand = useCallback(
+    (cmd) => {
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState(APP_STATE.EXECUTING);
+      const ctx = {
+        signal: controller.signal,
+        log(message) {
+          if (!controller.signal.aborted) {
+            const id = `output-${outputCountRef.current++}`;
+            appendStaticItem({ kind: "output", id, line: message });
+          }
+        },
+        prompt(message) {
+          return new Promise((resolve, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptValue("");
+            promptResolveRef.current = resolve;
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        }
+      };
+      const uiController = uiControllers.get(cmd.name);
+      if (!uiController) {
+        const id = `output-${outputCountRef.current++}`;
+        appendStaticItem({ kind: "output", id, line: `Error: No controller found for "${cmd.name}"` });
+        setState(APP_STATE.IDLE);
+        return;
+      }
+      uiController(ctx).then(() => {
+        if (!controller.signal.aborted) {
+          setState(APP_STATE.IDLE);
+        }
+      }).catch((err) => {
+        if (controller.signal.aborted) return;
+        const id = `output-${outputCountRef.current++}`;
+        appendStaticItem({ kind: "output", id, line: `Error: ${formatError(err)}` });
+        setState(APP_STATE.IDLE);
+      });
+    },
+    [appendStaticItem, setState]
+  );
+  const handlePromptSubmit = useCallback(
+    (value) => {
+      const resolve = promptResolveRef.current;
+      promptResolveRef.current = null;
+      setState(APP_STATE.EXECUTING);
+      resolve?.(value);
+    },
+    [setState]
+  );
+  return {
+    runCommand,
+    handlePromptSubmit,
+    abortExecution,
+    promptMessage,
+    promptValue,
+    setPromptValue
+  };
+}
+
+// src/app.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+function App() {
+  const { exit } = useApp();
+  const [state, setState] = useState3(APP_STATE.IDLE);
+  const [inputValue, setInputValue] = useState3("");
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [staticItems, setStaticItems] = useState3([{ kind: "banner", id: "banner" }]);
+  const appendStaticItem = useCallback2((item) => {
+    setStaticItems((prev) => [...prev, item]);
+  }, []);
+  const { runCommand, handlePromptSubmit, abortExecution, promptMessage, promptValue, setPromptValue } = useCommandRunner({ appendStaticItem, setState });
+  const query = inputValue.startsWith("/") ? inputValue.slice(1) : "";
+  const filteredCommands = registry.search(query);
+  useInput(
+    (input, key) => {
+      if (key.ctrl && input === "c") {
+        exit();
+        return;
+      }
+      if ((state === APP_STATE.EXECUTING || state === APP_STATE.PROMPTING) && key.escape) {
+        abortExecution();
+        setState(APP_STATE.IDLE);
+        return;
+      }
+      if (state === APP_STATE.PALETTE) {
+        if (key.escape) {
+          setState(APP_STATE.IDLE);
+          setInputValue("");
+          return;
+        }
+        if (key.upArrow) {
+          setSelectedIndex((prev) => Math.max(0, prev - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelectedIndex((prev) => Math.min(filteredCommands.length - 1, prev + 1));
+          return;
+        }
+        if (key.return) {
+          const cmd = filteredCommands[selectedIndex];
+          if (cmd) {
+            setInputValue("");
+            runCommand(cmd);
+          }
+          return;
+        }
+        if (key.backspace || key.delete) {
+          setInputValue((prev) => {
+            const next = prev.slice(0, -1);
+            if (!next.startsWith("/")) {
+              setState(APP_STATE.IDLE);
+              return "";
+            }
+            return next;
+          });
+          setSelectedIndex(0);
+          return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+          setInputValue((prev) => prev + input);
+          setSelectedIndex(0);
+        }
+      }
+    },
+    { isActive: true }
+  );
+  const handleIdleInputChange = useCallback2((value) => {
+    setInputValue(value);
+    if (value.startsWith("/")) {
+      setState(APP_STATE.PALETTE);
+      setSelectedIndex(0);
+    }
+  }, []);
+  const handleIdleSubmit = useCallback2(
+    (value) => {
+      if (!value.startsWith("/")) return;
+      const name = value.slice(1).trim();
+      const cmd = registry.get(name);
+      if (cmd) runCommand(cmd);
+    },
+    [runCommand]
+  );
+  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)" })
+        ] });
+      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 })
+        ] });
+      default:
+        return /* @__PURE__ */ jsx6(
+          Prompt,
+          {
+            value: inputValue,
+            onChange: state === APP_STATE.IDLE ? handleIdleInputChange : () => {
+            },
+            onSubmit: state === APP_STATE.IDLE ? handleIdleSubmit : () => {
+            },
+            disabled: state === APP_STATE.PALETTE
+          }
+        );
+    }
+  }
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(ScrollbackHistory, { items: staticItems, version }),
+    renderActiveArea(),
+    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx6(CommandPalette, { commands: filteredCommands, selectedIndex })
+  ] });
+}
+
+// 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) {
+  const {
+    applicationName,
+    applicationDisplayName,
+    applicationDescription,
+    hasUserInterface,
+    hasBackendService
+  } = args2;
+  if (!applicationName || !applicationDisplayName || !applicationDescription) {
+    console.error("Error: applicationName, applicationDisplayName, and applicationDescription 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);
+  }
+  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,
+      hasUserInterface: hasUserInterface === "yes",
+      hasBackendService: hasBackendService === "yes"
+    },
+    { log: console.log }
+  );
+}
+
+// src/controllers/cli/init.cli-controller.ts
+async function initCliController(args2) {
+  const { organizationName, platformName, platformDisplayName } = args2;
+  if (!organizationName || !platformName || !platformDisplayName) {
+    console.error("Error: organizationName, platformName, and platformDisplayName are required.");
+    process.exit(1);
+  }
+  await initService(
+    { organizationName, platformName, platformDisplayName },
+    { log: console.log }
+  );
+}
+
+// src/controllers/cli/configure-idp.cli-controller.ts
+async function configureIdpCliController(args2) {
+  const logger = { log: console.log };
+  const { providerType, name, issuer, clientId, clientSecret } = args2;
+  if (!providerType || !name || !issuer || !clientId || !clientSecret) {
+    logger.log("Error: Missing required arguments: providerType, name, issuer, clientId, clientSecret");
+    process.exit(1);
+  }
+  const provider = idpProviderRegistry.get(providerType);
+  if (!provider) {
+    logger.log(`Error: Unknown IDP type "${providerType}"`);
+    process.exit(1);
+  }
+  const extras = {};
+  for (const field of provider.fields) {
+    const value = args2[field.key];
+    if (!value) {
+      logger.log(`Error: Missing required argument for ${providerType}: ${field.key}`);
+      process.exit(1);
+    }
+    extras[field.key] = value;
+  }
+  await configureIdpService({ providerType, name, issuer, clientId, clientSecret, extras }, logger);
+}
+
+// src/utils/run-npm-script.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;
+  }
+  return new Promise((resolve) => {
+    const child = spawn("npm", ["run", scriptName], {
+      cwd: localDir,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (signal) {
+      if (signal.aborted) {
+        child.kill("SIGTERM");
+        resolve();
+        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(`Command "npm run ${scriptName}" exited with code ${code}.`);
+      }
+      resolve();
+    });
+    child.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      logger.log(`Failed to run "npm run ${scriptName}": ${err.message}`);
+      resolve();
+    });
+  });
+}
+
+// src/commands/local-scripts/local-script.command.ts
+var INSTALL_COMMAND_NAME = "install";
+var BUILD_COMMAND_NAME = "build";
+var START_COMMAND_NAME = "start";
+var STOP_COMMAND_NAME = "stop";
+var DESTROY_COMMAND_NAME = "destroy";
+async function runLocalScript(scriptName, logger, signal) {
+  await runNpmScript(scriptName, logger, signal);
+}
+
+// src/services/local-script.service.ts
+async function localScriptService(scriptName, logger, signal) {
+  await runLocalScript(scriptName, logger, signal);
+}
+
+// src/utils/cli-spinner.ts
+var FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS2 = 80;
+function createCliSpinner(label) {
+  let frame = 0;
+  let intervalId = null;
+  function render2() {
+    process.stdout.write(`\r${FRAMES2[frame]} ${label}`);
+    frame = (frame + 1) % FRAMES2.length;
+  }
+  function clearLine() {
+    process.stdout.write("\r\x1B[K");
+  }
+  return {
+    start() {
+      render2();
+      intervalId = setInterval(render2, INTERVAL_MS2);
+    },
+    log(message) {
+      clearLine();
+      console.log(message);
+      render2();
+    },
+    stop() {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      clearLine();
+    }
+  };
+}
+
+// src/controllers/cli/local-script.cli-controller.ts
+function createLocalScriptCliController(scriptName) {
+  return async (_args) => {
+    const spinner = createCliSpinner(`Running ${scriptName}\u2026`);
+    spinner.start();
+    await localScriptService(scriptName, { log: (msg) => spinner.log(msg) });
+    spinner.stop();
+  };
+}
+
+// src/controllers/cli/registry.ts
+var cliControllers = /* @__PURE__ */ new Map([
+  [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
+  [INIT_COMMAND_NAME, initCliController],
+  [CONFIGURE_IDP_COMMAND_NAME, configureIdpCliController],
+  [INSTALL_COMMAND_NAME, createLocalScriptCliController(INSTALL_COMMAND_NAME)],
+  [BUILD_COMMAND_NAME, createLocalScriptCliController(BUILD_COMMAND_NAME)],
+  [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],
+  [STOP_COMMAND_NAME, createLocalScriptCliController(STOP_COMMAND_NAME)],
+  [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)]
+]);
+
+// src/utils/parse-args.ts
+function parseKeyValueArgs(args2) {
+  const result = {};
+  for (const arg of args2) {
+    const eqIndex = arg.indexOf("=");
+    if (eqIndex > 0) {
+      const key = arg.slice(0, eqIndex);
+      const value = arg.slice(eqIndex + 1);
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/index.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var args = process.argv.slice(2);
+if (args.length === 0) {
+  render(/* @__PURE__ */ jsx7(App, {}));
+} else {
+  const commandName = args[0];
+  const params = parseKeyValueArgs(args.slice(1));
+  const controller = cliControllers.get(commandName);
+  if (!controller) {
+    console.error(`Unknown command: ${commandName}`);
+    process.exit(1);
+  }
+  await controller(params);
+}