@kb-labs/cli-commands 2.4.0 → 2.6.0

package/dist/index.js

@@ -10,7 +10,7 @@ import { glob } from 'glob';
 import { defineSystemCommand, defineSystemCommandGroup } from '@kb-labs/shared-command-kit';
 import { createRegistry, formatDiagnosticReport } from '@kb-labs/core-registry';
 import { readMarketplaceLock, DiagnosticCollector } from '@kb-labs/core-discovery';
-import { platform } from '@kb-labs/core-runtime';
+import { platform, platformSync } from '@kb-labs/core-runtime';
 import { CredentialsManager } from '@kb-labs/cli-runtime/gateway';
 import Ajv from 'ajv';
 import { createRequire } from 'module';
@@ -167,7 +167,8 @@ var discover_exports = {};
 __export(discover_exports, {
   __test: () => __test,
   discoverManifests: () => discoverManifests,
-  discoverManifestsByNamespace: () => discoverManifestsByNamespace
+  discoverManifestsByNamespace: () => discoverManifestsByNamespace,
+  resetInProcCache: () => resetInProcCache
 });
 function createManifestV3Loader(commandId) {
   return async () => {
@@ -207,8 +208,12 @@ function createUnavailableManifest(pkgName, error) {
       throw new Error(`Cannot load ${pkgName} CLI manifest. ${rawMsg}`);
     }
   };
+  manifest._synthetic = true;
   return manifest;
 }
+function resetInProcCache() {
+  inProcDiscoveryCache = null;
+}
 async function computeManifestHash(manifestPath) {
   try {
     const content = await promises.readFile(manifestPath, "utf8");
@@ -551,7 +556,7 @@ async function discoverNodeModules(cwd) {
     const packageInfos = [];
     const scanPromises = [];
     for (const entry of entries) {
-      if (!entry.isDirectory()) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) {
         continue;
       }
       const scanEntry = async () => {
@@ -561,7 +566,7 @@ async function discoverNodeModules(cwd) {
           const scopeDir = path.join(nmDir, entry.name);
           try {
             const scopedDirs = await promises.readdir(scopeDir, { withFileTypes: true });
-            for (const scopedEntry of scopedDirs.filter((d) => d.isDirectory())) {
+            for (const scopedEntry of scopedDirs.filter((d) => d.isDirectory() || d.isSymbolicLink())) {
               pkgRoot = path.join(scopeDir, scopedEntry.name);
               pkg = await readPackageJson(path.join(pkgRoot, PACKAGE_JSON));
               if (!pkg) {
@@ -791,6 +796,11 @@ async function saveCache(cwd, results) {
   const now = Date.now();
   const stateHasher = createHash("sha256");
   for (const result of results) {
+    const allSynthetic = result.manifests.length > 0 && result.manifests.every((m) => m._synthetic === true);
+    if (allSynthetic) {
+      log("debug", `[plugins][cache] Skipping synthetic unavailable manifest for ${result.packageName}`);
+      continue;
+    }
     try {
       const manifestHash = await computeManifestHash(result.manifestPath);
       const pkgJsonPath = path.join(result.pkgRoot.split("/").join(path.sep), PACKAGE_JSON);
@@ -851,7 +861,7 @@ async function saveCache(cwd, results) {
     log("debug", `Failed to save cache: ${err.message}`);
   }
 }
-async function discoverManifests(cwd, noCache = false) {
+async function discoverManifests(cwd, noCache = false, options = {}) {
   const startTime = Date.now();
   const timings = {};
   if (noCache) {
@@ -927,7 +937,8 @@ async function discoverManifests(cwd, noCache = false) {
     }
   }
   const nmStart = Date.now();
-  const installed = await discoverNodeModules(cwd);
+  const nodeModulesRoot = options.platformRoot ?? cwd;
+  const installed = await discoverNodeModules(nodeModulesRoot);
   timings.nodeModules = Date.now() - nmStart;
   if (installed.length > 0) {
     log("info", `Discovered ${installed.length} installed packages with CLI manifests`);
@@ -981,6 +992,7 @@ var init_discover = __esm({
     __test = {
       ensureManifestLoader,
       createManifestV3Loader
+      // resetInProcCache is exported directly (not via __test) since it's part of the public API
     };
     PACKAGE_JSON = "package.json";
     MANIFEST_LOAD_TIMEOUT = 1500;
@@ -1524,7 +1536,8 @@ var diag = defineSystemCommand({
       details: { nodeVersion, cliVersion, platform: platform11, arch }
     });
     try {
-      const discovered = await discoverManifests(cwd, false);
+      const platformRoot = process.env.KB_PLATFORM_ROOT;
+      const discovered = await discoverManifests(cwd, false, { platformRoot });
       const manifests = registry.listManifests();
       const enabled = manifests.filter((m) => m.available && !m.shadowed).length;
       const disabled = manifests.filter((m) => !m.available).length;
@@ -1764,6 +1777,9 @@ var registryDiagnostics = defineSystemCommand({
     }
   }
 });
+
+// src/registry/plugins-state.ts
+init_discover();
 async function clearCache(cwd, options) {
   const cleared = [];
   const cacheDir = path.join(cwd, ".kb", "cache");
@@ -1792,6 +1808,7 @@ async function clearCache(cwd, options) {
     }
   } catch {
   }
+  resetInProcCache();
   const modulesCleared = [];
   if (options?.deep) {
     try {
@@ -3140,6 +3157,146 @@ var authCreateServiceAccount = defineSystemCommand({
     return { ok: true, clientId: data.clientId, clientSecret: data.clientSecret, hostId: data.hostId };
   }
 });
+function isMode(value) {
+  return value === "validate" || value === "reconcile" || value === "auto";
+}
+var platformSyncCommand = defineSystemCommand({
+  name: "provision",
+  description: "Reconcile .kb/marketplace.lock with installed adapters & plugins",
+  longDescription: "Reads .kb/marketplace.lock as the declarative source of truth for which adapters and plugins this installation needs, and makes the filesystem match. In monorepo/dev mode it only validates. In prod/Docker build mode it installs missing marketplace packages via pnpm.",
+  category: "platform",
+  examples: generateExamples("platform provision", "kb", [
+    { flags: {} },
+    { flags: { mode: "validate" } },
+    { flags: { mode: "reconcile", json: true } },
+    { flags: { "dry-run": true } }
+  ]),
+  flags: {
+    json: { type: "boolean", description: "Output machine-readable JSON" },
+    mode: {
+      type: "string",
+      description: "Sync mode: validate | reconcile | auto (default: auto)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Never install, fail on drift"
+    },
+    root: {
+      type: "string",
+      description: "Workspace root (default: current working directory)"
+    }
+  },
+  analytics: {
+    command: "platform.sync",
+    startEvent: "PLATFORM_SYNC_STARTED",
+    finishEvent: "PLATFORM_SYNC_FINISHED"
+  },
+  async handler(ctx, _argv, flags) {
+    const cwd = getContextCwd(ctx);
+    const root = flags.root ?? cwd;
+    const modeFlag = flags.mode;
+    const mode = isMode(modeFlag) ? modeFlag : "auto";
+    const dryRun = Boolean(flags["dry-run"]);
+    const logger = ctx.platform?.logger;
+    logger?.info("platform sync started", { root, mode, dryRun });
+    const result = await platformSync({
+      root,
+      mode,
+      dryRun,
+      logger
+    });
+    logger?.info("platform sync finished", {
+      ok: result.ok,
+      mode: result.mode,
+      checked: result.checked,
+      missing: result.missing.length,
+      mismatched: result.mismatched.length,
+      installed: result.installed.length,
+      errors: result.errors.length
+    });
+    return {
+      ok: result.ok,
+      status: result.ok ? "success" : "error",
+      sync: result
+    };
+  },
+  formatter(result, ctx, flags) {
+    if (flags.json) {
+      console.log(JSON.stringify(result.sync ?? result, null, 2));
+      return;
+    }
+    const sync = result.sync;
+    if (!sync) {
+      ctx.ui.error("Platform Sync", {
+        sections: [{ header: "Error", items: [result.error ?? "Unknown error"] }]
+      });
+      return;
+    }
+    const summary = [
+      `Mode: ${sync.mode}${sync.mode !== flags.mode && flags.mode !== "auto" ? " (auto-detected)" : ""}`,
+      `Checked: ${sync.checked}`
+    ];
+    if (sync.lockMissing) {
+      summary.push("Lock: not found (nothing to reconcile)");
+    }
+    if (sync.installed.length) {
+      summary.push(`Installed: ${sync.installed.length}`);
+    }
+    if (sync.missing.length) {
+      summary.push(`Missing: ${sync.missing.length}`);
+    }
+    if (sync.mismatched.length) {
+      summary.push(`Integrity mismatch: ${sync.mismatched.length}`);
+    }
+    if (sync.errors.length) {
+      summary.push(`Errors: ${sync.errors.length}`);
+    }
+    const sections = [
+      { header: "Summary", items: summary }
+    ];
+    if (sync.installed.length) {
+      sections.push({
+        header: "Installed",
+        items: sync.installed.map((id) => `\u2022 ${id}`)
+      });
+    }
+    if (sync.missing.length) {
+      sections.push({
+        header: "Missing",
+        items: sync.missing.map((id) => `\u2022 ${id}`)
+      });
+    }
+    if (sync.mismatched.length) {
+      sections.push({
+        header: "Integrity mismatch",
+        items: sync.mismatched.map((id) => `\u2022 ${id}`)
+      });
+    }
+    if (sync.errors.length) {
+      sections.push({
+        header: "Errors",
+        items: sync.errors.map((e) => `\u2022 ${e.packageId}: ${e.message}`)
+      });
+    }
+    const nextSteps = [];
+    if (!sync.ok) {
+      if (sync.missing.length && sync.mode === "validate") {
+        nextSteps.push("kb platform provision --mode reconcile   Install missing packages");
+      }
+      if (sync.mismatched.length) {
+        nextSteps.push("kb marketplace install <pkg>             Re-install mismatched packages");
+      }
+    }
+    if (nextSteps.length) {
+      sections.push({ header: "Next Steps", items: nextSteps });
+    }
+    if (sync.ok) {
+      ctx.ui.success("Platform Sync", { sections });
+    } else {
+      ctx.ui.error("Platform Sync", { sections });
+    }
+  }
+});
 
 // src/commands/system/groups.ts
 var infoGroup = defineSystemCommandGroup("info", "System information commands", [
@@ -3172,6 +3329,9 @@ var authGroup = defineSystemCommandGroup("auth", "Gateway authentication command
   authStatus,
   authCreateServiceAccount
 ]);
+var platformGroup = defineSystemCommandGroup("platform", "Platform lifecycle commands", [
+  platformSyncCommand
+]);
 var req = createRequire(import.meta.url);
 var __filename$1 = fileURLToPath(import.meta.url);
 var __dirname$1 = path.dirname(__filename$1);
@@ -3655,12 +3815,15 @@ async function registerBuiltinCommands(input = {}) {
   registry.registerGroup(docsGroup);
   registry.registerGroup(logsGroup);
   registry.registerGroup(authGroup);
+  registry.registerGroup(platformGroup);
   try {
     const cwd = getContextCwd({ cwd: input.cwd });
     const env = input.env ?? process.env;
     const noCache = process.argv.includes("--no-cache") || env.KB_PLUGIN_NO_CACHE === "1";
     const { discoverManifests: discoverManifests2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
-    const discovered = await discoverManifests2(cwd, noCache);
+    const discovered = await discoverManifests2(cwd, noCache, {
+      platformRoot: input.platformRoot
+    });
     if (discovered.length > 0) {
       log3.info(`Discovered ${discovered.length} packages with CLI manifests`);
       const { valid: readyToRegister, skipped: preflightSkipped } = preflightManifests(discovered, log3);