@kosdev-code/kos-ui-cli 2.0.43 → 2.0.45

package/src/lib/generators/dev/index.mjs

@@ -0,0 +1,437 @@
+// generators/dev/index.mjs
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, createWriteStream } from "fs";
+import http from "http";
+import path from "path";
+import {
+  getAllHosts,
+  getHost,
+  filterPlugins,
+  checkProjectExists,
+  validateDevConfig,
+} from "../../utils/dev-config.mjs";
+
+export const metadata = {
+  key: "dev",
+  name: "Development Server",
+  description: "Start development servers for host applications and plugins",
+  namedArguments: {
+    host: "host",
+    plugins: "plugins",
+    disable: "disable",
+    pluginsOnly: "pluginsOnly",
+    interactive: "interactive",
+  },
+};
+
+// Process management
+const processes = [];
+const verbose = process.env.VERBOSE_PLUGIN_DEV === "true";
+
+function cleanup() {
+  console.log(chalk.yellow("\nCleaning up..."));
+  processes.forEach((proc) => {
+    if (proc && !proc.killed) {
+      if (verbose) {
+        console.log(chalk.cyan(`  Stopping process ${proc.pid}`));
+      }
+      proc.kill();
+    }
+  });
+  console.log(chalk.green("Cleanup complete"));
+  process.exit(0);
+}
+
+// Register cleanup handlers
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+
+/**
+ * Check if a port is healthy
+ */
+async function checkPortHealth(port, endpoint = "/api/kos/ui/plugins/contexts") {
+  return new Promise((resolve) => {
+    const req = http.get(`http://localhost:${port}${endpoint}`, (res) => {
+      resolve(res.statusCode === 200);
+    });
+    req.on("error", () => resolve(false));
+    req.setTimeout(1000, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Wait for server to be ready
+ */
+async function waitForServer(port, name, maxWaitSeconds = 120, endpoint = "/api/kos/ui/plugins/contexts") {
+  console.log(chalk.yellow(`Waiting for ${name} to be ready...`));
+
+  const startTime = Date.now();
+  const maxWaitMs = maxWaitSeconds * 1000;
+
+  while (Date.now() - startTime < maxWaitMs) {
+    const isHealthy = await checkPortHealth(port, endpoint);
+    if (isHealthy) {
+      const elapsed = Math.floor((Date.now() - startTime) / 1000);
+      console.log(chalk.green(`✓ ${name} ready on port ${port}! (${elapsed}s)`));
+      return true;
+    }
+
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    if (elapsed > 0 && elapsed % 5 === 0) {
+      console.log(`  ... still waiting (${elapsed}s)`);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  console.log(chalk.red(`✗ Timeout waiting for ${name}`));
+  return false;
+}
+
+/**
+ * Start a dev server
+ */
+function startDevServer(project, port, logFile, env = {}) {
+  console.log(chalk.blue(`Starting ${project} on port ${port}`));
+
+  const logStream = createWriteStream(logFile, { flags: "w" });
+
+  const proc = spawn("npx", ["nx", "run", `${project}:serve`], {
+    env: {
+      ...process.env,
+      ...env,
+      VERBOSE_PLUGIN_DEV: verbose ? "true" : "false",
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  proc.stdout.pipe(logStream);
+  proc.stderr.pipe(logStream);
+
+  proc.on("error", (err) => {
+    console.log(chalk.red(`Failed to start ${project}: ${err.message}`));
+  });
+
+  proc.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(chalk.red(`${project} exited with code ${code}`));
+    }
+  });
+
+  processes.push(proc);
+
+  console.log(chalk.green(`  ✓ PID: ${proc.pid}, Log: ${logFile}`));
+
+  return proc;
+}
+
+/**
+ * Start internal development mode (host + plugins)
+ */
+async function startInternalDevelopment(hostConfig, plugins, logDir) {
+  console.log(chalk.green("=================================================================="));
+  console.log(chalk.green("Internal Development Mode"));
+  console.log(chalk.green(`Host: ${hostConfig.name}`));
+  console.log(chalk.green(`Plugins: ${plugins.length}`));
+  console.log(chalk.green("=================================================================="));
+  console.log("");
+
+  // Create log directory
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  // Start plugin dev servers
+  console.log(chalk.yellow("Starting plugin dev servers..."));
+  for (const plugin of plugins) {
+    const logFile = path.join(logDir, `${plugin.project}.log`);
+    startDevServer(plugin.project, plugin.port, logFile);
+  }
+
+  console.log("");
+  console.log(chalk.yellow("Waiting for plugin dev servers to start..."));
+  await new Promise((resolve) => setTimeout(resolve, 8000));
+
+  // Verify plugin servers
+  console.log(chalk.yellow("Verifying plugin dev servers..."));
+  let allReady = true;
+
+  for (const plugin of plugins) {
+    const pluginEndpoint = plugin.healthCheckEndpoint || "/api/kos/ui/plugins/contexts";
+    const isReady = await checkPortHealth(plugin.port, pluginEndpoint);
+    if (isReady) {
+      console.log(chalk.green(`  ✓ ${plugin.project} ready on port ${plugin.port}`));
+    } else {
+      console.log(chalk.red(`  ✗ ${plugin.project} NOT ready on port ${plugin.port}`));
+      allReady = false;
+    }
+  }
+
+  if (!allReady) {
+    console.log(chalk.red(`\nSome plugin servers failed to start. Check logs in ${logDir}/`));
+    process.exit(1);
+  }
+
+  // Build environment variables
+  console.log("");
+  console.log(chalk.yellow("Configuring host app environment..."));
+
+  const hostEnv = {
+    USE_LOCAL_PLUGINS: "true",
+  };
+
+  // Add plugin-specific env vars
+  for (const plugin of plugins) {
+    const envVar = plugin.project.toUpperCase().replace(/-/g, "_") + "_DEV";
+    hostEnv[envVar] = "true";
+    console.log(chalk.green(`  ✓ ${envVar}=true`));
+  }
+
+  // Start host app
+  console.log("");
+  console.log(chalk.yellow(`Starting host app (${hostConfig.project})...`));
+  const hostLogFile = path.join(logDir, `${hostConfig.project}.log`);
+  startDevServer(hostConfig.project, hostConfig.port, hostLogFile, hostEnv);
+  console.log("");
+
+  // Wait for host app
+  const hostEndpoint = hostConfig.healthCheckEndpoint || "/api/kos/ui/plugins/contexts";
+  const hostReady = await waitForServer(hostConfig.port, hostConfig.project, 120, hostEndpoint);
+
+  if (!hostReady) {
+    console.log(chalk.red("Host app failed to start"));
+    process.exit(1);
+  }
+
+  // Print summary
+  printSummary(hostConfig, plugins, logDir);
+}
+
+/**
+ * Start third-party development mode (plugins only)
+ */
+async function startThirdPartyDevelopment(hostConfig, plugins, logDir) {
+  console.log(chalk.green("=================================================================="));
+  console.log(chalk.green("Third-Party Development Mode"));
+  console.log(chalk.green(`Plugin Context: ${hostConfig.pluginContext}`));
+  console.log(chalk.green(`Plugins: ${plugins.length}`));
+  console.log(chalk.green("=================================================================="));
+  console.log("");
+
+  // Create log directory
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  // Start plugin dev servers only
+  console.log(chalk.yellow("Starting plugin dev servers..."));
+  for (const plugin of plugins) {
+    const logFile = path.join(logDir, `${plugin.project}.log`);
+    startDevServer(plugin.project, plugin.port, logFile);
+  }
+
+  console.log("");
+  console.log(chalk.yellow("Waiting for plugin dev servers to start..."));
+  await new Promise((resolve) => setTimeout(resolve, 8000));
+
+  // Verify plugin servers
+  console.log(chalk.yellow("Verifying plugin dev servers..."));
+  let allReady = true;
+
+  for (const plugin of plugins) {
+    const pluginEndpoint = plugin.healthCheckEndpoint || "/api/kos/ui/plugins/contexts";
+    const isReady = await checkPortHealth(plugin.port, pluginEndpoint);
+    if (isReady) {
+      console.log(chalk.green(`  ✓ ${plugin.project} ready on port ${plugin.port}`));
+    } else {
+      console.log(chalk.red(`  ✗ ${plugin.project} NOT ready on port ${plugin.port}`));
+      allReady = false;
+    }
+  }
+
+  if (!allReady) {
+    console.log(chalk.red(`\nSome plugin servers failed to start. Check logs in ${logDir}/`));
+    process.exit(1);
+  }
+
+  // Print third-party instructions
+  printThirdPartyInstructions(plugins, hostConfig, logDir);
+}
+
+/**
+ * Print summary for internal development
+ */
+function printSummary(hostConfig, plugins, logDir) {
+  console.log("");
+  console.log(chalk.green("=================================================================="));
+  console.log(chalk.green("Development Environment Ready!"));
+  console.log(chalk.green("=================================================================="));
+  console.log("");
+  console.log(chalk.blue("Plugin Dev Servers:"));
+
+  for (const plugin of plugins) {
+    console.log(`  - ${plugin.project}: http://localhost:${plugin.port}`);
+  }
+
+  console.log("");
+  console.log(chalk.blue("Host App:"));
+  console.log(`  - ${hostConfig.project}: http://localhost:${hostConfig.port}`);
+  console.log("");
+  console.log(chalk.blue("Logs:"));
+  console.log(`  - ${logDir}/`);
+  console.log("");
+  console.log(chalk.yellow("Press Ctrl+C to stop all servers"));
+  console.log("");
+}
+
+/**
+ * Print third-party connection instructions
+ */
+function printThirdPartyInstructions(plugins, hostConfig, logDir) {
+  console.log("");
+  console.log(chalk.green("=================================================================="));
+  console.log(chalk.green("Plugin Dev Servers Running"));
+  console.log(chalk.green("=================================================================="));
+  console.log("");
+  console.log(chalk.blue("Plugin Dev Servers:"));
+
+  for (const plugin of plugins) {
+    console.log(`  - ${plugin.project}: http://localhost:${plugin.port}`);
+  }
+
+  console.log("");
+  console.log(chalk.yellow("Connection Instructions:"));
+  console.log("");
+  console.log(chalk.cyan("Connect to your deployed device using query parameters:"));
+  console.log("");
+
+  const yourIp = "<your-development-machine-ip>";
+  const deviceUrl = "<device-ip:port>";
+  const pluginServers = plugins.map((p) => `http://${yourIp}:${p.port}`).join(",");
+
+  console.log(chalk.green(`  ${deviceUrl}/?pluginDevServers=${pluginServers}`));
+  console.log("");
+  console.log(chalk.yellow("Replace:"));
+  console.log(`  - ${chalk.cyan("<your-development-machine-ip>")} with your machine's IP address`);
+  console.log(`  - ${chalk.cyan("<device-ip:port>")} with your device's address`);
+  console.log("");
+  console.log(chalk.yellow("Example:"));
+  const examplePluginServers = plugins.map((p) => `http://localhost:${p.port}`).join(",");
+  console.log(
+    chalk.green(
+      `  http://192.168.1.100:8080/?pluginDevServers=${examplePluginServers}`
+    )
+  );
+  console.log("");
+  console.log(chalk.blue("Logs:"));
+  console.log(`  - ${logDir}/`);
+  console.log("");
+  console.log(chalk.yellow("Press Ctrl+C to stop all servers"));
+  console.log("");
+}
+
+export default async function (plop) {
+  plop.setActionType("runDev", async function (answers) {
+    // Validate configuration
+    const validation = validateDevConfig();
+    if (!validation.isValid) {
+      console.log(chalk.red("\nError: Invalid development configuration"));
+      validation.errors.forEach((err) => console.log(chalk.red(`  - ${err}`)));
+      console.log("");
+      console.log(chalk.yellow("This workspace does not support metadata-driven development."));
+      console.log(chalk.yellow("Run the migration generator or create a new workspace with the latest preset."));
+      return "Failed: Invalid configuration";
+    }
+
+    const { host, plugins: pluginsArg, disable, pluginsOnly } = answers;
+
+    // Get host configuration
+    const hostConfig = getHost(host);
+    if (!hostConfig) {
+      console.log(chalk.red(`\nError: Host '${host}' not found in .kos.json`));
+      return `Failed: Host not found`;
+    }
+
+    // Parse plugin filters
+    const pluginFilter = pluginsArg ? pluginsArg.split(",") : null;
+    const disableFilter = disable ? disable.split(",") : null;
+
+    // Filter plugins
+    const plugins = filterPlugins(hostConfig.plugins, {
+      plugins: pluginFilter,
+      disable: disableFilter,
+    });
+
+    if (plugins.length === 0) {
+      console.log(chalk.yellow("Warning: No plugins selected"));
+      console.log("");
+    }
+
+    // Determine log directory
+    const logDir = process.env.DEV_LOG_DIR || "/tmp/kos-dev-logs";
+
+    // Determine mode
+    const hostProjectExists = checkProjectExists(hostConfig.project);
+
+    if (hostProjectExists && !pluginsOnly) {
+      // Internal Development Mode
+      await startInternalDevelopment(hostConfig, plugins, logDir);
+    } else {
+      // Third-Party Development Mode
+      if (!pluginsOnly && !hostProjectExists) {
+        console.log(chalk.yellow(`Note: Host project '${hostConfig.project}' not found in workspace.`));
+        console.log(chalk.yellow("Starting in third-party development mode (plugins only)."));
+        console.log("");
+      }
+      await startThirdPartyDevelopment(hostConfig, plugins, logDir);
+    }
+
+    // Keep process running
+    await new Promise(() => {});
+  });
+
+  // Get available hosts for prompts
+  const hosts = getAllHosts();
+
+  if (hosts.length === 0) {
+    console.warn("[kos-cli] No hosts found in .kos.json development configuration");
+  }
+
+  plop.setGenerator("dev", {
+    description: "Start development servers for host applications and plugins",
+    prompts: [
+      {
+        type: "list",
+        name: "host",
+        message: "Select a host application:",
+        choices: hosts.map((h) => ({
+          name: `${h.name} (${h.type}) - ${h.plugins.length} plugin(s)`,
+          value: h.name,
+        })),
+      },
+      {
+        type: "input",
+        name: "plugins",
+        message: "Specific plugins to start (comma-separated aliases, leave empty for all enabled):",
+        default: "",
+      },
+      {
+        type: "input",
+        name: "disable",
+        message: "Plugins to disable (comma-separated aliases, leave empty for none):",
+        default: "",
+      },
+      {
+        type: "confirm",
+        name: "pluginsOnly",
+        message: "Start plugins only (third-party mode)?",
+        default: false,
+      },
+    ],
+    actions: () => [{ type: "runDev" }],
+  });
+}

package/src/lib/generators/env/index.mjs

@@ -8,6 +8,7 @@ import { findStudioHome } from "../../utils/studio-home.mjs";
 export const metadata = {
   key: "env",
   name: "Discover and Set Studio Environment Variables",
+  namedArguments: { interactive: "interactive" },
 };
 export default async function (plop) {
   plop.setPrompt("directory", directoryPrompt);

package/src/lib/generators/kab/index.mjs

@@ -0,0 +1,82 @@
+// generators/kab/index.mjs
+import { execSync } from "child_process";
+import inquirer from "inquirer";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+
+export const metadata = {
+  key: "kab",
+  name: "Run Kab Target",
+  namedArguments: {
+    project: "project",
+    interactive: "interactive"
+  },
+};
+
+async function getProjectsWithTarget(target) {
+  try {
+    const output = execSync(`npx nx show projects --with-target ${target} --json`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return JSON.parse(output);
+  } catch (error) {
+    return [];
+  }
+}
+
+export default async function (plop) {
+  const projects = await getProjectsWithTarget("kab");
+
+  if (projects.length === 0) {
+    console.warn("[kos-cli] No projects found with kab target");
+    // Still register the generator but it will fail gracefully
+  }
+
+  plop.setActionType("runKab", async function (answers) {
+    const isWorkspace = await detectWorkspace();
+
+    if (!isWorkspace) {
+      console.warn(
+        "[kos-cli] Not inside an Nx workspace. Cannot run kab target."
+      );
+      return "Skipped: Not a workspace";
+    }
+
+    const { project } = answers;
+
+    if (project === "all") {
+      console.log("[kos-cli] Running kab on all projects with kab target...");
+      try {
+        execSync("npx nx run-many --target=kab", {
+          stdio: "inherit",
+        });
+        return "Successfully ran kab on all projects";
+      } catch (error) {
+        throw new Error(`Failed to run kab on all projects: ${error.message}`);
+      }
+    } else {
+      console.log(`[kos-cli] Running kab on ${project}...`);
+      try {
+        execSync(`npx nx run ${project}:kab`, {
+          stdio: "inherit",
+        });
+        return `Successfully ran kab on ${project}`;
+      } catch (error) {
+        throw new Error(`Failed to run kab on ${project}: ${error.message}`);
+      }
+    }
+  });
+
+  plop.setGenerator("kab", {
+    description: "Run the kab target on a project",
+    prompts: [
+      {
+        type: "list",
+        name: "project",
+        message: "Select a project to run kab:",
+        choices: [...projects, new inquirer.Separator(), { name: "Run on all projects", value: "all" }],
+      },
+    ],
+    actions: () => [{ type: "runKab" }],
+  });
+}

package/src/lib/generators/metadata.json

@@ -23,12 +23,31 @@
       }
     }
   },
+  {
+    "category": "dev",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "dev",
+      "name": "Development Server",
+      "description": "Start development servers for host applications and plugins",
+      "namedArguments": {
+        "host": "host",
+        "plugins": "plugins",
+        "disable": "disable",
+        "pluginsOnly": "pluginsOnly",
+        "interactive": "interactive"
+      }
+    }
+  },
   {
     "category": "env",
     "file": "index.mjs",
     "metadata": {
       "key": "env",
-      "name": "Discover and Set Studio Environment Variables"
+      "name": "Discover and Set Studio Environment Variables",
+      "namedArguments": {
+        "interactive": "interactive"
+      }
     }
   },
   {
@@ -44,6 +63,18 @@
       }
     }
   },
+  {
+    "category": "kab",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "kab",
+      "name": "Run Kab Target",
+      "namedArguments": {
+        "project": "project",
+        "interactive": "interactive"
+      }
+    }
+  },
   {
     "category": "model",
     "file": "add-future.mjs",
@@ -79,6 +110,7 @@
         "parentAware": "parentAware",
         "singleton": "singleton",
         "dataServices": "dataServices",
+        "autoRegister": "autoRegister",
         "dryRun": "dryRun",
         "interactive": "interactive"
       }
@@ -97,6 +129,7 @@
         "parentAware": "parentAware",
         "singleton": "singleton",
         "dataServices": "dataServices",
+        "autoRegister": "autoRegister",
         "dryRun": "dryRun",
         "interactive": "interactive"
       }
@@ -145,6 +178,7 @@
         "singleton": "singleton",
         "dataServices": "dataServices",
         "futureAware": "futureAware",
+        "autoRegister": "autoRegister",
         "dryRun": "dryRun",
         "interactive": "interactive"
       }
@@ -225,6 +259,17 @@
           "project": "componentProject",
           "componentProject": "componentProject"
         }
+      },
+      {
+        "key": "plugin:custom",
+        "name": "KOS UI Plugin Custom (User-Specified Contribution)",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject",
+          "contributionKey": "contributionKey"
+        }
       }
     ]
   },
@@ -300,6 +345,29 @@
       }
     }
   },
+  {
+    "category": "serve",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "serve",
+      "name": "Run Serve Target",
+      "namedArguments": {
+        "project": "project",
+        "interactive": "interactive"
+      }
+    }
+  },
+  {
+    "category": "version",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "version",
+      "name": "Display CLI and SDK Version Information",
+      "namedArguments": {
+        "interactive": "interactive"
+      }
+    }
+  },
   {
     "category": "workspace",
     "file": "index.mjs",
@@ -308,7 +376,8 @@
       "name": "Create a new KOS UI Workspace",
       "namedArguments": {
         "name": "workspaceName",
-        "workspaceName": "workspaceName"
+        "workspaceName": "workspaceName",
+        "enablePlugins": "enablePlugins"
       }
     }
   },

package/src/lib/generators/model/add-future.mjs

@@ -20,13 +20,29 @@ export const metadata = {
 };
 
 export default async function (plop) {
-  const allModels = await getAllModels();
-  const modelChoices = allModels.map((m) => ({
-    name: `${m.model} (${m.project})`,
-    value: m.model,
-  }));
+  // Check if we're in interactive mode by looking at process args
+  const isInteractive = process.argv.includes('-i') || process.argv.includes('--interactive');
+  
+  // For interactive mode, use lazy loading. For non-interactive, load immediately.
+  let modelChoices;
+  if (isInteractive) {
+    modelChoices = async () => {
+      const allModels = await getAllModels();
+      return allModels.map((m) => ({
+        name: `${m.model} (${m.project})`,
+        value: m.model,
+      }));
+    };
+  } else {
+    const allModels = await getAllModels();
+    modelChoices = allModels.map((m) => ({
+      name: `${m.model} (${m.project})`,
+      value: m.model,
+    }));
+  }
 
   plop.setActionType("addFutureToModel", async function (answers) {
+    const allModels = await getAllModels();
     const modelProject = allModels.find(
       (m) => m.model === answers.modelName
     )?.project;