@join-pantheon/cli 0.30.0 → 0.31.1

package/dist/doctor.js

@@ -6,7 +6,7 @@ import { describeWindows, scanMcpWindows } from "./mcp-windows.js";
 import { grantsSeen, measureMcp, toolsReport, HOST_STARTUP_ALLOWANCE_MS, STARTUP_WARN_MS } from "./measure.js";
 import { FEEDBACK_ADDRESS } from "./feedback.js";
 import { loadProfile, profileInitialized, wakeMode } from "./profile.js";
-import { isApprovedWaker, loadPolicy, relayKnowsAdmitters } from "./worker-policy.js";
+import { isApprovedWaker, loadPolicy, relayKnowsAdmitters, unsandboxedAllowed } from "./worker-policy.js";
 import { commandState } from "./command-state.js";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir, platform } from "node:os";
@@ -18,7 +18,7 @@ import { approvalSummary, chosenApproval, copilotMcpConfigFile, kiroMcpConfigFil
 import { hookState, readIntent, agentHookStates } from "./notify.js";
 import { loadPersonas } from "./persona.js";
 import { workerProc, menubarProc, notifierProc } from "./machine.js";
-import { chooseAgent, describeChoice, unattendedRefusal, skippedSummary } from "./agents.js";
+import { agentById, chooseAgent, describeChoice, unattendedRefusal, skippedSummary, SANDBOXED_FOR_UNATTENDED } from "./agents.js";
 import { onPathNamed } from "./which.js";
 import { VERSION } from "./version.js";
 import { serviceInstalled, servicesUnavailable } from "./service.js";
@@ -138,14 +138,15 @@ export async function doctor(projectDir) {
     add("pass", "config", `${cfg.member} in "${cfg.space}" via ${cfg.relay}  (${CONFIG_PATH})`, undefined, "present");
     const here = resolveFor(projectDir, { strict: true });
     const nTeams = Object.keys(loadAll()?.spaces ?? {}).length;
+    const folderHere = here.reason === "binding" && !here.repo;
     if (here.reason === "binding")
-        add("pass", "team", `this repo is bound to "${here.cfg.space}"${here.repo?.origin ? ` (${here.repo.origin})` : ""}`, undefined, `this repo is bound to a team (${nTeams} on this machine)`);
+        add("pass", "team", folderHere ? `this folder is bound to "${here.cfg.space}" (${here.binding?.path ?? projectDir}) — no git needed` : `this repo is bound to "${here.cfg.space}"${here.repo?.origin ? ` (${here.repo.origin})` : ""}`, undefined, `this ${folderHere ? "folder" : "repo"} is bound to a team (${nTeams} on this machine)`);
     else if (here.reason === "single")
         add("pass", "team", `"${cfg.space}" — your only team, so every folder resolves to it`, undefined, "one team on this machine");
     else if (here.reason === "unbound")
         add("fail", "team", `this folder is not bound to any of your ${nTeams} teams — agents opened here will refuse to send`, `from the team's checkout: pantheon use <team> --here   (pantheon spaces lists them)`, `folder not bound to any of ${nTeams} teams`);
     else if (here.reason === "stale")
-        add("fail", "team", `this repo is bound to a team this machine has left (${here.binding?.space})`, "pantheon use <team> --here, or pantheon join <invite>", "bound to a team this machine has left");
+        add("fail", "team", `this ${here.repo ? "repo" : "folder"} is bound to a team this machine has left (${here.binding?.space})`, "pantheon use <team> --here, or pantheon join <invite>", "bound to a team this machine has left");
     if (here.repo && !here.repo.shared)
         add("warn", "team", "this repo has no origin remote", "DELIVERED must name a commit a teammate can fetch; add a remote before delivering", "repo has no origin remote");
     const nonce = "doctor-selftest";
@@ -208,7 +209,10 @@ export async function doctor(projectDir) {
         ? add("pass", "PATH", "`pantheon` resolves by name", undefined, "pantheon resolves by name")
         : add("warn", "PATH", "`pantheon` is not on PATH", "install it globally (`npm install -g @join-pantheon/cli`) and make sure your npm global bin dir (`npm bin -g`) is on PATH", "pantheon is not on PATH");
     const inRepo = git(["rev-parse", "--is-inside-work-tree"], projectDir) === "true";
-    if (!inRepo) {
+    if (!inRepo && folderHere) {
+        add("pass", "git", "a plain folder — messages, questions and decisions work here; code is handed over from a repo", undefined, "plain folder, no git needed");
+    }
+    else if (!inRepo) {
         add("warn", "git", `${projectDir} is not a git repo`, "DELIVERED requires a pushed branch + commit, so the work needs to live in a repo you both clone", "not a git repo");
     }
     else {
@@ -226,20 +230,28 @@ export async function doctor(projectDir) {
         : add("warn", "agent cli", "found none of claude / codex / cursor-agent / copilot / kiro-cli on PATH", "fine if you only drive agents through a GUI (Conductor, Cursor, VS Code, the Kiro IDE), but `pantheon worker` needs a CLI to spawn", "none of claude / codex / cursor-agent / copilot / kiro-cli on PATH");
     if (agents.length) {
         try {
-            const choice = chooseAgent("auto", { prefer: prof.agent.primary_surface });
+            let unsandboxedOk = false;
+            try {
+                unsandboxedOk = unsandboxedAllowed(loadPolicy());
+            }
+            catch { }
+            const choice = chooseAgent("auto", { prefer: prof.agent.primary_surface, unsandboxedOk });
             const line = describeChoice(choice);
             const bad = choice.signIn && !choice.signIn.ok && !choice.signIn.unknown;
             const fellBack = !!prof.agent.primary_surface && choice.backend.id !== prof.agent.primary_surface && agents.length > 0;
             const shareLine = `${choice.backend.label} — ${choice.signIn?.detail ?? "not checked"}${choice.skipped.length ? `; ${skippedSummary(choice)}` : ""}`;
-            const refused = unattendedRefusal(choice);
+            const refused = unattendedRefusal(choice, { unsandboxedOk });
+            const surface = prof.agent.primary_surface ? agentById(prof.agent.primary_surface) : undefined;
             if (refused)
-                add("warn", "worker agent", line, `woken runs are refused here, not tried: ${refused}`, shareLine);
+                add("warn", "worker agent", line, `teammates' requests wait for your next session here: ${refused}`, shareLine);
             else if (bad)
                 add("warn", "worker agent", line, `nothing is signed in, so every woken run here fails until you sign in: ${choice.skipped.map((x) => x.why).join("; ") || "sign in to the agent CLI"}`, shareLine);
             else if (fellBack)
                 add("warn", "worker agent", line, prof.agent.primary_surface === "kiro"
-                    ? `you chose Kiro at setup; Kiro cannot yet be fenced to its worktree for unattended runs, so runs use ${choice.backend.label}`
-                    : `you chose ${prof.agent.primary_surface} at setup; runs use ${choice.backend.label} until it is signed in again`, shareLine);
+                    ? `you chose Kiro at setup; Kiro answers in your live sessions, and runs while you're away use ${choice.backend.label}`
+                    : surface && !SANDBOXED_FOR_UNATTENDED.has(surface.id) && !unsandboxedOk
+                        ? `you chose ${surface.label} at setup; runs while you're away use ${choice.backend.label} in its sandbox (to have ${surface.label} answer them: pantheon policy grant unsandboxed-runs)`
+                        : `you chose ${prof.agent.primary_surface} at setup; runs use ${choice.backend.label} until it is signed in again`, shareLine);
             else
                 add("pass", "worker agent", line, undefined, shareLine);
         }
@@ -371,17 +383,51 @@ export async function doctor(projectDir) {
     const hookStates = agentHookStates(projectDir);
     const hook = hookStates[0] ?? hookState(projectDir);
     const reportsActivity = hookStates.some((s) => s.events?.some((e) => /prompt|UserPromptSubmit|beforeSubmitPrompt/i.test(e))) || (hook.events?.includes("UserPromptSubmit") ?? false);
+    {
+        const { loadPins, pinsPath } = await import("./pins.js");
+        const { brokenStateFiles, brokenStateFix } = await import("./file-lock.js");
+        const { dirname } = await import("node:path");
+        const broken = brokenStateFiles(dirname(pinsPath()));
+        if (broken.length)
+            add("fail", "signing", `${broken.join(", ")} in ${dirname(pinsPath())} cannot be read and written — they are what stops a request being run twice, so the worker holds every unattended run until they are fixed`, brokenStateFix(broken), "state files broken");
+        const all = loadPins();
+        if (all.corrupt)
+            add("fail", "signing", `${pinsPath()} could not be read — no message is trusted until it can be`, "restore it from a backup, or remove it to pin teammates' keys afresh (then check each with them: pantheon trust)", "keys.json unreadable");
+        const t = all.teams[client.pinKey()];
+        const pending = Object.entries(t?.members ?? {}).filter(([, p]) => p.pending).map(([m]) => m);
+        const n = Object.keys(t?.members ?? {}).filter((m) => m !== cfg.member).length;
+        if (client.features.includes("act-sig")) {
+            if (pending.length)
+                add("warn", "signing", `${pending.join(", ")}'s key changed — their messages are not trusted here until you check the new key with them`, `pantheon trust ${pending[0]}`, `${pending.length} key change${pending.length === 1 ? "" : "s"} waiting`);
+            else
+                add("pass", "signing", `messages are signed; this machine checks them against ${n} teammate key${n === 1 ? "" : "s"} it pinned (pantheon trust lists them)`, undefined, `signed; ${n} keys pinned`);
+        }
+        else if (t?.sigs || client.signaturesExpected()) {
+            add("fail", "signing", "this team's relay does not carry signatures, though this machine expects them (it signed before, or you joined with 0.31+) — requests are not run here until it does", "check the relay's version with its operator (pantheon doctor on a teammate's machine)", "relay stopped carrying signatures");
+        }
+        else {
+            add("warn", "signing", "this team's relay does not carry signatures yet (a relay before 0.31), so messages cannot be checked against their senders' keys", "upgrade the relay", "relay without signatures");
+        }
+    }
     const workerUp = workerProc().running;
     const mode = wakeMode(loadProfile(cfg));
+    const anyoneWhy = loadProfile(cfg).agent.wake_default === "anyone" ? "you chose \"anyone\"" : "\"anyone\" is the default";
     const policy = loadPolicy();
     const approvedHere = admittedPeers.filter((m) => isApprovedWaker(policy, [client.spaceId ?? cfg.spaceId, cfg.space], m.member));
     const teamKey = client.spaceId ?? cfg.spaceId ?? cfg.space;
     const notCarried = mode === "approved" && !policy.wakersCarried?.[teamKey] && !policy.wakersCarried?.[cfg.space] && !relayKnowsAdmitters(client.members, cfg.member);
     const effective = mode === "anyone" || notCarried ? wakers : mode === "no" ? [] : approvedHere.filter((m) => m.may_wake);
     const blockedByTeam = mode === "approved" ? approvedHere.filter((m) => !m.may_wake) : [];
-    if (!effective.length) {
+    const noSvcHere = servicesUnavailable(host.platform);
+    if (!effective.length && mode === "approved" && !blockedByTeam.length && !notCarried) {
+        if (workerUp)
+            add("pass", "wake rights", "nobody approved yet — you are asked the first time a teammate's request needs this machine (Always / Just this once / No)", undefined, "ask on first request; worker running");
+        else
+            add("warn", "wake rights", "no worker is running here, so teammates' requests wait for you — and nobody is asked", noSvcHere ? "Pantheon does not run in the background on Windows yet, so a peer's act waits until your agent is open" : "start it: pantheon service install worker (it serves every repo and folder bound here)", "ask on first request; worker not running");
+    }
+    else if (!effective.length) {
         const why = mode === "no" ? "this machine is set not to be woken"
-            : mode === "anyone" ? "you chose \"anyone\", and the team lets nobody wake workers"
+            : mode === "anyone" ? `${anyoneWhy}, and the team lets nobody wake workers`
                 : blockedByTeam.length ? `approved here: ${blockedByTeam.map((m) => m.member).join(", ")}, but the team does not let them wake workers yet`
                     : "nobody is approved on this machine";
         add("warn", "wake rights", `no teammate can wake a worker on this machine — ${why}`, mode === "no" ? "that is what you chose; pantheon setup to change it"
@@ -389,7 +435,7 @@ export async function doctor(projectDir) {
                 : "that is a safe default; let one teammate wake this machine with `pantheon wake allow <name>` when you want unattended replies", `nobody can wake this machine (${mode}); worker ${workerUp ? "running" : "not running"}`);
     }
     else {
-        const who = `${effective.map((m) => m.member).join(", ")} can wake a worker here (${mode === "anyone" ? "you chose \"anyone\"" : notCarried ? "the team's may_wake decides until this relay is 0.30 or newer" : "approved on this machine"})`;
+        const who = `${effective.map((m) => m.member).join(", ")} can wake a worker here (${mode === "anyone" ? anyoneWhy : notCarried ? "the team's may_wake decides until this relay is 0.30 or newer" : "approved on this machine"})`;
         const wakers = effective;
         if (workerUp) {
             add("pass", "wake rights", `${who} — worker is running`, undefined, `${wakers.length} may wake; worker running`);
@@ -398,12 +444,44 @@ export async function doctor(projectDir) {
             const noSvc = servicesUnavailable(host.platform);
             add("warn", "wake rights", `${who}, but no worker is running here, so nothing can be woken`, noSvc
                 ? "Pantheon does not run in the background on Windows yet, so a peer's act waits until your agent is open"
-                : "start one with `pantheon service install worker --project <a git repo>`; until then a peer's act waits for you to type", `${wakers.length} may wake; worker not running`);
+                : "start one with `pantheon service install worker` (it serves every repo and folder bound here); until then a peer's act waits for you to type", `${wakers.length} may wake; worker not running`);
+        }
+    }
+    {
+        const f = loadAll();
+        const m = f && Object.values(f.spaces ?? {}).find((x) => x.id === (client.spaceId ?? cfg.spaceId) || x.name === cfg.space);
+        if (f && m) {
+            const { teamWorkspaces } = await import("./worker-fleet.js");
+            const ws = teamWorkspaces(f, m.id);
+            const fps = new Set(ws.map((w) => w.fp).filter(Boolean));
+            const missing = (m.repos ?? []).filter((r) => !fps.has(r.fp)).map((r) => r.name);
+            if (ws.length) {
+                add("pass", "worker serves", `${ws.map((w) => `${w.name}${w.kind === "folder" ? " (folder)" : ""}`).join(", ")}${missing.length ? ` — not on this machine: ${missing.join(", ")}` : ""}`, missing.length ? "requests about those are told they wait for you; clone them, then: pantheon repo find" : undefined, `${ws.length} workspace${ws.length === 1 ? "" : "s"}${missing.length ? `, ${missing.length} team repo${missing.length === 1 ? "" : "s"} not here` : ""}`);
+            }
         }
     }
     {
         const cs = commandState({ project: projectDir });
-        add("pass", "commands", `woken runs: ${cs.summary}`, undefined, cs.level === "off" ? "woken runs edit files only" : `woken runs may run commands (${cs.allowBash ? "--allow-bash" : "granted here"})`);
+        let servesRepo = true;
+        try {
+            const f = loadAll();
+            const m = f && Object.values(f.spaces ?? {}).find((x) => x.id === (client.spaceId ?? cfg.spaceId) || x.name === cfg.space);
+            if (f && m) {
+                const ws = (await import("./worker-fleet.js")).teamWorkspaces(f, m.id);
+                servesRepo = !ws.length || ws.some((w) => w.kind === "repo");
+            }
+        }
+        catch { }
+        if (!servesRepo)
+            add("pass", "commands", "not used here — a docs folder is read and answered from, never run in", undefined, "docs folder only; commands not used");
+        else {
+            const { commandCaveat } = await import("./command-state.js");
+            const caveat = cs.level !== "off" ? commandCaveat() : "";
+            if (caveat)
+                add("warn", "commands", `woken runs: ${cs.summary} — ${caveat}`, undefined, "how woken runs here use commands");
+            else
+                add("pass", "commands", `woken runs: ${cs.summary}`, undefined, cs.level === "off" ? "woken runs edit files only" : `woken runs may run commands (${cs.allowBash ? "--allow-bash" : "granted here"})`);
+        }
         if (cs.level !== "off" && host.platform === "linux") {
             const missing = ["bwrap", "socat"].filter((b) => !onPathNamed(b, "linux"));
             if (missing.length)

package/dist/file-lock.js

@@ -0,0 +1,197 @@
+import { closeSync, existsSync, linkSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname, join } from "node:path";
+const STALE_MS = 15_000;
+const WAIT_MS = 20_000;
+const sleepSync = (ms) => { try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+catch { } };
+const readLock = (lock) => { try {
+    return readStateFile(lock);
+}
+catch {
+    return null;
+} };
+function alive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+function stale(lock, content) {
+    let age;
+    try {
+        age = Math.abs(Date.now() - statSync(lock).mtimeMs);
+    }
+    catch {
+        return false;
+    }
+    if (age > STALE_MS)
+        return true;
+    const m = /^(\d+) [0-9a-f]{24}$/.exec(content ?? "");
+    if (!m)
+        return age > 1_000;
+    return !alive(Number(m[1])) && age > 50;
+}
+const clear = (p) => { try {
+    rmSync(p, { recursive: true, force: true });
+}
+catch { } };
+function takeOver(lock, seen) {
+    const brk = `${lock}.break`;
+    const mine = `${brk}.${process.pid}.${randomBytes(4).toString("hex")}`;
+    try {
+        writeFileSync(mine, "", { flag: "wx", mode: 0o600 });
+    }
+    catch {
+        return;
+    }
+    try {
+        try {
+            linkSync(mine, brk);
+        }
+        catch {
+            try {
+                const st = statSync(brk);
+                if (!st.isFile() || Math.abs(Date.now() - st.mtimeMs) > 5_000)
+                    clear(brk);
+            }
+            catch { }
+            return;
+        }
+        try {
+            const now = readLock(lock);
+            if (now !== seen || !stale(lock, now))
+                return;
+            const aside = `${lock}.stale.${process.pid}.${randomBytes(4).toString("hex")}`;
+            try {
+                renameSync(lock, aside);
+            }
+            catch {
+                clear(lock);
+                return;
+            }
+            if (readLock(aside) !== seen) {
+                try {
+                    linkSync(aside, lock);
+                }
+                catch { }
+            }
+            clear(aside);
+        }
+        finally {
+            try {
+                rmSync(brk, { force: true });
+            }
+            catch { }
+        }
+    }
+    finally {
+        try {
+            rmSync(mine, { force: true });
+        }
+        catch { }
+    }
+}
+export function readStateFile(p) {
+    let st;
+    try {
+        st = statSync(p);
+    }
+    catch {
+        return null;
+    }
+    if (!st.isFile())
+        throw new Error(`${p} is not a plain file`);
+    return readFileSync(p, "utf8");
+}
+export function brokenStateFiles(dir) {
+    const out = [];
+    if (existsSync(dir)) {
+        const probe = join(dir, `.write-check.${randomBytes(4).toString("hex")}`);
+        try {
+            writeFileSync(probe, "", { flag: "wx", mode: 0o600 });
+            rmSync(probe, { force: true });
+        }
+        catch {
+            out.push("(the folder)");
+        }
+    }
+    for (const f of ["nonces.json", "continued.json", "keys.json"]) {
+        const p = join(dir, f);
+        try {
+            const text = readStateFile(p);
+            if (text === null)
+                continue;
+            JSON.parse(text);
+            closeSync(openSync(p, "r+"));
+        }
+        catch {
+            out.push(f);
+        }
+    }
+    return out;
+}
+export function brokenStateFix(broken) {
+    const files = broken.filter((b) => b !== "(the folder)");
+    const parts = [];
+    if (broken.includes("(the folder)"))
+        parts.push("make the Pantheon folder writable again (its permissions) — do not delete it: it holds your key and memberships");
+    if (files.length)
+        parts.push(`repair or delete ${files.join(", ")} (one made read-only or locked: make it writable again; one that is a folder or not a file: delete it)`);
+    return parts.join("; ");
+}
+export function withFileLock(f, fn) {
+    mkdirSync(dirname(f), { recursive: true, mode: 0o700 });
+    const lock = `${f}.lock`;
+    const token = `${process.pid} ${randomBytes(12).toString("hex")}`;
+    const deadline = Date.now() + WAIT_MS;
+    const made = `${lock}.${randomBytes(6).toString("hex")}.new`;
+    writeFileSync(made, token, { mode: 0o600, flag: "wx" });
+    try {
+        for (;;) {
+            let got = false;
+            try {
+                linkSync(made, lock);
+                got = true;
+            }
+            catch (e) {
+                const code = e.code;
+                if (code !== "EEXIST" && !(process.platform === "win32" && (code === "EPERM" || code === "EACCES" || code === "EBUSY")))
+                    throw e;
+            }
+            if (got)
+                break;
+            const content = readLock(lock);
+            if (stale(lock, content))
+                takeOver(lock, content);
+            if (Date.now() > deadline)
+                throw new Error(`${f} is locked by another pantheon process (${lock})`);
+            sleepSync(2 + Math.floor(Math.random() * 8));
+        }
+    }
+    finally {
+        try {
+            rmSync(made, { force: true });
+        }
+        catch { }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        if (readLock(lock) === token) {
+            try {
+                rmSync(lock, { force: true });
+            }
+            catch { }
+        }
+    }
+}
+//# sourceMappingURL=file-lock.js.map