@kosdev-code/kos-ui-cli 2.1.20 → 2.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosdev-code/kos-ui-cli",
-  "version": "2.1.20",
+  "version": "2.1.22",
   "bin": {
     "kosui": "./src/lib/cli.mjs"
   },
@@ -21,7 +21,7 @@
   "main": "./src/index.js",
   "kos": {
     "build": {
-      "gitHash": "21d74bd5b3b2a8206284fa74551b078c7f951398"
+      "gitHash": "14929950a1c351744473e8cb80a2b0ec2364c590"
     }
   },
   "publishConfig": {

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

@@ -0,0 +1,434 @@
+// 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) {
+  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);
+    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 isReady = await checkPortHealth(plugin.port);
+    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 hostReady = await waitForServer(hostConfig.port, hostConfig.project);
+
+  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 isReady = await checkPortHealth(plugin.port);
+    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/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/workspace/index.mjs

@@ -9,7 +9,8 @@ export const metadata = {
   name: "Create a new KOS UI Workspace",
   namedArguments: {
     name: "workspaceName",
-    workspaceName: "workspaceName"
+    workspaceName: "workspaceName",
+    enablePlugins: "enablePlugins"
   }
 };
 export default async function (plop) {
@@ -17,6 +18,7 @@ export default async function (plop) {
     await createWorkspace("@kosdev-code/kos-nx-plugin", {
       nxCloud: "skip",
       name: answers.workspaceName,
+      enablePlugins: answers.enablePlugins,
     });
     return `Workspace ${answers.workspaceName} created.`;
   });
@@ -30,10 +32,16 @@ export default async function (plop) {
         message: "Enter the workspace name",
         validate: required,
       },
+      {
+        type: "confirm",
+        name: "enablePlugins",
+        message: "Do you want to enable plugin support?",
+        default: true,
+      },
     ],
     actions: () => [{ type: "createWorkspace" }],
   });
-  
+
   // Register additional workspace generators
   await registerListModels(plop);
   await registerListProjects(plop);

package/src/lib/plopfile.mjs

@@ -13,6 +13,7 @@ import registerComponent from "./generators/component/index.mjs";
 import registerPluginComponent from "./generators/plugin/index.mjs";
 
 import registerCacheGenerators from "./generators/cache/index.mjs";
+import registerDev from "./generators/dev/index.mjs";
 import registerEnv from "./generators/env/index.mjs";
 import registerKab from "./generators/kab/index.mjs";
 import registerServe from "./generators/serve/index.mjs";
@@ -59,6 +60,7 @@ export default async function (plop) {
   await registerSplashProject(plop);
   await registerI18n(plop);
   await registerI18nNamespace(plop);
+  await registerDev(plop);
   await registerEnv(plop);
   await registerKab(plop);
   await registerServe(plop);

package/src/lib/utils/dev-config.mjs

@@ -0,0 +1,150 @@
+// utils/dev-config.mjs
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+
+/**
+ * Read the development configuration from root .kos.json
+ *
+ * @returns {Object|null} Development config or null if not found
+ */
+export function getDevConfig() {
+  const workspaceRoot = process.cwd();
+  const kosJsonPath = path.join(workspaceRoot, '.kos.json');
+
+  if (!existsSync(kosJsonPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(kosJsonPath, 'utf-8');
+    const config = JSON.parse(content);
+
+    if (config.type !== 'root') {
+      return null;
+    }
+
+    if (!config.development || !config.development.hosts) {
+      return null;
+    }
+
+    return config.development;
+  } catch (error) {
+    console.error(`[kos-cli] Error reading .kos.json: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Find a host configuration by name
+ *
+ * @param {string} hostName - Name of the host to find
+ * @returns {Object|null} Host config or null if not found
+ */
+export function getHost(hostName) {
+  const devConfig = getDevConfig();
+
+  if (!devConfig) {
+    return null;
+  }
+
+  return devConfig.hosts.find(h => h.name === hostName) || null;
+}
+
+/**
+ * Get all available hosts
+ *
+ * @returns {Array} Array of host configurations
+ */
+export function getAllHosts() {
+  const devConfig = getDevConfig();
+
+  if (!devConfig) {
+    return [];
+  }
+
+  return devConfig.hosts || [];
+}
+
+/**
+ * Filter plugins based on options
+ *
+ * @param {Array} hostPlugins - Array of plugin configs from host
+ * @param {Object} options - Filter options
+ * @param {Array} options.plugins - Specific plugin aliases to include
+ * @param {Array} options.disable - Plugin aliases to exclude
+ * @returns {Array} Filtered array of plugin configurations
+ */
+export function filterPlugins(hostPlugins, options = {}) {
+  let plugins = hostPlugins.filter(p => p.enabled);
+
+  // If specific plugins requested, override enabled flag
+  if (options.plugins && options.plugins.length > 0) {
+    plugins = hostPlugins.filter(p => options.plugins.includes(p.alias));
+  }
+
+  // Apply disable list
+  if (options.disable && options.disable.length > 0) {
+    plugins = plugins.filter(p => !options.disable.includes(p.alias));
+  }
+
+  return plugins;
+}
+
+/**
+ * Check if a project exists in the workspace
+ *
+ * @param {string} projectName - Name of the project
+ * @returns {boolean} True if project exists
+ */
+export function checkProjectExists(projectName) {
+  const workspaceRoot = process.cwd();
+
+  // Check common project locations
+  const appPath = path.join(workspaceRoot, 'apps', projectName, 'project.json');
+  const libPath = path.join(workspaceRoot, 'libs', projectName, 'project.json');
+  const pluginPath = path.join(workspaceRoot, 'plugins', projectName, 'project.json');
+  const packagesPath = path.join(workspaceRoot, 'packages', projectName, 'project.json');
+
+  return existsSync(appPath) ||
+         existsSync(libPath) ||
+         existsSync(pluginPath) ||
+         existsSync(packagesPath);
+}
+
+/**
+ * Validate development configuration
+ *
+ * @returns {Object} Validation result with isValid and errors
+ */
+export function validateDevConfig() {
+  const devConfig = getDevConfig();
+  const errors = [];
+
+  if (!devConfig) {
+    errors.push('.kos.json missing or does not contain development configuration');
+    return { isValid: false, errors };
+  }
+
+  if (!Array.isArray(devConfig.hosts) || devConfig.hosts.length === 0) {
+    errors.push('No hosts defined in development configuration');
+    return { isValid: false, errors };
+  }
+
+  // Validate each host
+  devConfig.hosts.forEach((host, idx) => {
+    if (!host.name) {
+      errors.push(`Host at index ${idx} missing required 'name' field`);
+    }
+    if (!host.project) {
+      errors.push(`Host at index ${idx} missing required 'project' field`);
+    }
+    if (!host.port) {
+      errors.push(`Host at index ${idx} missing required 'port' field`);
+    }
+    if (!Array.isArray(host.plugins)) {
+      errors.push(`Host '${host.name}' missing 'plugins' array`);
+    }
+  });
+
+  return { isValid: errors.length === 0, errors };
+}