@join-pantheon/cli 0.29.1 → 0.30.0

package/dist/machine.js

@@ -1,9 +1,9 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync, readdirSync, rmSync, rmdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import { homedir, hostname, networkInterfaces, platform } from "node:os";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { CONFIG_DIR } from "./config.js";
-import { disableService, plistPath, serviceInstalled, serviceLogFile, unitPath, uninstallService } from "./service.js";
+import { borrowedHome, disableService, existingUnitPath, plistPath, serviceInstalled, serviceLogFile, unitPath, unitPaths, uninstallService } from "./service.js";
 import { copilotMcpConfigFile, vsCodeUserDir, kiroMcpConfigFile, kiroDir } from "./install.js";
 const sh = (cmd) => {
     try {
@@ -13,19 +13,48 @@ const sh = (cmd) => {
         return null;
     }
 };
+const SYSTEM_PATH = ["/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+export function runTool(cmd, args) {
+    try {
+        const PATH = [...new Set([...(process.env.PATH ?? "").split(":"), ...SYSTEM_PATH].filter(Boolean))].join(":");
+        return execFileSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000, env: { ...process.env, PATH, LC_ALL: "C" } }).trim() || null;
+    }
+    catch (e) {
+        const out = e.stdout;
+        return typeof out === "string" && out.trim() ? out.trim() : null;
+    }
+}
+export function launchctlRow(list, label) {
+    for (const line of list.split("\n")) {
+        const cols = line.trim().split(/\s+/);
+        if (cols.length < 3 || cols[2] !== label)
+            continue;
+        const pid = /^\d+$/.test(cols[0]) ? Number(cols[0]) : null;
+        return { pid, status: cols[1] };
+    }
+    return null;
+}
+export function firstPid(out) {
+    for (const line of (out ?? "").split("\n"))
+        if (/^\s*\d+\s*$/.test(line) && Number(line) > 0)
+            return Number(line);
+    return null;
+}
 function uptime(pid) {
-    const out = sh(`ps -o etime= -p ${pid}`);
-    return out ? out.trim() : undefined;
+    if (platform() === "win32")
+        return undefined;
+    const out = runTool("ps", ["-o", "etime=", "-p", String(pid)]);
+    return out && /^[\d:-]+$/.test(out.trim()) ? out.trim() : undefined;
 }
 function fromLaunchd(kind) {
     if (platform() !== "darwin")
         return {};
     const label = `dev.pantheon.${kind}`;
-    const row = sh(`launchctl list | grep -w ${label}`);
+    const row = launchctlRow(runTool("launchctl", ["list"]) ?? "", label);
     if (!row)
         return {};
-    const [pidRaw, statusRaw] = row.split(/\s+/);
-    const pid = Number(pidRaw);
+    const pid = row.pid ?? NaN;
+    const statusRaw = row.status;
     const info = {
         managedBy: "launchd",
         label,
@@ -58,9 +87,9 @@ export function parseSystemdShow(out) {
     };
 }
 function fromSystemd(kind) {
-    if (platform() !== "linux" || !existsSync(unitPath(kind)))
+    if (platform() !== "linux" || !existingUnitPath(kind))
         return {};
-    const out = sh(`systemctl --user show pantheon-${kind} -p MainPID -p ActiveState -p ExecMainStatus 2>/dev/null`);
+    const out = runTool("systemctl", ["--user", "show", `pantheon-${kind}`, "-p", "MainPID", "-p", "ActiveState", "-p", "ExecMainStatus"]);
     const label = `pantheon-${kind}.service`;
     if (!out)
         return { managedBy: "systemd", label, running: false };
@@ -76,9 +105,10 @@ const fromManager = (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;
-    if (!Number.isFinite(pid))
+    if (platform() === "win32")
+        return null;
+    const pid = firstPid(runTool("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"]));
+    if (pid === null)
         return null;
     return { pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
 }
@@ -92,20 +122,220 @@ export function relayProc(port) {
     }
     return { kind: "relay", running: false, managedBy: svc.managedBy ?? "none", ...svc };
 }
-function bareProc(kind, pattern) {
+function bareProc(kind) {
     const svc = fromManager(kind);
     if (svc.running && svc.pid)
         return { kind, ...svc, running: true };
-    const bare = sh(`pgrep -f "${pattern}" | head -1`);
-    const pid = bare ? Number(bare) : NaN;
-    if (Number.isFinite(pid)) {
+    const pid = findBareProcess(kind);
+    if (pid !== null) {
         return { kind, running: true, managedBy: "foreground", pid, ...(uptime(pid) ? { since: uptime(pid) } : {}) };
     }
     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 workerProc() { return bareProc("worker"); }
+export function notifierProc() { return bareProc("notifier"); }
+export function menubarProc() { return bareProc("menubar"); }
+const BARE_PATTERN = {
+    worker: /pantheon.* worker/,
+    notifier: /pantheon.* notifier/,
+    menubar: /pantheon.* menubar|pantheon-tray/,
+    relay: /pantheon.* relay/,
+};
+const PGREP_PATTERN = {
+    worker: "[p]antheon.* worker",
+    notifier: "[p]antheon.* notifier",
+    menubar: "[p]antheon.* menubar|[p]antheon-tray",
+    relay: "[p]antheon.* relay",
+};
+export const workerPidFile = (home = CONFIG_DIR) => join(home, "worker.pid");
+const aliveReal = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+};
+function runPowerShell(args) {
+    const root = process.env.SystemRoot ?? process.env.windir;
+    const exe = root && existsSync(join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"))
+        ? join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+    try {
+        return execFileSync(exe, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 6_000, windowsHide: true }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function windowsProcessInfo(pid, run = runPowerShell) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    const script = `$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; if ($p) { [DateTimeOffset]::new($p.CreationDate).ToUnixTimeMilliseconds(); $p.CommandLine }`;
+    const out = run(["-NoProfile", "-NonInteractive", "-Command", script]);
+    if (!out)
+        return null;
+    const [first, ...rest] = out.split(/\r?\n/);
+    const ms = Number(first?.trim());
+    return { startedMs: Number.isFinite(ms) && ms > 0 ? ms : null, cmd: rest.join(" ").trim() || null };
+}
+export const realProcScanIo = () => {
+    const win = new Map();
+    const winInfo = (pid) => { if (!win.has(pid))
+        win.set(pid, windowsProcessInfo(pid)); return win.get(pid) ?? null; };
+    return {
+        platform: platform(),
+        selfPid: process.pid,
+        procDir: "/proc",
+        pgrep: (pattern) => {
+            try {
+                return execFileSync("pgrep", ["-f", pattern], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 });
+            }
+            catch (e) {
+                const st = e.status;
+                return st === 1 ? "" : null;
+            }
+        },
+        ppidOf: (pid) => firstPid(runTool("ps", ["-o", "ppid=", "-p", String(pid)])),
+        alive: aliveReal,
+        cmdlineOf: (pid) => {
+            const p = platform();
+            if (p === "linux") {
+                try {
+                    return readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).join(" ") || null;
+                }
+                catch {
+                    return null;
+                }
+            }
+            if (p === "darwin")
+                return runTool("ps", ["-o", "command=", "-p", String(pid)]);
+            if (p === "win32")
+                return winInfo(pid)?.cmd ?? null;
+            return null;
+        },
+        startedAt: (pid) => (platform() === "win32" ? winInfo(pid)?.startedMs ?? null : null),
+        ...(typeof process.getuid === "function" ? { uid: process.getuid() } : {}),
+        pidFile: workerPidFile(),
+    };
+};
+export function readProcTable(procDir) {
+    let names;
+    try {
+        names = readdirSync(procDir);
+    }
+    catch {
+        return null;
+    }
+    const out = [];
+    for (const n of names) {
+        if (!/^\d+$/.test(n))
+            continue;
+        try {
+            const cmd = readFileSync(join(procDir, n, "cmdline"), "utf8").split("\0").filter(Boolean).join(" ");
+            const stat = readFileSync(join(procDir, n, "stat"), "utf8");
+            const ppid = Number(stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/)[1]);
+            let uid;
+            try {
+                const m = /^Uid:\s+(\d+)/m.exec(readFileSync(join(procDir, n, "status"), "utf8"));
+                if (m)
+                    uid = Number(m[1]);
+            }
+            catch { }
+            if (uid === undefined) {
+                try {
+                    uid = statSync(join(procDir, n)).uid;
+                }
+                catch { }
+            }
+            out.push({ pid: Number(n), ppid: Number.isFinite(ppid) ? ppid : 0, cmd, ...(uid !== undefined ? { uid } : {}) });
+        }
+        catch { }
+    }
+    return out;
+}
+export const isPantheonKindCommand = (kind, cmd) => BARE_PATTERN[kind].test(cmd) || (/pantheon|cli\.js/i.test(cmd) && new RegExp(`\\b${kind}\\b`).test(cmd));
+const START_SLACK_MS = 10_000;
+function pidFileWorker(io) {
+    let rec = null;
+    try {
+        rec = JSON.parse(readFileSync(io.pidFile, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    const pid = Number(rec?.pid);
+    if (!Number.isInteger(pid) || pid <= 0 || pid === io.selfPid)
+        return null;
+    const stale = () => { try {
+        rmSync(io.pidFile, { force: true });
+    }
+    catch { } return null; };
+    if (!io.alive(pid))
+        return stale();
+    const cmd = io.cmdlineOf(pid);
+    if (cmd !== null && !isPantheonKindCommand("worker", cmd))
+        return stale();
+    const born = io.startedAt?.(pid) ?? null;
+    if (born !== null) {
+        if (typeof rec?.procStart === "number") {
+            if (Math.abs(born - rec.procStart) > START_SLACK_MS)
+                return stale();
+        }
+        else {
+            const wrote = Date.parse(rec?.started ?? "");
+            if (Number.isFinite(wrote) && born > wrote + START_SLACK_MS)
+                return stale();
+        }
+    }
+    return { pid, confirmed: cmd !== null };
+}
+export function findBareProcess(kind, io = realProcScanIo()) {
+    const fromPidFile = () => (kind === "worker" ? pidFileWorker(io)?.pid ?? null : null);
+    if (io.platform === "linux") {
+        const table = readProcTable(io.procDir);
+        if (!table)
+            return fromPidFile();
+        const parent = new Map(table.map((p) => [p.pid, p.ppid]));
+        const skip = new Set();
+        for (let p = io.selfPid, n = 0; p && p > 0 && n < 64; p = parent.get(p), n++)
+            skip.add(p);
+        const mine = (p) => io.uid === undefined || p.uid === io.uid;
+        const hit = table.find((p) => !skip.has(p.pid) && mine(p) && BARE_PATTERN[kind].test(p.cmd));
+        return hit ? hit.pid : fromPidFile();
+    }
+    if (io.platform === "darwin") {
+        const out = io.pgrep(PGREP_PATTERN[kind]);
+        if (out === null)
+            return fromPidFile();
+        const skip = new Set();
+        for (let p = io.selfPid, n = 0; p && p > 1 && n < 64; p = io.ppidOf(p), n++)
+            skip.add(p);
+        for (const line of out.split("\n")) {
+            const pid = Number(line.trim());
+            if (Number.isInteger(pid) && pid > 0 && !skip.has(pid))
+                return pid;
+        }
+        return fromPidFile();
+    }
+    return fromPidFile();
+}
+export function recordWorkerPid(file = workerPidFile()) {
+    try {
+        mkdirSync(dirname(file), { recursive: true });
+        const procStart = Math.round(Date.now() - process.uptime() * 1000);
+        writeFileSync(file, JSON.stringify({ pid: process.pid, started: new Date().toISOString(), procStart, argv: process.argv.slice(1) }) + "\n");
+        const pid = process.pid;
+        process.on("exit", () => {
+            try {
+                if (JSON.parse(readFileSync(file, "utf8")).pid === pid)
+                    rmSync(file, { force: true });
+            }
+            catch { }
+        });
+    }
+    catch { }
+}
 export function wiring() {
     const out = [];
     const claude = sh(`claude mcp list 2>/dev/null | grep -i "^pantheon"`);
@@ -166,13 +396,50 @@ export function dataSummary(dir) {
     const spaces = files.length;
     return `${acts} acts across ${spaces} space${spaces > 1 ? "s" : ""}`;
 }
+const killBySh = (cmd) => {
+    const m = /^kill (\d+)$/.exec(cmd);
+    if (!m)
+        return sh(cmd);
+    try {
+        process.kill(Number(m[1]), "SIGTERM");
+        return "";
+    }
+    catch {
+        return null;
+    }
+};
+const killPid = (pid) => {
+    try {
+        process.kill(pid, "SIGTERM");
+        return null;
+    }
+    catch (e) {
+        return e.code ?? "failed";
+    }
+};
+const killHint = (pid) => platform() === "win32" ? `taskkill /PID ${pid ?? "<pid>"} /T /F` : `kill ${pid ?? "<pid>"}`;
+export function managerDefinitionPath(kind, plat = platform(), run = runTool) {
+    if (plat === "darwin") {
+        const out = run("launchctl", ["print", `gui/${process.getuid?.() ?? 501}/dev.pantheon.${kind}`]);
+        return /^\s*path = (.+)$/m.exec(out ?? "")?.[1]?.trim() ?? null;
+    }
+    if (plat === "linux") {
+        const out = run("systemctl", ["--user", "show", `pantheon-${kind}`, "-p", "FragmentPath"]);
+        return /^FragmentPath=(.+)$/m.exec(out ?? "")?.[1]?.trim() || null;
+    }
+    return null;
+}
 const defaultStopIo = (port = 8787) => ({
     proc: (kind) => kind === "relay" ? relayProc(port) : kind === "worker" ? workerProc() : kind === "menubar" ? menubarProc() : notifierProc(),
     installed: (kind) => serviceInstalled(kind),
-    sh,
+    sh: killBySh,
     disable: (kind) => disableService(kind),
-    cmdline: (pid) => sh(`ps -o command= -p ${pid}`),
+    cmdline: (pid) => (platform() === "win32" ? windowsProcessInfo(pid)?.cmd ?? null : runTool("ps", ["-o", "command=", "-p", String(pid)])),
+    borrowed: () => borrowedHome(),
+    loadedFrom: (kind) => managerDefinitionPath(kind),
+    kill: killPid,
 });
+export const borrowedHomeLine = (kind) => `${kind === "services" ? "services" : `${kind}:`} left alone — HOME (${homedir()}) is not your own home (a test, a sandbox or another account's folder), so the service manager's jobs here are the real user's, not this home's. Nothing was stopped; run this from your own login to stop your services`;
 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);
@@ -180,16 +447,43 @@ export function stopProcResult(kind, io = defaultStopIo()) {
     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 borrowed = (io.borrowed ?? borrowedHome)();
     const killLive = (q) => {
         if (!q.running || !q.pid)
             return null;
+        if (q.managedBy === "launchd" || q.managedBy === "systemd") {
+            if (borrowed)
+                return { line: borrowedHomeLine(kind), killed: false };
+            const want = q.managedBy === "launchd" ? plistPath(kind) : unitPath(kind);
+            const oursAt = q.managedBy === "launchd" ? [want] : unitPaths(kind);
+            const got = io.loadedFrom?.(kind) ?? null;
+            if (io.loadedFrom && (!got || !oursAt.some((w) => resolve(w) === resolve(got)))) {
+                return { line: `${kind}: pid ${q.pid} runs under ${q.managedBy} from ${got ?? "a definition it did not name"}, not ${want} — not this home's, left alone`, killed: false };
+            }
+        }
         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}`);
+        else if (q.managedBy !== "launchd" && q.managedBy !== "systemd" && io.cmdline) {
+            const cmd = io.cmdline(q.pid);
+            if (cmd === null) {
+                return { line: `${kind}: pid ${q.pid} could not be confirmed as Pantheon's ${kind} (its command line could not be read), so it was left alone — a pid is soon reused, and this one may be another program by now. If it is the ${kind}: ${killHint(q.pid)}`, killed: false };
+            }
+            if (!isPantheonKindCommand(kind, cmd)) {
+                return { line: `${kind}: pid ${q.pid} is not Pantheon's ${kind} any more (${cmd.slice(0, 80)}) — left alone`, killed: false };
+            }
+        }
+        const err = io.kill ? io.kill(q.pid) : (io.sh(`kill ${q.pid}`), null);
+        if (err === "ESRCH")
+            return { line: `${kind}: pid ${q.pid} had already exited`, killed: true };
+        if (err === "EPERM") {
+            return { line: `${kind}: pid ${q.pid} is not yours to stop (EPERM) — it belongs to another user on this machine; nothing was stopped`, killed: false };
+        }
+        if (err)
+            return { line: `${kind}: could not stop pid ${q.pid} (${err}) — try: ${killHint(q.pid)}`, killed: false };
         return { line: `${kind}: stopped pid ${q.pid}${q.managedBy === "foreground" ? " (it was started by hand, not as a service)" : ""}`, killed: true };
     };
     if (ours) {
@@ -200,10 +494,15 @@ export function stopProcResult(kind, io = defaultStopIo()) {
             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}`);
+            if (borrowed) {
+                lines.push(`${kind}: could not disable the service (${e.message.split("\n")[0]}) — HOME (${homedir()}) is not your own home, so the service manager was left alone; run this from your own login to stop your services`);
+            }
+            else {
+                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);
@@ -271,6 +570,11 @@ export function stopMachine(what, opts, io = defaultStopIo(opts.port), hosts = h
         lines.push(...r.lines);
         if (kind === "relay")
             relayStopped = r.stopped;
+        if (kind === "worker" && opts.killRun) {
+            const k = opts.killRun();
+            if (k)
+                lines.push(`worker: ${k}`);
+        }
     }
     if (!relayStopped)
         return { lines };
@@ -283,6 +587,76 @@ export function stopMachine(what, opts, io = defaultStopIo(opts.port), hosts = h
     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.` };
 }
+export function ownWorkerPid(io = realProcScanIo()) {
+    const w = pidFileWorker(io);
+    return w?.confirmed ? w.pid : null;
+}
+export function removePantheonWorktrees(repos, roots, git = (repo, args) => execFileSync("git", ["-C", repo, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 30_000 })) {
+    const removed = [], left = [];
+    const real = (p) => { try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    } };
+    const rootsReal = roots.map(real);
+    const under = (p) => { const pp = real(p); return rootsReal.some((rr) => pp === rr || pp.startsWith(rr + "/") || pp.startsWith(rr + "\\")); };
+    for (const repo of [...new Set(repos.map((r) => resolve(r)))]) {
+        let list;
+        try {
+            list = git(repo, ["worktree", "list", "--porcelain"]);
+        }
+        catch {
+            continue;
+        }
+        const trees = [...list.matchAll(/^worktree (.+)$/gm)].map((m) => m[1].trim()).filter(under);
+        let n = 0;
+        for (const t of trees) {
+            try {
+                git(repo, ["worktree", "remove", "--force", t]);
+                n++;
+            }
+            catch (e) {
+                left.push(`the worktree ${t} in ${repo} (${e.message.split("\n")[0]}) — git -C ${repo} worktree remove --force ${t}`);
+            }
+        }
+        try {
+            git(repo, ["worktree", "prune"]);
+        }
+        catch { }
+        if (n)
+            removed.push(`${n} worktree${n === 1 ? "" : "s"} the worker made in ${repo}`);
+    }
+    return { removed, left };
+}
+export function removeHomeLeftovers(home, keep) {
+    const removed = [], left = [];
+    const items = [
+        ["worker-policy.json", "the worker's wake policy (who may wake it, and self-upgrade) — a rejoin starts from no grants"],
+        ["profile.json", "your profile (name, title, what you decide)"],
+        ["spend.json", "the spend ledger"],
+        ["worker.pid", "the worker's pid file"],
+        ["bin", "the menu bar's and alerts' files (the .command scripts, pantheon-hud, pantheon-tray)"],
+    ];
+    for (const [name, what] of items) {
+        const f = join(home, name);
+        if (!existsSync(f))
+            continue;
+        if (keep && name !== "worker.pid" && name !== "bin") {
+            left.push(`${what}, ${f} (--keep-identity)`);
+            continue;
+        }
+        try {
+            rmSync(f, { recursive: true, force: true });
+            removed.push(`${what} (${f})`);
+        }
+        catch (e) {
+            left.push(`${what}, ${f} — could not remove (${e.message.split("\n")[0]})`);
+        }
+    }
+    return { removed, left };
+}
+export const accountStillExists = (email) => `your account${email ? ` ${email}` : ""} still exists — this machine is signed out. Sign back in with: pantheon login${email ? ` --email ${email}` : ""}   (pantheon signup would fail: the email is taken). To delete the account itself: pantheon account delete, before leaving`;
 const LOG_KINDS = ["worker", "relay", "notifier", "menubar"];
 export function uninstallMachine(opts, io) {
     const lines = [], removed = [], left = [];
@@ -290,9 +664,11 @@ export function uninstallMachine(opts, io) {
     for (const kind of kinds) {
         if (io.installed(kind)) {
             try {
-                for (const l of io.uninstall(kind))
+                const said = io.uninstall(kind);
+                for (const l of said)
                     lines.push(`${kind}: ${l.trim()}`);
-                removed.push(`the ${kind} service — stopped, and its definition deleted so it cannot return at login`);
+                const files = said.map((l) => /^\s*removed (.+)$/.exec(l)?.[1]?.trim()).filter((f) => !!f);
+                removed.push(`the ${kind} service — stopped, and its definition deleted so it cannot return at login${files.length ? ` (${files.join(", ")})` : ""}`);
             }
             catch (e) {
                 left.push(`the ${kind} service (${e.message.split("\n")[0]}) — pantheon service uninstall ${kind}`);
@@ -303,8 +679,22 @@ export function uninstallMachine(opts, io) {
             if (kind === "relay")
                 for (const l of io.stop(kind))
                     lines.push(l);
+            else if (kind === "worker" && p.pid && io.ownWorkerPid?.() === p.pid && io.kill) {
+                if (io.kill(p.pid))
+                    removed.push(`the worker started by hand (pid ${p.pid}) — stopped; with no config it could only idle`);
+                else
+                    left.push(`a worker started by hand is still running (pid ${p.pid}) and could not be stopped — close its terminal, or: ${killHint(p.pid)}`);
+            }
+            else if (io.borrowed?.()) {
+                left.push(`a ${kind} (pid ${p.pid ?? "?"}) is running on this machine — with HOME borrowed, it is probably another home's, so it was left alone`);
+            }
             else
-                left.push(`a ${kind} started by hand is still running (pid ${p.pid ?? "?"}) — close its terminal, or: kill ${p.pid ?? "<pid>"}`);
+                left.push(`a ${kind} started by hand is still running (pid ${p.pid ?? "?"}) — close its terminal, or: ${killHint(p.pid)}`);
+        }
+        if (kind === "worker" && io.killRun) {
+            const k = io.killRun();
+            if (k)
+                removed.push(`${k.replace(/^stopped /, "")} — stopped`);
         }
     }
     if (!opts.stopRelay && (io.installed("relay") || io.proc("relay").running)) {
@@ -359,8 +749,12 @@ export function uninstallMachine(opts, io) {
 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)`);
+    if (!workerDown) {
+        const plat = io.platform ?? platform();
+        lines.push((io.borrowed ?? borrowedHome)()
+            ? `  ! a worker is still running, and it is not this home's to stop: HOME (${homedir()}) is not your own home, so the service manager's worker here is the real user's. Run pantheon panic from your own login`
+            : `  ! the worker is still running. Stop it by hand: ${plat === "darwin" ? "launchctl bootout gui/$(id -u)/dev.pantheon.worker   or kill its pid (pantheon ps)" : plat === "win32" ? "taskkill /PID <pid> /F   (the pid is in pantheon ps)" : "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");
@@ -384,6 +778,70 @@ 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 tailLines(file, n) {
+    if (n <= 0)
+        return "";
+    let fd;
+    try {
+        fd = openSync(file, "r");
+    }
+    catch {
+        return "";
+    }
+    try {
+        const size = fstatSync(fd).size;
+        let pos = size, text = "";
+        const chunk = 64 * 1024;
+        while (pos > 0 && (text.match(/\n/g)?.length ?? 0) <= n) {
+            const len = Math.min(chunk, pos);
+            pos -= len;
+            const buf = Buffer.alloc(len);
+            readSync(fd, buf, 0, len, pos);
+            text = buf.toString("utf8") + text;
+        }
+        const lines = text.split("\n");
+        const trailing = text.endsWith("\n");
+        if (trailing)
+            lines.pop();
+        return lines.slice(-n).join("\n") + (lines.length ? "\n" : "");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export async function followFile(file, onData, opts = {}) {
+    let pos = (() => { try {
+        return statSync(file).size;
+    }
+    catch {
+        return 0;
+    } })();
+    const pollMs = opts.pollMs ?? 500;
+    while (!opts.signal?.aborted) {
+        await new Promise((r) => setTimeout(r, pollMs));
+        let size;
+        try {
+            size = statSync(file).size;
+        }
+        catch {
+            continue;
+        }
+        if (size < pos)
+            pos = 0;
+        if (size === pos)
+            continue;
+        const fd = openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(size - pos);
+            readSync(fd, buf, 0, buf.length, pos);
+            pos = size;
+            onData(buf.toString("utf8"));
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+}
 export function statFile(f) {
     try {
         const s = statSync(f);
@@ -409,6 +867,10 @@ export function realUninstallIo(deps) {
         hasIntent: deps.hasIntent,
         clearIntent: deps.clearIntent,
         logDir: join(CONFIG_DIR, "logs"),
+        ownWorkerPid: () => ownWorkerPid(),
+        borrowed: () => borrowedHome(),
+        kill: (pid) => killPid(pid) === null,
+        ...(deps.killRun ? { killRun: deps.killRun } : {}),
     };
 }
 //# sourceMappingURL=machine.js.map