@cleocode/caamp 1.3.1 → 1.5.0

package/dist/{chunk-DT22SZ7X.js → chunk-G7UPJOYG.js}

@@ -1613,120 +1613,9 @@ async function configureProviderGlobalAndProject(provider, options) {
   };
 }
 
-// src/core/lock-utils.ts
-import { open, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4, rm as rm3, rename, stat } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
-var STALE_LOCK_MS = 5e3;
-function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
-}
-async function removeStaleLock() {
-  try {
-    const info = await stat(LOCK_GUARD_PATH);
-    if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
-      await rm3(LOCK_GUARD_PATH, { force: true });
-      return true;
-    }
-  } catch {
-  }
-  return false;
-}
-async function acquireLockGuard(retries = 40, delayMs = 25) {
-  await mkdir4(AGENTS_HOME, { recursive: true });
-  for (let attempt = 0; attempt < retries; attempt += 1) {
-    try {
-      const handle = await open(LOCK_GUARD_PATH, "wx");
-      await handle.close();
-      return;
-    } catch (error) {
-      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
-        throw error;
-      }
-      if (attempt === 0) {
-        const removed = await removeStaleLock();
-        if (removed) continue;
-      }
-      await sleep(delayMs);
-    }
-  }
-  throw new Error("Timed out waiting for lock file guard");
-}
-async function releaseLockGuard() {
-  await rm3(LOCK_GUARD_PATH, { force: true });
-}
-async function writeLockFileUnsafe(lock) {
-  const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile6(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
-  await rename(tmpPath, LOCK_FILE_PATH);
-}
-async function readLockFile() {
-  try {
-    if (!existsSync10(LOCK_FILE_PATH)) {
-      return { version: 1, skills: {}, mcpServers: {} };
-    }
-    const content = await readFile6(LOCK_FILE_PATH, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return { version: 1, skills: {}, mcpServers: {} };
-  }
-}
-async function updateLockFile(updater) {
-  await acquireLockGuard();
-  try {
-    const lock = await readLockFile();
-    await updater(lock);
-    await writeLockFileUnsafe(lock);
-    return lock;
-  } finally {
-    await releaseLockGuard();
-  }
-}
-
-// src/core/mcp/lock.ts
-async function recordMcpInstall(serverName, source, sourceType, agents, isGlobal) {
-  await updateLockFile((lock) => {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = lock.mcpServers[serverName];
-    lock.mcpServers[serverName] = {
-      name: serverName,
-      scopedName: serverName,
-      source,
-      sourceType,
-      installedAt: existing?.installedAt ?? now,
-      updatedAt: now,
-      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
-      canonicalPath: "",
-      isGlobal
-    };
-  });
-}
-async function removeMcpFromLock(serverName) {
-  let removed = false;
-  await updateLockFile((lock) => {
-    if (!(serverName in lock.mcpServers)) return;
-    delete lock.mcpServers[serverName];
-    removed = true;
-  });
-  return removed;
-}
-async function getTrackedMcpServers() {
-  const lock = await readLockFile();
-  return lock.mcpServers;
-}
-async function saveLastSelectedAgents(agents) {
-  await updateLockFile((lock) => {
-    lock.lastSelectedAgents = agents;
-  });
-}
-async function getLastSelectedAgents() {
-  const lock = await readLockFile();
-  return lock.lastSelectedAgents;
-}
-
 // src/core/mcp/cleo.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir2 } from "os";
 import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
 var CLEO_SERVER_NAMES = {
@@ -1820,7 +1709,7 @@ function checkCommandReachability(command) {
   if (hasPathSeparator || command.startsWith("~")) {
     const expanded = expandHome(command);
     const candidate = isAbsolute2(expanded) ? expanded : resolve3(process.cwd(), expanded);
-    if (existsSync11(candidate)) {
+    if (existsSync10(candidate)) {
       return { reachable: true, method: "path", detail: candidate };
     }
     return { reachable: false, method: "path", detail: candidate };
@@ -1849,10 +1738,269 @@ function parseEnvAssignments(values) {
   }
   return env;
 }
+function extractVersionTag(packageSpec) {
+  if (!packageSpec) return void 0;
+  const atIndex = packageSpec.lastIndexOf("@");
+  if (atIndex <= 0) return void 0;
+  return packageSpec.slice(atIndex + 1);
+}
 function isCleoSource(source) {
   return source.trim().toLowerCase() === "cleo";
 }
 
+// src/core/lock-utils.ts
+import { open, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4, rm as rm3, rename, stat } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
+var STALE_LOCK_MS = 5e3;
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function removeStaleLock() {
+  try {
+    const info = await stat(LOCK_GUARD_PATH);
+    if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
+      await rm3(LOCK_GUARD_PATH, { force: true });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function acquireLockGuard(retries = 40, delayMs = 25) {
+  await mkdir4(AGENTS_HOME, { recursive: true });
+  for (let attempt = 0; attempt < retries; attempt += 1) {
+    try {
+      const handle = await open(LOCK_GUARD_PATH, "wx");
+      await handle.close();
+      return;
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      if (attempt === 0) {
+        const removed = await removeStaleLock();
+        if (removed) continue;
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw new Error("Timed out waiting for lock file guard");
+}
+async function releaseLockGuard() {
+  await rm3(LOCK_GUARD_PATH, { force: true });
+}
+async function writeLockFileUnsafe(lock) {
+  const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile6(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, LOCK_FILE_PATH);
+}
+async function readLockFile() {
+  try {
+    if (!existsSync11(LOCK_FILE_PATH)) {
+      return { version: 1, skills: {}, mcpServers: {} };
+    }
+    const content = await readFile6(LOCK_FILE_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, skills: {}, mcpServers: {} };
+  }
+}
+async function updateLockFile(updater) {
+  await acquireLockGuard();
+  try {
+    const lock = await readLockFile();
+    await updater(lock);
+    await writeLockFileUnsafe(lock);
+    return lock;
+  } finally {
+    await releaseLockGuard();
+  }
+}
+
+// src/core/mcp/lock.ts
+async function recordMcpInstall(serverName, source, sourceType, agents, isGlobal, version) {
+  await updateLockFile((lock) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.mcpServers[serverName];
+    lock.mcpServers[serverName] = {
+      name: serverName,
+      scopedName: serverName,
+      source,
+      sourceType,
+      version: version ?? existing?.version,
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now,
+      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
+      canonicalPath: "",
+      isGlobal
+    };
+  });
+}
+async function removeMcpFromLock(serverName) {
+  let removed = false;
+  await updateLockFile((lock) => {
+    if (!(serverName in lock.mcpServers)) return;
+    delete lock.mcpServers[serverName];
+    removed = true;
+  });
+  return removed;
+}
+async function getTrackedMcpServers() {
+  const lock = await readLockFile();
+  return lock.mcpServers;
+}
+async function saveLastSelectedAgents(agents) {
+  await updateLockFile((lock) => {
+    lock.lastSelectedAgents = agents;
+  });
+}
+async function getLastSelectedAgents() {
+  const lock = await readLockFile();
+  return lock.lastSelectedAgents;
+}
+
+// src/core/mcp/reconcile.ts
+function inferCleoLockData(config, channel) {
+  const command = typeof config.command === "string" ? config.command : "";
+  const args = Array.isArray(config.args) ? config.args.filter((a) => typeof a === "string") : [];
+  const packageArg = args.find(
+    (a) => a.includes(CLEO_MCP_NPM_PACKAGE)
+  );
+  if (packageArg) {
+    const version = extractVersionTag(packageArg);
+    return {
+      source: packageArg,
+      sourceType: "package",
+      version
+    };
+  }
+  if (channel === "dev" || command.includes("/") || command.includes("\\")) {
+    return {
+      source: command,
+      sourceType: "command",
+      version: void 0
+    };
+  }
+  const full = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+  return {
+    source: full || "unknown",
+    sourceType: "command",
+    version: void 0
+  };
+}
+async function reconcileCleoLock(options = {}) {
+  const result = {
+    backfilled: [],
+    pruned: [],
+    alreadyTracked: 0,
+    errors: []
+  };
+  const lockEntries = await getTrackedMcpServers();
+  const providers = getInstalledProviders();
+  const targetProviders = options.providerIds?.length ? providers.filter((p) => options.providerIds.includes(p.id)) : providers;
+  const scopes = [];
+  if (options.global && !options.project) {
+    scopes.push("global");
+  } else if (options.project && !options.global) {
+    scopes.push("project");
+  } else {
+    scopes.push("project", "global");
+  }
+  const groups = /* @__PURE__ */ new Map();
+  const liveCleoServerNames = /* @__PURE__ */ new Set();
+  for (const scope of scopes) {
+    for (const provider of targetProviders) {
+      let entries;
+      try {
+        entries = await listMcpServers(provider, scope);
+      } catch {
+        result.errors.push({
+          message: `Failed to read config for ${provider.id} (${scope})`
+        });
+        continue;
+      }
+      for (const entry of entries) {
+        const channel = resolveChannelFromServerName(entry.name);
+        if (!channel) continue;
+        liveCleoServerNames.add(entry.name);
+        const isGlobal = scope === "global";
+        const groupKey = `${entry.name}:${isGlobal ? "global" : "project"}`;
+        if (lockEntries[entry.name] !== void 0) {
+          const existing2 = groups.get(groupKey);
+          if (!existing2) {
+            result.alreadyTracked++;
+          }
+          continue;
+        }
+        const existing = groups.get(groupKey);
+        if (existing) {
+          if (!existing.agents.includes(provider.id)) {
+            existing.agents.push(provider.id);
+          }
+        } else {
+          groups.set(groupKey, {
+            serverName: entry.name,
+            channel,
+            scope,
+            agents: [provider.id],
+            config: entry.config
+          });
+        }
+      }
+    }
+  }
+  for (const group of groups.values()) {
+    const inferred = inferCleoLockData(group.config, group.channel);
+    if (!options.dryRun) {
+      try {
+        await recordMcpInstall(
+          group.serverName,
+          inferred.source,
+          inferred.sourceType,
+          group.agents,
+          group.scope === "global",
+          inferred.version
+        );
+      } catch (err) {
+        result.errors.push({
+          message: `Failed to backfill ${group.serverName}: ${err instanceof Error ? err.message : String(err)}`
+        });
+        continue;
+      }
+    }
+    result.backfilled.push({
+      serverName: group.serverName,
+      channel: group.channel,
+      scope: group.scope,
+      agents: group.agents,
+      source: inferred.source,
+      sourceType: inferred.sourceType,
+      version: inferred.version
+    });
+  }
+  if (options.prune) {
+    for (const [serverName] of Object.entries(lockEntries)) {
+      const channel = resolveChannelFromServerName(serverName);
+      if (!channel) continue;
+      if (!liveCleoServerNames.has(serverName)) {
+        if (!options.dryRun) {
+          try {
+            await removeMcpFromLock(serverName);
+          } catch (err) {
+            result.errors.push({
+              message: `Failed to prune ${serverName}: ${err instanceof Error ? err.message : String(err)}`
+            });
+            continue;
+          }
+        }
+        result.pruned.push(serverName);
+      }
+    }
+  }
+  return result;
+}
+
 // src/core/sources/parser.ts
 var GITHUB_SHORTHAND = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
 var GITHUB_URL = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?/;
@@ -3817,19 +3965,22 @@ export {
   applyMcpInstallWithPolicy,
   updateInstructionsSingleOperation,
   configureProviderGlobalAndProject,
-  readLockFile,
-  recordMcpInstall,
-  removeMcpFromLock,
-  getTrackedMcpServers,
-  saveLastSelectedAgents,
-  getLastSelectedAgents,
   normalizeCleoChannel,
   resolveCleoServerName,
   resolveChannelFromServerName,
   buildCleoProfile,
   checkCommandReachability,
   parseEnvAssignments,
+  extractVersionTag,
   isCleoSource,
+  readLockFile,
+  recordMcpInstall,
+  removeMcpFromLock,
+  getTrackedMcpServers,
+  saveLastSelectedAgents,
+  getLastSelectedAgents,
+  inferCleoLockData,
+  reconcileCleoLock,
   parseSource,
   isMarketplaceScoped,
   formatNetworkError,
@@ -3869,4 +4020,4 @@ export {
   toSarif,
   validateSkill
 };
-//# sourceMappingURL=chunk-DT22SZ7X.js.map
+//# sourceMappingURL=chunk-G7UPJOYG.js.map