vexp-cli 3.3.3 → 3.3.6

package/dist/mcp-supervisor.js

@@ -135,6 +135,97 @@ export function parentPid(pid) {
         return undefined;
     }
 }
+/**
+ * The command line of a running process, or undefined when it cannot be read.
+ *
+ * A pid on record proves nothing about what runs under it today: the process
+ * that wrote the record may have ended, and the number may have been handed
+ * to another program since (a window reload, a reboot). Doctor named such a
+ * pid in a line that told the reader to end it, having tested only that some
+ * process had it (field report, 2026-10-08). Same contract as parentPid:
+ * unreadable is "cannot tell", never "yes".
+ */
+export function processCommandLine(pid) {
+    try {
+        if (process.platform === "linux") {
+            try {
+                const args = fs.readFileSync(`/proc/${pid}/cmdline`, "utf-8").split("\0").filter(Boolean);
+                if (args.length > 0)
+                    return args.join(" ");
+            }
+            catch { /* no /proc entry to read: ask ps */ }
+        }
+        const r = process.platform === "win32"
+            ? spawnSync("powershell", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`], { encoding: "utf-8", timeout: 4000, windowsHide: true })
+            : spawnSync("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf-8", timeout: 4000 });
+        const line = String(r.stdout ?? "").trim();
+        return r.status === 0 && line ? line : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Is the process behind a recorded supervisor pid still vexp? "vexp" when its
+ * command line names vexp (and `serve`, for a record a `vexp serve` wrote),
+ * "other" when it reads as another program, "unreadable" when it cannot be
+ * read. Only "vexp" may be named as a process to end.
+ */
+export function vexpProcessCheck(commandLine, owner) {
+    if (commandLine === undefined)
+        return "unreadable";
+    if (!/\bvexp\b/i.test(commandLine))
+        return "other";
+    return owner !== "serve" || /\bserve\b/.test(commandLine) ? "vexp" : "other";
+}
+/** How to end a process, as the reader would type it: `kill` is not a
+ *  command in cmd.exe, and a console-less node ignores a taskkill without /F. */
+export function endProcessCommand(pid, platform = process.platform) {
+    return platform === "win32" ? `taskkill /PID ${pid} /F` : `kill ${pid}`;
+}
+/**
+ * What to print when this CLI replaces an older MCP server on its port, or
+ * null for nothing.
+ *
+ * The warning was written for one case: a `vexp serve` left behind by an
+ * older install, whose 60 s loop takes the port back. It was printed for
+ * every record, so a CLI run through npx called the VS Code extension host
+ * "a supervisor from an older install" and asked for it to be ended first
+ * (field report, 2026-10-08). The extension has no loop on this server and
+ * leaves a newer one alone, so for its record there is nothing to end; and a
+ * pid is named only when the process behind it still reads as vexp. A server
+ * started by a `vexp` command (owner "cli") has nothing behind it that takes
+ * the port back either, and is replaced without a word.
+ */
+export function takeoverNotice(existing, 
+/** The process that started the server, when one is still running under that pid. */
+boss, cliVersion, platform = process.platform) {
+    const was = existing.version ?? "pre-2.4";
+    if (existing.owner === "plugin") {
+        return (`  replacing the MCP server on :${existing.port} (v${was}, started by the vexp extension of an IDE) with v${cliVersion} from this CLI.\n` +
+            `     Nothing needs ending: the extension leaves a newer server alone. No agent that vexp sets up uses this server unless Codex's transport is set to http.`);
+    }
+    // A `vexp` command that started the server on its way has no loop on it:
+    // what follows is the story of a resident `vexp serve`, and of a record
+    // that does not say what wrote it.
+    if (existing.owner === "cli")
+        return null;
+    if (!boss)
+        return null;
+    const check = vexpProcessCheck(boss.commandLine, existing.owner);
+    if (check === "other")
+        return null; // the pid was handed to another program: the supervisor is gone
+    const head = `  ⚠ replacing the MCP server on :${existing.port} (was v${was}). `;
+    const why = `before restarting any daemon: its health loop deletes daemon registrations as fast as they are written.`;
+    if (check === "unreadable") {
+        return (head +
+            `It was started by a supervisor from an older install; whether that one still runs could not be read.\n` +
+            `     If :${existing.port} reverts, 'vexp doctor' says how to find it: end it FIRST — ${why}`);
+    }
+    return (head +
+        `It was started by pid ${boss.pid}, a supervisor from an older install.\n` +
+        `     If :${existing.port} reverts, end that process FIRST ('${endProcessCommand(boss.pid, platform)}') — ${why}`);
+}
 export function mcpBundleVersion(mcpPath) {
     const pkg = path.resolve(path.dirname(mcpPath), "..", "package.json");
     try {
@@ -195,13 +286,13 @@ export async function ensureMcpHttpServer(opts = {}) {
             // port revert with nothing to read. The supervisor is the parent of the
             // server we are about to end; the recorded pid, when a recent build
             // wrote it, says the same thing without a process lookup.
-            const boss = existing.spawnedByPid ?? parentPid(existing.pid);
-            if (boss !== undefined && isPidAlive(boss)) {
-                console.error(`  ⚠ replacing the MCP server on :${port} (was v${existing.version ?? "pre-2.4"}). ` +
-                    `It was started by pid ${boss}, a supervisor from an older install.\n` +
-                    `     If :${port} reverts, end that process FIRST — before restarting any daemon: its ` +
-                    `health loop deletes daemon registrations as fast as they are written.`);
-            }
+            // A server the IDE extension started has no such process: its record
+            // names the extension host, and nothing there takes the port back. Nor
+            // has one that a `vexp` command started on its way.
+            const bossPid = existing.owner === "plugin" || existing.owner === "cli" ? undefined : existing.spawnedByPid ?? parentPid(existing.pid);
+            const notice = takeoverNotice(existing, bossPid !== undefined && isPidAlive(bossPid) ? { pid: bossPid, commandLine: processCommandLine(bossPid) } : undefined, CLI_VERSION);
+            if (notice)
+                console.error(notice);
             try {
                 process.kill(existing.pid, "SIGTERM");
             }

package/dist/stop-all.js

@@ -0,0 +1,116 @@
+import { socketPathFor } from "./socket-path.js";
+/** The rows in what `daemons --json` printed, or null when that is not the
+ *  listing (an engine that predates the command, an error in its place). */
+export function parseDaemonRows(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const list = parsed?.daemons;
+    if (!Array.isArray(list))
+        return null;
+    const rows = [];
+    for (const r of list) {
+        if (!r || typeof r.workspace !== "string" || !r.workspace || typeof r.socket !== "string" || !r.socket)
+            continue;
+        rows.push({
+            workspace: r.workspace,
+            socket: r.socket,
+            alive: r.alive === true,
+            ...(typeof r.version === "string" ? { version: r.version } : {}),
+            ...(typeof r.pid === "number" ? { pid: r.pid } : {}),
+            ...(typeof r.exe === "string" && r.exe ? { exe: r.exe } : {}),
+        });
+    }
+    return rows;
+}
+/**
+ * The daemons behind the live rows, one per socket, in the engine's order.
+ *
+ * A connected repo is registered with the socket of the workspace that
+ * serves it, so two rows can be one daemon. It is stopped once, from the
+ * workspace the socket belongs to: `daemon-cmd stop` reads the pid file of
+ * the folder it runs in, and a connected repo has none.
+ */
+export function daemonsToStop(rows, socketOf = socketPathFor) {
+    const bySocket = new Map();
+    for (const row of rows) {
+        if (!row.alive)
+            continue;
+        const group = bySocket.get(row.socket);
+        if (group)
+            group.push(row);
+        else
+            bySocket.set(row.socket, [row]);
+    }
+    const targets = [];
+    for (const group of bySocket.values()) {
+        const owner = group.find((r) => socketOf(r.workspace) === r.socket) ?? group[0];
+        targets.push({
+            workspace: owner.workspace,
+            socket: owner.socket,
+            ...(owner.pid !== undefined ? { pid: owner.pid } : {}),
+            ...(owner.exe !== undefined ? { exe: owner.exe } : {}),
+            alsoServes: group.filter((r) => r !== owner).map((r) => r.workspace),
+        });
+    }
+    return targets;
+}
+/** A daemon running the engine inside an editor extension's folder
+ *  (`.../extensions/vexp.vexp-vscode-<version>.../`): an editor window
+ *  started it, and owns it. */
+export function startedByEditor(exe) {
+    return !!exe && /vexp\.vexp-vscode-\d/i.test(exe);
+}
+/** The first line the engine printed, looking through its streams in the
+ *  order given: stdout first for an answer, stderr first for an error. */
+export function engineSaid(...streams) {
+    for (const text of streams) {
+        const line = (text ?? "").split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0);
+        if (line)
+            return line;
+    }
+    return "";
+}
+/** Did `daemon-cmd stop` end a daemon? Its sentence is "Daemon (PID n)
+ *  stopped"; "No daemon running (no PID file found)" and "... was not
+ *  running" also exit 0, and neither ended the daemon the listing saw. */
+export function daemonWasStopped(said, status) {
+    return status === 0 && /Daemon \(PID \d+\) stopped\b/.test(said);
+}
+/** The lines that go under a workspace's own line. */
+export function stopNotes(result) {
+    const notes = [];
+    if (result.target.alsoServes.length > 0) {
+        notes.push(`the same daemon served ${result.target.alsoServes.join(", ")}`);
+    }
+    // Said whether or not the stop landed: either way this daemon is back, or
+    // still there, a moment later.
+    if (startedByEditor(result.target.exe)) {
+        notes.push("started by an editor window, which starts it again: close or reload that window");
+    }
+    return notes;
+}
+/**
+ * Whether to say, once, that a stop is not a good-bye: while `vexp serve`
+ * runs, a stopped workspace that still has its manifest is brought back
+ * within a minute (the note `vexp stop <workspace>` prints).
+ */
+export function supervisorNoteDue(results, hasManifest) {
+    return results.some((r) => r.stopped && hasManifest(r.target.workspace));
+}
+/** The last line, and whether every daemon listed was stopped. */
+export function stopAllSummary(results) {
+    const total = results.length;
+    const stopped = results.filter((r) => r.stopped).length;
+    const daemons = (n) => `${n} daemon${n === 1 ? "" : "s"}`;
+    if (stopped === total)
+        return { line: `${daemons(stopped)} stopped`, ok: true };
+    return {
+        line: `${stopped} of ${daemons(total)} stopped; ${total - stopped} not stopped, for the reason given on its line`,
+        ok: false,
+    };
+}