@join-pantheon/cli 0.31.0 → 0.31.2-rc.1

package/README.md

@@ -127,8 +127,10 @@ Need another (a third person, or your own second machine)? `pantheon invite`.
 
 ### Plans on the hosted relay
 
-A free account creates **one space** with **two people** in it — you and one invite. Personas,
-messages and history are not limited. Joining spaces other people created is not limited either,
+A free account creates up to **three spaces**, with **two people** in each, and can have three
+invite links open per space. A link is not a seat: if a third person uses one, they are told the
+team is full and who can upgrade it, the owner gets an email, and the same link works once there is
+room. Personas, messages and history are not limited. Joining spaces other people created is not limited either,
 so a colleague on a bigger plan can always invite you. When you hit a limit the command says so
 and what to do; `pantheon status` shows your plan and how much of it you are using. Need more?
 [joinpantheon.network](https://www.joinpantheon.network). A space you founded and no longer need

package/dist/agent-outage.js

@@ -0,0 +1,87 @@
+const MIN = 60_000, HOUR = 60 * MIN;
+export const MAX_TEXT_WAIT_MS = 6 * HOUR;
+const TAIL_LINES = 5;
+const PLAN = "its organization has disabled subscription access for it";
+const LIMIT = "its usage limit is reached";
+const SIGNIN = "its sign-in was refused";
+const OVERLOAD = "its service is overloaded";
+const KINDS = {
+    "claude-code": [
+        { re: /disabled Claude subscription access/i, why: PLAN, wait: 6 * HOUR },
+        { re: /Claude AI usage limit reached|(?:5-hour|weekly|Opus|session) limit reached|you(?:'|’)ve hit your (?:usage )?limit|out of extra usage|credit balance is too low/i, why: LIMIT, wait: HOUR },
+        { re: /OAuth token has expired|Invalid API key · Please run \/login|Please run \/login/i, why: SIGNIN, wait: HOUR },
+        { re: /overloaded_error/i, why: OVERLOAD, wait: 15 * MIN },
+    ],
+    codex: [
+        { re: /you(?:'|’)ve hit your usage limit|exceeded retry limit, last status: 429|insufficient_quota/i, why: LIMIT, wait: HOUR },
+    ],
+    cursor: [
+        { re: /you(?:'|’)ve hit your usage limit|usage limit (?:reached|exceeded) for|out of (?:fast )?requests/i, why: LIMIT, wait: HOUR },
+    ],
+    copilot: [
+        { re: /you(?:'|’)ve hit a rate limit|exceeded your (?:monthly )?(?:premium requests|copilot) (?:quota|allowance|limit)/i, why: LIMIT, wait: HOUR },
+    ],
+    kiro: [],
+};
+function namedTime(line, now) {
+    const rel = /try again in\s+(\d{1,3})\s*(minute|min|hour|hr|day)s?\b/i.exec(line);
+    if (rel) {
+        const n = Number(rel[1]);
+        const u = rel[2].toLowerCase();
+        return now + n * (u.startsWith("d") ? 24 * HOUR : u.startsWith("h") ? HOUR : MIN);
+    }
+    const m = /(?:resets?|reset at|try again (?:at|after))\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i.exec(line);
+    if (!m)
+        return null;
+    let h = Number(m[1]);
+    const min = m[2] ? Number(m[2]) : 0;
+    const ap = m[3]?.toLowerCase();
+    if (ap === "pm" && h < 12)
+        h += 12;
+    if (ap === "am" && h === 12)
+        h = 0;
+    if (h > 23 || min > 59 || (!ap && !m[2]))
+        return null;
+    const d = new Date(now);
+    d.setHours(h, min, 0, 0);
+    let t = d.getTime();
+    if (t <= now)
+        t += 24 * HOUR;
+    return t;
+}
+export function detectOutage(agent, tail, now = Date.now()) {
+    const lines = tail.split("\n").map((l) => l.trim()).filter(Boolean).slice(-TAIL_LINES);
+    for (const k of KINDS[agent] ?? []) {
+        const line = lines.find((l) => k.re.test(l));
+        if (!line)
+            continue;
+        const epoch = agent === "claude-code" ? /Claude AI usage limit reached\|(\d{10})\b/i.exec(line) : null;
+        const named = epoch ? Number(epoch[1]) * 1000 : namedTime(line, now);
+        const until = named && named > now ? Math.min(named, now + MAX_TEXT_WAIT_MS) : now + k.wait;
+        return { why: k.why, until: Math.max(until, now + 5 * MIN) };
+    }
+    return null;
+}
+export function whenAgain(until, now = Date.now()) {
+    const d = new Date(until);
+    const hm = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+    return new Date(now).toDateString() === d.toDateString() ? hm : `${d.toLocaleDateString("en-GB", { weekday: "short" })} ${hm}`;
+}
+export function activeOutages(all, now = Date.now()) {
+    const out = {};
+    for (const [id, o] of all) {
+        if (o.until > now)
+            out[id] = o;
+        else
+            all.delete(id);
+    }
+    return out;
+}
+export function earliest(outages) {
+    let best;
+    for (const o of Object.values(outages))
+        if (o && (!best || o.until < best.until))
+            best = o;
+    return best;
+}
+//# sourceMappingURL=agent-outage.js.map

package/dist/agents.js

@@ -1,10 +1,13 @@
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmSync } from "node:fs";
 import { constants as osConstants, homedir, platform } from "node:os";
-import { join, dirname, isAbsolute } from "node:path";
+import { join, dirname, isAbsolute, relative } from "node:path";
+import { copyInside, mkdirInside, writeInside } from "./safe-write.js";
+import { gitCallEnv, safeGitArgs } from "./git-safe.js";
 import { launcher, kiroDir } from "./install.js";
 import { agentSpawn, which } from "./which.js";
+import { earliest, whenAgain } from "./agent-outage.js";
 import { PANTHEON_TOOL_NAMES, PANTHEON_TOOLS } from "./tools.js";
 import { claudeRunSettings, NO_CLAUDE_FEATURES, runTmpDir, sandboxCacheEnv, versionAtLeast } from "./claude-confine.js";
 export function launchArgs(agent, prompt, name) {
@@ -211,7 +214,8 @@ export function chooseAgent(preferred, opts = {}) {
         const hit = available.find((a) => a.backend.id === backend.id);
         if (!hit)
             throw new Error(`${backend.label} is not on PATH (looked for ${backend.binaries.join(", ")})`);
-        return { backend, binary: hit.binary, signIn: state(backend, hit.binary), because: "pinned", skipped: [] };
+        const out = opts.outages?.[backend.id];
+        return { backend, binary: hit.binary, signIn: state(backend, hit.binary), because: "pinned", skipped: [], ...(out ? { outage: out } : {}) };
     }
     if (!available.length)
         throw new Error("no agent CLI on PATH — install claude, codex, cursor-agent, copilot, or kiro-cli");
@@ -239,12 +243,29 @@ export function chooseAgent(preferred, opts = {}) {
             order.splice(0, order.length, ...boxed);
     }
     for (const c of order) {
+        const out = opts.outages?.[c.backend.id];
+        if (out) {
+            skipped.push({ backend: c.backend, why: `unavailable until ${whenAgain(out.until)} — ${out.why}` });
+            continue;
+        }
         const s = state(c.backend, c.binary);
         if (!s || s.ok || s.unknown)
             return { backend: c.backend, binary: c.binary, ...(s ? { signIn: s } : {}), because: c.because, skipped };
         skipped.push({ backend: c.backend, why: `${s.detail} — ${SIGN_IN_CHECK[c.backend.id].fix}` });
     }
-    const first = order.find((o) => !NEEDS_SIGN_IN_BEFORE_SPAWN.has(o.backend.id)) ?? order[0];
+    const outs = {};
+    for (const o of order) {
+        const x = opts.outages?.[o.backend.id];
+        if (x)
+            outs[o.backend.id] = x;
+    }
+    const soonest = earliest(outs);
+    if (soonest) {
+        const first = order.find((o) => outs[o.backend.id] === soonest);
+        return { backend: first.backend, binary: first.binary, because: `${first.because} (every agent here is unavailable for now)`, skipped, outage: soonest };
+    }
+    const live = order;
+    const first = live.find((o) => !NEEDS_SIGN_IN_BEFORE_SPAWN.has(o.backend.id)) ?? live[0];
     return { backend: first.backend, binary: first.binary, signIn: state(first.backend, first.binary), because: `${first.because} (none signed in)`, skipped };
 }
 export function unattendedRefusal(c, o = {}) {
@@ -371,7 +392,7 @@ export function repoCommands(worktree, rev) {
         return { ok: [], refused: [] };
     let bytes;
     try {
-        bytes = execFileSync("git", ["-C", worktree, "show", `${rev}:${REPO_COMMANDS_FILE}`], { stdio: ["ignore", "pipe", "ignore"], timeout: 10_000, maxBuffer: 1 << 20 });
+        bytes = execFileSync("git", safeGitArgs(worktree, ["-C", worktree, "show", `${rev}:${REPO_COMMANDS_FILE}`]), { stdio: ["ignore", "pipe", "ignore"], env: gitCallEnv(["show"], process.env), timeout: 10_000, maxBuffer: 1 << 20 });
     }
     catch {
         return { ok: [], refused: [] };
@@ -451,6 +472,7 @@ export function headlessSpawn(opts) {
                 ...(opts.readOnlyDirs?.length ? { readOnlyDirs: opts.readOnlyDirs } : {}),
                 runTmp, bashRules, version: f.version, ...(opts.claude.home ? { home: opts.claude.home } : {}),
                 ...(opts.os ? { os: opts.os } : {}), ...(opts.claude.userSettings ? { userSettings: opts.claude.userSettings } : {}),
+                ...(opts.claude.gitCommon ? { gitCommon: opts.claude.gitCommon } : {}),
             });
             if (f.permissionPrompts)
                 extra.push("--permission-prompts", "none");
@@ -629,16 +651,28 @@ export function tomlInlineTable(kv, literal = false) {
 export function tomlLiteral(v) {
     return /['\r\n]/.test(v) ? JSON.stringify(v) : `'${v}'`;
 }
-export function materializeSpawnFiles(worktree, spawn) {
+export function materializeSpawnFiles(worktree, spawn, runHome) {
+    const rootOf = (p) => {
+        for (const r of [runHome, worktree]) {
+            if (!r)
+                continue;
+            const rel = relative(r, p);
+            if (rel && !rel.startsWith("..") && !isAbsolute(rel))
+                return r;
+        }
+        if (!runHome && isAbsolute(p)) {
+            mkdirSync(dirname(p), { recursive: true, mode: 0o700 });
+            return dirname(p);
+        }
+        throw new Error(`${p} is neither in the worktree nor in the run's home — not written`);
+    };
     for (const f of spawn.writeFiles ?? []) {
         const p = isAbsolute(f.path) ? f.path : join(worktree, f.path);
-        mkdirSync(dirname(p), { recursive: true, mode: 0o700 });
-        writeFileSync(p, f.contents, { mode: 0o600 });
+        writeInside(rootOf(p), p, f.contents, 0o600);
     }
     for (const c of spawn.copyFiles ?? []) {
         try {
-            mkdirSync(dirname(c.to), { recursive: true, mode: 0o700 });
-            copyFileSync(c.from, c.to);
+            copyInside(rootOf(c.to), c.from, c.to, 0o600);
         }
         catch { }
     }
@@ -690,7 +724,7 @@ export function hashPath(p) {
 }
 function headOf(worktree) {
     try {
-        return execFileSync("git", ["-C", worktree, "rev-parse", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim();
+        return execFileSync("git", safeGitArgs(worktree, ["-C", worktree, "rev-parse", "HEAD"]), { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], env: gitCallEnv(["rev-parse"], process.env), timeout: 10_000 }).trim();
     }
     catch {
         return "";
@@ -768,11 +802,11 @@ function freeName(base) {
         if (!taken(`${base}-${i}`))
             return `${base}-${i}`;
 }
-const writeManifest = (dir, m) => writeFileSync(join(dir, "manifest.json"), JSON.stringify(m), { mode: 0o600 });
+const writeManifest = (dir, m) => writeInside(dir, join(dir, "manifest.json"), JSON.stringify(m), 0o600);
 function keepDiscarded(stashRoot, dir, rel) {
     const to = join(stashRoot, "quarantine-kept", `${Date.now()}-${randomBytes(3).toString("hex")}`, rel);
     try {
-        mkdirSync(dirname(to), { recursive: true, mode: 0o700 });
+        mkdirInside(stashRoot, dirname(to));
         moveSync(join(dir, "files", rel), to);
         return to;
     }
@@ -826,10 +860,15 @@ function restoreFrom(stashRoot, dir, m, mode) {
             r.lines.push(`${e.rel}: could not be put back (${err.message.split("\n")[0]}); it stays held for the next run`);
         }
     }
-    if (left.length)
-        writeManifest(dir, { ...m, moved: left });
-    else
-        rmSync(dir, { recursive: true, force: true });
+    try {
+        if (left.length)
+            writeManifest(dir, { ...m, moved: left });
+        else
+            rmSync(dir, { recursive: true, force: true });
+    }
+    catch (err) {
+        r.lines.push(`the record of what is still held could not be written (${err.message.split("\n")[0]}); the held files are in ${dir}`);
+    }
     return r;
 }
 function readManifest(file) {
@@ -850,7 +889,7 @@ export function recoverRepoAgentConfig(worktree, stashRoot) {
         if (existsSync(join(dir, "manifest.json"))) {
             const kept = join(stashRoot, "quarantine-kept", `${Date.now()}-legacy`);
             try {
-                mkdirSync(dirname(kept), { recursive: true });
+                mkdirInside(stashRoot, dirname(kept));
                 moveSync(dir, kept);
             }
             catch { }
@@ -942,7 +981,7 @@ export function quarantineRepoAgentConfig(worktree, stashRoot) {
     const recovered = recoverRepoAgentConfig(worktree, stashRoot);
     const dir = quarantineDir(stashRoot, worktree);
     const m = { v: 2, worktree, head: headOf(worktree), moved: [], wrote: {} };
-    mkdirSync(join(dir, "files"), { recursive: true, mode: 0o700 });
+    mkdirInside(stashRoot, join(dir, "files"));
     let done = null;
     const restore = () => {
         if (done)
@@ -962,7 +1001,7 @@ export function quarantineRepoAgentConfig(worktree, stashRoot) {
                 continue;
             const hash = hashPath(join(worktree, unit));
             const to = join(dir, "files", unit);
-            mkdirSync(dirname(to), { recursive: true, mode: 0o700 });
+            mkdirInside(stashRoot, dirname(to));
             moveSync(join(worktree, unit), to);
             m.moved.push({ rel: unit, hash });
             writeManifest(dir, m);

package/dist/claude-confine.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { lstatSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { writeInside } from "./safe-write.js";
 import { homedir, platform, tmpdir } from "node:os";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { agentSpawn } from "./which.js";
@@ -97,6 +98,17 @@ export const GIT_DENY_RULES = [
     "Bash(git push --delete*)", "Bash(git push * --delete*)", "Bash(git push -d *)", "Bash(git push * -d *)",
     "Bash(git push --mirror*)", "Bash(git push * --mirror*)", "Bash(git push --all*)", "Bash(git push * --all*)",
 ];
+export function gitDataDeny(common) {
+    const c = resolve(common);
+    const files = [join(c, "config"), join(c, "commondir"), join(c, "objects", "info", "alternates")];
+    try {
+        for (const w of readdirSync(join(c, "worktrees")))
+            for (const f of ["config.worktree", "commondir", "gitdir"])
+                files.push(join(c, "worktrees", w, f));
+    }
+    catch { }
+    return { files, dirs: [join(c, "hooks"), join(c, "info")] };
+}
 const inside = (child, parent) => {
     const r = relative(parent, child);
     return r === "" || (!!r && !r.startsWith("..") && !isAbsolute(r));
@@ -175,6 +187,7 @@ export function claudeRunSettings(i) {
         return !bad;
     });
     const keeps = [worktree, ...readOnly];
+    const gitDeny = i.gitCommon ? gitDataDeny(i.gitCommon) : null;
     for (const t of targets) {
         if (seen.has(t.abs))
             continue;
@@ -200,6 +213,11 @@ export function claudeRunSettings(i) {
             return [`Read(${p})`, `Edit(${p})`];
         }),
         ...readOnly.flatMap((d) => [`Edit(${ruleSpelling(d, home, os)}/**)`, ...SECRET_FILE_GLOBS.map((g) => `Read(${ruleSpelling(d, home, os)}/**/${g})`)]),
+        ...(gitDeny ? [
+            ...gitDeny.dirs.map((d) => `Edit(${ruleSpelling(d, home, os)}/**)`),
+            ...gitDeny.files.map((f) => `Edit(${ruleSpelling(f, home, os)})`),
+            `Edit(${ruleSpelling(join(resolve(i.gitCommon), "worktrees"), home, os)}/*/config.worktree)`,
+        ] : []),
     ];
     if (!i.allowBash) {
         const permissions = { deny: ["Bash", "PowerShell", ...fileRules] };
@@ -230,7 +248,7 @@ export function claudeRunSettings(i) {
         allowUnsandboxedCommands: false,
         filesystem: {
             allowWrite: [...new Set([resolve(i.runTmp), resolve(tmpdir())])],
-            denyWrite: readOnly.map((d) => sandboxSpelling(d, home)),
+            denyWrite: [...readOnly.map((d) => sandboxSpelling(d, home)), ...(gitDeny ? [...gitDeny.dirs, ...gitDeny.files].map((p) => sandboxSpelling(p, home)) : [])],
             denyRead: denied.map((t) => sandboxSpelling(t.abs, home)),
             allowRead: [hooks],
         },
@@ -253,8 +271,7 @@ export function runTmpDir(runHome) {
     if (!/^[0-9a-f]{32}$/.test(salt)) {
         salt = randomBytes(16).toString("hex");
         try {
-            mkdirSync(runHome, { recursive: true, mode: 0o700 });
-            writeFileSync(saltFile, salt, { mode: 0o600 });
+            writeInside(runHome, saltFile, salt, 0o600);
         }
         catch { }
     }