npm - @echomem/mcp - Versions diffs - 1.4.2 → 1.4.3 - Mend

@echomem/mcp 1.4.2 → 1.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/hud/cli.js CHANGED Viewed

File without changes

package/dist/hud/web.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { MCP_PACKAGE_VERSION } from "../package-metadata.js";
 export const HUD_HTML = String.raw `<!doctype html>
 <html lang="en">
   <head>
@@ -193,6 +194,7 @@ export const HUD_HTML = String.raw `<!doctype html>
       const history = [];
       let lastSource = '';
       let prevTurnState = null;
+      const hudVersion = 'v${MCP_PACKAGE_VERSION}';
       updateBubbleSkins();
       if ('ResizeObserver' in window) {
         const observer = new ResizeObserver(updateBubbleSkins);
@@ -261,7 +263,7 @@ export const HUD_HTML = String.raw `<!doctype html>
           if (deltaEl) deltaEl.style.display = 'none';
           prevTurnState = null;
           main.textContent = 'No active session yet';
-          client.textContent = '';
+          client.textContent = 'EchoMem HUD · ' + hudVersion;
           if (summary) summary.textContent = 'Start working in Codex or Claude and I’ll check the context here.';
           if (fullness) fullness.textContent = '';
           if (meterfill) meterfill.style.width = '0';
@@ -285,7 +287,7 @@ export const HUD_HTML = String.raw `<!doctype html>
         hud.classList.remove('s-green', 's-amber', 's-red');
         hud.classList.add('s-' + (score.color || 'green'));
         main.textContent = stateWord(score.color) + ' · ' + fmt(score.ctTokens) + ' ctx';
-        client.textContent = label(score.client);
+        client.textContent = label(score.client) + ' · ' + hudVersion;
         if (summary) summary.textContent = summaryLine(score.color);
         const sat = typeof score.saturationPct === 'number' ? score.saturationPct
           : (score.modelContextWindow ? Math.round(100 * (score.ctTokens || 0) / score.modelContextWindow) : 0);

package/dist/index.js CHANGED Viewed

File without changes

package/dist/setup.js CHANGED Viewed

@@ -14,7 +14,7 @@
  */
 import http from "node:http";
 import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { Worker } from "node:worker_threads";
 import fs from "node:fs";
 import os from "node:os";
@@ -30,7 +30,7 @@ import { syncCodexUsage } from "./codex-sync.js";
 import { renderSetupPage } from "./setup-page.js";
 import { repoLabel } from "./forensics.js";
 import { installHooks } from "./hud/hooks.js";
-import { MCP_PACKAGE_LABEL, MCP_PACKAGE_VERSION, MCP_UPDATE_COMMAND } from "./package-metadata.js";
+import { MCP_PACKAGE_LABEL, MCP_PACKAGE_NAME, MCP_PACKAGE_VERSION, MCP_UPDATE_COMMAND } from "./package-metadata.js";
 // The hosted connect-device page is now only the account-auth/token courier. The dashboard itself is
 // served by this localhost bridge, where local logs and processed/unprocessed counts never leave the
 // device unless the user explicitly starts migration. Override the hosted auth origin with ECHO_WEB_URL.
@@ -142,6 +142,283 @@ export function writeJsonClientConfig(configPath, entry) {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
+export function writeClaudeCodeConfig(entry) {
+    try {
+        execFileSync("claude", ["mcp", "add-json", "echomem", JSON.stringify(entry)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 10000,
+        });
+        return "wrote";
+    }
+    catch {
+        return "unavailable";
+    }
+}
+function readJsonClientEntry(configPath) {
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        const servers = config.mcpServers;
+        if (!servers || typeof servers !== "object" || Array.isArray(servers))
+            return null;
+        const entry = servers.echomem;
+        return entry && typeof entry === "object" && !Array.isArray(entry) ? entry : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readCodexEntry(configPath) {
+    let content = "";
+    try {
+        content = fs.readFileSync(configPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => /^\s*\[mcp_servers\.echomem\]\s*$/.test(line));
+    if (start < 0)
+        return null;
+    let end = start + 1;
+    while (end < lines.length && !/^\s*\[/.test(lines[end]))
+        end++;
+    const block = lines.slice(start, end);
+    const command = parseTomlString(block.find((line) => /^\s*command\s*=/.test(line)));
+    const args = parseTomlStringArray(block.find((line) => /^\s*args\s*=/.test(line)));
+    return command ? { command, args } : null;
+}
+function parseTomlString(line) {
+    if (!line)
+        return undefined;
+    const match = line.match(/=\s*(".*")\s*$/);
+    if (!match)
+        return undefined;
+    try {
+        const value = JSON.parse(match[1]);
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseTomlStringArray(line) {
+    if (!line)
+        return [];
+    const match = line.match(/=\s*(\[.*\])\s*$/);
+    if (!match)
+        return [];
+    try {
+        const value = JSON.parse(match[1]);
+        return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function entryArgs(entry) {
+    return Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string") : [];
+}
+function entryCommand(entry) {
+    return typeof entry.command === "string" && entry.command.trim() ? entry.command.trim() : undefined;
+}
+function entryTarget(entry) {
+    const command = entryCommand(entry) ?? "(missing command)";
+    const args = entryArgs(entry);
+    return [command, ...args].join(" ");
+}
+function packageVersionFromPath(entryPath) {
+    let current = entryPath;
+    try {
+        current = fs.realpathSync(entryPath);
+    }
+    catch {
+        /* keep the original path; it may still be inside an existing package dir */
+    }
+    try {
+        if (fs.existsSync(current) && fs.statSync(current).isFile())
+            current = path.dirname(current);
+    }
+    catch {
+        current = path.dirname(current);
+    }
+    for (let i = 0; i < 12; i += 1) {
+        const packagePath = path.join(current, "package.json");
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+            if (pkg.name === MCP_PACKAGE_NAME && typeof pkg.version === "string") {
+                return { version: pkg.version, packagePath };
+            }
+        }
+        catch {
+            /* keep walking */
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+export function resolveServerEntryVersion(entry) {
+    const command = entryCommand(entry);
+    const args = entryArgs(entry);
+    const npxPackageArg = args.find((arg) => arg === MCP_PACKAGE_NAME || arg.startsWith(`${MCP_PACKAGE_NAME}@`));
+    if (command && path.basename(command).replace(/\.(cmd|exe)$/i, "") === "npx" && npxPackageArg) {
+        const suffix = npxPackageArg.slice(MCP_PACKAGE_NAME.length);
+        if (suffix === "@latest")
+            return { runtime: "latest" };
+        if (suffix.startsWith("@") && /^\d+\.\d+\.\d+/.test(suffix.slice(1)))
+            return { version: suffix.slice(1) };
+        return { runtime: "dynamic" };
+    }
+    const candidates = [...args, command].filter((value) => typeof value === "string");
+    for (const candidate of candidates) {
+        if (!candidate.includes(MCP_PACKAGE_NAME) && !candidate.includes(`${path.sep}echomem-mcp`))
+            continue;
+        const resolved = packageVersionFromPath(candidate);
+        if (resolved)
+            return resolved;
+    }
+    return {};
+}
+function compareSemver(a, b) {
+    const av = a.split(/[.-]/).map((part) => Number(part));
+    const bv = b.split(/[.-]/).map((part) => Number(part));
+    for (let i = 0; i < Math.max(av.length, bv.length, 3); i += 1) {
+        const ai = Number.isFinite(av[i]) ? av[i] : 0;
+        const bi = Number.isFinite(bv[i]) ? bv[i] : 0;
+        if (ai !== bi)
+            return ai > bi ? 1 : -1;
+    }
+    return 0;
+}
+function versionState(version, desiredVersion) {
+    if (!version || !desiredVersion)
+        return "unknown";
+    const cmp = compareSemver(version, desiredVersion);
+    if (cmp < 0)
+        return "stale";
+    if (cmp > 0)
+        return "newer";
+    return "ok";
+}
+function readLatestPublishedVersion() {
+    try {
+        const raw = execFileSync("npm", ["view", MCP_PACKAGE_NAME, "version", "--silent"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 3500,
+        }).trim();
+        return /^\d+\.\d+\.\d+/.test(raw) ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function inspectClientConfig(client, desiredVersion) {
+    if (client.kind === "snippet")
+        return inspectClaudeCodeConfig(client, desiredVersion);
+    if (client.kind === "json" && !fs.existsSync(path.dirname(client.configPath)))
+        return null;
+    if (client.kind === "command" && !fs.existsSync(client.detectDir))
+        return null;
+    const entry = client.kind === "json" ? readJsonClientEntry(client.configPath) : readCodexEntry(client.configPath);
+    if (!entry) {
+        return {
+            id: client.id,
+            label: client.label,
+            configured: false,
+            detail: `no EchoMem MCP entry in ${client.configPath}`,
+            state: "missing",
+            command: `${MCP_UPDATE_COMMAND} --client ${client.id}`,
+        };
+    }
+    const resolved = resolveServerEntryVersion(entry);
+    const state = resolved.runtime === "latest" ? "ok" : versionState(resolved.version, desiredVersion);
+    return {
+        id: client.id,
+        label: client.label,
+        configured: true,
+        detail: entryTarget(entry),
+        version: resolved.version,
+        packagePath: resolved.packagePath,
+        runtime: resolved.runtime,
+        state,
+        command: state === "stale" || state === "missing" ? `${MCP_UPDATE_COMMAND} --client ${client.id}` : undefined,
+    };
+}
+function inspectClaudeCodeConfig(client, desiredVersion) {
+    if (!fs.existsSync(home(".claude")))
+        return null;
+    try {
+        const output = execFileSync("claude", ["mcp", "list"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 3000,
+        });
+        const line = output.split("\n").find((item) => item.toLowerCase().includes("echomem"));
+        if (!line) {
+            return {
+                id: client.id,
+                label: client.label,
+                configured: false,
+                detail: "Claude Code reports no EchoMem MCP server",
+                state: "missing",
+                command: `${MCP_UPDATE_COMMAND} --client ${client.id}`,
+            };
+        }
+        const match = line.match(new RegExp(`${MCP_PACKAGE_NAME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}@(\\d+\\.\\d+\\.\\d+)`));
+        const version = match?.[1];
+        return {
+            id: client.id,
+            label: client.label,
+            configured: true,
+            detail: line.trim(),
+            version,
+            state: versionState(version, desiredVersion),
+            command: version && versionState(version, desiredVersion) === "stale" ? `${MCP_UPDATE_COMMAND} --client ${client.id}` : undefined,
+        };
+    }
+    catch {
+        return {
+            id: client.id,
+            label: client.label,
+            configured: false,
+            detail: "Claude Code CLI not available for `claude mcp list`; add EchoMem from Claude Code manually",
+            state: "unknown",
+        };
+    }
+}
+function inspectClientConfigs(desiredVersion) {
+    return knownClients()
+        .map((client) => inspectClientConfig(client, desiredVersion))
+        .filter((report) => report !== null);
+}
+function formatClientConfigReport(report) {
+    const lines = [];
+    const status = report.state === "ok"
+        ? "ok"
+        : report.state === "stale"
+            ? "stale"
+            : report.state === "newer"
+                ? "newer than this status command"
+                : report.state === "missing"
+                    ? "missing"
+                    : "unknown";
+    const version = report.runtime === "latest"
+        ? "latest at launch"
+        : report.runtime === "dynamic"
+            ? "dynamic npm resolution"
+            : report.version
+                ? `${MCP_PACKAGE_NAME}@${report.version}`
+                : "version unknown";
+    lines.push(`  ${report.label}: ${report.configured ? "configured" : "not configured"} (${status}; ${version})`);
+    lines.push(`    ${report.detail}`);
+    if (report.command)
+        lines.push(`    Update: ${report.command}`);
+    return lines;
+}
 // ---------------------------------------------------------------------------
 // Browser + localhost callback
 // ---------------------------------------------------------------------------
@@ -788,7 +1065,13 @@ async function cmdSetup(flags) {
                     console.log(`✅ ${c.label} already has the EchoMem MCP entry: ${c.configPath}`);
             }
             else {
-                console.log(`ℹ️  ${c.label}: ${c.note}\n   entry: ${JSON.stringify(entry)}`);
+                const result = c.id === "claude-code" ? writeClaudeCodeConfig(entry) : "unavailable";
+                if (result === "wrote") {
+                    console.log(`✅ Wrote EchoMem MCP entry to ${c.label} via \`claude mcp add-json\` — start a new Claude Code session to load it.`);
+                }
+                else {
+                    console.log(`ℹ️  ${c.label}: ${c.note}\n   entry: ${JSON.stringify(entry)}`);
+                }
             }
         }
     }
@@ -1381,10 +1664,17 @@ async function cmdUnlock(flags) {
     store.saveKey(keyB64);
     console.log("✅ Vault unlocked. Reload your MCP client (or start a new session).");
 }
-async function cmdStatus() {
+async function cmdStatus(flags = {}) {
     const store = new KeyStore();
     const token = store.getToken();
     console.log(`EchoMem MCP: ${MCP_PACKAGE_LABEL}`);
+    const latest = flags["no-network"] ? undefined : readLatestPublishedVersion();
+    if (latest) {
+        console.log(`Published latest: ${MCP_PACKAGE_NAME}@${latest}`);
+        if (compareSemver(MCP_PACKAGE_VERSION, latest) < 0) {
+            console.log(`This status command is older than latest. Update client configs with: ${MCP_UPDATE_COMMAND}`);
+        }
+    }
     console.log(`Credentials file: ${store.path()}`);
     console.log(`API token: ${token ? "present" : "MISSING — run `echomem-mcp login`"}`);
     if (token) {
@@ -1408,6 +1698,14 @@ async function cmdStatus() {
     console.log(`Encryption key: ${store.getKey() ? "present" : store.isKeyExpired() ? "EXPIRED — run `echomem-mcp unlock`" : "not set"}`);
     const detected = detectClients();
     console.log(`Detected clients: ${detected.length ? detected.map((c) => c.label).join(", ") : "none auto-detected"}`);
+    const reports = inspectClientConfigs(latest ?? MCP_PACKAGE_VERSION);
+    if (reports.length) {
+        console.log("Client MCP configs:");
+        for (const report of reports) {
+            for (const line of formatClientConfigReport(report))
+                console.log(line);
+        }
+    }
 }
 function cmdLogout() {
     const store = new KeyStore();
@@ -1430,6 +1728,7 @@ Usage:
   echomem-mcp login                 Approve this device in the browser (or --token/--passphrase)
   echomem-mcp unlock                Re-derive the encryption key after its TTL (or --passphrase)
   echomem-mcp status                Show token/key/clients
+  echomem-mcp doctor [--no-network] Diagnose configured client bridge versions
   echomem-mcp logout                Remove stored credentials
   echomem-mcp report [--json]       Your AI coding memory audit (local, no login, $0)
   echomem-mcp migrate [--since D]   Import your existing Codex/Claude history into your memory
@@ -1468,7 +1767,10 @@ export async function runCli(argv) {
             await cmdUnlock(flags);
             return true;
         case "status":
-            await cmdStatus();
+            await cmdStatus(flags);
+            return true;
+        case "doctor":
+            await cmdStatus(flags);
             return true;
         case "logout":
             cmdLogout();

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "EchoMem Cloud-First MCP Server",
   "main": "dist/index.js",
   "type": "module",