alegra-data-agent 0.2.5 → 0.2.6

package/dist/commands/status.js

@@ -35,13 +35,20 @@ function reportMcps(manifest, lock) {
         const ok = [];
         const missing = [];
         const modified = [];
+        const broken = [];
+        const stale = [];
+        const prevHashes = lock.mcps?.[name]?.renderedHash;
         for (const t of targets) {
             const label = TARGETS[t].label;
-            const state = inspectMcpInTarget(entry, TARGETS[t]);
+            const state = inspectMcpInTarget(entry, TARGETS[t], prevHashes?.[t]);
             if (state === "ok")
                 ok.push(label);
             else if (state === "missing")
                 missing.push(label);
+            else if (state === "stale")
+                stale.push(label);
+            else if (state === "broken")
+                broken.push(label);
             else
                 modified.push(label);
         }
@@ -50,13 +57,59 @@ function reportMcps(manifest, lock) {
             notes.push(gray(`ok en ${ok.join(", ")}`));
         if (modified.length > 0)
             notes.push(dim(`editado a mano en ${modified.join(", ")}`));
+        if (broken.length > 0)
+            notes.push(yellow(`sin \`type\` — el cliente la descarta en ${broken.join(", ")}`));
+        if (stale.length > 0)
+            notes.push(dim(`formato viejo en ${stale.join(", ")} — se actualiza`));
         if (missing.length > 0)
             notes.push(yellow(`falta en ${missing.join(", ")}`));
-        const icon = missing.length > 0 ? yellow("✗") : modified.length > 0 ? dim("~") : green("✓");
+        const icon = missing.length > 0 || broken.length > 0
+            ? yellow("✗")
+            : stale.length > 0 || modified.length > 0
+                ? dim("~")
+                : green("✓");
         log(`    ${icon} ${name} ${gray("·")} ${notes.join(gray(" · "))}`);
     }
     log("");
 }
+function reportAccountConnectorOverlap(manifest) {
+    const claudeCfg = TARGETS["claude-code"].mcpConfigPath;
+    if (!existsSync(claudeCfg))
+        return;
+    let connected = [];
+    try {
+        const cfg = JSON.parse(readFileSync(claudeCfg, "utf-8"));
+        if (!Array.isArray(cfg.claudeAiMcpEverConnected))
+            return;
+        connected = cfg.claudeAiMcpEverConnected.filter((x) => typeof x === "string");
+    }
+    catch {
+        return;
+    }
+    if (connected.length === 0)
+        return;
+    const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const overlap = [];
+    for (const name of Object.keys(manifest.mcps ?? {})) {
+        const ours = norm(name);
+        const dup = connected.find((c) => {
+            const label = norm(c.replace(/^claude\.ai\s*/i, ""));
+            return label.includes(ours) || ours.includes(label);
+        });
+        if (dup)
+            overlap.push(`${name} ↔ "${dup}"`);
+    }
+    if (overlap.length === 0)
+        return;
+    logWarn(`Tenés ${overlap.length} connector(s) de tu cuenta que duplican un MCP del agente:`);
+    for (const o of overlap)
+        log(gray(`                  ${o}`));
+    log(gray("                  Son servidores distintos, cada uno con su propia autenticación."));
+    log(gray("                  Si el oficial no está autenticado, el agente puede responder por el"));
+    log(gray("                  tuyo — y un connector personalizado apunta a donde alguien escribió."));
+    log(gray(`                  Autenticá los del agente: /mcp → click en el servicio → Authenticate.`));
+    log("");
+}
 export function findRogueMetabase(manifest, specs = Object.values(TARGETS)) {
     const official = manifest.mcps?.metabase?.url;
     if (!official)
@@ -163,6 +216,7 @@ export async function runStatus() {
     log("");
     reportMcps(manifest, lock);
     reportRogueMetabase(manifest);
+    reportAccountConnectorOverlap(manifest);
     const total = drift.toInstall.length +
         drift.toUpdate.length +
         drift.mcps.toInstall.length +

package/dist/commands/update.js

@@ -96,7 +96,7 @@ async function runUpdateOnce(opts) {
         log(`    ${cyan("+")} ${name} ${gray("(MCP nuevo)")}`);
     for (const name of drift.mcps.toUpdate) {
         const motivo = drift.mcps.missing.includes(name)
-            ? "(MCP ausente en el cliente — se repone)"
+            ? "(MCP ausente o descartado por el cliente — se repone)"
             : "(MCP actualizado)";
         log(`    ${yellow("↻")} ${name} ${gray(motivo)}`);
     }

package/dist/installer.js

@@ -378,7 +378,26 @@ function unregisterMcpInTomlBlock(name, spec) {
     atomicWriteFile(spec.mcpConfigPath, next);
     return true;
 }
-export function inspectMcpInTarget(mcp, spec) {
+export function renderedEntryHash(mcp, spec) {
+    const rendered = spec.mcpMechanism === "toml-block"
+        ? renderMcpToml(mcp).trim()
+        : stableStringify(renderMcpForTarget(mcp, spec));
+    return createHash("sha256").update(rendered).digest("hex");
+}
+function hashOf(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function isDiscardedByClient(current, spec) {
+    if (!spec.mcpHttpTypeValue)
+        return false;
+    if (!current || typeof current !== "object")
+        return false;
+    const entry = current;
+    if (typeof entry[spec.mcpUrlKey] !== "string")
+        return false;
+    return typeof entry.type !== "string";
+}
+export function inspectMcpInTarget(mcp, spec, prevHash) {
     try {
         if (!existsSync(spec.mcpConfigPath))
             return "missing";
@@ -386,7 +405,10 @@ export function inspectMcpInTarget(mcp, spec) {
             const block = extractTomlBlock(readFileSync(spec.mcpConfigPath, "utf-8"), mcp.name);
             if (block === null)
                 return "missing";
-            return block.trim() === renderMcpToml(mcp).trim() ? "ok" : "modified";
+            const current = block.trim();
+            if (current === renderMcpToml(mcp).trim())
+                return "ok";
+            return prevHash && hashOf(current) === prevHash ? "stale" : "modified";
         }
         const cfg = JSON.parse(readFileSync(spec.mcpConfigPath, "utf-8"));
         const section = cfg[spec.mcpRootKey];
@@ -395,16 +417,24 @@ export function inspectMcpInTarget(mcp, spec) {
         const current = section[mcp.name];
         if (current === undefined)
             return "missing";
-        return stableStringify(current) === stableStringify(renderMcpForTarget(mcp, spec))
-            ? "ok"
-            : "modified";
+        const currentStr = stableStringify(current);
+        if (currentStr === stableStringify(renderMcpForTarget(mcp, spec)))
+            return "ok";
+        if (prevHash && hashOf(currentStr) === prevHash)
+            return "stale";
+        if (isDiscardedByClient(current, spec))
+            return "broken";
+        return "modified";
     }
     catch {
         return "missing";
     }
 }
-function mcpMissingInTargets(mcp, targets) {
-    return targets.filter((id) => inspectMcpInTarget(mcp, TARGETS[id]) === "missing");
+function mcpNeedsRepairInTargets(mcp, targets, renderedHash) {
+    return targets.filter((id) => {
+        const state = inspectMcpInTarget(mcp, TARGETS[id], renderedHash?.[id]);
+        return state === "missing" || state === "stale" || state === "broken";
+    });
 }
 const cleanedTargets = new Set();
 function resolveTargets(opts) {
@@ -609,11 +639,14 @@ export function installMcp(mcp, opts = {}) {
         prev.targets.length === targetIds.length &&
         prev.targets.every((t) => targetIds.includes(t));
     const configChanged = !prev || prev.configHash !== mcpConfigHash(mcp);
-    const writeTargets = opts.force || configChanged
-        ? wantedTargets
-        : wantedTargets.filter((t) => inspectMcpInTarget(mcp, t) === "missing");
+    const prevHashes = readLockFile().mcps?.[mcp.name]?.renderedHash;
+    const needsWrite = (t) => {
+        const state = inspectMcpInTarget(mcp, t, prevHashes?.[t.id]);
+        return state === "missing" || state === "stale" || state === "broken";
+    };
+    const writeTargets = opts.force || configChanged ? wantedTargets : wantedTargets.filter(needsWrite);
     const alreadyThere = wantedTargets
-        .filter((t) => !writeTargets.includes(t) && inspectMcpInTarget(mcp, t) !== "missing")
+        .filter((t) => !writeTargets.includes(t) && !needsWrite(t))
         .map((t) => t.id);
     if (writeTargets.length === 0 && targetsMatch) {
         return { name: mcp.name, kind: "mcp", status: "unchanged", targets: targetIds };
@@ -647,12 +680,18 @@ export function installMcp(mcp, opts = {}) {
             error: failures.join("; "),
         };
     }
+    const renderedHash = { ...(prev?.renderedHash ?? {}) };
+    for (const t of writeTargets) {
+        if (okTargets.includes(t.id))
+            renderedHash[t.id] = renderedEntryHash(mcp, t);
+    }
     lock.mcps[mcp.name] = {
         name: mcp.name,
         installedFrom: getPackageVersion(),
         installedAt: new Date().toISOString(),
         configHash: mcpConfigHash(mcp),
         targets: okTargets,
+        renderedHash,
     };
     writeLockFile(lock);
     return {
@@ -828,7 +867,7 @@ export function detectDrift(manifest) {
             mcps.toUpdate.push(name);
             continue;
         }
-        const missing = mcpMissingInTargets(manifestMcps[name], (prevMcp.targets ?? []));
+        const missing = mcpNeedsRepairInTargets(manifestMcps[name], (prevMcp.targets ?? []), prevMcp.renderedHash);
         if (missing.length > 0) {
             mcps.toUpdate.push(name);
             mcps.missing.push(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alegra-data-agent",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "private": false,
   "description": "Agente de Data interno de Alegra. Instala skills + MCPs en tu cliente de IA con un comando.",
   "license": "UNLICENSED",