@echomem/mcp 1.4.45 → 1.4.47

package/dist/setup.js

@@ -15,7 +15,7 @@
  */
 import http from "node:http";
 import { randomUUID } from "node:crypto";
-import { execFileSync, spawn } from "node:child_process";
+import { execFileSync, spawn, spawnSync, } from "node:child_process";
 import { Worker } from "node:worker_threads";
 import fs from "node:fs";
 import os from "node:os";
@@ -505,11 +505,124 @@ function claudeCodeLocalEchoMemProjects(configPath) {
         .map(([projectPath]) => projectPath)
         .sort();
 }
+function versionedClaudeCodeExecutables(root, executable) {
+    let versions;
+    try {
+        versions = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return versions
+        .filter((entry) => entry.isDirectory())
+        .sort((left, right) => right.name.localeCompare(left.name, undefined, { numeric: true }))
+        .map((entry) => path.join(root, entry.name, executable))
+        .filter((candidate) => fs.existsSync(candidate));
+}
+/**
+ * Return every safe Claude Code launcher location worth trying. Claude Desktop bundles the CLI,
+ * but Windows Store/MSIX installs expose its real files below the package LocalCache instead of
+ * the caller's ordinary APPDATA/PATH view.
+ */
+export function claudeCodeCommandCandidates(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? os.homedir();
+    const candidates = [];
+    const configured = env.CLAUDE_CODE_EXECUTABLE?.trim();
+    if (configured)
+        candidates.push(configured);
+    candidates.push("claude");
+    if (platform === "win32") {
+        const appData = env.APPDATA?.trim() || path.join(homeDir, "AppData", "Roaming");
+        const localAppData = env.LOCALAPPDATA?.trim() || path.join(homeDir, "AppData", "Local");
+        candidates.push(...versionedClaudeCodeExecutables(path.join(appData, "Claude", "claude-code"), "claude.exe"), ...versionedClaudeCodeExecutables(path.join(localAppData, "Claude", "claude-code"), "claude.exe"));
+        const packagesRoot = path.join(localAppData, "Packages");
+        try {
+            for (const entry of fs.readdirSync(packagesRoot, { withFileTypes: true })) {
+                if (!entry.isDirectory() || !/^Claude_/i.test(entry.name))
+                    continue;
+                candidates.push(...versionedClaudeCodeExecutables(path.join(packagesRoot, entry.name, "LocalCache", "Roaming", "Claude", "claude-code"), "claude.exe"));
+            }
+        }
+        catch {
+            /* A non-Store install has no Packages directory. */
+        }
+        const executionAlias = path.join(localAppData, "Microsoft", "WindowsApps", "claude.exe");
+        if (fs.existsSync(executionAlias))
+            candidates.push(executionAlias);
+    }
+    else if (platform === "darwin") {
+        for (const candidate of [
+            "/Applications/Claude.app/Contents/Resources/claude",
+            path.join(homeDir, "Applications", "Claude.app", "Contents", "Resources", "claude"),
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+        ]) {
+            if (fs.existsSync(candidate))
+                candidates.push(candidate);
+        }
+    }
+    return [...new Set(candidates)];
+}
+function escapeWindowsCmdCommand(value) {
+    return value.replace(/([()\][%!^"`<>&|;, *?])/g, "^$1");
+}
+function escapeWindowsCmdArgument(value) {
+    let escaped = value
+        .replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"")
+        .replace(/(?=(\\+?)?)\1$/g, "$1$1");
+    escaped = `"${escaped}"`;
+    return escaped.replace(/([()\][%!^"`<>&|;, *?])/g, "^$1");
+}
+function execClaudeCodeSync(args, options, commandCandidates) {
+    let candidates = commandCandidates ? [...commandCandidates] : claudeCodeCommandCandidates();
+    if (process.platform === "win32" && !commandCandidates) {
+        try {
+            const pathMatches = execFileSync("where.exe", ["claude"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 3000,
+                windowsHide: true,
+            }).split(/\r?\n/).map((candidate) => candidate.trim()).filter(Boolean);
+            candidates = [...new Set([...pathMatches, ...candidates])];
+        }
+        catch {
+            /* The bundled Desktop candidates below remain available. */
+        }
+    }
+    let lastError = new Error("Claude Code CLI was not found.");
+    for (const command of candidates) {
+        try {
+            if (process.platform === "win32" && /\.(cmd|bat)$/i.test(command)) {
+                const shellCommand = [escapeWindowsCmdCommand(command), ...args.map(escapeWindowsCmdArgument)].join(" ");
+                const spawnOptions = {
+                    ...options,
+                    windowsHide: true,
+                    windowsVerbatimArguments: true,
+                };
+                const result = spawnSync(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `"${shellCommand}"`], spawnOptions);
+                if (result.error)
+                    throw result.error;
+                if (result.status !== 0) {
+                    throw new Error(result.stderr?.trim() || `Claude Code exited with status ${result.status ?? "unknown"}.`);
+                }
+                return result.stdout || "";
+            }
+            return execFileSync(command, args, process.platform === "win32" ? { ...options, windowsHide: true } : options);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError;
+}
 export function writeClaudeCodeConfig(entry, options = {}) {
     // EchoMem belongs at user scope so every Claude Code project resolves the same durable runtime.
     // Older CLI versions wrote local/project entries, which take precedence over user scope and can
     // keep launching a deleted npm cache or stale runtime. Migrate those only after user scope is safe.
     const configPath = options.configPath ?? home(".claude.json");
+    let failureReason;
     const emptyResult = () => ({
         state: "unavailable",
         removedLocalProjects: [],
@@ -517,18 +630,21 @@ export function writeClaudeCodeConfig(entry, options = {}) {
         failedLocalProjects: [],
         restoredPreviousUserEntry: false,
         preservedDesktopManaged: false,
+        failureReason,
     });
     const runClaude = (args, cwd) => {
         try {
-            execFileSync("claude", args, {
+            execClaudeCodeSync(args, {
                 cwd,
                 encoding: "utf8",
                 stdio: ["ignore", "pipe", "pipe"],
                 timeout: 10000,
-            });
+            }, options.claudeCommands);
+            failureReason = undefined;
             return true;
         }
-        catch {
+        catch (error) {
+            failureReason = commandFailureMessage(error);
             return false;
         }
     };
@@ -547,8 +663,10 @@ export function writeClaudeCodeConfig(entry, options = {}) {
         if (previousUserEntry && !removeUser())
             return emptyResult();
         if (!addUser(desiredUserEntry)) {
+            const addFailureReason = failureReason;
             if (previousUserEntry)
                 restoredPreviousUserEntry = addUser(previousUserEntry);
+            failureReason = addFailureReason;
             return { ...emptyResult(), restoredPreviousUserEntry };
         }
     }
@@ -765,7 +883,7 @@ function inspectClaudeCodeConfig(client, desiredVersion) {
     if (!fs.existsSync(home(".claude")))
         return null;
     try {
-        const output = execFileSync("claude", ["mcp", "list"], {
+        const output = execClaudeCodeSync(["mcp", "list"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
             timeout: 3000,
@@ -2821,6 +2939,7 @@ async function cmdSetup(flags) {
     // --dev is already an explicit request to replace the managed runtime with a checkout.
     const forceHeadless = flags["force-headless"] === true || typeof flags.dev === "string";
     const configurationFailures = [];
+    const configuredTargets = [];
     if (targets.length === 0) {
         console.log("No client auto-detected. Add this MCP server entry manually:\n");
         console.log(JSON.stringify({ echomem: entry }, null, 2));
@@ -2828,66 +2947,90 @@ async function cmdSetup(flags) {
     }
     else {
         for (const c of targets) {
-            if (c.kind === "json") {
-                const result = writeJsonClientConfig(c.configPath, entry, { forceHeadless });
-                if (result === "desktop-managed") {
-                    console.log(`✅ Kept the valid Echo Desktop-managed EchoMem entry for ${c.label}: ${c.configPath}`);
-                }
-                else {
-                    console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath}`);
-                }
-            }
-            else if (c.kind === "command") {
-                const result = writeCodexConfig(c.configPath, entry, { forceHeadless });
-                if (result === "wrote")
-                    console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath} — start a new Codex session to load it.`);
-                else if (result === "desktop-managed")
-                    console.log(`✅ Kept the valid Echo Desktop-managed EchoMem entry for ${c.label}: ${c.configPath}`);
-                else
-                    console.log(`✅ ${c.label} already has the EchoMem MCP entry: ${c.configPath}`);
-            }
-            else {
-                const result = c.id === "claude-code"
-                    ? writeClaudeCodeConfig(entry, { forceHeadless })
-                    : "unavailable";
-                if (result !== "unavailable" && result.state === "wrote") {
-                    if (result.preservedDesktopManaged) {
-                        console.log(`✅ Kept the valid Echo Desktop-managed EchoMem user entry for ${c.label}.`);
+            try {
+                if (c.kind === "json") {
+                    const result = writeJsonClientConfig(c.configPath, entry, { forceHeadless });
+                    if (result === "desktop-managed") {
+                        console.log(`✅ Kept the valid Echo Desktop-managed EchoMem entry for ${c.label}: ${c.configPath}`);
                     }
                     else {
-                        console.log(`✅ Wrote EchoMem MCP entry to ${c.label} via \`claude mcp add-json\` — start a new Claude Code session to load it.`);
-                    }
-                    if (result.removedLocalProjects.length > 0) {
-                        console.log(`✅ Removed ${result.removedLocalProjects.length} stale Claude Code project-local EchoMem ${result.removedLocalProjects.length === 1 ? "entry" : "entries"}.`);
-                    }
-                    if (result.skippedLocalProjects.length > 0) {
-                        console.log(`ℹ️  Ignored ${result.skippedLocalProjects.length} EchoMem local ${result.skippedLocalProjects.length === 1 ? "entry" : "entries"} for deleted project directories; they cannot shadow the user entry.`);
+                        console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath}`);
                     }
+                    configuredTargets.push(c);
+                }
+                else if (c.kind === "command") {
+                    const result = writeCodexConfig(c.configPath, entry, { forceHeadless });
+                    if (result === "wrote")
+                        console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath} — start a new Codex session to load it.`);
+                    else if (result === "desktop-managed")
+                        console.log(`✅ Kept the valid Echo Desktop-managed EchoMem entry for ${c.label}: ${c.configPath}`);
+                    else
+                        console.log(`✅ ${c.label} already has the EchoMem MCP entry: ${c.configPath}`);
+                    configuredTargets.push(c);
                 }
                 else {
-                    const failedProjects = result === "unavailable" ? [] : result.failedLocalProjects;
-                    configurationFailures.push(failedProjects.length > 0
-                        ? `${c.label} still has project-local EchoMem overrides in: ${failedProjects.join(", ")}`
-                        : `${c.label} user-scoped EchoMem entry could not be verified`);
+                    const result = c.id === "claude-code"
+                        ? writeClaudeCodeConfig(entry, { forceHeadless })
+                        : "unavailable";
+                    if (result !== "unavailable" && result.state === "wrote") {
+                        if (result.preservedDesktopManaged) {
+                            console.log(`✅ Kept the valid Echo Desktop-managed EchoMem user entry for ${c.label}.`);
+                        }
+                        else {
+                            console.log(`✅ Wrote EchoMem MCP entry to ${c.label} via \`claude mcp add-json\` — start a new Claude Code session to load it.`);
+                        }
+                        if (result.removedLocalProjects.length > 0) {
+                            console.log(`✅ Removed ${result.removedLocalProjects.length} stale Claude Code project-local EchoMem ${result.removedLocalProjects.length === 1 ? "entry" : "entries"}.`);
+                        }
+                        if (result.skippedLocalProjects.length > 0) {
+                            console.log(`ℹ️  Ignored ${result.skippedLocalProjects.length} EchoMem local ${result.skippedLocalProjects.length === 1 ? "entry" : "entries"} for deleted project directories; they cannot shadow the user entry.`);
+                        }
+                        configuredTargets.push(c);
+                    }
+                    else {
+                        const failedProjects = result === "unavailable" ? [] : result.failedLocalProjects;
+                        const reason = result === "unavailable" ? undefined : result.failureReason;
+                        if (result !== "unavailable" && result.state === "needs-repair")
+                            configuredTargets.push(c);
+                        configurationFailures.push({
+                            client: c,
+                            reason: failedProjects.length > 0
+                                ? `${c.label} still has project-local EchoMem overrides in: ${failedProjects.join(", ")}`
+                                : `${c.label} user-scoped EchoMem entry could not be verified${reason ? `: ${reason}` : ""}`,
+                        });
+                    }
                 }
             }
+            catch (error) {
+                configurationFailures.push({
+                    client: c,
+                    reason: `${c.label} configuration was left unchanged: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
         }
     }
     if (configurationFailures.length > 0) {
-        throw new Error([
-            "EchoMem MCP configuration is incomplete; onboarding was stopped before login/import.",
-            ...configurationFailures.map((failure) => `- ${failure}`),
-            `Retry with: ${MCP_UPDATE_COMMAND} --client claude-code`,
-        ].join("\n"));
+        const explicitSingleClient = Boolean(requested && requested !== "all" && flags.all !== true);
+        const failureMessage = [
+            explicitSingleClient
+                ? "EchoMem could not configure the requested MCP client."
+                : "EchoMem skipped MCP clients that were unavailable or could not be configured.",
+            ...configurationFailures.map((failure) => `- ${failure.reason}`),
+            ...configurationFailures.map((failure) => `Retry ${failure.client.label} later with: ${MCP_UPDATE_COMMAND} --client ${failure.client.id}`),
+        ].join("\n");
+        if (explicitSingleClient)
+            throw new Error(failureMessage);
+        console.log(`⚠️  ${failureMessage}`);
+        console.log("Continuing with the available clients; account connection and local-history import are not blocked.");
     }
     if (!flags["no-agents-md"]) {
-        writeMemoryGuidanceForTargets(targets);
+        writeMemoryGuidanceForTargets(configuredTargets);
     }
     if (!flags["no-codex-skills"]) {
-        writeCodexSkillsForTargets(targets);
+        writeCodexSkillsForTargets(configuredTargets);
     }
     if (flags["no-save-hooks"] !== true) {
-        writeLifecycleHooksForTargets(targets);
+        writeLifecycleHooksForTargets(configuredTargets);
     }
     console.log("");
     if (flags["skip-login"] || flags["no-login"]) {
@@ -2928,7 +3071,7 @@ async function cmdInit(flags) {
     }
     console.log("");
     console.log("🎉 EchoMem is ready.");
-    console.log("   • MCP memory is configured for every coding agent installed on this machine.");
+    console.log("   • MCP memory is configured for every available coding agent EchoMem could connect to on this machine.");
     console.log("   • Echo Desktop shows connection status and manages this device credential.");
     console.log('   • Try it now: ask your agent — "search my EchoMem for what I\'ve been working on and recap it."');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.45",
+  "version": "1.4.47",
   "description": "EchoMem MCP bridge: cloud-first memory tools and the Agent Doctor workspace forensics report (cost ledger + 3D repo city)",
   "main": "dist/index.js",
   "type": "module",