vexp-cli 2.0.4 → 2.0.6

package/dist/cli.js

@@ -5,8 +5,9 @@ import ora from "ora";
 import { spawn, spawnSync, execFileSync } from "child_process";
 import * as path from "path";
 import * as fs from "fs";
+import * as net from "net";
 import { checkbox } from "@inquirer/prompts";
-import { getBinaryPath, getInstalledVersion, getMcpServerPath } from "./binary.js";
+import { getBinaryPath, getInstalledVersion, getMcpServerPath, binaryEnv } from "./binary.js";
 import { detectAgents, getAgentList, configureSelectedAgents } from "./agent-config.js";
 import { CLI_VERSION } from "./version.js";
 import { activateLicense, deactivateLicense, readLicenseLimits, readDeviceBlocked, } from "./license.js";
@@ -17,6 +18,34 @@ program
     .description("Vexp — Graph-RAG context engine for AI coding agents")
     .version(CLI_VERSION);
 // ────────────────────────────────────────────────────
+// Auto-start daemon before any action that needs it
+// ────────────────────────────────────────────────────
+//
+// Commands that either manage the daemon themselves (setup, daemon-cmd)
+// or don't need it (license, version, activate, deactivate) are skipped.
+// Everything else triggers a lightweight probe + silent spawn if the
+// workspace was already configured (marker: .vexp/manifest.json).
+const AUTOSTART_SKIP = new Set([
+    "setup", "daemon-cmd", "activate", "deactivate", "license", "version",
+]);
+program.hook("preAction", async (_thisCmd, actionCmd) => {
+    if (process.env.VEXP_NO_AUTOSTART === "1")
+        return;
+    if (AUTOSTART_SKIP.has(actionCmd.name()))
+        return;
+    const workspaceRoot = findConfiguredWorkspace();
+    if (!workspaceRoot)
+        return;
+    let binaryPath;
+    try {
+        binaryPath = getBinaryPath();
+    }
+    catch {
+        return;
+    }
+    await ensureDaemonRunning(workspaceRoot, binaryPath);
+});
+// ────────────────────────────────────────────────────
 // Resolve the platform binary (no network — bundled via npm)
 // ────────────────────────────────────────────────────
 function ensureBinary() {
@@ -34,7 +63,7 @@ let replMode = false;
 function runBinary(binaryPath, args) {
     if (replMode) {
         // In REPL mode, run synchronously and don't exit the process
-        const result = spawnSync(binaryPath, args, { stdio: "inherit" });
+        const result = spawnSync(binaryPath, args, { stdio: "inherit", env: binaryEnv(binaryPath) });
         if (result.error) {
             console.error(chalk.red(`Error: ${result.error.message}`));
         }
@@ -42,6 +71,7 @@ function runBinary(binaryPath, args) {
     }
     const child = spawn(binaryPath, args, {
         stdio: "inherit",
+        env: binaryEnv(binaryPath),
     });
     child.on("exit", (code) => {
         process.exit(code ?? 0);
@@ -56,6 +86,8 @@ function runBinaryAsync(binaryPath, args, options) {
     return new Promise((resolve, reject) => {
         const child = spawn(binaryPath, args, {
             stdio: options?.silent ? "pipe" : "inherit",
+            cwd: options?.cwd,
+            env: binaryEnv(binaryPath),
         });
         child.on("exit", (code) => {
             if (code === 0)
@@ -67,6 +99,160 @@ function runBinaryAsync(binaryPath, args, options) {
     });
 }
 // ────────────────────────────────────────────────────
+// Background services (daemon + MCP HTTP bridge)
+// ────────────────────────────────────────────────────
+/**
+ * Walk up from cwd looking for `.vexp/manifest.json` — the marker that
+ * `vexp setup` has been run on this tree. Returns null if none found.
+ */
+function findConfiguredWorkspace(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, ".vexp", "manifest.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+/** Quick TCP probe — true if something is already listening on 127.0.0.1:port. */
+function isPortInUse(port) {
+    return new Promise((resolve) => {
+        const sock = net.createConnection({ port, host: "127.0.0.1" });
+        const timer = setTimeout(() => { sock.destroy(); resolve(false); }, 300);
+        sock.on("connect", () => { clearTimeout(timer); sock.destroy(); resolve(true); });
+        sock.on("error", () => { clearTimeout(timer); resolve(false); });
+    });
+}
+/** True if the Unix socket at `socketPath` accepts a connection within `timeoutMs`. */
+function isSocketAlive(socketPath, timeoutMs = 300) {
+    return new Promise((resolve) => {
+        if (!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); });
+    });
+}
+/** Check if the PID recorded in .vexp/daemon.pid is a live process. */
+function isDaemonPidAlive(workspaceRoot) {
+    const pidFile = path.join(workspaceRoot, ".vexp", "daemon.pid");
+    try {
+        const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+        if (!pid || isNaN(pid))
+            return { alive: false };
+        try {
+            process.kill(pid, 0); // signal 0 = existence check, no actual signal
+            return { alive: true, pid };
+        }
+        catch {
+            return { alive: false };
+        }
+    }
+    catch {
+        return { alive: false };
+    }
+}
+/**
+ * Ensure the vexp-core daemon is running for the given workspace. Fast when
+ * it's already up (single socket probe). Idempotent lato Rust (PID file
+ * check + `kill -0`), so re-invoking when up is a no-op.
+ *
+ * Silent on success. On failure prints a one-liner pointing at the log.
+ * Honors VEXP_NO_AUTOSTART=1 as opt-out.
+ */
+async function ensureDaemonRunning(workspaceRoot, binaryPath) {
+    if (process.env.VEXP_NO_AUTOSTART === "1")
+        return;
+    const socketPath = path.join(workspaceRoot, ".vexp", "daemon.sock");
+    if (await isSocketAlive(socketPath))
+        return;
+    try {
+        await runBinaryAsync(binaryPath, ["daemon-cmd", "start"], {
+            silent: true,
+            cwd: workspaceRoot,
+        });
+    }
+    catch {
+        const logPath = path.join(workspaceRoot, ".vexp", "daemon.log");
+        console.error(chalk.yellow(`  ⚠ Could not auto-start vexp daemon — see ${logPath}`));
+    }
+}
+/**
+ * Start the vexp daemon and MCP HTTP server in the background.
+ * Used by both the non-interactive `setup` command and the REPL setup flow.
+ * Both services detach via setsid (Rust) / Node detached+unref, so they
+ * survive terminal close and VSCode restart.
+ */
+async function startBackgroundServices(binaryPath, workspaceRoot) {
+    // Start daemon
+    const spinnerDaemon = ora("Starting vexp daemon...").start();
+    try {
+        await runBinaryAsync(binaryPath, ["daemon-cmd", "start"], { silent: true, cwd: workspaceRoot });
+        const socketPath = path.join(workspaceRoot, ".vexp", "daemon.sock");
+        if (fs.existsSync(socketPath)) {
+            spinnerDaemon.succeed("vexp daemon started");
+        }
+        else {
+            const logPath = path.join(workspaceRoot, ".vexp", "daemon.log");
+            spinnerDaemon.warn(`Daemon socket not ready — check ${logPath}`);
+        }
+    }
+    catch {
+        spinnerDaemon.warn("Daemon already running or failed to start (non-fatal)");
+    }
+    // Start MCP HTTP server (needed for Codex and HTTP-based agents).
+    // Detect collisions: VS Code plugin may have already bound :7821.
+    const mcpPath = getMcpServerPath();
+    if (mcpPath) {
+        const spinnerMcp = ora("Starting MCP HTTP server...").start();
+        if (await isPortInUse(7821)) {
+            spinnerMcp.succeed("MCP HTTP server already running on port 7821");
+        }
+        else {
+            try {
+                const { randomUUID } = await import("crypto");
+                const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+                let mcpToken = "";
+                const tokenPath = home ? path.join(home, ".vexp", "mcp.token") : "";
+                if (tokenPath) {
+                    try {
+                        mcpToken = fs.readFileSync(tokenPath, "utf-8").trim();
+                    }
+                    catch { }
+                }
+                if (!mcpToken) {
+                    mcpToken = randomUUID();
+                    if (tokenPath) {
+                        fs.mkdirSync(path.dirname(tokenPath), { recursive: true });
+                        fs.writeFileSync(tokenPath, mcpToken, { mode: 0o600 });
+                    }
+                }
+                const mcpChild = spawn("node", [mcpPath, "--http", "--port=7821"], {
+                    detached: true,
+                    stdio: "ignore",
+                    env: {
+                        ...process.env,
+                        VEXP_WORKSPACE: workspaceRoot,
+                        VEXP_HTTP: "1",
+                        VEXP_PORT: "7821",
+                        VEXP_MCP_TOKEN: mcpToken,
+                    },
+                });
+                mcpChild.unref();
+                spinnerMcp.succeed("MCP HTTP server started (port 7821)");
+            }
+            catch {
+                spinnerMcp.warn("MCP HTTP server failed to start (non-fatal)");
+            }
+        }
+    }
+}
+// ────────────────────────────────────────────────────
 // Commands
 // ────────────────────────────────────────────────────
 program
@@ -185,7 +371,7 @@ program
 });
 program
     .command("compress <file>")
-    .description("Compress a markdown/text file using caveman-style prose compression (backup to <name>.original.md)")
+    .description("Compress a markdown/text file using prose compression (backup to <name>.original.md)")
     .option("--level <lvl>", "Compression level: off | lite | full | ultra", "full")
     .action(async (file, opts) => {
     const binaryPath = ensureBinary();
@@ -307,55 +493,8 @@ program
     else {
         console.log(chalk.dim("  Skipping indexing (--no-index)"));
     }
-    // Step 2.5: Start daemon in background (survives terminal close)
-    const spinnerDaemon = ora("Starting vexp daemon...").start();
-    try {
-        await runBinaryAsync(binaryPath, ["daemon-cmd", "start"], { silent: true });
-        spinnerDaemon.succeed("vexp daemon started");
-    }
-    catch {
-        spinnerDaemon.warn("Daemon already running or failed to start (non-fatal)");
-    }
-    // Step 2.6: Start MCP HTTP server (needed for Codex and HTTP-based agents)
-    const mcpPath = getMcpServerPath();
-    if (mcpPath) {
-        const spinnerMcp = ora("Starting MCP HTTP server...").start();
-        try {
-            const { randomUUID } = await import("crypto");
-            const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-            let mcpToken = "";
-            const tokenPath = home ? path.join(home, ".vexp", "mcp.token") : "";
-            if (tokenPath) {
-                try {
-                    mcpToken = fs.readFileSync(tokenPath, "utf-8").trim();
-                }
-                catch { }
-            }
-            if (!mcpToken) {
-                mcpToken = randomUUID();
-                if (tokenPath) {
-                    fs.mkdirSync(path.dirname(tokenPath), { recursive: true });
-                    fs.writeFileSync(tokenPath, mcpToken, { mode: 0o600 });
-                }
-            }
-            const mcpChild = spawn("node", [mcpPath, "--http", "--port=7821"], {
-                detached: true,
-                stdio: "ignore",
-                env: {
-                    ...process.env,
-                    VEXP_WORKSPACE: workspaceRoot,
-                    VEXP_HTTP: "1",
-                    VEXP_PORT: "7821",
-                    VEXP_MCP_TOKEN: mcpToken,
-                },
-            });
-            mcpChild.unref();
-            spinnerMcp.succeed("MCP HTTP server started (port 7821)");
-        }
-        catch {
-            spinnerMcp.warn("MCP HTTP server failed to start (non-fatal)");
-        }
-    }
+    // Step 2.5: Start daemon + MCP HTTP server (survive terminal close)
+    await startBackgroundServices(binaryPath, workspaceRoot);
     // In personal mode, make .vexp/ fully gitignored
     if (isPersonal) {
         const vexpGitignore = path.join(workspaceRoot, ".vexp", ".gitignore");
@@ -530,6 +669,8 @@ async function runSetupInteractive(rl) {
     // Step 1: Index
     console.log(chalk.dim("  Indexing codebase...\n"));
     runBinary(binaryPath, ["init", workspaceRoot]);
+    // Step 1.5: Start daemon + MCP HTTP server (parity with non-interactive setup)
+    await startBackgroundServices(binaryPath, workspaceRoot);
     // Step 2: Select agents
     const allAgents = getAgentList();
     const detected = detectAgents(workspaceRoot);
@@ -671,6 +812,21 @@ const MENU_LICENSE = [
     { key: "2", label: "activate", hint: "Activate a Pro/Team license key", description: "Enter a license key to unlock Pro or Team features.\n    Get your key at https://vexp.dev/#pricing" },
     { key: "3", label: "deactivate", hint: "Remove current license", description: "Removes the active license. Free plan limits will apply." },
 ];
+/** Format a duration as a compact uptime string (e.g. "2h 14m", "47s"). */
+function formatUptime(seconds) {
+    if (seconds < 60)
+        return `${Math.floor(seconds)}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+    return `${Math.floor(seconds / 86400)}d ${Math.floor((seconds % 86400) / 3600)}h`;
+}
+/** Format a workspace path for display: shorten $HOME → ~. */
+function shortPath(p) {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    return home && p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
 function printBanner() {
     const version = CLI_VERSION;
     console.log("");
@@ -682,21 +838,52 @@ function printBanner() {
     console.log(chalk.dim("    ╚═══╝  ╚══════╝╚═╝  ╚═╝╚═╝") + chalk.dim(`  v${version}`));
     console.log("");
     console.log(chalk.dim("  Context Engine for AI Coding Agents"));
-    // One-liner LLM status
+    console.log("");
+    // ── Daemon status line (3 states, symmetric to LLM) ──
+    const ws = findConfiguredWorkspace();
+    if (!ws) {
+        console.log(chalk.dim("  ○ Daemon: no workspace configured here"));
+        console.log(chalk.dim("    → type '1 > 3' to run full setup, or `vexp setup`"));
+    }
+    else {
+        const { alive, pid } = isDaemonPidAlive(ws);
+        if (alive && pid) {
+            // Derive uptime from daemon.pid mtime (portable, no /proc parsing).
+            let uptime = "";
+            try {
+                const st = fs.statSync(path.join(ws, ".vexp", "daemon.pid"));
+                uptime = `, uptime ${formatUptime((Date.now() - st.mtimeMs) / 1000)}`;
+            }
+            catch { /* non-fatal */ }
+            console.log(chalk.green(`  ● Daemon: running (PID ${pid}${uptime}) — ${shortPath(ws)}`));
+        }
+        else {
+            console.log(chalk.yellow("  ○ Daemon: not running"));
+            console.log(chalk.dim("    → type '1 > 5 > start' to launch it, or `vexp daemon-cmd start`"));
+        }
+    }
+    // ── LLM status line (3 states: active / installed-not-active / not installed) ──
     try {
         const llmBin = ensureBinary();
         const stdout = execFileSync(llmBin, ["setup-llm", "--status"], {
             timeout: 5000,
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"],
+            env: binaryEnv(llmBin),
         });
-        const operational = /Operational:\s*true/.test(stdout);
+        const operational = /Operational:\s*true/i.test(stdout);
+        const installed = /Installed:\s*true/i.test(stdout);
         const model = stdout.match(/Model:\s*(.+)/)?.[1]?.trim() ?? "";
         if (operational) {
-            console.log(chalk.green(`  ● LLM: ${model} (active)`));
+            console.log(chalk.green(`  ● LLM: ${model || "local"} (active)`));
+        }
+        else if (installed) {
+            console.log(chalk.yellow("  ○ LLM: installed but not active"));
+            console.log(chalk.dim("    → type '1 > 6 > start' to start it, or `vexp setup-llm --start`"));
         }
         else {
-            console.log(chalk.dim("  ○ LLM: not configured — type 'setup-llm' or press 1 > 6"));
+            console.log(chalk.dim("  ○ LLM: not installed"));
+            console.log(chalk.dim("    → type '1 > 6 > install' to download (~3.5 GB), or `vexp setup-llm --install`"));
         }
     }
     catch {
@@ -727,6 +914,17 @@ function ask(rl, prompt) {
 }
 async function interactiveMode() {
     const readline = await import("readline");
+    // Auto-start the daemon (if workspace configured) before printing the
+    // banner, so the banner's Daemon line reflects the correct final state.
+    // Silent when already running or no workspace configured.
+    const workspaceRoot = findConfiguredWorkspace();
+    if (workspaceRoot) {
+        try {
+            const binaryPath = getBinaryPath();
+            await ensureDaemonRunning(workspaceRoot, binaryPath);
+        }
+        catch { /* banner will reflect actual state */ }
+    }
     printBanner();
     printMainMenu();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });