@join-pantheon/cli 0.28.0 → 0.29.0

package/dist/machine.js

@@ -1,9 +1,9 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { homedir, platform } from "node:os";
+import { existsSync, readFileSync, readdirSync, rmSync, rmdirSync, statSync } from "node:fs";
+import { homedir, hostname, networkInterfaces, platform } from "node:os";
 import { join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
-import { plistPath } from "./service.js";
+import { disableService, plistPath, serviceInstalled, serviceLogFile, unitPath, uninstallService } from "./service.js";
 import { copilotMcpConfigFile, vsCodeUserDir, kiroMcpConfigFile, kiroDir } from "./install.js";
 const sh = (cmd) => {
     try {
@@ -46,6 +46,35 @@ function fromLaunchd(kind) {
     }
     return info;
 }
+export function parseSystemdShow(out) {
+    const get = (k) => new RegExp(`^${k}=(.*)$`, "m").exec(out)?.[1]?.trim();
+    const pid = Number(get("MainPID"));
+    const state = get("ActiveState");
+    const status = get("ExecMainStatus");
+    return {
+        active: state === "active" || state === "activating" || state === "reloading",
+        ...(Number.isFinite(pid) && pid > 0 ? { pid } : {}),
+        ...(status && status !== "0" ? { lastExit: status } : {}),
+    };
+}
+function fromSystemd(kind) {
+    if (platform() !== "linux" || !existsSync(unitPath(kind)))
+        return {};
+    const out = sh(`systemctl --user show pantheon-${kind} -p MainPID -p ActiveState -p ExecMainStatus 2>/dev/null`);
+    const label = `pantheon-${kind}.service`;
+    if (!out)
+        return { managedBy: "systemd", label, running: false };
+    const s = parseSystemdShow(out);
+    return {
+        managedBy: "systemd", label,
+        ...(s.active && s.pid ? { running: true, pid: s.pid, since: uptime(s.pid) } : { running: false }),
+        ...(s.lastExit ? { lastExit: s.lastExit } : {}),
+    };
+}
+const fromManager = (kind) => {
+    const l = fromLaunchd(kind);
+    return l.managedBy ? l : fromSystemd(kind);
+};
 function listenerOn(port) {
     const out = sh(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null | head -1`);
     const pid = out ? Number(out) : NaN;
@@ -54,48 +83,29 @@ function listenerOn(port) {
     return { pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
 }
 export function relayProc(port) {
-    const svc = fromLaunchd("relay");
+    const svc = fromManager("relay");
     const held = listenerOn(port);
     if (svc.running && svc.pid)
-        return { kind: "relay", running: true, managedBy: "launchd", ...svc };
+        return { kind: "relay", ...svc, running: true };
     if (held) {
         return { kind: "relay", running: true, managedBy: "foreground", pid: held.pid, ...(held.since ? { since: held.since } : {}) };
     }
-    return { kind: "relay", running: false, managedBy: svc.label ? "launchd" : "none", ...svc };
-}
-export function workerProc() {
-    const svc = fromLaunchd("worker");
-    if (svc.running && svc.pid)
-        return { kind: "worker", running: true, managedBy: "launchd", ...svc };
-    const bare = sh(`pgrep -f "pantheon.* worker" | head -1`);
-    const pid = bare ? Number(bare) : NaN;
-    if (Number.isFinite(pid)) {
-        return { kind: "worker", running: true, managedBy: "foreground", pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
-    }
-    return { kind: "worker", running: false, managedBy: svc.label ? "launchd" : "none", ...svc };
-}
-export function notifierProc() {
-    const svc = fromLaunchd("notifier");
-    if (svc.running && svc.pid)
-        return { kind: "notifier", running: true, managedBy: "launchd", ...svc };
-    const bare = sh(`pgrep -f "pantheon.* notifier" | head -1`);
-    const pid = bare ? Number(bare) : NaN;
-    if (Number.isFinite(pid)) {
-        return { kind: "notifier", running: true, managedBy: "foreground", pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
-    }
-    return { kind: "notifier", running: false, managedBy: svc.label ? "launchd" : "none", ...svc };
+    return { kind: "relay", running: false, managedBy: svc.managedBy ?? "none", ...svc };
 }
-export function menubarProc() {
-    const svc = fromLaunchd("menubar");
+function bareProc(kind, pattern) {
+    const svc = fromManager(kind);
     if (svc.running && svc.pid)
-        return { kind: "menubar", running: true, managedBy: "launchd", ...svc };
-    const bare = sh(`pgrep -f "pantheon.* menubar|pantheon-tray" | head -1`);
+        return { kind, ...svc, running: true };
+    const bare = sh(`pgrep -f "${pattern}" | head -1`);
     const pid = bare ? Number(bare) : NaN;
     if (Number.isFinite(pid)) {
-        return { kind: "menubar", running: true, managedBy: "foreground", pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
+        return { kind, running: true, managedBy: "foreground", pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
     }
-    return { kind: "menubar", running: false, managedBy: svc.label ? "launchd" : "none", ...svc };
+    return { kind, running: false, managedBy: svc.managedBy ?? "none", ...svc };
 }
+export function workerProc() { return bareProc("worker", "pantheon.* worker"); }
+export function notifierProc() { return bareProc("notifier", "pantheon.* notifier"); }
+export function menubarProc() { return bareProc("menubar", "pantheon.* menubar|pantheon-tray"); }
 export function wiring() {
     const out = [];
     const claude = sh(`claude mcp list 2>/dev/null | grep -i "^pantheon"`);
@@ -129,7 +139,7 @@ export function wiring() {
 export function logFileFor(kind, proc) {
     if (proc.logPath && existsSync(proc.logPath))
         return proc.logPath;
-    for (const c of [join(process.cwd(), ".pantheon", `${kind}.log`), join(CONFIG_DIR, `${kind}.log`)]) {
+    for (const c of [serviceLogFile(kind), join(process.cwd(), ".pantheon", `${kind}.log`), join(CONFIG_DIR, `${kind}.log`)]) {
         if (existsSync(c))
             return c;
     }
@@ -149,32 +159,223 @@ export function dataSummary(dir) {
     const spaces = files.split("\n").length;
     return `${acts} acts across ${spaces} space${spaces > 1 ? "s" : ""}`;
 }
-const defaultStopIo = () => ({
-    proc: (kind) => kind === "relay" ? relayProc(8787) : kind === "worker" ? workerProc() : kind === "menubar" ? menubarProc() : notifierProc(),
-    installed: (kind) => existsSync(plistPath(kind)),
+const defaultStopIo = (port = 8787) => ({
+    proc: (kind) => kind === "relay" ? relayProc(port) : kind === "worker" ? workerProc() : kind === "menubar" ? menubarProc() : notifierProc(),
+    installed: (kind) => serviceInstalled(kind),
     sh,
+    disable: (kind) => disableService(kind),
+    cmdline: (pid) => sh(`ps -o command= -p ${pid}`),
 });
-export function stopProc(kind, io = defaultStopIo()) {
+export const isPantheonCommand = (cmd) => /pantheon/i.test(cmd) || /\bcli\.js\s+(relay|start)\b/.test(cmd);
+export function stopProcResult(kind, io = defaultStopIo()) {
     const p = io.proc(kind);
+    const ours = io.installed(kind);
+    if (!ours && (p.managedBy === "launchd" || p.managedBy === "systemd") && p.running) {
+        return { lines: [`${kind}: running under ${p.managedBy}, but not installed from this home — left alone`], stopped: false };
+    }
+    const killLive = (q) => {
+        if (!q.running || !q.pid)
+            return null;
+        if (kind === "relay") {
+            const cmd = (io.cmdline ?? (() => null))(q.pid);
+            if (!cmd || !isPantheonCommand(cmd)) {
+                return { line: `relay: the port is held by pid ${q.pid}${cmd ? ` (${cmd.slice(0, 80)})` : ""}, which is not Pantheon's relay — left alone`, killed: false };
+            }
+        }
+        io.sh(`kill ${q.pid}`);
+        return { line: `${kind}: stopped pid ${q.pid}${q.managedBy === "foreground" ? " (it was started by hand, not as a service)" : ""}`, killed: true };
+    };
+    if (ours) {
+        const lines = [];
+        let disabled = false;
+        try {
+            io.disable(kind);
+            disabled = true;
+        }
+        catch (e) {
+            const how = platform() === "darwin"
+                ? `launchctl disable gui/${process.getuid?.() ?? 0}/dev.pantheon.${kind}`
+                : `systemctl --user disable --now pantheon-${kind}`;
+            lines.push(`${kind}: could not disable the service (${e.message.split("\n")[0]}) — it may start again at login; try: ${how}`);
+        }
+        const after = io.proc(kind);
+        const k = killLive(after);
+        if (k)
+            lines.push(k.line);
+        const stillUp = !!after.running && !k?.killed;
+        if (disabled) {
+            lines.unshift(`${kind}: ${stillUp ? "disabled, but a process is still running (see below)" : p.running || k?.killed ? "stopped, and will not start again at login" : "was not running; disabled, and will not start again at login"}`);
+            lines.push(`        start it again with: pantheon service install ${kind}`);
+        }
+        return { lines, stopped: (p.running && disabled && !stillUp) || !!k?.killed };
+    }
     if (!p.running)
-        return [`${kind}: already stopped`];
-    if (p.managedBy === "launchd") {
-        if (!io.installed(kind))
-            return [`${kind}: running under launchd, but not installed from this home — left alone`];
-        const plist = plistPath(kind);
-        const uid = process.getuid?.() ?? 0;
-        if (io.sh(`launchctl bootout gui/${uid}/dev.pantheon.${kind} 2>&1`) !== null ||
-            io.sh(`launchctl unload -w "${plist}" 2>&1`) !== null) {
-            return [`${kind}: stopped, and will not restart at login`,
-                `        start it again with: pantheon service install ${kind}`];
+        return { lines: [`${kind}: already stopped`], stopped: false };
+    const k = killLive(p);
+    if (k)
+        return { lines: [k.line], stopped: k.killed };
+    return { lines: [`${kind}: running but no pid found — nothing stopped`], stopped: false };
+}
+export function stopProc(kind, io = defaultStopIo()) {
+    return stopProcResult(kind, io).lines;
+}
+export async function waitStopped(kind, ms = 3000, proc = defaultStopIo().proc) {
+    const until = Date.now() + ms;
+    for (;;) {
+        if (!proc(kind).running)
+            return true;
+        if (Date.now() >= until)
+            return false;
+        await new Promise((r) => setTimeout(r, 200));
+    }
+}
+export function hostsRelay(url, port, localAddrs = localAddresses(), host = hostname()) {
+    if (!url)
+        return false;
+    let u;
+    try {
+        u = new URL(url.replace(/^ws/, "http"));
+    }
+    catch {
+        return false;
+    }
+    const p = Number(u.port || (u.protocol === "https:" ? 443 : 80));
+    if (p !== port)
+        return false;
+    const h = u.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    const names = new Set(["localhost", "0.0.0.0", "::", "::1", host.toLowerCase(), `${host.toLowerCase()}.local`, ...localAddrs.map((a) => a.toLowerCase())]);
+    return names.has(h) || /^127\./.test(h);
+}
+export function localAddresses() {
+    try {
+        return Object.values(networkInterfaces()).flatMap((l) => (l ?? []).map((a) => a.address));
+    }
+    catch {
+        return [];
+    }
+}
+export function stopMachine(what, opts, io = defaultStopIo(opts.port), hosts = hostsRelay) {
+    const lines = [];
+    let relayStopped = false;
+    for (const kind of ["relay", "worker", "notifier", "menubar"]) {
+        if (what !== kind && what !== "all")
+            continue;
+        const r = stopProcResult(kind, io);
+        lines.push(...r.lines);
+        if (kind === "relay")
+            relayStopped = r.stopped;
+    }
+    if (!relayStopped)
+        return { lines };
+    const teams = opts.teams ?? (opts.teamRelay ? [{ name: "", relay: opts.teamRelay }] : []);
+    const hostedHere = teams.filter((t) => hosts(t.relay, opts.port));
+    if (hostedHere.length) {
+        const named = hostedHere.map((t) => t.name).filter(Boolean);
+        return { lines, note: `${named.length ? `Your teammates in ${named.map((n) => `"${n}"`).join(", ")} are` : "Your teammates are"} offline until a relay is running again.` };
+    }
+    const elsewhere = [...new Set(teams.map((t) => t.relay))];
+    return { lines, note: `Your team${teams.length === 1 ? "'s relay is" : "s' relays are"} ${elsewhere.join(", ") || "elsewhere"}, not this one — your teammates are not affected.` };
+}
+const LOG_KINDS = ["worker", "relay", "notifier", "menubar"];
+export function uninstallMachine(opts, io) {
+    const lines = [], removed = [], left = [];
+    const kinds = ["worker", "notifier", "menubar", ...(opts.stopRelay ? ["relay"] : [])];
+    for (const kind of kinds) {
+        if (io.installed(kind)) {
+            try {
+                for (const l of io.uninstall(kind))
+                    lines.push(`${kind}: ${l.trim()}`);
+                removed.push(`the ${kind} service — stopped, and its definition deleted so it cannot return at login`);
+            }
+            catch (e) {
+                left.push(`the ${kind} service (${e.message.split("\n")[0]}) — pantheon service uninstall ${kind}`);
+            }
+        }
+        const p = io.proc(kind);
+        if (p.running && p.managedBy === "foreground") {
+            if (kind === "relay")
+                for (const l of io.stop(kind))
+                    lines.push(l);
+            else
+                left.push(`a ${kind} started by hand is still running (pid ${p.pid ?? "?"}) — close its terminal, or: kill ${p.pid ?? "<pid>"}`);
+        }
+    }
+    if (!opts.stopRelay && (io.installed("relay") || io.proc("relay").running)) {
+        left.push("the relay — others may be using it. Stop and remove it too: pantheon leave --stop-relay");
+    }
+    if (io.hasIntent()) {
+        io.clearIntent();
+        removed.push("the hook intent (hook-intent.json) — nothing will put the hooks back");
+    }
+    const mcp = io.removeMcpEntries();
+    removed.push(...mcp.removed);
+    left.push(...mcp.left);
+    try {
+        if (existsSync(io.logDir)) {
+            rmSync(io.logDir, { recursive: true, force: true });
+            removed.push(`service logs (${io.logDir})`);
+        }
+    }
+    catch { }
+    const repoDir = join(opts.project, ".pantheon");
+    let repoLogs = 0;
+    for (const k of LOG_KINDS) {
+        const f = join(repoDir, `${k}.log`);
+        try {
+            if (existsSync(f)) {
+                rmSync(f, { force: true });
+                repoLogs++;
+            }
         }
-        return [`${kind}: could not stop the service — try: launchctl bootout gui/${uid}/dev.pantheon.${kind}`];
+        catch { }
     }
-    if (p.pid) {
-        io.sh(`kill ${p.pid}`);
-        return [`${kind}: stopped pid ${p.pid} (it was started by hand, not as a service)`];
+    if (repoLogs) {
+        let rest = [];
+        try {
+            rest = readdirSync(repoDir);
+        }
+        catch { }
+        if (!rest.length) {
+            try {
+                rmdirSync(repoDir);
+            }
+            catch { }
+            removed.push(`${repoDir} (service logs an older version wrote into your repo)`);
+        }
+        else {
+            removed.push(`${repoLogs} service log${repoLogs === 1 ? "" : "s"} from ${repoDir}`);
+            left.push(`${repoDir}: ${rest.join(", ")} — your team's files, not logs`);
+        }
     }
-    return [`${kind}: running but no pid found — nothing stopped`];
+    return { lines, removed, left };
+}
+export async function panicMachine(io) {
+    const lines = io.stopWorker().map((l) => `  ${l}`);
+    const workerDown = await io.workerDown();
+    if (!workerDown)
+        lines.push(`  ! the worker is still running. Stop it by hand: ${platform() === "darwin" ? "launchctl bootout gui/$(id -u)/dev.pantheon.worker" : "systemctl --user disable --now pantheon-worker"}   or kill its pid (pantheon ps)`);
+    let allRevoked = true;
+    if (!io.teams.length)
+        lines.push("  no team on this machine, so there are no wake grants to revoke");
+    for (const t of io.teams) {
+        try {
+            const who = await io.revoke(t);
+            lines.push(who.length ? `  ${t.name}: revoked wake rights from ${who.join(", ")}` : `  ${t.name}: no peer had wake rights to revoke`);
+        }
+        catch (e) {
+            allRevoked = false;
+            lines.push(`  ${t.name}: could not reach its relay (${e.message.split("\n")[0]}), so its wake grants were not changed — run pantheon panic again when it is reachable`);
+        }
+    }
+    if (workerDown)
+        lines.push("", "  Nothing can start an agent run on this machine now.");
+    else
+        lines.push("", "  The worker is still running — stop it as above.");
+    return { lines, workerDown, ok: workerDown && allRevoked };
+}
+export function leavePlan(all) {
+    const teams = Object.values(all?.spaces ?? {}).map((m) => ({ name: m.name, relay: m.relay }));
+    return { teams, ...(all?.member ? { member: all.member } : {}) };
 }
 export function statFile(f) {
     try {
@@ -185,4 +386,22 @@ export function statFile(f) {
         return "unreadable";
     }
 }
+export function realUninstallIo(deps) {
+    const s = defaultStopIo(deps.port ?? 8787);
+    return {
+        installed: (k) => serviceInstalled(k),
+        uninstall: (k) => uninstallService(k),
+        stop: (k) => stopProc(k, s),
+        proc: (k) => {
+            const p = s.proc(k);
+            if (k === "relay" && p.running && p.managedBy === "foreground" && p.pid && !isPantheonCommand(s.cmdline?.(p.pid) ?? ""))
+                return { ...p, running: false };
+            return p;
+        },
+        removeMcpEntries: deps.removeMcpEntries,
+        hasIntent: deps.hasIntent,
+        clearIntent: deps.clearIntent,
+        logDir: join(CONFIG_DIR, "logs"),
+    };
+}
 //# sourceMappingURL=machine.js.map

package/dist/mcp-supervisor.js

@@ -261,6 +261,11 @@ export async function superviseMcp() {
             await new Promise((r) => setTimeout(r, 250));
         if (!children.has(c))
             return;
+        try {
+            mkdirSync(supervisorStateDir(), { recursive: true });
+            writeFileSync(join(supervisorStateDir(), `retiring-${c.proc.pid}`), String(Date.now()));
+        }
+        catch { }
         try {
             c.proc.stdin.end();
         }

package/dist/mcp.js

@@ -1,3 +1,6 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
@@ -15,6 +18,7 @@ import { loadProfile, organizationProfile, routeDecision } from "./profile.js";
 import { renderBrief } from "./brief.js";
 import { protocol, sessionInstructions } from "./mcp-instructions.js";
 import { recentRuns } from "./spend.js";
+import { refusalOf } from "./refusal.js";
 const ACT_HELP = {
     NOTE: "FYI. Creates no obligation.",
     ASK: "A question a named peer owes you an answer to. Requires `to`.",
@@ -111,15 +115,16 @@ export async function runMcp() {
     const mcpActivity = role === "interactive" && !!backend &&
         (backend.id === "claude-code" ? !hooksOn : true);
     let toolsInFlight = 0;
+    const activityKey = `${process.pid.toString(36)}-${randomBytes(4).toString("hex")}`;
     const activityIdle = () => {
         if (!mcpActivity)
             return;
-        reportMcpIdle(cfg, client.session, client.readSeq || client.head).catch(() => false);
+        reportMcpIdle(cfg, activityKey, client.readSeq || client.head).catch(() => false);
     };
     const activityBusy = () => {
         if (!mcpActivity)
             return;
-        reportMcpBusy(cfg, client.session).catch(() => false);
+        reportMcpBusy(cfg, activityKey).catch(() => false);
     };
     const activityAround = async (fn) => {
         if (mcpActivity) {
@@ -154,6 +159,11 @@ export async function runMcp() {
                 return fail(`pantheon: still connecting to the relay (${Math.round((Date.now() - startedAt) / 100) / 10}s since this session started) — ` +
                     `try this call again in a moment. Nothing to restart.`);
             }
+            const refused = connectError ? refusalOf(connectError) : null;
+            if (refused) {
+                return fail(`pantheon: the relay refused this machine (${refused.code}): ${refused.message}\n` +
+                    `${refused.fix ? `The fix: ${refused.fix}.\n` : ""}Waiting will not clear this: it needs your human. Once they fix it, this session connects on its own — nothing to restart. Keep working locally meanwhile.`);
+            }
             return fail(`pantheon cannot reach the relay yet: ${connectError ?? "no answer"}. Retrying in the background; try again in a few seconds.\n` +
                 `${versionNote() ?? "If this persists the relay may be down — tell your human, and keep working locally meanwhile."}`);
         }
@@ -474,7 +484,9 @@ export async function runMcp() {
         url.searchParams.set("space", cfg.space);
         url.searchParams.set("token", cfg.token);
         url.searchParams.set("goal", goal);
-        return fetch(url).then(async (res) => {
+        return fetch(url, { signal: AbortSignal.timeout(10_000) }).then(async (res) => {
+            if (!res.ok)
+                return fail(`the relay answered ${res.status} for this goal's thread — try again in a moment`);
             const { acts } = (await res.json());
             const hits = acts.filter((a) => a.goal === goal).slice(-(limit ?? 60));
             return text(`goal ${g.id} "${g.title}" [${g.state}] ${g.acts}/${g.budget} acts${deadlineLabel(g.deadline)}\nacceptance: ${g.acceptance || "(none)"}\n\n` +
@@ -490,11 +502,26 @@ export async function runMcp() {
         shuttingDown = true;
         if (mcpActivity && client.connected) {
             await Promise.race([
-                reportMcpIdle(cfg, client.session, client.readSeq || client.head).catch(() => false),
+                reportMcpIdle(cfg, activityKey, client.readSeq || client.head).catch(() => false),
                 new Promise((r) => setTimeout(r, 1_200)),
             ]);
         }
-        client.close();
+        let handover = false;
+        if (process.env.PANTHEON_MCP_SUPERVISED) {
+            try {
+                const { supervisorStateDir } = await import("./mcp-supervisor.js");
+                const mark = join(supervisorStateDir(), `retiring-${process.pid}`);
+                if (existsSync(mark)) {
+                    handover = true;
+                    rmSync(mark, { force: true });
+                }
+            }
+            catch { }
+        }
+        if (handover)
+            client.handOff();
+        else
+            client.close();
         process.exit(0);
     };
     process.on("SIGINT", shutdown);
@@ -521,7 +548,7 @@ export async function runMcp() {
                 connectError = e.message;
                 connecting = false;
                 firstAttemptDone();
-                if (/^PENDING\b/.test(connectError)) {
+                if (/^PENDING\b/.test(connectError) || refusalOf(connectError)) {
                     await new Promise((r) => setTimeout(r, PENDING_RETRY_MS));
                     continue;
                 }