vexp-cli 2.0.11 → 2.0.13

package/dist/mcp-supervisor.js

@@ -0,0 +1,235 @@
+import * as fs from "fs";
+import * as net from "net";
+import * as os from "os";
+import * as path from "path";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { getMcpServerPath } from "./binary.js";
+const DEFAULT_PORT = 7821;
+function pidFilePath() {
+    const home = os.homedir();
+    return path.join(home, ".vexp", "mcp.pid");
+}
+function tokenFilePath() {
+    const home = os.homedir();
+    return path.join(home, ".vexp", "mcp.token");
+}
+function readPidRecord() {
+    try {
+        const raw = fs.readFileSync(pidFilePath(), "utf-8");
+        const rec = JSON.parse(raw);
+        if (typeof rec.pid === "number" && typeof rec.port === "number") {
+            return {
+                pid: rec.pid,
+                port: rec.port,
+                startedAt: rec.startedAt ?? 0,
+                owner: rec.owner ?? "unknown",
+            };
+        }
+    }
+    catch {
+        /* missing or malformed */
+    }
+    return null;
+}
+function writePidRecord(rec) {
+    const p = pidFilePath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(rec, null, 2), { mode: 0o600 });
+}
+function removePidFile() {
+    try {
+        fs.unlinkSync(pidFilePath());
+    }
+    catch { /* already gone */ }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPortInUse(port, timeoutMs = 300) {
+    return new Promise((resolve) => {
+        const sock = net.createConnection({ port, host: "127.0.0.1" });
+        const timer = setTimeout(() => { sock.destroy(); resolve(false); }, timeoutMs);
+        sock.on("connect", () => { clearTimeout(timer); sock.destroy(); resolve(true); });
+        sock.on("error", () => { clearTimeout(timer); resolve(false); });
+    });
+}
+export function resolveOrGenerateMcpToken() {
+    const p = tokenFilePath();
+    try {
+        const existing = fs.readFileSync(p, "utf-8").trim();
+        if (existing)
+            return existing;
+    }
+    catch { /* missing */ }
+    const token = randomUUID();
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, token, { mode: 0o600 });
+    }
+    catch { /* non-fatal */ }
+    return token;
+}
+/**
+ * Ensure exactly one vexp-mcp HTTP server is running, tracked via
+ * `~/.vexp/mcp.pid`. Shared between CLI, VS Code plugin, and `vexp serve`
+ * so that stop/start cycles, multiple VS Code windows, and the login
+ * supervisor never duplicate the process.
+ *
+ * Returns the current (alive) PID whether it was reused or freshly
+ * spawned. Sets `started=true` only on fresh spawn.
+ *
+ * The MCP server is deliberately workspace-agnostic: clients disambiguate
+ * via URL path /ws/<workspaceHash>/mcp. No VEXP_WORKSPACE env is passed.
+ */
+export async function ensureMcpHttpServer(opts = {}) {
+    const port = opts.port ?? DEFAULT_PORT;
+    const owner = opts.owner ?? "unknown";
+    const token = opts.token ?? resolveOrGenerateMcpToken();
+    const mcpPath = getMcpServerPath();
+    if (!mcpPath)
+        return null;
+    // Fast path: already alive and tracked.
+    {
+        const existing = readPidRecord();
+        if (existing && existing.port === port && isPidAlive(existing.pid) && (await isPortInUse(port))) {
+            return { pid: existing.pid, port, started: false };
+        }
+    }
+    // Slow path: we may need to spawn. Serialize across concurrent callers
+    // in the SAME process (CLI REPL race) AND across processes (plugin +
+    // CLI running in parallel). Atomic mkdir on ~/.vexp/mcp.lock gives both.
+    const lockDir = path.join(os.homedir(), ".vexp", "mcp.lock");
+    fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+    let iHoldLock = false;
+    const deadline = Date.now() + 3000;
+    while (Date.now() < deadline) {
+        try {
+            fs.mkdirSync(lockDir); // atomic; fails EEXIST if someone else is spawning
+            iHoldLock = true;
+            break;
+        }
+        catch {
+            // Someone else is spawning. Re-probe — if they finish quickly we can
+            // just reuse their result without ever acquiring the lock.
+            await new Promise((r) => setTimeout(r, 100));
+            const rec = readPidRecord();
+            if (rec && rec.port === port && isPidAlive(rec.pid) && (await isPortInUse(port))) {
+                return { pid: rec.pid, port, started: false };
+            }
+        }
+    }
+    if (!iHoldLock) {
+        // Lock dir is stuck (likely from a crashed process that didn't clean
+        // up). Force-break and retry once.
+        try {
+            fs.rmdirSync(lockDir);
+        }
+        catch { /* not ours to break */ }
+        try {
+            fs.mkdirSync(lockDir);
+            iHoldLock = true;
+        }
+        catch { /* give up */ }
+    }
+    try {
+        // Double-check under the lock — another holder may have just spawned.
+        const existing = readPidRecord();
+        if (existing && existing.port === port && isPidAlive(existing.pid) && (await isPortInUse(port))) {
+            return { pid: existing.pid, port, started: false };
+        }
+        if (existing)
+            removePidFile();
+        // Non-tracked process already bound to :port — don't clobber.
+        if (await isPortInUse(port)) {
+            return { pid: -1, port, started: false };
+        }
+        const child = spawn("node", [mcpPath, "--http", `--port=${port}`], {
+            detached: true,
+            stdio: "ignore",
+            env: {
+                ...process.env,
+                VEXP_HTTP: "1",
+                VEXP_PORT: String(port),
+                VEXP_MCP_TOKEN: token,
+            },
+        });
+        child.unref();
+        const pid = child.pid;
+        if (!pid)
+            return null;
+        writePidRecord({ pid, port, startedAt: Date.now(), owner });
+        // Wait for the child to actually bind the port BEFORE releasing the
+        // lock. Without this, a second caller arriving right after release
+        // sees pidfile+live-pid but port-not-yet-bound → falsely concludes
+        // the spawn failed and starts another one. Cap at 3s; if it takes
+        // longer, caller logic will re-probe or surface the error downstream.
+        const bindDeadline = Date.now() + 3000;
+        while (Date.now() < bindDeadline) {
+            if (await isPortInUse(port))
+                break;
+            if (!isPidAlive(pid))
+                break; // child died — stop waiting
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        return { pid, port, started: true };
+    }
+    finally {
+        if (iHoldLock) {
+            try {
+                fs.rmdirSync(lockDir);
+            }
+            catch { /* best effort */ }
+        }
+    }
+}
+/**
+ * Stop the vexp-mcp HTTP server.
+ *
+ * If `expectedOwner` is set, only stop if the running process was started
+ * by that owner — prevents a plugin instance from killing a `vexp serve`
+ * supervisor's MCP process. Pass no owner to force-stop regardless.
+ */
+export async function stopMcpHttpServer(expectedOwner) {
+    const rec = readPidRecord();
+    if (!rec)
+        return false;
+    if (expectedOwner && rec.owner !== expectedOwner && rec.owner !== "unknown") {
+        return false;
+    }
+    if (!isPidAlive(rec.pid)) {
+        removePidFile();
+        return false;
+    }
+    try {
+        process.kill(rec.pid, "SIGTERM");
+    }
+    catch { /* already dead */ }
+    const deadline = Date.now() + 2000;
+    while (Date.now() < deadline) {
+        if (!isPidAlive(rec.pid))
+            break;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    if (isPidAlive(rec.pid)) {
+        try {
+            process.kill(rec.pid, "SIGKILL");
+        }
+        catch { /* gone */ }
+    }
+    removePidFile();
+    return true;
+}
+export function mcpHttpStatus() {
+    const rec = readPidRecord();
+    if (rec && isPidAlive(rec.pid)) {
+        return { running: true, pid: rec.pid, port: rec.port, owner: rec.owner };
+    }
+    return { running: false };
+}

package/dist/serve.js

@@ -0,0 +1,160 @@
+import * as fs from "fs";
+import * as net from "net";
+import * as os from "os";
+import * as path from "path";
+import { spawn } from "child_process";
+import { getBinaryPath, binaryEnv } from "./binary.js";
+import { ensureMcpHttpServer } from "./mcp-supervisor.js";
+const HEALTH_INTERVAL_MS = 60_000;
+const DEFAULT_MCP_PORT = 7821;
+function registryPath() {
+    return path.join(os.homedir(), ".vexp", "daemons.json");
+}
+function autostartLogPath() {
+    return path.join(os.homedir(), ".vexp", "autostart.log");
+}
+function readRegistry() {
+    try {
+        return JSON.parse(fs.readFileSync(registryPath(), "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeRegistry(reg) {
+    const p = registryPath();
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(reg, null, 2), "utf-8");
+    }
+    catch { /* non-fatal */ }
+}
+function isSocketAlive(socketPath, timeoutMs = 300) {
+    return new Promise((resolve) => {
+        if (process.platform !== "win32" && !fs.existsSync(socketPath)) {
+            resolve(false);
+            return;
+        }
+        const sock = net.createConnection({ path: socketPath });
+        const timer = setTimeout(() => { sock.destroy(); resolve(false); }, timeoutMs);
+        sock.on("connect", () => { clearTimeout(timer); sock.destroy(); resolve(true); });
+        sock.on("error", () => { clearTimeout(timer); resolve(false); });
+    });
+}
+function appendLog(line) {
+    const stamped = `[${new Date().toISOString()}] ${line}\n`;
+    try {
+        fs.mkdirSync(path.dirname(autostartLogPath()), { recursive: true });
+        fs.appendFileSync(autostartLogPath(), stamped);
+    }
+    catch { /* non-fatal */ }
+    process.stderr.write(stamped);
+}
+function rotateLogIfLarge() {
+    const p = autostartLogPath();
+    try {
+        const st = fs.statSync(p);
+        if (st.size > 2 * 1024 * 1024) {
+            fs.renameSync(p, p + ".old");
+        }
+    }
+    catch { /* missing */ }
+}
+async function resurrectDaemon(workspaceRoot, socketPath) {
+    const manifest = path.join(workspaceRoot, ".vexp", "manifest.json");
+    if (!fs.existsSync(manifest))
+        return false;
+    if (await isSocketAlive(socketPath))
+        return true;
+    let binary;
+    try {
+        binary = getBinaryPath();
+    }
+    catch (err) {
+        appendLog(`daemon ${workspaceRoot}: no vexp-core binary (${err instanceof Error ? err.message : err})`);
+        return false;
+    }
+    try {
+        const child = spawn(binary, ["daemon", "--workspace", workspaceRoot, "--socket", socketPath], {
+            detached: true,
+            stdio: "ignore",
+            env: binaryEnv(binary),
+        });
+        child.unref();
+        appendLog(`daemon spawned: ${workspaceRoot} (pid=${child.pid})`);
+        return true;
+    }
+    catch (err) {
+        appendLog(`daemon spawn failed for ${workspaceRoot}: ${err instanceof Error ? err.message : err}`);
+        return false;
+    }
+}
+async function resurrectAll() {
+    const reg = readRegistry();
+    const live = {};
+    for (const [ws, sock] of Object.entries(reg)) {
+        const manifest = path.join(ws, ".vexp", "manifest.json");
+        if (!fs.existsSync(manifest)) {
+            appendLog(`registry prune: ${ws} (no manifest)`);
+            continue;
+        }
+        const ok = await resurrectDaemon(ws, sock);
+        if (ok)
+            live[ws] = sock;
+    }
+    writeRegistry(live);
+}
+async function startMcp() {
+    const port = parseInt(process.env.VEXP_PORT ?? String(DEFAULT_MCP_PORT), 10);
+    const result = await ensureMcpHttpServer({ port, owner: "serve" });
+    if (!result) {
+        appendLog(`MCP server: could not resolve mcp-server.cjs path`);
+        return;
+    }
+    if (result.pid === -1) {
+        appendLog(`MCP server: port ${port} already bound by an unknown process — leaving as-is`);
+        return;
+    }
+    appendLog(result.started
+        ? `MCP server started (pid=${result.pid}, port=${result.port})`
+        : `MCP server already running (pid=${result.pid}, port=${result.port})`);
+}
+async function healthLoop() {
+    while (true) {
+        await new Promise((r) => setTimeout(r, HEALTH_INTERVAL_MS));
+        rotateLogIfLarge();
+        try {
+            await resurrectAll();
+            await startMcp();
+        }
+        catch (err) {
+            appendLog(`health loop error: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+}
+/**
+ * Entry point for `vexp serve`. Long-running supervisor invoked by OS
+ * login autostart (LaunchAgent / systemd --user / Startup folder).
+ *
+ * Responsibilities:
+ *  1. Resurrect every daemon listed in ~/.vexp/daemons.json whose
+ *     workspace still has a .vexp/manifest.json (incremental reindex
+ *     happens inside the Rust daemon on startup).
+ *  2. Keep exactly one vexp-mcp HTTP server alive on :7821 via the
+ *     shared mcp.pid lock (mcp-supervisor).
+ *  3. Periodically re-check and re-spawn anything that died.
+ */
+export async function runServe() {
+    rotateLogIfLarge();
+    appendLog("vexp serve starting");
+    const shutdown = () => {
+        appendLog("vexp serve received shutdown signal");
+        process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    await resurrectAll();
+    await startMcp();
+    appendLog("vexp serve ready — entering health loop");
+    await healthLoop();
+}

package/dist/trace.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import * as os from "os";
+/** True when the CLI was launched with -i / --trace, or VEXP_TRACE=1. */
+export function isTraceEnabled() {
+    if (process.env.VEXP_TRACE === "1")
+        return true;
+    const argv = process.argv.slice(2);
+    return argv.includes("-i") || argv.includes("--trace");
+}
+/**
+ * Scrub potentially-sensitive data from a string before logging:
+ * - IPv4/IPv6 loopback/private addresses → <ip>
+ * - UUIDs (tokens) → <token>
+ * - Bearer values → <token>
+ * - User home path → ~
+ */
+export function redact(s) {
+    const home = os.homedir();
+    let out = s;
+    out = out.replace(/\b\d{1,3}(?:\.\d{1,3}){3}\b/g, "<ip>");
+    out = out.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<token>");
+    out = out.replace(/Bearer\s+[A-Za-z0-9._-]+/g, "Bearer <token>");
+    if (home && home.length > 1) {
+        const safe = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        out = out.replace(new RegExp(safe, "g"), "~");
+    }
+    return out;
+}
+function clock() {
+    const d = new Date();
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    const ss = String(d.getSeconds()).padStart(2, "0");
+    return `${hh}:${mm}:${ss}`;
+}
+export class Tracer {
+    enabled;
+    depth = 0;
+    constructor(enabled = isTraceEnabled()) {
+        this.enabled = enabled;
+    }
+    indent() {
+        return "  ".repeat(this.depth);
+    }
+    emit(sym, color, msg, extra) {
+        if (!this.enabled)
+            return;
+        const prefix = chalk.dim(`[${clock()}]`) + " " + this.indent() + color(sym);
+        const line = extra
+            ? `${prefix} ${redact(msg)} ${chalk.dim(extra)}`
+            : `${prefix} ${redact(msg)}`;
+        process.stderr.write(line + "\n");
+    }
+    info(msg) { this.emit("·", chalk.dim, msg); }
+    /**
+     * Execute `fn` bracketed by trace markers. Logs ✓ on success, ✗ on
+     * failure; rethrows so the caller's control flow is unchanged.
+     */
+    async step(name, fn) {
+        if (!this.enabled)
+            return await fn();
+        this.emit("▶", chalk.cyan, name);
+        this.depth++;
+        const start = Date.now();
+        try {
+            const out = await fn();
+            this.depth--;
+            this.emit("✓", chalk.green, name, `${Date.now() - start}ms`);
+            return out;
+        }
+        catch (err) {
+            this.depth--;
+            const msg = err instanceof Error ? err.message : String(err);
+            this.emit("✗", chalk.red, `${name} — ${redact(msg)}`, `${Date.now() - start}ms`);
+            throw err;
+        }
+    }
+}
+/** Shared tracer instance — cheap to re-create but convenient as a default. */
+export const tracer = new Tracer();