vexp-mcp 2.0.19 → 2.0.21

package/dist/daemon-client.js

@@ -12,54 +12,101 @@ export class DaemonClient {
     explicitSocketPath;
     requestCounter = 0;
     sessionId;
-    daemonSpawnAttempted = false;
+    /** Epoch ms of the last daemon auto-spawn attempt. Cooldown-gated rather than
+     *  one-shot so a long-lived HTTP MCP server (the autonomous Codex supervisor)
+     *  can resurrect the daemon repeatedly when VS Code is closed and the daemon
+     *  exits — not only on the first connection of its lifetime. */
+    lastSpawnAttemptMs = 0;
     static MAX_RETRIES = 3;
     static RETRY_DELAY_MS = 1500;
+    static SPAWN_COOLDOWN_MS = 10_000;
     static RETRYABLE_CODES = ["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE"];
-    constructor(socketPath, sessionId) {
+    /** Workspace root used to (re)spawn the daemon and, when no socket is
+     *  resolvable, to compute the expected socket/pipe path. Set by the HTTP
+     *  transport so a per-workspace request can resurrect *its* daemon even when
+     *  VEXP_WORKSPACE is not in the supervisor's env. */
+    spawnWorkspaceRoot;
+    constructor(socketPath, sessionId, spawnWorkspaceRoot) {
         // 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();
+        this.spawnWorkspaceRoot = spawnWorkspaceRoot;
     }
     /**
-     * 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.
+     * On a connection failure, attempt to start the daemon (idempotent lato
+     * Rust). Cooldown-gated so a long-lived HTTP MCP server keeps the workspace
+     * daemon alive without VS Code: when the daemon dies, the next request that
+     * fails re-spawns it (after SPAWN_COOLDOWN_MS). Silent: success = next retry
+     * connects; failure = the ordinary retry/error path surfaces a clear error
+     * with the registry candidates and the daemon log tail. Disable via
+     * VEXP_NO_AUTOSTART=1.
      */
     async maybeSpawnDaemon() {
-        if (this.daemonSpawnAttempted)
+        const now = Date.now();
+        if (now - this.lastSpawnAttemptMs < DaemonClient.SPAWN_COOLDOWN_MS)
             return;
-        this.daemonSpawnAttempted = true;
+        this.lastSpawnAttemptMs = now;
         if (process.env.VEXP_NO_AUTOSTART === "1")
             return;
-        const workspaceRoot = process.env.VEXP_WORKSPACE ?? discoverWorkspaceRoot();
+        const workspaceRoot = this.spawnWorkspaceRoot ?? 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) => {
+            // Propagate workspace + home so the spawned daemon resolves the right
+            // index and license dir even when the MCP server was launched from an
+            // unrelated cwd / a stripped env (e.g. the detached HTTP supervisor).
+            const env = binaryEnvFor(binary);
+            env.VEXP_WORKSPACE = workspaceRoot;
             const child = spawn(binary, ["daemon-cmd", "start"], {
                 cwd: workspaceRoot,
                 stdio: "ignore",
                 detached: true,
-                env: binaryEnvFor(binary),
+                env,
             });
-            const done = () => { resolve(); };
+            // Detach: the daemon (a grandchild of daemon-cmd) must outlive us.
+            child.unref();
+            let settled = false;
+            const done = () => { if (!settled) {
+                settled = true;
+                resolve();
+            } };
             child.on("exit", done);
             child.on("error", done);
-            // Cap total wait at 4s: Rust daemon-cmd itself waits 2s for socket.
+            // Cap total wait at 4s: Rust daemon-cmd itself waits ~2s for the socket.
             setTimeout(done, 4000);
         });
     }
+    /** Tail of the daemon log files, for actionable connection errors. */
+    daemonLogTail(maxLines = 12) {
+        const workspaceRoot = this.spawnWorkspaceRoot ?? process.env.VEXP_WORKSPACE ?? discoverWorkspaceRoot();
+        for (const name of ["daemon.log", "vexp.log"]) {
+            try {
+                const p = path.join(workspaceRoot, ".vexp", name);
+                const lines = fs.readFileSync(p, "utf-8").trimEnd().split("\n");
+                if (lines.length && lines.some((l) => l.trim())) {
+                    return `\n--- ${name} (last ${Math.min(maxLines, lines.length)} lines) ---\n` +
+                        lines.slice(-maxLines).join("\n");
+                }
+            }
+            catch { /* missing */ }
+        }
+        return "";
+    }
     /** Resolve socket path at request time to survive daemon restarts. */
     get socketPath() {
         if (this.explicitSocketPath)
             return this.explicitSocketPath;
+        // HTTP per-workspace client: target this workspace's deterministic socket
+        // so a freshly respawned daemon is reconnected even if the registry was
+        // stale/missing when the request arrived.
+        if (this.spawnWorkspaceRoot)
+            return socketPathForWorkspace(this.spawnWorkspaceRoot);
         return resolveDaemonSocket() ?? getDefaultSocketPath();
     }
     static isRetryableError(err) {
@@ -78,8 +125,8 @@ 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.
+                    // On the first failure, (re)start the daemon (cooldown-gated so a
+                    // long-lived supervisor can resurrect it whenever it dies).
                     if (attempt === 0) {
                         await this.maybeSpawnDaemon();
                     }
@@ -89,10 +136,21 @@ export class DaemonClient {
                     await new Promise((r) => setTimeout(r, DaemonClient.RETRY_DELAY_MS));
                     continue;
                 }
-                throw lastError;
+                throw this.augmentDaemonError(lastError);
             }
         }
-        throw lastError;
+        throw this.augmentDaemonError(lastError);
+    }
+    /** Append the daemon log tail to a connection error so a failure that
+     *  survived auto-spawn + retries is actionable instead of opaque. */
+    augmentDaemonError(err) {
+        if (!DaemonClient.isRetryableError(err))
+            return err;
+        const tail = this.daemonLogTail();
+        if (tail && !err.message.includes("--- daemon.log") && !err.message.includes("--- vexp.log")) {
+            err.message += tail;
+        }
+        return err;
     }
     /**
      * Call a tool with streaming support. Returns the final result.
@@ -505,6 +563,42 @@ export function resolveSocketByWorkspaceHash(hashPrefix) {
     }
     return null;
 }
+/**
+ * Reverse lookup: hash prefix -> workspace root, from `~/.vexp/daemons.json`.
+ *
+ * Unlike resolveSocketByWorkspaceHash this does NOT require the socket to be
+ * live — it returns the workspace even for a crashed daemon whose stale
+ * registry entry survived (the common "VS Code closed, daemon child killed"
+ * case). The HTTP transport uses it to (re)spawn the *correct* workspace
+ * daemon on demand. fnvHash is one-way, so a gracefully-deregistered daemon
+ * (entry removed) is unrecoverable from the hash alone — returns null.
+ */
+export function resolveWorkspaceByHash(hashPrefix) {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    if (!home)
+        return null;
+    let registry;
+    try {
+        registry = JSON.parse(fs.readFileSync(path.join(home, ".vexp", "daemons.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    const target = hashPrefix.toLowerCase();
+    for (const ws of Object.keys(registry)) {
+        if (fnvHash(ws.toLowerCase()).slice(0, 8) === target)
+            return ws;
+    }
+    return null;
+}
+/** Deterministic socket/pipe path for a workspace root — mirrors the Rust
+ *  daemon's get_socket_path (vexp-core/src/utils.rs). */
+function socketPathForWorkspace(ws) {
+    if (process.platform === "win32") {
+        return `\\\\.\\pipe\\vexp-${fnvHash(ws.toLowerCase()).slice(0, 8)}`;
+    }
+    return path.join(ws, ".vexp", "daemon.sock");
+}
 /** Human-friendly hint printed when a connection attempt fails — enumerates
  *  what we tried to make the failure actionable instead of misleading. */
 function daemonRunHint() {

package/dist/index.js

@@ -7,7 +7,7 @@ import { createServer } from "http";
 import { randomUUID } from "crypto";
 import fs from "fs";
 import path from "path";
-import { DaemonClient, resolveSocketByWorkspaceHash } from "./daemon-client.js";
+import { DaemonClient, resolveSocketByWorkspaceHash, resolveWorkspaceByHash } from "./daemon-client.js";
 import { GET_CONTEXT_CAPSULE_DEFINITION, handleGetContextCapsule, } from "./tools/get-context-capsule.js";
 import { GET_IMPACT_GRAPH_DEFINITION, handleGetImpactGraph, } from "./tools/get-impact-graph.js";
 import { SEARCH_LOGIC_FLOW_DEFINITION, handleSearchLogicFlow, } from "./tools/search-logic-flow.js";
@@ -228,14 +228,20 @@ async function startHttp(fallbackDaemon, port) {
     app.all("/ws/:hash/mcp", async (req, res) => {
         const { hash } = req.params;
         const socketPath = resolveSocketByWorkspaceHash(hash);
-        if (!socketPath) {
+        // Recover the workspace root from the registry even when the daemon is
+        // dead (stale entry survives a crash / VS Code close) so we can resurrect
+        // *that* workspace's daemon on demand — the autonomous supervisor.
+        const workspaceRoot = resolveWorkspaceByHash(hash);
+        if (!socketPath && !workspaceRoot) {
             res.status(503).json({
                 error: "NoDaemon",
-                message: `No running daemon matches workspace hash ${hash}. Run 'vexp setup' or 'vexp daemon-cmd start' in the project.`,
+                message: `No daemon and no known workspace for hash ${hash}. Run 'vexp setup' or 'vexp daemon-cmd start' in the project.`,
             });
             return;
         }
-        const daemon = new DaemonClient(socketPath);
+        // Pass the workspace so DaemonClient targets the right socket and, on a
+        // connection failure, (re)spawns the daemon for this workspace.
+        const daemon = new DaemonClient(socketPath ?? undefined, undefined, workspaceRoot ?? undefined);
         await handleMcpRequest(req, res, hash, daemon);
     });
     // Legacy route — kept for backward compat. Uses the fallback daemon,

package/package.json

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