agentloom 0.1.9 → 0.1.10

package/dist/commands/update.js

@@ -59,21 +59,28 @@ async function runEntityAwareUpdate(options) {
         console.log("No lock entries matched the requested source filter.");
         return;
     }
+    console.log(`Checking ${entries.length} lock entr${entries.length === 1 ? "y" : "ies"} for updates...`);
     let updated = 0;
     let skipped = 0;
-    for (const entry of entries) {
+    for (const [index, entry] of entries.entries()) {
+        const progressPrefix = formatUpdateProgressPrefix(index, entries.length);
+        const entryLabel = formatLockEntryLabel(entry);
         if (!entryIncludesTarget(entry, options.target)) {
+            console.log(`${progressPrefix} Skipping ${entryLabel} (does not track ${options.target}).`);
             skipped += 1;
             continue;
         }
+        console.log(`${progressPrefix} Checking ${entryLabel}...`);
         const probe = prepareSource({
             source: entry.source,
             ref: entry.requestedRef,
             subdir: entry.subdir,
         });
-        const hasNewCommit = probe.resolvedCommit !== entry.resolvedCommit;
+        const latestCommit = probe.resolvedCommit;
+        const hasNewCommit = latestCommit !== entry.resolvedCommit;
         probe.cleanup();
         if (!hasNewCommit) {
+            console.log(`${progressPrefix} Up to date at ${formatShortCommit(entry.resolvedCommit)}.`);
             skipped += 1;
             continue;
         }
@@ -83,9 +90,11 @@ async function runEntityAwareUpdate(options) {
             !updatePlan.importMcp &&
             !updatePlan.importRules &&
             !updatePlan.importSkills) {
+            console.log(`${progressPrefix} Skipping ${entryLabel} (no tracked entities selected for update).`);
             skipped += 1;
             continue;
         }
+        console.log(`${progressPrefix} Updating ${entryLabel} (${formatShortCommit(entry.resolvedCommit)} -> ${formatShortCommit(latestCommit)})...`);
         try {
             const importOptions = {
                 source: entry.source,
@@ -142,6 +151,7 @@ async function runEntityAwareUpdate(options) {
                 rawSource: entry.source,
                 summary,
             });
+            console.log(`${progressPrefix} Updated ${entryLabel} to ${formatShortCommit(summary.resolvedCommit)}.`);
             updated += 1;
         }
         catch (err) {
@@ -163,6 +173,25 @@ async function runEntityAwareUpdate(options) {
         });
     }
 }
+function formatUpdateProgressPrefix(index, total) {
+    return `[${index + 1}/${total}]`;
+}
+function formatLockEntryLabel(entry) {
+    const base = entry.source;
+    const refSuffix = typeof entry.requestedRef === "string" && entry.requestedRef.length > 0
+        ? `@${entry.requestedRef}`
+        : "";
+    const subdirSuffix = typeof entry.subdir === "string" && entry.subdir.length > 0
+        ? ` (${entry.subdir})`
+        : "";
+    return `${base}${refSuffix}${subdirSuffix}`;
+}
+function formatShortCommit(commit) {
+    const normalized = commit.trim();
+    if (normalized.length <= 12)
+        return normalized;
+    return normalized.slice(0, 12);
+}
 function buildEntryUpdatePlan(entry, target) {
     const includeAgents = shouldUpdateEntity(entry, "agent", target);
     const includeCommands = shouldUpdateEntity(entry, "command", target);

package/dist/core/migration.js

@@ -914,6 +914,15 @@ async function migrateMcp(options, summary) {
         writeCanonicalMcp(options.paths, merged);
     }
 }
+const MANAGED_MCP_CANONICAL_KEYS_BY_PROVIDER = {
+    cursor: ["url", "command", "args", "env"],
+    claude: ["type", "url", "command", "args", "env"],
+    codex: ["url", "command", "args", "env"],
+    opencode: ["url", "command", "args", "env"],
+    gemini: ["url", "command", "args", "env"],
+    copilot: ["type", "url", "command", "args", "env", "tools"],
+    pi: ["url", "command", "args", "env"],
+};
 function collectProviderMcpServers(paths, providers) {
     let detected = 0;
     const servers = new Map();
@@ -930,13 +939,13 @@ function collectProviderMcpServers(paths, providers) {
 }
 function readProviderMcp(paths, provider) {
     if (provider === "cursor") {
-        return readJsonMcpServers(getCursorMcpPath(paths));
+        return readJsonMcpServers(getCursorMcpPath(paths), provider);
     }
     if (provider === "claude") {
-        return readJsonMcpServers(getClaudeMcpPath(paths));
+        return readJsonMcpServers(getClaudeMcpPath(paths), provider);
     }
     if (provider === "copilot") {
-        return readJsonMcpServers(getCopilotMcpPath(paths));
+        return readJsonMcpServers(getCopilotMcpPath(paths), provider);
     }
     if (provider === "opencode") {
         return readOpenCodeMcp(getOpenCodeConfigPath(paths));
@@ -948,16 +957,16 @@ function readProviderMcp(paths, provider) {
         return readCodexMcp(getCodexConfigPath(paths));
     }
     if (provider === "pi") {
-        return readJsonMcpServers(getPiMcpPath(paths));
+        return readJsonMcpServers(getPiMcpPath(paths), provider);
     }
     return {};
 }
-function readJsonMcpServers(filePath) {
+function readJsonMcpServers(filePath, provider) {
     const parsed = readJsonIfExists(filePath);
     if (!parsed || !isObject(parsed.mcpServers)) {
         return {};
     }
-    return normalizeMcpServerRecord(parsed.mcpServers);
+    return normalizeManagedMcpServerRecord(parsed.mcpServers, MANAGED_MCP_CANONICAL_KEYS_BY_PROVIDER[provider]);
 }
 function readOpenCodeMcp(filePath) {
     const parsed = readJsonIfExists(filePath);
@@ -1013,17 +1022,31 @@ function readCodexMcp(filePath) {
     const parsed = raw.trim() ? TOML.parse(raw) : {};
     if (!isObject(parsed.mcp_servers))
         return {};
-    return normalizeMcpServerRecord(parsed.mcp_servers);
+    return normalizeManagedMcpServerRecord(parsed.mcp_servers, MANAGED_MCP_CANONICAL_KEYS_BY_PROVIDER.codex);
 }
-function normalizeMcpServerRecord(raw) {
+function normalizeManagedMcpServerRecord(raw, allowedKeys) {
     const servers = {};
     for (const [name, config] of Object.entries(raw)) {
-        if (!isObject(config))
+        const normalized = pickManagedMcpFields(config, allowedKeys);
+        if (!normalized)
             continue;
-        servers[name] = cloneRecord(config);
+        servers[name] = normalized;
     }
     return servers;
 }
+function pickManagedMcpFields(config, allowedKeys) {
+    if (!isObject(config)) {
+        return null;
+    }
+    const next = {};
+    for (const key of allowedKeys) {
+        const value = config[key];
+        if (value !== undefined) {
+            next[key] = cloneRecord(value);
+        }
+    }
+    return Object.keys(next).length > 0 ? next : null;
+}
 function normalizeCanonicalServer(server) {
     if (!server) {
         return {

package/dist/sync/index.js

@@ -361,8 +361,10 @@ function syncProviderMcp(options) {
         const resolved = resolveMcpForProvider(options.mcp, provider);
         if (provider === "cursor") {
             const outputPath = getCursorMcpPath(options.paths);
+            const existing = readJsonIfExists(outputPath) ?? {};
             const payload = {
-                mcpServers: mapMcpServers(resolved, ["url", "command", "args", "env"]),
+                ...existing,
+                mcpServers: mergeManagedMcpServerEntries(existing.mcpServers, mapMcpServers(resolved, ["url", "command", "args", "env"]), ["url", "command", "args", "env"]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -381,19 +383,24 @@ function syncProviderMcp(options) {
                 continue;
             }
             const mcpPath = getClaudeMcpPath(options.paths);
-            const claudeServers = mapMcpServers(resolved, [
+            const existingMcp = readJsonIfExists(mcpPath) ?? {};
+            const managedClaudeServers = mapMcpServers(resolved, [
                 "type",
                 "url",
                 "command",
                 "args",
                 "env",
             ]);
-            for (const [serverName, config] of Object.entries(claudeServers)) {
+            for (const [serverName, config] of Object.entries(managedClaudeServers)) {
                 if (!("type" in config) && typeof config.url === "string") {
                     config.type = "http";
                 }
             }
-            maybeWriteJson(mcpPath, { mcpServers: claudeServers }, options.dryRun);
+            const claudeServers = mergeManagedMcpServerEntries(existingMcp.mcpServers, managedClaudeServers, ["type", "url", "command", "args", "env"]);
+            maybeWriteJson(mcpPath, {
+                ...existingMcp,
+                mcpServers: claudeServers,
+            }, options.dryRun);
             options.generated.add(mcpPath);
             settings.enabledMcpjsonServers = Object.keys(claudeServers).sort();
             maybeWriteJson(settingsPath, settings, options.dryRun);
@@ -403,28 +410,34 @@ function syncProviderMcp(options) {
         if (provider === "opencode") {
             const outputPath = getOpenCodeConfigPath(options.paths);
             const existing = readJsonIfExists(outputPath) ?? {};
-            const mcp = {};
+            const managedMcp = {};
             for (const [serverName, config] of Object.entries(resolved)) {
                 if (typeof config.url === "string") {
-                    mcp[serverName] = {
+                    managedMcp[serverName] = {
                         type: "remote",
                         url: config.url,
                     };
                 }
                 else {
-                    mcp[serverName] = {
+                    managedMcp[serverName] = {
                         type: "local",
                         command: config.command,
                         args: Array.isArray(config.args) ? config.args : undefined,
                     };
                 }
                 if (isObject(config.env)) {
-                    mcp[serverName].environment = config.env;
+                    managedMcp[serverName].environment = config.env;
                 }
             }
             const payload = {
                 ...existing,
-                mcp,
+                mcp: mergeManagedMcpServerEntries(existing.mcp, managedMcp, [
+                    "type",
+                    "url",
+                    "command",
+                    "args",
+                    "environment",
+                ]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -453,7 +466,7 @@ function syncProviderMcp(options) {
             const payload = {
                 ...existing,
                 experimental,
-                mcpServers,
+                mcpServers: mergeManagedMcpServerEntries(existing.mcpServers, mcpServers, ["httpUrl", "command", "args", "env"]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -461,6 +474,8 @@ function syncProviderMcp(options) {
         }
         if (provider === "copilot") {
             const profileMcpPath = getCopilotMcpPath(options.paths);
+            const managedKeys = ["type", "url", "command", "args", "env", "tools"];
+            const existingProfileMcp = readJsonIfExists(profileMcpPath) ?? {};
             const copilotServers = mapMcpServers(resolved, [
                 "type",
                 "url",
@@ -477,20 +492,25 @@ function syncProviderMcp(options) {
                     config.type = config.url ? "http" : "local";
                 }
             }
-            maybeWriteJson(profileMcpPath, { mcpServers: copilotServers }, options.dryRun);
+            maybeWriteJson(profileMcpPath, {
+                ...existingProfileMcp,
+                mcpServers: mergeManagedMcpServerEntries(existingProfileMcp.mcpServers, copilotServers, managedKeys),
+            }, options.dryRun);
             options.generated.add(profileMcpPath);
             if (options.paths.scope === "global") {
                 const settingsPath = getVsCodeSettingsPath(options.paths.homeDir);
                 const settings = readJsonIfExists(settingsPath) ?? {};
-                settings["mcp.servers"] = copilotServers;
+                settings["mcp.servers"] = mergeManagedMcpServerEntries(settings["mcp.servers"], copilotServers, managedKeys);
                 maybeWriteJson(settingsPath, settings, options.dryRun);
                 options.generated.add(settingsPath);
             }
         }
         if (provider === "pi") {
             const outputPath = getPiMcpPath(options.paths);
+            const existing = readJsonIfExists(outputPath) ?? {};
             const payload = {
-                mcpServers: mapMcpServers(resolved, ["url", "command", "args", "env"]),
+                ...existing,
+                mcpServers: mergeManagedMcpServerEntries(existing.mcpServers, mapMcpServers(resolved, ["url", "command", "args", "env"]), ["url", "command", "args", "env"]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -813,22 +833,19 @@ function syncCodex(options) {
     let nextServers = [...trackedServers];
     if (options.includeMcp) {
         const previousServers = new Set(trackedServers);
+        const managedCodexMcpServers = mapMcpServers(options.resolvedMcp, [
+            "url",
+            "command",
+            "args",
+            "env",
+        ]);
         for (const oldServer of previousServers) {
             if (!Object.prototype.hasOwnProperty.call(options.resolvedMcp, oldServer)) {
                 delete mcpServers[oldServer];
             }
         }
-        for (const [serverName, config] of Object.entries(options.resolvedMcp)) {
-            const mapped = {};
-            if (typeof config.url === "string")
-                mapped.url = config.url;
-            if (typeof config.command === "string")
-                mapped.command = config.command;
-            if (Array.isArray(config.args))
-                mapped.args = config.args;
-            if (isObject(config.env))
-                mapped.env = config.env;
-            mcpServers[serverName] = mapped;
+        for (const [serverName, config] of Object.entries(managedCodexMcpServers)) {
+            mcpServers[serverName] = mergeManagedMcpServerEntry(mcpServers[serverName], config, ["url", "command", "args", "env"]);
         }
         parsed.mcp_servers = mcpServers;
         nextServers = Object.keys(options.resolvedMcp).sort();
@@ -895,6 +912,28 @@ function mapMcpServers(servers, allowedKeys) {
     }
     return mapped;
 }
+function mergeManagedMcpServerEntries(existingServers, nextServers, managedKeys) {
+    const merged = {};
+    for (const [serverName, config] of Object.entries(nextServers)) {
+        merged[serverName] = mergeManagedMcpServerEntry(isObject(existingServers) ? existingServers[serverName] : undefined, config, managedKeys);
+    }
+    return merged;
+}
+function mergeManagedMcpServerEntry(existingConfig, nextConfig, managedKeys) {
+    const merged = isObject(existingConfig) ? cloneSyncValue(existingConfig) : {};
+    for (const key of managedKeys) {
+        delete merged[key];
+    }
+    for (const [key, value] of Object.entries(nextConfig)) {
+        if (value !== undefined) {
+            merged[key] = cloneSyncValue(value);
+        }
+    }
+    return merged;
+}
+function cloneSyncValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
 function maybeWriteJson(filePath, payload, dryRun) {
     if (dryRun)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentloom",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Unified agent and MCP sync CLI for multi-provider AI tooling",
   "type": "module",
   "bin": {