@kb-labs/cli-commands 2.5.0 → 2.9.0

package/dist/{discover-8_R7njIS.d.ts → discover-BY7VE2Hf.d.ts}

@@ -208,6 +208,12 @@ declare const __test: {
     ensureManifestLoader: typeof ensureManifestLoader;
     createManifestV3Loader: typeof createManifestV3Loader;
 };
+/**
+ * Reset the in-process discovery cache.
+ * Call this after clearing the disk cache so the next discoverManifests() call
+ * in the same process performs a fresh scan rather than serving stale results.
+ */
+declare function resetInProcCache(): void;
 /**
  * Main discovery function — discovers command manifests from workspace,
  * current package, and `node_modules`.
@@ -231,4 +237,4 @@ declare function discoverManifests(cwd: string, noCache?: boolean, options?: {
  */
 declare function discoverManifestsByNamespace(cwd: string, namespace: string, noCache?: boolean): Promise<DiscoveryResult[]>;
 
-export { type AvailabilityCheck as A, type CommandGroup as C, type DiscoveryResult as D, type FlagDefinition as F, type GlobalFlags as G, type ProductGroup as P, type RegisteredCommand as R, __test as _, type Command as a, findCommandWithType as b, type CommandType as c, type CommandLookupResult as d, discoverManifestsByNamespace as e, findCommand as f, discoverManifests as g, type CommandManifest as h, type CommandModule as i, type PackageCacheEntry as j, type CacheFile as k, registry as r };
+export { type AvailabilityCheck as A, type CommandGroup as C, type DiscoveryResult as D, type FlagDefinition as F, type GlobalFlags as G, type ProductGroup as P, type RegisteredCommand as R, __test as _, type Command as a, type CacheFile as b, type CommandLookupResult as c, type CommandManifest as d, type CommandModule as e, type CommandType as f, type PackageCacheEntry as g, discoverManifests as h, discoverManifestsByNamespace as i, findCommand as j, findCommandWithType as k, resetInProcCache as l, registry as r };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as CommandGroup, P as ProductGroup, a as Command, R as RegisteredCommand } from './discover-8_R7njIS.js';
-export { A as AvailabilityCheck, k as CacheFile, d as CommandLookupResult, h as CommandManifest, i as CommandModule, c as CommandType, D as DiscoveryResult, F as FlagDefinition, G as GlobalFlags, j as PackageCacheEntry, g as discoverManifests, e as discoverManifestsByNamespace, f as findCommand, b as findCommandWithType, r as registry } from './discover-8_R7njIS.js';
+import { C as CommandGroup, P as ProductGroup, a as Command, R as RegisteredCommand } from './discover-BY7VE2Hf.js';
+export { A as AvailabilityCheck, b as CacheFile, c as CommandLookupResult, d as CommandManifest, e as CommandModule, f as CommandType, D as DiscoveryResult, F as FlagDefinition, G as GlobalFlags, g as PackageCacheEntry, h as discoverManifests, i as discoverManifestsByNamespace, j as findCommand, k as findCommandWithType, r as registry } from './discover-BY7VE2Hf.js';
 import { ILogger } from '@kb-labs/core-platform';
 export { TimingTracker } from '@kb-labs/shared-cli-ui';
 import * as _kb_labs_shared_command_kit from '@kb-labs/shared-command-kit';

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);
@@ -982,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;
@@ -1766,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");
@@ -1794,6 +1808,7 @@ async function clearCache(cwd, options) {
     }
   } catch {
   }
+  resetInProcCache();
   const modulesCleared = [];
   if (options?.deep) {
     try {
@@ -3142,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", [
@@ -3174,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);
@@ -3657,6 +3815,7 @@ 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;