vexp-cli 2.0.11 → 2.0.13

package/dist/cli.js

@@ -12,11 +12,21 @@ import { detectAgents, getAgentList, configureSelectedAgents } from "./agent-con
 import { CLI_VERSION } from "./version.js";
 import { activateLicense, deactivateLicense, readLicenseLimits, readDeviceBlocked, } from "./license.js";
 import { checkForUpdate } from "./update-check.js";
+import { ensureMcpHttpServer, mcpHttpStatus } from "./mcp-supervisor.js";
+import { installAutostart, installAutostartIfNeeded, uninstallAutostart, autostartStatus } from "./autostart.js";
+import { runServe } from "./serve.js";
+import { isTraceEnabled } from "./trace.js";
 const program = new Command();
 program
     .name("vexp")
     .description("Vexp — Graph-RAG context engine for AI coding agents")
-    .version(CLI_VERSION);
+    .version(CLI_VERSION)
+    .option("-i, --trace", "Verbose trace mode: print every step with timing (IPs/tokens redacted)");
+// Propagate -i / --trace to spawned children via env var so subprocess
+// (daemon, MCP, serve) inherits the trace flag.
+if (isTraceEnabled()) {
+    process.env.VEXP_TRACE = "1";
+}
 // ────────────────────────────────────────────────────
 // Auto-start daemon before any action that needs it
 // ────────────────────────────────────────────────────
@@ -27,6 +37,7 @@ program
 // workspace was already configured (marker: .vexp/manifest.json).
 const AUTOSTART_SKIP = new Set([
     "setup", "daemon-cmd", "activate", "deactivate", "license", "version",
+    "serve", "autostart", "use",
 ]);
 program.hook("preAction", async (_thisCmd, actionCmd) => {
     if (process.env.VEXP_NO_AUTOSTART === "1")
@@ -43,7 +54,9 @@ program.hook("preAction", async (_thisCmd, actionCmd) => {
     catch {
         return;
     }
-    await ensureDaemonRunning(workspaceRoot, binaryPath);
+    // Full bootstrap: daemon + MCP + autostart-if-needed. All three steps are
+    // internally idempotent — no duplicate processes across invocations.
+    await ensureBootstrap(workspaceRoot, binaryPath);
 });
 // ────────────────────────────────────────────────────
 // Resolve the platform binary (no network — bundled via npm)
@@ -133,15 +146,6 @@ function findConfiguredWorkspace(startDir = process.cwd()) {
         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) => {
@@ -199,6 +203,33 @@ async function ensureDaemonRunning(workspaceRoot, binaryPath) {
         console.error(chalk.yellow(`  ⚠ Could not auto-start vexp daemon — see ${logPath}`));
     }
 }
+/**
+ * Full lazy bootstrap for any `vexp` invocation. Each step is already
+ * idempotent on its own — calling this from multiple places (preAction,
+ * REPL, setup) can never spawn duplicates:
+ *   - `ensureDaemonRunning`   → socket probe, skips spawn if alive
+ *   - `ensureMcpHttpServer`   → ~/.vexp/mcp.pid + port probe, no-op if live
+ *   - `installAutostartIfNeeded` → marker ~/.vexp/autostart-installed
+ *
+ * The point of this wrapper is to ensure users who upgraded via
+ * `npm update` and then just typed `vexp` (never re-running `setup`) still
+ * get: daemon up, MCP :7821 up, OS autostart installed for future reboots.
+ *
+ * Honors VEXP_NO_AUTOSTART=1 as a global bypass.
+ */
+async function ensureBootstrap(workspaceRoot, binaryPath) {
+    if (process.env.VEXP_NO_AUTOSTART === "1")
+        return;
+    await ensureDaemonRunning(workspaceRoot, binaryPath);
+    try {
+        await ensureMcpHttpServer({ owner: "cli" });
+    }
+    catch { /* non-fatal */ }
+    try {
+        installAutostartIfNeeded();
+    }
+    catch { /* non-fatal */ }
+}
 /**
  * Start the vexp daemon and MCP HTTP server in the background.
  * Used by both the non-interactive `setup` command and the REPL setup flow.
@@ -222,52 +253,28 @@ async function startBackgroundServices(binaryPath, workspaceRoot) {
     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");
+    // Start MCP HTTP server via the shared supervisor — singleton across
+    // CLI, VS Code plugin, and `vexp serve` (tracked by ~/.vexp/mcp.pid).
+    // Workspace-agnostic: routing is done via URL path /ws/<hash>/mcp.
+    const spinnerMcp = ora("Starting MCP HTTP server...").start();
+    try {
+        const result = await ensureMcpHttpServer({ owner: "cli" });
+        if (!result) {
+            spinnerMcp.warn("MCP HTTP server not available (missing mcp-server bundle)");
+        }
+        else if (result.pid === -1) {
+            spinnerMcp.warn(`Port ${result.port} already bound by an unknown process`);
+        }
+        else if (result.started) {
+            spinnerMcp.succeed(`MCP HTTP server started (pid=${result.pid}, port=${result.port})`);
         }
         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)");
-            }
+            spinnerMcp.succeed(`MCP HTTP server already running (pid=${result.pid}, port=${result.port})`);
         }
     }
+    catch (err) {
+        spinnerMcp.warn(`MCP HTTP server failed to start: ${err instanceof Error ? err.message : err}`);
+    }
 }
 // ────────────────────────────────────────────────────
 // Commands
@@ -602,6 +609,22 @@ program
             }
         }
     }
+    // Step 5: Install login autostart (per-user, no admin required)
+    if (process.env.VEXP_NO_AUTOSTART_INSTALL !== "1") {
+        const spinnerAuto = ora("Installing login autostart...").start();
+        try {
+            const r = installAutostart();
+            if (r.installed) {
+                spinnerAuto.succeed(`Login autostart installed (${r.mechanism})`);
+            }
+            else {
+                spinnerAuto.warn("Autostart not installed on this platform");
+            }
+        }
+        catch (err) {
+            spinnerAuto.warn(`Autostart install failed: ${err instanceof Error ? err.message : err}`);
+        }
+    }
     // Final summary
     console.log("");
     console.log(chalk.green.bold("✓ vexp setup complete!"));
@@ -743,6 +766,15 @@ async function runSetupInteractive(rl) {
         }
         console.log(chalk.green(`\n  ✓ Setup complete — ${result.agents.length} agent(s) configured\n`));
     }
+    // Login autostart — opt-out via env
+    if (process.env.VEXP_NO_AUTOSTART_INSTALL !== "1") {
+        try {
+            const r = installAutostart();
+            if (r.installed)
+                console.log(chalk.green(`  ✓ Login autostart installed (${r.mechanism})`));
+        }
+        catch { /* non-fatal */ }
+    }
 }
 // ────────────────────────────────────────────────────
 // License management
@@ -804,6 +836,80 @@ program
     console.log("");
 });
 // ────────────────────────────────────────────────────
+// Background supervisor + OS autostart
+// ────────────────────────────────────────────────────
+program
+    .command("serve")
+    .description("Run the login supervisor: resurrect known daemons + keep MCP HTTP alive (used by autostart)")
+    .action(async () => {
+    await runServe();
+});
+program
+    .command("autostart <action>")
+    .description("Manage login autostart: install | uninstall | status")
+    .action(async (action) => {
+    if (action === "install") {
+        const r = installAutostart();
+        if (r.installed) {
+            console.log(chalk.green(`✓ Autostart installed via ${r.mechanism}`));
+            if (r.path)
+                console.log(chalk.dim(`  ${r.path}`));
+        }
+        else {
+            console.log(chalk.yellow("⚠ Autostart not installed (unsupported platform or insufficient permissions)"));
+        }
+    }
+    else if (action === "uninstall") {
+        uninstallAutostart();
+        console.log(chalk.yellow("✓ Autostart removed (daemons already running are not killed)"));
+    }
+    else if (action === "status") {
+        const s = autostartStatus();
+        const mcp = mcpHttpStatus();
+        console.log(chalk.bold("\nvexp Autostart Status\n"));
+        if (s.installed) {
+            console.log(`  Installed: ${chalk.green("yes")} (${s.mechanism})`);
+            if (s.path)
+                console.log(`  Path:      ${s.path}`);
+        }
+        else {
+            console.log(`  Installed: ${chalk.dim("no")}`);
+        }
+        if (mcp.running) {
+            console.log(`  MCP:       ${chalk.green(`running pid=${mcp.pid} port=${mcp.port}`)} (${mcp.owner})`);
+        }
+        else {
+            console.log(`  MCP:       ${chalk.dim("not running")}`);
+        }
+        console.log("");
+    }
+    else {
+        console.error(chalk.red(`Unknown action: ${action}. Use install | uninstall | status`));
+        process.exit(1);
+    }
+});
+program
+    .command("use <workspacePath>")
+    .description("Switch codex (global MCP config) to point at a different configured workspace")
+    .action(async (workspacePath) => {
+    const resolved = path.resolve(workspacePath);
+    const manifest = path.join(resolved, ".vexp", "manifest.json");
+    if (!fs.existsSync(manifest)) {
+        console.error(chalk.red(`No .vexp/manifest.json at ${resolved}. Run 'vexp setup' there first.`));
+        process.exit(1);
+    }
+    const binaryPath = ensureBinary();
+    const mcpServerPath = getMcpServerPath();
+    // Import lazily so configureCodexGlobal's side effects (TOML rewrite + legacy cleanup) only fire here.
+    const { configureSelectedAgents } = await import("./agent-config.js");
+    const version = (await getInstalledVersion()) ?? CLI_VERSION;
+    // "Codex" is a no-op file-wise in non-detect mode but the shared flow
+    // also writes codex global config via configureCodexGlobal — pass an
+    // empty agent list so only the MCP side runs.
+    configureSelectedAgents(resolved, binaryPath, version, ["Codex"], mcpServerPath);
+    console.log(chalk.green(`✓ codex now points at ${resolved}`));
+});
+// ────────────────────────────────────────────────────
 // Version
 // ────────────────────────────────────────────────────
 program
@@ -857,7 +963,7 @@ function shortPath(p) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     return home && p.startsWith(home) ? "~" + p.slice(home.length) : p;
 }
-function printBanner() {
+async function printBanner() {
     const version = CLI_VERSION;
     console.log("");
     console.log(chalk.cyan.bold("  ██╗   ██╗███████╗██╗  ██╗██████╗"));
@@ -869,23 +975,33 @@ function printBanner() {
     console.log("");
     console.log(chalk.dim("  Context Engine for AI Coding Agents"));
     console.log("");
-    // ── Daemon status line (3 states, symmetric to LLM) ──
+    // ── Daemon status line ──
+    //
+    // Source of truth is the socket (same signal as `daemon-cmd status`).
+    // Falling back to `.vexp/daemon.pid` + `kill(pid,0)` produces inconsistent
+    // UX after reboot: the file persists with a dead pid, `kill` fails, the
+    // banner says "not running", but the Rust daemon-cmd status probes the
+    // socket and reports "running". Using the socket here makes the banner
+    // agree with status.
     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).
+        const socketPath = path.join(ws, ".vexp", "daemon.sock");
+        const socketAlive = await isSocketAlive(socketPath);
+        if (socketAlive) {
+            // Display PID + uptime when we can read them; otherwise a plain "running".
+            const { pid } = isDaemonPidAlive(ws);
             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)}`));
+            const pidPart = pid ? `PID ${pid}${uptime}` : "socket alive";
+            console.log(chalk.green(`  ● Daemon: running (${pidPart}) — ${shortPath(ws)}`));
         }
         else {
             console.log(chalk.yellow("  ○ Daemon: not running"));
@@ -944,18 +1060,19 @@ 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.
+    // Full bootstrap so users who upgraded the CLI without re-running
+    // `vexp setup` still get a working state (daemon + MCP :7821 up, OS
+    // autostart installed for the next reboot). All steps are idempotent so
+    // running this alongside `vexp setup` never creates duplicates.
     const workspaceRoot = findConfiguredWorkspace();
     if (workspaceRoot) {
         try {
             const binaryPath = getBinaryPath();
-            await ensureDaemonRunning(workspaceRoot, binaryPath);
+            await ensureBootstrap(workspaceRoot, binaryPath);
         }
         catch { /* banner will reflect actual state */ }
     }
-    printBanner();
+    await printBanner();
     printMainMenu();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     rl.on("close", () => { console.log(""); process.exit(0); });
@@ -1006,34 +1123,39 @@ async function interactiveMode() {
             const direct = allItems.find((m) => m.label === input);
             if (direct) {
                 await executeCommand(direct.label, rl);
+                // After a direct command, reprint the main menu so options stay visible.
+                printMainMenu();
                 continue;
             }
             console.log(chalk.dim("  Choose 1-4 or type a command name. 'q' to exit.\n"));
             continue;
         }
         // ── Sub-menus ──
+        const menuMap = { config: MENU_CONFIG, explore: MENU_EXPLORE, savings: MENU_SAVINGS, license: MENU_LICENSE };
+        const titles = { config: "Setup & Config", explore: "Explore & Analyze", savings: "Token Savings", license: "License" };
         if (input === "b" || input === "back") {
             currentMenu = "main";
             printMainMenu();
             continue;
         }
         if (input === "?" || input === "help" || input === "menu") {
-            const menus = { config: MENU_CONFIG, explore: MENU_EXPLORE, savings: MENU_SAVINGS, license: MENU_LICENSE };
-            const titles = { config: "Setup & Config", explore: "Explore & Analyze", savings: "Token Savings", license: "License" };
-            printSubMenu(titles[currentMenu], menus[currentMenu]);
+            printSubMenu(titles[currentMenu], menuMap[currentMenu]);
             continue;
         }
-        const menuMap = { config: MENU_CONFIG, explore: MENU_EXPLORE, savings: MENU_SAVINGS, license: MENU_LICENSE };
         const items = menuMap[currentMenu];
         const item = items.find((m) => m.key === input || m.label === input);
         if (!item) {
             console.log(chalk.dim(`  Unknown option. Type a number (1-${items.length}), 'b' to go back, or 'q' to exit.\n`));
+            printSubMenu(titles[currentMenu], items);
             continue;
         }
         // Show description before executing
         console.log(chalk.dim(`\n    ${item.description}\n`));
         await executeCommand(item.label, rl);
         console.log("");
+        // Sticky sub-menu: reprint the current sub-menu after every command so
+        // the user always sees the available options without typing '?'.
+        printSubMenu(titles[currentMenu], items);
     }
 }
 async function executeCommand(label, rl) {
@@ -1059,49 +1181,80 @@ async function executeCommand(label, rl) {
                 break;
             }
             case "daemon-cmd": {
-                const action = await ask(rl, chalk.cyan("    Action (start/stop/status/logs): "));
-                const valid = ["start", "stop", "status", "logs"];
-                if (valid.includes(action.trim())) {
-                    const binaryPath = ensureBinary();
-                    runBinary(binaryPath, ["daemon-cmd", action.trim()]);
-                }
-                else {
-                    console.log(chalk.dim("    Cancelled."));
+                // Sticky sub-sub-menu: stay here until user types 'b' (back).
+                const binaryPath = ensureBinary();
+                const valid = new Set(["start", "stop", "status", "logs"]);
+                const printDaemonMenu = () => {
+                    console.log("");
+                    console.log(chalk.cyan("    ── Daemon ──"));
+                    console.log(`      ${chalk.bold("start")}   ${chalk.dim("Launch the daemon for this workspace")}`);
+                    console.log(`      ${chalk.bold("stop")}    ${chalk.dim("Stop the running daemon")}`);
+                    console.log(`      ${chalk.bold("status")}  ${chalk.dim("Show node/edge/file counts and uptime")}`);
+                    console.log(`      ${chalk.bold("logs")}    ${chalk.dim("Tail .vexp/vexp.log")}`);
+                    console.log(`      ${chalk.dim("b")}       ${chalk.dim("Back to Setup & Config")}`);
+                    console.log("");
+                };
+                printDaemonMenu();
+                while (true) {
+                    const action = (await ask(rl, chalk.cyan("    daemon> "))).trim().toLowerCase();
+                    if (!action)
+                        continue;
+                    if (action === "b" || action === "back")
+                        break;
+                    if (valid.has(action)) {
+                        runBinary(binaryPath, ["daemon-cmd", action]);
+                        printDaemonMenu();
+                        continue;
+                    }
+                    console.log(chalk.dim("    Unknown action. Use start, stop, status, logs, or 'b' to go back."));
                 }
                 break;
             }
             case "setup-llm": {
-                console.log("");
-                console.log(chalk.cyan("    Local LLM compression (vexp-devmind)"));
-                console.log(chalk.dim("    All processing runs locally — no data leaves your machine.\n"));
-                console.log(`    ${chalk.bold("1")}  Install / Reinstall (~3.5 GB download)`);
-                console.log(`    ${chalk.bold("2")}  Start               (enable without re-downloading)`);
-                console.log(`    ${chalk.bold("3")}  Check for updates   (no download if up to date)`);
-                console.log(`    ${chalk.bold("4")}  Status              (show current config + hardware)`);
-                console.log(`    ${chalk.bold("5")}  Disable             (keep files, stop using LLM)`);
-                console.log(`    ${chalk.dim("b")}  ${chalk.dim("Cancel")}`);
-                console.log("");
-                const llmChoice = await ask(rl, chalk.cyan("    Choose: "));
+                // Sticky sub-sub-menu.
                 const llmBinary = ensureBinary();
-                switch (llmChoice.trim()) {
-                    case "1":
-                        console.log(chalk.dim("    Starting LLM setup (this may take several minutes)…\n"));
-                        runBinary(llmBinary, ["setup-llm", "--install"]);
-                        break;
-                    case "2":
-                        runBinary(llmBinary, ["setup-llm", "--enable"]);
-                        break;
-                    case "3":
-                        runBinary(llmBinary, ["setup-llm", "--check-updates"]);
-                        break;
-                    case "4":
-                        runBinary(llmBinary, ["setup-llm", "--status"]);
-                        break;
-                    case "5":
-                        runBinary(llmBinary, ["setup-llm", "--disable"]);
+                const printLlmMenu = () => {
+                    console.log("");
+                    console.log(chalk.cyan("    ── Local LLM (vexp-devmind) ──"));
+                    console.log(chalk.dim("    All processing runs locally — no data leaves your machine."));
+                    console.log("");
+                    console.log(`      ${chalk.bold("1")}  Install / Reinstall  ${chalk.dim("(~3.5 GB download)")}`);
+                    console.log(`      ${chalk.bold("2")}  Start                ${chalk.dim("(enable without re-downloading)")}`);
+                    console.log(`      ${chalk.bold("3")}  Check for updates    ${chalk.dim("(no download if up to date)")}`);
+                    console.log(`      ${chalk.bold("4")}  Status               ${chalk.dim("(current config + hardware)")}`);
+                    console.log(`      ${chalk.bold("5")}  Disable              ${chalk.dim("(keep files, stop using LLM)")}`);
+                    console.log(`      ${chalk.dim("b")}  ${chalk.dim("Back to Setup & Config")}`);
+                    console.log("");
+                };
+                printLlmMenu();
+                while (true) {
+                    const c = (await ask(rl, chalk.cyan("    llm> "))).trim().toLowerCase();
+                    if (!c)
+                        continue;
+                    if (c === "b" || c === "back")
                         break;
-                    default:
-                        console.log(chalk.dim("    Cancelled."));
+                    switch (c) {
+                        case "1":
+                            console.log(chalk.dim("    Starting LLM setup (this may take several minutes)…\n"));
+                            runBinary(llmBinary, ["setup-llm", "--install"]);
+                            break;
+                        case "2":
+                            runBinary(llmBinary, ["setup-llm", "--enable"]);
+                            break;
+                        case "3":
+                            runBinary(llmBinary, ["setup-llm", "--check-updates"]);
+                            break;
+                        case "4":
+                            runBinary(llmBinary, ["setup-llm", "--status"]);
+                            break;
+                        case "5":
+                            runBinary(llmBinary, ["setup-llm", "--disable"]);
+                            break;
+                        default:
+                            console.log(chalk.dim("    Unknown option. Use 1-5 or 'b' to go back."));
+                            continue;
+                    }
+                    printLlmMenu();
                 }
                 break;
             }