vexp-mcp 2.0.3 → 2.0.5

package/dist/daemon-client.js

@@ -1,22 +1,67 @@
 import * as net from "net";
 import * as path from "path";
 import * as fs from "fs";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
 /**
  * Client per comunicare con il vexp-core daemon via Unix socket / Named pipe.
  * Protocol: JSON lines (newline-delimited JSON).
  */
 export class DaemonClient {
-    socketPath;
+    explicitSocketPath;
     requestCounter = 0;
     sessionId;
+    daemonSpawnAttempted = false;
     static MAX_RETRIES = 3;
     static RETRY_DELAY_MS = 1500;
     static RETRYABLE_CODES = ["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE"];
     constructor(socketPath, sessionId) {
-        this.socketPath = socketPath ?? getDefaultSocketPath();
+        // When a caller passes an explicit path we honor it for the client's
+        // lifetime (back-compat for tests and one-shot CLI usage). When omitted,
+        // we re-resolve via the registry on every connect so a long-lived HTTP
+        // MCP server can follow daemons that start/stop while it's up.
+        this.explicitSocketPath = socketPath;
         this.sessionId = sessionId ?? randomUUID();
     }
+    /**
+     * On the first connection failure, attempt to start the daemon once
+     * (idempotent lato Rust). Silent: success = next retry connects;
+     * failure = the ordinary retry/error path still surfaces a clear error
+     * with the registry candidates. Controlled by VEXP_NO_AUTOSTART=1.
+     */
+    async maybeSpawnDaemon() {
+        if (this.daemonSpawnAttempted)
+            return;
+        this.daemonSpawnAttempted = true;
+        if (process.env.VEXP_NO_AUTOSTART === "1")
+            return;
+        const workspaceRoot = process.env.VEXP_WORKSPACE ?? discoverWorkspaceRoot();
+        if (!fs.existsSync(path.join(workspaceRoot, ".vexp", "manifest.json")))
+            return;
+        const binary = resolveVexpCoreBinary();
+        if (!binary)
+            return;
+        await new Promise((resolve) => {
+            const child = spawn(binary, ["daemon-cmd", "start"], {
+                cwd: workspaceRoot,
+                stdio: "ignore",
+                detached: true,
+                env: binaryEnvFor(binary),
+            });
+            const done = () => { resolve(); };
+            child.on("exit", done);
+            child.on("error", done);
+            // Cap total wait at 4s: Rust daemon-cmd itself waits 2s for socket.
+            setTimeout(done, 4000);
+        });
+    }
+    /** Resolve socket path at request time to survive daemon restarts. */
+    get socketPath() {
+        if (this.explicitSocketPath)
+            return this.explicitSocketPath;
+        return resolveDaemonSocket() ?? getDefaultSocketPath();
+    }
     static isRetryableError(err) {
         const msg = err.message;
         return DaemonClient.RETRYABLE_CODES.some((code) => msg.includes(code));
@@ -33,6 +78,11 @@ export class DaemonClient {
             catch (err) {
                 lastError = err instanceof Error ? err : new Error(String(err));
                 if (attempt < DaemonClient.MAX_RETRIES && DaemonClient.isRetryableError(lastError)) {
+                    // First failure: try to auto-start the daemon (one-shot).
+                    // Subsequent failures skip the spawn and just retry.
+                    if (attempt === 0) {
+                        await this.maybeSpawnDaemon();
+                    }
                     console.error(`[vexp-mcp] Daemon connection failed (${lastError.message}), ` +
                         `retrying in ${DaemonClient.RETRY_DELAY_MS}ms ` +
                         `(attempt ${attempt + 1}/${DaemonClient.MAX_RETRIES})`);
@@ -119,7 +169,7 @@ export class DaemonClient {
                 }
             });
             client.on("error", (err) => {
-                settle(() => reject(new Error(`Daemon connection error: ${err.message}. Is vexp daemon running?`)));
+                settle(() => reject(new Error(`Daemon connection error: ${err.message}. ${daemonRunHint()}`)));
             });
             client.on("close", () => {
                 settle(() => reject(new Error("Daemon connection closed unexpectedly")));
@@ -178,7 +228,7 @@ export class DaemonClient {
                 }
             });
             client.on("error", (err) => {
-                settle(() => reject(new Error(`Daemon connection error: ${err.message}. Is vexp daemon running?`)));
+                settle(() => reject(new Error(`Daemon connection error: ${err.message}. ${daemonRunHint()}`)));
             });
             client.on("close", () => {
                 settle(() => reject(new Error("Daemon connection closed unexpectedly")));
@@ -198,6 +248,64 @@ export class DaemonClient {
         }
     }
 }
+/**
+ * Locate the vexp-core binary from the MCP server's own filesystem
+ * position. Supports three layouts:
+ *   - Env override: VEXP_CORE_PATH
+ *   - CLI npm install: the MCP bundle lives in vexp-cli/mcp/ with a
+ *     sibling @vexp/core-<plat> package at ../../@vexp/core-<plat>/bin/
+ *   - VSCode extension: binaries/vexp-core-<plat>/ alongside dist/
+ *   - Dev fallback: target/release/vexp-core in the monorepo
+ * Returns null if nothing matches.
+ */
+function resolveVexpCoreBinary() {
+    if (process.env.VEXP_CORE_PATH && fs.existsSync(process.env.VEXP_CORE_PATH)) {
+        return process.env.VEXP_CORE_PATH;
+    }
+    // __dirname may not exist in ESM — derive it from import.meta.url fallback.
+    let scriptDir;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        scriptDir = typeof __dirname !== "undefined" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+    }
+    catch {
+        scriptDir = process.cwd();
+    }
+    const plat = `${process.platform}-${process.arch === "arm64" ? "arm64" : "x64"}`;
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const candidates = [
+        // CLI npm install: mcp-server.cjs → ../../@vexp/core-<plat>/bin/vexp-core
+        path.resolve(scriptDir, "..", "..", "@vexp", `core-${plat}`, "bin", `vexp-core${ext}`),
+        // Same but relative from dist/mcp-server.cjs inside vexp-cli
+        path.resolve(scriptDir, "..", "node_modules", "@vexp", `core-${plat}`, "bin", `vexp-core${ext}`),
+        // VSCode extension: dist/mcp-server.cjs → ../binaries/vexp-core-<plat>/vexp-core
+        path.resolve(scriptDir, "..", "binaries", `vexp-core-${plat}`, `vexp-core${ext}`),
+        // Dev fallback: monorepo target/release
+        path.resolve(scriptDir, "..", "..", "..", "target", "release", `vexp-core${ext}`),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+}
+/**
+ * Build env for spawning vexp-core: prepend binary dir to LD_LIBRARY_PATH
+ * (Linux) / DYLD_* (macOS) so the loader finds bundled libggml/libllama
+ * even when the binary's RPATH is missing (e.g. older VSIX artifacts).
+ */
+function binaryEnvFor(binaryPath) {
+    const dir = path.dirname(binaryPath);
+    const env = { ...process.env };
+    if (process.platform === "linux") {
+        env.LD_LIBRARY_PATH = env.LD_LIBRARY_PATH ? `${dir}:${env.LD_LIBRARY_PATH}` : dir;
+    }
+    else if (process.platform === "darwin") {
+        env.DYLD_LIBRARY_PATH = env.DYLD_LIBRARY_PATH ? `${dir}:${env.DYLD_LIBRARY_PATH}` : dir;
+        env.DYLD_FALLBACK_LIBRARY_PATH = env.DYLD_FALLBACK_LIBRARY_PATH ? `${dir}:${env.DYLD_FALLBACK_LIBRARY_PATH}` : dir;
+    }
+    return env;
+}
 /** FNV-1a 64-bit hash — must match vexp-core/src/utils.rs md5_hash() */
 function fnvHash(input) {
     let hash = BigInt("0xcbf29ce484222325");
@@ -239,38 +347,145 @@ function discoverWorkspaceRoot() {
     }
     return cwd;
 }
-function getDefaultSocketPath() {
+/**
+ * Read `~/.vexp/daemons.json` and pick the best entry for the given workspace.
+ *
+ * The Rust daemon registers itself here on startup on ALL platforms (main.rs
+ * writes `{workspace_root → socket_path}`). This is the authoritative way to
+ * find a live daemon when the MCP server was spawned from an unrelated cwd
+ * (typical for Claude Code, Cursor, Windsurf, GitHub Copilot — they start
+ * MCP servers from ~, from the file's dir, etc., never guaranteed to be the
+ * workspace root).
+ *
+ * Selection policy:
+ *   1. Exact workspace match
+ *   2. Longest workspace that is a prefix of `workspaceHint` (handles
+ *      submodule / nested-directory cwd pointing at a parent daemon)
+ *   3. If registry has exactly one entry, use it
+ *   4. Otherwise `null` (caller should error clearly)
+ */
+function pickFromDaemonRegistry(workspaceHint) {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    if (!home)
+        return null;
+    const registryPath = path.join(home, ".vexp", "daemons.json");
+    let registry;
+    try {
+        registry = JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    // Filter out stale entries: SIGKILL'd daemons don't run their Drop
+    // handler so the registry accumulates ghost workspaces. Keep only
+    // entries whose socket file still exists (Windows named pipes are
+    // always exposed by the kernel, so skip the file check there).
+    const allEntries = Object.entries(registry);
+    const entries = process.platform === "win32"
+        ? allEntries
+        : allEntries.filter(([, sock]) => {
+            try {
+                return fs.statSync(sock).isSocket();
+            }
+            catch {
+                return false;
+            }
+        });
+    if (entries.length === 0)
+        return null;
+    const hintNorm = workspaceHint.toLowerCase();
+    for (const [ws, sock] of entries) {
+        if (ws.toLowerCase() === hintNorm)
+            return sock;
+    }
+    let bestWs = "";
+    let bestSock = null;
+    for (const [ws, sock] of entries) {
+        const wsNorm = ws.toLowerCase();
+        if (hintNorm.startsWith(wsNorm + path.sep) || hintNorm === wsNorm) {
+            if (wsNorm.length > bestWs.length) {
+                bestWs = wsNorm;
+                bestSock = sock;
+            }
+        }
+    }
+    if (bestSock)
+        return bestSock;
+    if (entries.length === 1)
+        return entries[0][1];
+    return null;
+}
+/**
+ * Resolve the daemon socket path / named pipe, cross-platform, using:
+ *   1. `VEXP_SOCKET` env — explicit override (highest precedence)
+ *   2. Workspace-local socket if it exists (`<workspaceRoot>/.vexp/daemon.sock`)
+ *   3. Global daemon registry `~/.vexp/daemons.json` (written by the Rust
+ *      daemon at startup on all platforms)
+ *   4. Platform-specific fallback (Windows hash pipe, otherwise `null` →
+ *      caller surfaces a clear "no daemon" error)
+ *
+ * Does NOT fall back to `~/.vexp/daemon.sock` — the daemon never writes
+ * there; that path is a dead-end that masks the real error.
+ */
+export function resolveDaemonSocket() {
+    const explicit = process.env["VEXP_SOCKET"];
+    if (explicit)
+        return explicit;
     const workspaceRoot = process.env["VEXP_WORKSPACE"] ?? discoverWorkspaceRoot();
     if (process.platform === "win32") {
-        // 1. Try reading daemon.pipe from discovered workspace
+        // Workspace-specific pipe name file written by the daemon
         const pipeFile = path.join(workspaceRoot, ".vexp", "daemon.pipe");
         try {
             const pipeName = fs.readFileSync(pipeFile, "utf-8").trim();
             if (pipeName)
                 return pipeName;
         }
-        catch { /* file doesn't exist */ }
-        // 2. Try global daemon registry (~/.vexp/daemons.json)
-        const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-        if (home) {
-            const registryPath = path.join(home, ".vexp", "daemons.json");
-            try {
-                const registry = JSON.parse(fs.readFileSync(registryPath, "utf-8"));
-                const entries = Object.entries(registry);
-                if (entries.length > 0) {
-                    const normalizedCwd = workspaceRoot.toLowerCase();
-                    for (const [ws, pipe] of entries) {
-                        if (ws.toLowerCase() === normalizedCwd)
-                            return pipe;
-                    }
-                    return entries[0][1]; // fallback to first available
-                }
-            }
-            catch { }
-        }
-        // 3. Fallback: compute hash
+        catch { /* missing */ }
+        // Registry
+        const fromRegistry = pickFromDaemonRegistry(workspaceRoot);
+        if (fromRegistry)
+            return fromRegistry;
+        // Hash-based last-ditch (daemon should always register, so this is rare)
         const hash = fnvHash(workspaceRoot.toLowerCase());
         return `\\\\.\\pipe\\vexp-${hash.slice(0, 8)}`;
     }
+    // Unix: prefer workspace-local if the socket file actually exists
+    const cwdSocket = path.join(workspaceRoot, ".vexp", "daemon.sock");
+    if (fs.existsSync(cwdSocket))
+        return cwdSocket;
+    // Registry (Linux + macOS) — the piece that was missing
+    const fromRegistry = pickFromDaemonRegistry(workspaceRoot);
+    if (fromRegistry)
+        return fromRegistry;
+    return null;
+}
+/** Back-compat wrapper: some callers expect a string (old behavior).
+ *  Returns the resolved path or the nominal workspace path so the caller's
+ *  connect attempt produces a meaningful ENOENT with the real path. */
+function getDefaultSocketPath() {
+    const resolved = resolveDaemonSocket();
+    if (resolved)
+        return resolved;
+    const workspaceRoot = process.env["VEXP_WORKSPACE"] ?? discoverWorkspaceRoot();
     return path.join(workspaceRoot, ".vexp", "daemon.sock");
 }
+export { discoverWorkspaceRoot };
+/** Human-friendly hint printed when a connection attempt fails — enumerates
+ *  what we tried to make the failure actionable instead of misleading. */
+function daemonRunHint() {
+    const workspaceRoot = process.env["VEXP_WORKSPACE"] ?? discoverWorkspaceRoot();
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const candidates = [];
+    if (process.env["VEXP_SOCKET"])
+        candidates.push(`VEXP_SOCKET=${process.env["VEXP_SOCKET"]}`);
+    candidates.push(`${workspaceRoot}/.vexp/daemon.sock`);
+    if (home) {
+        try {
+            const reg = JSON.parse(fs.readFileSync(path.join(home, ".vexp", "daemons.json"), "utf-8"));
+            for (const [ws, sock] of Object.entries(reg))
+                candidates.push(`registry: ${ws} → ${sock}`);
+        }
+        catch { /* registry missing is expected when no daemon has run yet */ }
+    }
+    return `Tried: [${candidates.join(", ")}]. Run \`vexp setup\` in your project to start the daemon, or set VEXP_WORKSPACE / VEXP_SOCKET.`;
+}

package/dist/index.js

@@ -61,105 +61,11 @@ function allToolsEnabled() {
     const lowered = v.trim().toLowerCase();
     return lowered === "1" || lowered === "true" || lowered === "yes" || lowered === "on";
 }
-/** FNV-1a 64-bit hash — must match vexp-core/src/utils.rs md5_hash() */
-function fnvHash(input) {
-    let hash = BigInt("0xcbf29ce484222325");
-    const prime = BigInt("0x100000001b3");
-    const mask = BigInt("0xffffffffffffffff");
-    const bytes = Buffer.from(input, "utf-8");
-    for (const byte of bytes) {
-        hash ^= BigInt(byte);
-        hash = (hash * prime) & mask;
-    }
-    return hash.toString(16);
-}
-/**
- * Walk up from cwd looking for .vexp/ or .git/ to find the workspace root.
- * Used when VEXP_WORKSPACE is not set (e.g., Codex, Cursor, or other agents
- * spawn the MCP server without passing the workspace path).
- */
-function discoverWorkspaceRoot() {
-    const cwd = process.cwd();
-    // First pass: look for .vexp/ (strongest signal — daemon was started here)
-    let current = cwd;
-    while (true) {
-        if (fs.existsSync(path.join(current, ".vexp")))
-            return current;
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    // Second pass: look for .git/ (standard repo root)
-    current = cwd;
-    while (true) {
-        if (fs.existsSync(path.join(current, ".git")))
-            return current;
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return cwd;
-}
-function getSocketPath() {
-    if (process.env.VEXP_SOCKET)
-        return process.env.VEXP_SOCKET;
-    const workspaceRoot = process.env.VEXP_WORKSPACE ?? discoverWorkspaceRoot();
-    if (process.platform === "win32") {
-        // 1. Try reading daemon.pipe from discovered workspace
-        const pipeFile = path.join(workspaceRoot, ".vexp", "daemon.pipe");
-        try {
-            const pipeName = fs.readFileSync(pipeFile, "utf-8").trim();
-            if (pipeName)
-                return pipeName;
-        }
-        catch { /* file doesn't exist */ }
-        // 2. Try global daemon registry (~/.vexp/daemons.json)
-        const fromRegistry = readDaemonRegistry(workspaceRoot);
-        if (fromRegistry)
-            return fromRegistry;
-        // 3. Fallback: compute hash (may mismatch if path differs from daemon's)
-        const normalized = workspaceRoot.toLowerCase();
-        const hash = fnvHash(normalized);
-        return `\\\\.\\pipe\\vexp-${hash.slice(0, 8)}`;
-    }
-    const cwdSocket = `${workspaceRoot}/.vexp/daemon.sock`;
-    if (fs.existsSync(cwdSocket))
-        return cwdSocket;
-    const home = process.env.HOME ?? "/tmp";
-    return `${home}/.vexp/daemon.sock`;
-}
-/**
- * Read the global daemon registry (~/.vexp/daemons.json) to find a running daemon.
- * Falls back to: exact workspace match → single daemon → first available.
- */
-function readDaemonRegistry(workspaceRoot) {
-    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    if (!home)
-        return null;
-    const registryPath = path.join(home, ".vexp", "daemons.json");
-    try {
-        const registry = JSON.parse(fs.readFileSync(registryPath, "utf-8"));
-        const entries = Object.entries(registry);
-        if (entries.length === 0)
-            return null;
-        // Try exact match (case-insensitive on Windows)
-        const normalizedCwd = workspaceRoot.toLowerCase();
-        for (const [ws, pipe] of entries) {
-            if (ws.toLowerCase() === normalizedCwd)
-                return pipe;
-        }
-        // Single daemon running — use it directly
-        if (entries.length === 1)
-            return entries[0][1];
-        // Multiple daemons, no match — use first available
-        return entries[0][1];
-    }
-    catch {
-        return null;
-    }
-}
+// Socket path resolution + workspace discovery live in daemon-client.ts
+// as the single source of truth (exported: resolveDaemonSocket,
+// discoverWorkspaceRoot). The Rust daemon registers itself in
+// ~/.vexp/daemons.json on all platforms, which is the authoritative
+// lookup when an agent spawns the MCP server from an unrelated cwd.
 function createMcpServer(daemon) {
     const server = new Server({ name: "vexp-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
     server.setRequestHandler(ListToolsRequestSchema, () => ({
@@ -361,8 +267,12 @@ async function startHttp(daemon, port) {
 }
 async function main() {
     const args = process.argv.slice(2);
-    const socketPath = getSocketPath();
-    const daemon = new DaemonClient(socketPath);
+    // DaemonClient with no explicit socket: resolves via VEXP_SOCKET →
+    // workspace-local socket → ~/.vexp/daemons.json registry on every
+    // connect. A long-lived HTTP MCP server thus follows daemons that
+    // start/stop while it's up, and fresh stdio spawns pick the right
+    // daemon without restarting the MCP server.
+    const daemon = new DaemonClient();
     const useHttp = args.includes("--http") || process.env.VEXP_HTTP === "1";
     const port = parseInt(args.find((a) => a.startsWith("--port="))?.split("=")[1] ??
         process.env.VEXP_PORT ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vexp-mcp",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "vexp MCP server — AI context tools for coding agents",
   "type": "module",
   "main": "dist/index.js",