@join-pantheon/cli 0.28.0 → 0.29.0

package/dist/client.js

@@ -2,7 +2,7 @@ import WebSocket from "ws";
 import { signChallenge } from "./identity.js";
 import { newId } from "./protocol.js";
 import { VERSION } from "./version.js";
-import { describeNetError, explainNetError, trySystemFallback, wsOptions } from "./network.js";
+import { describeNetError, explainNetError, noteRelayAnswered, settleSystemFallback, systemFallbackPending, trySystemFallback, wsOptions } from "./network.js";
 export class PantheonClient {
     cfg;
     onEvent;
@@ -34,6 +34,9 @@ export class PantheonClient {
     connected = false;
     pending = null;
     lastError = null;
+    everReadMarked = false;
+    lastInbound = 0;
+    watchdog = null;
     session;
     role;
     enrolledToken = null;
@@ -76,21 +79,39 @@ export class PantheonClient {
         if (!this.everConnected)
             this.closed = false;
         const first = this.localOverride ?? this.cfg.relay;
-        return this.attempt(first).catch(async (e) => {
-            if (!this.localOverride && trySystemFallback(first, e)) {
+        const trial = !this.localOverride && systemFallbackPending(first);
+        const answered = (x) => x?.relayAnswered === true;
+        return this.attempt(first).then(() => { noteRelayAnswered(first); }, async (e) => {
+            if (trial) {
+                settleSystemFallback(first, answered(e));
+            }
+            else if (answered(e)) {
+                noteRelayAnswered(first);
+            }
+            else if (!this.localOverride && trySystemFallback(first, e)) {
+                if (this.everConnected)
+                    throw e;
                 this.closed = false;
+                const kept = this.lastError;
                 try {
-                    return await this.attempt(first);
+                    await this.attempt(first);
+                    settleSystemFallback(first, true);
+                    return;
                 }
                 catch (e2) {
-                    e = e2;
+                    const reached = answered(e2);
+                    settleSystemFallback(first, reached);
+                    if (reached)
+                        e = e2;
+                    else
+                        this.lastError = kept;
                 }
             }
             return this.afterFailure(e);
         }).catch((e) => {
-            if (!explainNetError(e))
+            if (!explainNetError(e, first))
                 throw e;
-            const out = new Error(describeNetError(e));
+            const out = new Error(describeNetError(e, first));
             out.code = e.code;
             throw out;
         });
@@ -109,17 +130,39 @@ export class PantheonClient {
             this.closed = false;
             this.localOverride = local;
             this.usingLoopback = true;
+            if (this.everConnected)
+                throw e;
             return this.attempt(local);
         }
     }
     attempt(address) {
         return new Promise((resolve, reject) => {
             let settled = false;
+            let heard = false;
+            const fail = reject;
+            reject = (err) => fail(heard ? Object.assign(err, { relayAnswered: true }) : err);
             this.ws?.terminate();
+            if (this.watchdog) {
+                clearInterval(this.watchdog);
+                this.watchdog = null;
+            }
             const ws = new WebSocket(address, { handshakeTimeout: 6000, ...wsOptions(address) });
             this.ws = ws;
+            this.lastInbound = Date.now();
+            ws.on("ping", () => { this.lastInbound = Date.now(); });
+            ws.on("pong", () => { this.lastInbound = Date.now(); });
+            this.watchdog = setInterval(() => {
+                if (this.ws === ws && this.connected && Date.now() - this.lastInbound > 45_000) {
+                    try {
+                        ws.terminate();
+                    }
+                    catch { }
+                }
+            }, 5_000);
+            this.watchdog.unref?.();
             ws.on("open", () => { });
             ws.on("message", (raw) => {
+                this.lastInbound = Date.now();
                 let msg;
                 try {
                     msg = JSON.parse(String(raw));
@@ -127,6 +170,8 @@ export class PantheonClient {
                 catch {
                     return;
                 }
+                if (typeof msg?.t === "string")
+                    heard = true;
                 this.onEvent?.(msg);
                 switch (msg.t) {
                     case "challenge":
@@ -142,7 +187,7 @@ export class PantheonClient {
                             display: this.cfg.display ?? this.cfg.member,
                             agent: this.cfg.agent ?? "unknown",
                             pkg: VERSION,
-                            from_seq: this.seq,
+                            ...(this.seq > 0 ? { from_seq: this.seq } : {}),
                             ...(this.cfg.repo ? { repo: this.cfg.repo, ...(this.cfg.repoOrigin ? { repo_origin: this.cfg.repoOrigin } : {}) } : {}),
                         }));
                         break;
@@ -175,8 +220,13 @@ export class PantheonClient {
                         this.session = msg.session;
                         this.everConnected = true;
                         this.head = msg.seq;
-                        if (this.readSeq < msg.seq)
+                        if (msg.seq < this.seq) {
+                            this.seq = msg.seq;
+                            this.readSeq = Math.min(this.readSeq, msg.seq);
+                        }
+                        if (!this.everReadMarked && this.readSeq < msg.seq)
                             this.readSeq = msg.seq;
+                        this.everReadMarked = true;
                         if (msg.token) {
                             this.enrolledToken = msg.token;
                             this.cfg.token = msg.token;
@@ -235,6 +285,8 @@ export class PantheonClient {
                     }
                     case "error": {
                         this.lastError = `${msg.code}: ${msg.message}`;
+                        if (msg.code === "SPACE_DELETED")
+                            this.closed = true;
                         const fn = msg.cid ? this.acks.get(msg.cid) : undefined;
                         if (fn && msg.cid) {
                             this.acks.delete(msg.cid);
@@ -274,13 +326,22 @@ export class PantheonClient {
                     reject(new Error(this.lastError ?? "relay connection failed"));
                 }
                 setTimeout(() => { if (!this.closed)
-                    this.connect().catch(() => { }); }, this.backoff);
+                    this.connect().catch(() => { }); }, Math.round(this.backoff * (0.5 + Math.random())));
                 this.backoff = Math.min(this.backoff * 2, 15_000);
             };
             ws.on("close", down);
             ws.on("error", (e) => { this.lastError = String(e.message ?? e); down(); });
         });
     }
+    handOff() {
+        this.closed = true;
+        for (const w of this.waiters) {
+            clearTimeout(w.timer);
+            w.resolve([]);
+        }
+        this.waiters = [];
+        this.ws?.close(4000, "handover");
+    }
     close() {
         this.closed = true;
         for (const w of this.waiters) {
@@ -288,7 +349,7 @@ export class PantheonClient {
             w.resolve([]);
         }
         this.waiters = [];
-        this.ws?.close();
+        this.ws?.close(1000);
     }
     push(rec) {
         for (let i = 0; i < this.waiters.length; i++) {
@@ -334,7 +395,7 @@ export class PantheonClient {
         });
     }
     rpc(payload) {
-        if (!this.ws || this.ws.readyState !== 1) {
+        if (!this.ws || this.ws.readyState !== 1 || !this.connected) {
             return Promise.reject(new Error(`not connected to relay (${this.lastError ?? "offline"})`));
         }
         const cid = `c${++this.cid}`;

package/dist/config.js

@@ -192,6 +192,21 @@ export function resolveForHook(cwd = process.cwd()) {
     const here = r.repo;
     return bound.some((b) => b.path === here.root || (!!b.origin && b.origin === here.origin)) ? r.cfg : null;
 }
+export function identity(file = loadAll()) {
+    const env = envView(file);
+    if (env)
+        return applyAgentEnv({
+            ...env,
+            ...(file?.account ? { account: file.account } : {}), ...(file?.pendingAuth ? { pendingAuth: file.pendingAuth } : {}),
+        });
+    if (!file)
+        return null;
+    return applyAgentEnv({
+        relay: file.relay, space: "", token: "", member: file.member, publicKey: file.publicKey, privateKey: file.privateKey,
+        ...(file.display ? { display: file.display } : {}), ...(file.agent ? { agent: file.agent } : {}),
+        ...(file.account ? { account: file.account } : {}), ...(file.pendingAuth ? { pendingAuth: file.pendingAuth } : {}),
+    });
+}
 export function load() {
     return resolveFor(process.cwd()).cfg;
 }

package/dist/doctor.js

@@ -15,12 +15,13 @@ import { approvalSummary, chosenApproval, onPath } from "./install.js";
 import { hookState, readIntent, agentHookStates } from "./notify.js";
 import { loadPersonas } from "./persona.js";
 import { workerProc, menubarProc, notifierProc } from "./machine.js";
-import { chooseAgent, describeChoice, unattendedRefusal } from "./agents.js";
+import { chooseAgent, describeChoice, unattendedRefusal, skippedSummary } from "./agents.js";
 import { onPathNamed } from "./which.js";
 import { VERSION } from "./version.js";
 import { serviceInstalled, servicesUnavailable } from "./service.js";
 import { hostEnv, platformName } from "./host-env.js";
-import { currentPlan, explainNetError, proxyFor, redactProxy } from "./network.js";
+import { currentPlan, explainNetError, routeFor, redactProxy } from "./network.js";
+import { refusalOf } from "./refusal.js";
 const HOSTED_RELAY = "relay.joinpantheon.network";
 const git = (args, cwd) => {
     try {
@@ -168,14 +169,16 @@ export async function doctor(projectDir) {
             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 ? `; ${choice.skipped.length} skipped (not signed in)` : ""}`;
+            const shareLine = `${choice.backend.label} — ${choice.signIn?.detail ?? "not checked"}${choice.skipped.length ? `; ${skippedSummary(choice)}` : ""}`;
             const refused = unattendedRefusal(choice);
             if (refused)
                 add("warn", "worker agent", line, `woken runs are refused here, not tried: ${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, `you chose ${prof.agent.primary_surface} at setup; runs use ${choice.backend.label} until it is signed in again`, shareLine);
+                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);
             else
                 add("pass", "worker agent", line, undefined, shareLine);
         }
@@ -224,7 +227,7 @@ export async function doctor(projectDir) {
         add("pass", "transport", url.protocol === "wss:" ? "wss:// (TLS)" : `ws:// on a private address (${url.host})`, undefined, url.protocol === "wss:" ? "wss:// (TLS)" : "ws:// on a private address");
     }
     const plan = currentPlan();
-    const via = proxyFor(cfg.relay, plan);
+    const via = routeFor(cfg.relay, plan);
     if (via) {
         add("pass", "network", `through the proxy ${redactProxy(via)} (from ${plan.source})`, undefined, `through a proxy (${plan.source})`);
     }
@@ -260,7 +263,7 @@ export async function doctor(projectDir) {
     }
     catch (e) {
         const msg = e.message;
-        const nx = explainNetError(e);
+        const nx = explainNetError(e, health);
         if (nx) {
             add("fail", "relay", `cannot reach ${health} — ${nx.why}`, nx.fix, `unreachable (${where}): ${nx.share}`);
             return out;
@@ -272,15 +275,15 @@ export async function doctor(projectDir) {
     let joined = false;
     await client.connect().then(() => { joined = true; }).catch(() => { });
     if (!joined) {
-        const nx = client.pending ? null : explainNetError(new Error(client.lastError ?? ""));
+        const nx = client.pending ? null : explainNetError(new Error(client.lastError ?? ""), cfg.relay);
         if (nx) {
             add("fail", "live link", `the health check got through but the live connection did not — ${nx.why}`, nx.fix, `live connection failed: ${nx.share}`);
             client.close();
             return out;
         }
         client.pending
-            ? add("fail", "membership", "registered but not admitted", `ask an admitted member to run: pantheon admit ${cfg.member} --may-wake   (confirm fingerprint ${fingerprint(cfg.publicKey)} with them by voice first)`, "registered, not admitted")
-            : add("fail", "membership", `refused: ${client.lastError ?? "unknown"}`, "if this is KEY_MISMATCH, someone else already registered your member name — pick another with --me, or have them revoke it", `refused: ${String(client.lastError ?? "unknown").split(/[\s:]/)[0]}`);
+            ? add("fail", "membership", "registered but not admitted", `ask an admitted member to run: pantheon admit ${cfg.member}   (confirm fingerprint ${fingerprint(cfg.publicKey)} with them by voice first)`, "registered, not admitted")
+            : ((r) => add("fail", "membership", `refused: ${r?.message ?? client.lastError ?? "unknown"}`, (r?.fix ?? "run pantheon status for the relay's reason").replace("<you>", cfg.member), `refused: ${r?.code ?? String(client.lastError ?? "unknown").split(/[\s:]/)[0]}`))(refusalOf(client.lastError ?? ""));
         client.close();
         return out;
     }
@@ -295,7 +298,7 @@ export async function doctor(projectDir) {
             .map((p) => `${p.member}[${online.has(p.member) ? "online" : "no session open"}]`).join("  "), undefined, `${admittedPeers.length} admitted, ${peersOnline} with a session open`)
         : add("warn", "peers", "nobody else is admitted to this space yet", "send your teammate an invite from `pantheon invite` (or the one `pantheon start` printed)", "nobody else admitted yet");
     if (pending.length) {
-        add("warn", "pending", pending.map((p) => `${p.member} (${p.fingerprint})`).join("  "), `confirm the fingerprint by voice, then: pantheon admit ${pending[0].member} --may-wake`, `${pending.length} waiting to be admitted`);
+        add("warn", "pending", pending.map((p) => `${p.member} (${p.fingerprint})`).join("  "), `confirm the fingerprint by voice, then: pantheon admit ${pending[0].member}   (add --may-wake only if they should be able to wake this machine)`, `${pending.length} waiting to be admitted`);
     }
     const wakers = client.members.filter((m) => m.admitted && m.may_wake && m.member !== cfg.member);
     const hookStates = agentHookStates(projectDir);

package/dist/grants.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { PANTHEON_TOOLS, PANTHEON_TOOL_NAMES, toolsAllowed } from "./tools.js";
+import { kiroDir } from "./kiro-files.js";
 export const CLAUDE_ALLOW = PANTHEON_TOOLS;
 export const CURSOR_ALLOW = PANTHEON_TOOL_NAMES.map((t) => `Mcp(pantheon:${t})`);
 export const claudeAllow = (approval) => toolsAllowed(approval).map((t) => `mcp__pantheon__${t}`);
@@ -12,6 +13,7 @@ const isOursClaude = (t) => t === CLAUDE_SERVER_RULE || t.startsWith("mcp__panth
 const isOursCursor = (t) => /^Mcp\(pantheon(?::[^)]*)?\)$/.test(t);
 export const claudeSettingsFile = () => join(homedir(), ".claude", "settings.json");
 export const cursorCliConfigFile = () => join(homedir(), ".cursor", "cli-config.json");
+export const kiroMcpFile = () => join(kiroDir(), "settings", "mcp.json");
 function readJson(file) {
     if (!existsSync(file))
         return null;
@@ -125,8 +127,21 @@ export function grantToolPermissions(approval = "approve") {
         { tool: "cursor perms", status: grantCursorToolPermissions(undefined, approval) },
     ];
 }
-export function revokeToolPermissions(claudeFile = claudeSettingsFile(), cursorFile = cursorCliConfigFile()) {
+export function revokeToolPermissions(claudeFile = claudeSettingsFile(), cursorFile = cursorCliConfigFile(), kiroFile = kiroMcpFile()) {
     const out = [];
+    {
+        const doc = readJson(kiroFile);
+        const servers = doc && doc !== "invalid" ? doc.mcpServers : undefined;
+        const entry = servers && typeof servers === "object" ? servers.pantheon : undefined;
+        if (entry && typeof entry === "object" && "autoApprove" in entry) {
+            delete entry.autoApprove;
+            try {
+                writeJson(kiroFile, doc);
+                out.push(`  removed pantheon tool approvals (autoApprove) from ${kiroFile}`);
+            }
+            catch { }
+        }
+    }
     for (const [file, isOurs] of [
         [claudeFile, isOursClaude],
         [cursorFile, isOursCursor],

package/dist/hooks-install.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { MAX_CONSECUTIVE_BLOCKS, isOurHookCommand } from "./notify.js";
 import { copilotHome, kiroHome } from "./agents.js";
-import { KIRO_AGENT_NAME, kiroAgentFile, kiroAgentDoc, readKiroAgent, writeKiroAgent, kiroDefaultIsPantheon } from "./kiro-files.js";
+import { KIRO_AGENT_NAME, kiroAgentFile, kiroAgentDoc, readKiroAgent, writeKiroAgent, kiroDefaultIsPantheon, gitTracks } from "./kiro-files.js";
 function ours(cmd) {
     return isOurHookCommand(cmd);
 }
@@ -262,6 +262,8 @@ export function kiroHookState(scope, projectDir = process.cwd()) {
 export function installKiroHooks(bin, scope, projectDir = process.cwd(), allowed = []) {
     const file = kiroAgentPath(scope, projectDir);
     const a = readKiroAgent(file);
+    if (a?.tracked)
+        return [`  skipped    ${file} is tracked by git — it belongs to the repo, so pantheon neither writes nor removes it`];
     if (a && !a.ours)
         return [`  skipped    ${file} is an agent called "${KIRO_AGENT_NAME}" that pantheon did not write — left as it is`];
     writeKiroAgent(file, kiroAgentDoc(bin, allowed));
@@ -279,7 +281,7 @@ export function removeKiroHooks(projectDir = process.cwd()) {
     const out = [];
     for (const scope of ["project", "user"]) {
         const file = kiroAgentPath(scope, projectDir);
-        if (!kiroHookState(scope, projectDir).installed)
+        if (!kiroHookState(scope, projectDir).installed || gitTracks(file))
             continue;
         try {
             rmSync(file, { force: true });

package/dist/host-env.js

@@ -1,12 +1,35 @@
 import { existsSync, readFileSync } from "node:fs";
 const CLOUD_VARS = [
     ["CODESPACES", "GitHub Codespaces ($CODESPACES)"],
+    ["CLOUDENV_ENVIRONMENT_ID", "GitHub Codespaces ($CLOUDENV_ENVIRONMENT_ID)"],
     ["REMOTE_CONTAINERS", "a VS Code dev container ($REMOTE_CONTAINERS)"],
     ["REMOTE_CONTAINERS_IPC", "a VS Code dev container ($REMOTE_CONTAINERS_IPC)"],
     ["DEVCONTAINER", "a dev container ($DEVCONTAINER)"],
     ["GITPOD_WORKSPACE_ID", "a Gitpod workspace ($GITPOD_WORKSPACE_ID)"],
     ["CLOUD_SHELL", "a cloud shell ($CLOUD_SHELL)"],
+    ["REPL_ID", "a Replit workspace ($REPL_ID)"],
 ];
+const CONTAINER_VARS = [
+    ["KUBERNETES_SERVICE_HOST", "a Kubernetes pod ($KUBERNETES_SERVICE_HOST)"],
+];
+const HOST_INITS = new Set(["systemd", "init", "openrc-init", "runit", "runit-init", "launchd", "dinit", "s6-svscan", "s6-linux-init", "shepherd"]);
+const SANDBOX_ROOT_FS = new Set(["overlay", "overlayfs", "9p", "virtiofs", "aufs"]);
+export function rootFsType(mountinfo) {
+    return rootMount(mountinfo)?.type ?? null;
+}
+export function rootMount(mountinfo) {
+    for (const line of mountinfo.split("\n")) {
+        const [pre, post] = line.split(" - ");
+        if (!pre || !post)
+            continue;
+        const f = pre.trim().split(/\s+/);
+        if (f[4] === "/") {
+            const [type = "", source = ""] = post.trim().split(/\s+/);
+            return { type, source };
+        }
+    }
+    return null;
+}
 export function hostEnv(env = process.env, plat = process.platform, exists = existsSync, read = (p) => readFileSync(p, "utf8")) {
     if (plat === "darwin") {
         return { platform: plat, kind: "local", evidence: [], ephemeral: false, desktop: true };
@@ -19,17 +42,39 @@ export function hostEnv(env = process.env, plat = process.platform, exists = exi
             kind = "cloud-workspace";
         }
     }
+    for (const [name, label] of CONTAINER_VARS)
+        if (env[name])
+            evidence.push(label);
+    if (env.container)
+        evidence.push(`a container runtime set $container=${env.container}`);
+    const readIf = (p) => { try {
+        return exists(p) ? read(p) : "";
+    }
+    catch {
+        return "";
+    } };
     if (exists("/.dockerenv"))
         evidence.push("/.dockerenv exists");
     if (exists("/run/.containerenv"))
         evidence.push("/run/.containerenv exists (podman)");
-    let cgroup = "";
-    try {
-        cgroup = exists("/proc/1/cgroup") ? read("/proc/1/cgroup") : "";
-    }
-    catch { }
-    if (/docker|containerd|kubepods|lxc/.test(cgroup))
+    if (exists("/var/run/secrets/kubernetes.io"))
+        evidence.push("/var/run/secrets/kubernetes.io exists (a Kubernetes pod)");
+    const version = readIf("/proc/version");
+    const wsl = !!env.WSL_DISTRO_NAME || /microsoft/i.test(version);
+    const cgroup = readIf("/proc/1/cgroup");
+    if (/docker|containerd|kubepods|lxc|libpod|crio/.test(cgroup))
         evidence.push("pid 1 is in a container cgroup (/proc/1/cgroup)");
+    else if (cgroup.trim() === "0::/" && !wsl)
+        evidence.push("pid 1 is at the root of its own cgroup namespace (/proc/1/cgroup: 0::/)");
+    const comm = readIf("/proc/1/comm").trim();
+    if (comm && !HOST_INITS.has(comm))
+        evidence.push(`pid 1 is "${comm}", not an init system (/proc/1/comm)`);
+    if (/gvisor/i.test(version) || /#1 SMP Sun Jan 10 15:06:54 PST 2016/.test(version))
+        evidence.push("the kernel is gVisor's (/proc/version)");
+    const root = rootMount(readIf("/proc/1/mountinfo"));
+    const ostree = exists("/run/ostree-booted") || root?.source === "composefs" || root?.type === "composefs";
+    if (root && SANDBOX_ROOT_FS.has(root.type) && !ostree)
+        evidence.push(`the root filesystem is ${root.type} (/proc/1/mountinfo)`);
     if (evidence.length && kind === "local")
         kind = "container";
     return {