@join-pantheon/cli 0.28.0 → 0.29.0

package/dist/accounts.js

@@ -168,6 +168,8 @@ export class Accounts {
             const existing = this.accountByEmail(e);
             if (existing && existing.status === "active")
                 return { ok: false, reason: "email_taken" };
+            if (existing && existing.status === "suspended")
+                return { ok: false, reason: "blocked" };
             const byName = this.accountByUsername(u);
             if (byName && byName.email !== e)
                 return { ok: false, reason: "username_taken" };
@@ -177,9 +179,12 @@ export class Accounts {
             if (!acct || acct.status !== "active")
                 return { ok: false, reason: "no_such_account" };
         }
-        const prev = this.db.prepare("SELECT created_at FROM verifications WHERE email = ?").get(e);
+        const prev = this.db.prepare("SELECT created_at, expires_at, pending_pubkey FROM verifications WHERE email = ?").get(e);
         if (prev && now() - prev.created_at < CODE_RESEND_COOLDOWN_MS)
             return { ok: false, reason: "too_soon" };
+        if (prev && now() < prev.expires_at && prev.pending_pubkey && prev.pending_pubkey !== opts.pubkey) {
+            return { ok: false, reason: "in_progress_elsewhere" };
+        }
         const code = String(randomInt(0, 1_000_000)).padStart(6, "0");
         this.db.prepare(`
       INSERT INTO verifications (email, code_hash, purpose, pending_username, pending_pubkey, pending_label, expires_at, attempts, created_at)
@@ -192,7 +197,7 @@ export class Accounts {
     `).run(e, sha(code), purpose, purpose === "signup" ? normalizeUsername(opts.username) : null, opts.pubkey, opts.label, now() + CODE_TTL_MS, now());
         return { ok: true, code };
     }
-    verify(email, code, ip) {
+    verify(email, code, ip, pubkey) {
         const e = normalizeEmail(email);
         const v = this.db.prepare("SELECT * FROM verifications WHERE email = ?").get(e);
         if (!v)
@@ -203,6 +208,8 @@ export class Accounts {
         }
         if (v.attempts >= MAX_ATTEMPTS)
             return { ok: false, reason: "too_many_attempts" };
+        if (pubkey && v.pending_pubkey && pubkey !== v.pending_pubkey)
+            return { ok: false, reason: "other_device" };
         const want = Buffer.from(v.code_hash, "hex");
         const got = Buffer.from(sha(code), "hex");
         const good = want.length === got.length && timingSafeEqual(want, got);
@@ -216,6 +223,10 @@ export class Accounts {
             let account;
             if (v.purpose === "signup") {
                 const existing = this.accountByEmail(e);
+                if (existing?.status === "suspended") {
+                    this.db.exec("ROLLBACK");
+                    return { ok: false, reason: "suspended" };
+                }
                 if (existing) {
                     account = existing;
                     run("UPDATE accounts SET status = 'active', username = ?, tos_at = COALESCE(tos_at, ?) WHERE id = ?").run(v.pending_username, now(), account.id);

package/dist/agents.js

@@ -1,7 +1,7 @@
 import { execFileSync } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, platform } from "node:os";
+import { createHash, randomBytes } from "node:crypto";
+import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { constants as osConstants, homedir, platform } from "node:os";
 import { join, dirname, isAbsolute } from "node:path";
 import { launcher, kiroDir } from "./install.js";
 import { agentSpawn, which } from "./which.js";
@@ -122,6 +122,8 @@ export const SIGN_IN_CHECK = {
     kiro: { args: ["whoami", "--format", "json"], fix: "run `kiro-cli login` (or set KIRO_API_KEY)" },
 };
 export const NEEDS_SIGN_IN_BEFORE_SPAWN = new Set(["kiro"]);
+export const NOT_FOR_UNATTENDED_RUNS = new Set(["kiro"]);
+export const KIRO_UNATTENDED_REFUSAL = "Kiro cannot yet be fenced to its worktree for unattended runs; the worker uses another installed agent, or none";
 export function kiroSignedIn(binary, run = runStatus, env = process.env, home = homedir(), os = platform()) {
     if (env.KIRO_API_KEY)
         return { ok: true, detail: "signed in (KIRO_API_KEY in the environment)" };
@@ -211,6 +213,12 @@ export function chooseAgent(preferred, opts = {}) {
         if (!order.some((o) => o.backend.id === a.backend.id))
             order.push({ ...a, because: available.length === 1 ? "only one on PATH" : "first signed in on PATH" });
     const skipped = [];
+    const usable = order.filter((c) => !NOT_FOR_UNATTENDED_RUNS.has(c.backend.id));
+    for (const c of order)
+        if (NOT_FOR_UNATTENDED_RUNS.has(c.backend.id) && usable.length)
+            skipped.push({ backend: c.backend, why: KIRO_UNATTENDED_REFUSAL });
+    if (usable.length)
+        order.splice(0, order.length, ...usable);
     for (const c of order) {
         const s = state(c.backend, c.binary);
         if (!s || s.ok || s.unknown)
@@ -221,6 +229,8 @@ export function chooseAgent(preferred, opts = {}) {
     return { backend: first.backend, binary: first.binary, signIn: state(first.backend, first.binary), because: `${first.because} (none signed in)`, skipped };
 }
 export function unattendedRefusal(c) {
+    if (NOT_FOR_UNATTENDED_RUNS.has(c.backend.id))
+        return KIRO_UNATTENDED_REFUSAL;
     if (!NEEDS_SIGN_IN_BEFORE_SPAWN.has(c.backend.id) || c.signIn?.ok)
         return null;
     return `${c.backend.label} is not signed in (${c.signIn?.detail ?? "not checked"}), and signed out it opens a browser to log in, so it is not started while you are away — ${SIGN_IN_CHECK[c.backend.id].fix}`;
@@ -229,6 +239,12 @@ export function describeChoice(c) {
     const head = `${c.backend.label}${c.signIn ? ` — ${c.signIn.detail}` : ""} (${c.because})`;
     return c.skipped.length ? `${head}; skipped ${c.skipped.map((s) => `${s.backend.label} — ${s.why}`).join("; ")}` : head;
 }
+export function skippedSummary(c) {
+    if (!c.skipped.length)
+        return "";
+    const why = [...new Set(c.skipped.map((s) => (s.why === KIRO_UNATTENDED_REFUSAL ? `${s.backend.label} cannot run unattended yet` : "not signed in")))];
+    return `${c.skipped.length} skipped (${why.join("; ")})`;
+}
 export function resolveAgent(preferred) {
     const c = chooseAgent(preferred, { check: null });
     return { backend: c.backend, binary: c.binary };
@@ -279,6 +295,9 @@ export function headlessSpawn(opts) {
     }
     if (opts.backend.id === "codex") {
         const entry = { command: l.command, args: l.args };
+        const win = (opts.os ?? platform()) === "win32";
+        const str = (v) => (win ? tomlLiteral(v) : JSON.stringify(v));
+        const list = (vs) => (win ? `[${vs.map(tomlLiteral).join(", ")}]` : JSON.stringify(vs));
         return {
             command: opts.binary,
             args: [
@@ -288,10 +307,10 @@ export function headlessSpawn(opts) {
                     : ["--sandbox", "read-only"]),
                 "--skip-git-repo-check",
                 "--ignore-user-config",
-                "-c", `mcp_servers.pantheon.command=${JSON.stringify(entry.command)}`,
-                "-c", `mcp_servers.pantheon.args=${JSON.stringify(entry.args)}`,
-                "-c", `mcp_servers.pantheon.env=${tomlInlineTable(fileEnv)}`,
-                "-c", `mcp_servers.pantheon.default_tools_approval_mode="approve"`,
+                "-c", `mcp_servers.pantheon.command=${str(entry.command)}`,
+                "-c", `mcp_servers.pantheon.args=${list(entry.args)}`,
+                "-c", `mcp_servers.pantheon.env=${tomlInlineTable(fileEnv, win)}`,
+                "-c", `mcp_servers.pantheon.default_tools_approval_mode=${str("approve")}`,
                 opts.prompt,
             ],
             env: procEnv,
@@ -397,8 +416,11 @@ function readCopilotConfig() {
         return {};
     }
 }
-export function tomlInlineTable(kv) {
-    return `{${Object.entries(kv).map(([k, v]) => `${k} = ${JSON.stringify(v)}`).join(", ")}}`;
+export function tomlInlineTable(kv, literal = false) {
+    return `{${Object.entries(kv).map(([k, v]) => `${k} = ${literal ? tomlLiteral(v) : JSON.stringify(v)}`).join(", ")}}`;
+}
+export function tomlLiteral(v) {
+    return /['\r\n]/.test(v) ? JSON.stringify(v) : `'${v}'`;
 }
 export function materializeSpawnFiles(worktree, spawn) {
     for (const f of spawn.writeFiles ?? []) {
@@ -419,4 +441,350 @@ export function backendFromLabel(label) {
         return undefined;
     return agentById(label);
 }
+export const REPO_AGENT_CONFIG = [
+    ".claude/settings.json",
+    ".claude/settings.local.json",
+    ".cursor/hooks.json",
+    ".cursor/mcp.json",
+    ".cursor/cli.json",
+    ".github/hooks",
+    ".mcp.json",
+    ".vscode/mcp.json",
+    ".kiro",
+    ".codex",
+];
+export const AGENT_EDIT_SUFFIX = ".pantheon-agent-edit";
+const quarantineDir = (stashRoot, worktree) => join(stashRoot, "quarantine", createHash("sha256").update(worktree).digest("hex").slice(0, 16));
+const isLink = (p) => { try {
+    return lstatSync(p).isSymbolicLink();
+}
+catch {
+    return false;
+} };
+export function hashPath(p) {
+    let st;
+    try {
+        st = lstatSync(p);
+    }
+    catch {
+        return null;
+    }
+    const h = createHash("sha256");
+    if (st.isSymbolicLink())
+        h.update(`l:${readlinkSync(p)}`);
+    else if (st.isDirectory()) {
+        h.update("d:");
+        for (const name of readdirSync(p).sort())
+            h.update(`${name}\0${hashPath(join(p, name)) ?? ""}\0`);
+    }
+    else
+        h.update("f:").update(readFileSync(p));
+    return h.digest("hex");
+}
+function headOf(worktree) {
+    try {
+        return execFileSync("git", ["-C", worktree, "rev-parse", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+const pause = (ms) => { try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+catch { } };
+export function moveSync(from, to, rename = renameSync) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            rename(from, to);
+            return;
+        }
+        catch (e) {
+            const code = e.code;
+            if (code === "EXDEV") {
+                cpSync(from, to, { recursive: true, verbatimSymlinks: true, errorOnExist: true, force: false });
+                if (hashPath(to) !== hashPath(from)) {
+                    rmSync(to, { recursive: true, force: true });
+                    throw e;
+                }
+                rmSync(from, { recursive: true, force: true });
+                return;
+            }
+            if ((code === "EPERM" || code === "EBUSY" || code === "EACCES") && attempt < 5) {
+                pause(100 * (attempt + 1));
+                continue;
+            }
+            throw e;
+        }
+    }
+}
+function movableUnit(root, rel) {
+    const parts = rel.split("/");
+    for (let i = 1; i <= parts.length; i++) {
+        const sub = parts.slice(0, i).join("/");
+        let st;
+        try {
+            st = lstatSync(join(root, sub));
+        }
+        catch {
+            return null;
+        }
+        if (st.isSymbolicLink())
+            return sub;
+    }
+    return rel;
+}
+function realParents(root, rel) {
+    const parts = rel.split("/").slice(0, -1);
+    for (let i = 1; i <= parts.length; i++) {
+        const p = join(root, parts.slice(0, i).join("/"));
+        try {
+            if (lstatSync(p).isDirectory())
+                continue;
+            moveSync(p, freeName(`${p}${AGENT_EDIT_SUFFIX}`));
+        }
+        catch { }
+        mkdirSync(p);
+    }
+}
+function freeName(base) {
+    const taken = (p) => { try {
+        lstatSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    } };
+    if (!taken(base))
+        return base;
+    for (let i = 2;; i++)
+        if (!taken(`${base}-${i}`))
+            return `${base}-${i}`;
+}
+const writeManifest = (dir, m) => writeFileSync(join(dir, "manifest.json"), JSON.stringify(m), { mode: 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 });
+        moveSync(join(dir, "files", rel), to);
+        return to;
+    }
+    catch {
+        return join(dir, "files", rel);
+    }
+}
+function restoreFrom(stashRoot, dir, m, mode) {
+    const r = { restored: [], setAside: [], discarded: [], lines: [] };
+    const left = [];
+    const headNow = mode === "recover" ? headOf(m.worktree) : m.head;
+    for (const e of m.moved) {
+        const from = join(dir, "files", e.rel);
+        if (!existsSync(from) && !isLink(from))
+            continue;
+        const to = join(m.worktree, e.rel);
+        try {
+            if (headNow !== m.head) {
+                const kept = keepDiscarded(stashRoot, dir, e.rel);
+                r.discarded.push(e.rel);
+                r.lines.push(`${e.rel}: not put back — the worktree moved from ${m.head.slice(0, 7) || "(no commit)"} to ${headNow.slice(0, 7) || "(no commit)"} since it was held; the held copy is at ${kept}`);
+                continue;
+            }
+            const now = hashPath(to);
+            if (now === e.hash) {
+                rmSync(from, { recursive: true, force: true });
+                r.restored.push(e.rel);
+                continue;
+            }
+            if (now !== null && m.wrote[e.rel] !== now) {
+                if (mode === "recover") {
+                    const kept = keepDiscarded(stashRoot, dir, e.rel);
+                    r.discarded.push(e.rel);
+                    r.lines.push(`${e.rel}: not put back — what is there now differs from what was held, and is kept; the held copy is at ${kept}`);
+                    continue;
+                }
+                const aside = freeName(`${to}${AGENT_EDIT_SUFFIX}`);
+                moveSync(to, aside);
+                r.setAside.push(e.rel);
+                r.lines.push(`${e.rel}: the run wrote here while it was held; its version is kept at ${aside}, and the repo's is back`);
+            }
+            else if (now !== null) {
+                rmSync(to, { recursive: true, force: true });
+            }
+            realParents(m.worktree, e.rel);
+            moveSync(from, to);
+            r.restored.push(e.rel);
+        }
+        catch (err) {
+            left.push(e);
+            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 });
+    return r;
+}
+function readManifest(file) {
+    try {
+        const m = JSON.parse(readFileSync(file, "utf8"));
+        if (m.v !== 2 || typeof m.worktree !== "string" || !Array.isArray(m.moved))
+            return null;
+        return { v: 2, worktree: m.worktree, head: typeof m.head === "string" ? m.head : "", moved: m.moved, wrote: m.wrote ?? {} };
+    }
+    catch {
+        return null;
+    }
+}
+export function recoverRepoAgentConfig(worktree, stashRoot) {
+    const dir = quarantineDir(stashRoot, worktree);
+    const m = readManifest(join(dir, "manifest.json"));
+    if (!m) {
+        if (existsSync(join(dir, "manifest.json"))) {
+            const kept = join(stashRoot, "quarantine-kept", `${Date.now()}-legacy`);
+            try {
+                mkdirSync(dirname(kept), { recursive: true });
+                moveSync(dir, kept);
+            }
+            catch { }
+            return { restored: [], setAside: [], discarded: ["*"], lines: [`an older held set for ${worktree} was not put back (it predates the checks that make that safe); it is kept at ${kept}`] };
+        }
+        return { restored: [], setAside: [], discarded: [], lines: [] };
+    }
+    return restoreFrom(stashRoot, dir, m, "recover");
+}
+export function pendingQuarantines(runHomesRoot) {
+    const out = [];
+    let homes = [];
+    try {
+        homes = readdirSync(runHomesRoot);
+    }
+    catch {
+        return out;
+    }
+    for (const h of homes) {
+        const q = join(runHomesRoot, h, "quarantine");
+        let sets = [];
+        try {
+            sets = readdirSync(q);
+        }
+        catch {
+            continue;
+        }
+        for (const s of sets) {
+            const m = readManifest(join(q, s, "manifest.json"));
+            if (m)
+                out.push({ runHome: join(runHomesRoot, h), worktree: m.worktree, head: m.head, paths: m.moved.map((e) => e.rel), dir: join(q, s) });
+        }
+    }
+    return out;
+}
+export function restorePendingQuarantines(runHomesRoot) {
+    const lines = [];
+    for (const p of pendingQuarantines(runHomesRoot)) {
+        if (!existsSync(p.worktree)) {
+            lines.push(`held agent config for ${p.worktree} (${p.paths.join(", ")}): that worktree is gone, so there is nothing to put it back into`);
+            continue;
+        }
+        const r = recoverRepoAgentConfig(p.worktree, p.runHome);
+        if (r.restored.length)
+            lines.push(`put back ${r.restored.join(", ")} in ${p.worktree}`);
+        lines.push(...r.lines);
+    }
+    return lines;
+}
+const openFences = new Set();
+const SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+const onSignal = (sig) => {
+    const onlyOurs = process.listenerCount(sig) === 1;
+    for (const f of [...openFences]) {
+        try {
+            f();
+        }
+        catch { }
+    }
+    if (onlyOurs) {
+        untrap();
+        process.exit(128 + (osConstants.signals[sig] ?? 15));
+    }
+};
+const onExit = () => { for (const f of [...openFences]) {
+    try {
+        f();
+    }
+    catch { }
+} };
+let trapped = false;
+function trap() {
+    if (trapped)
+        return;
+    trapped = true;
+    for (const s of SIGNALS)
+        process.on(s, onSignal);
+    process.on("exit", onExit);
+}
+function untrap() {
+    if (!trapped)
+        return;
+    trapped = false;
+    for (const s of SIGNALS)
+        process.removeListener(s, onSignal);
+    process.removeListener("exit", onExit);
+}
+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 });
+    let done = null;
+    const restore = () => {
+        if (done)
+            return { restored: [], setAside: [], discarded: [], lines: [] };
+        openFences.delete(restore);
+        if (!openFences.size)
+            untrap();
+        done = m.moved.length ? restoreFrom(stashRoot, dir, m, "run") : { restored: [], setAside: [], discarded: [], lines: [] };
+        if (!m.moved.length)
+            rmSync(dir, { recursive: true, force: true });
+        return done;
+    };
+    try {
+        for (const rel of REPO_AGENT_CONFIG) {
+            const unit = movableUnit(worktree, rel);
+            if (!unit || m.moved.some((u) => unit === u.rel || unit.startsWith(`${u.rel}/`)))
+                continue;
+            const hash = hashPath(join(worktree, unit));
+            const to = join(dir, "files", unit);
+            mkdirSync(dirname(to), { recursive: true, mode: 0o700 });
+            moveSync(join(worktree, unit), to);
+            m.moved.push({ rel: unit, hash });
+            writeManifest(dir, m);
+            if (m.moved.length === 1) {
+                openFences.add(restore);
+                trap();
+            }
+        }
+    }
+    catch (e) {
+        restore();
+        throw e;
+    }
+    if (!m.moved.length)
+        rmSync(dir, { recursive: true, force: true });
+    return {
+        moved: m.moved.map((e) => e.rel),
+        wrote: (rel) => {
+            const unit = m.moved.find((e) => rel === e.rel || rel.startsWith(`${e.rel}/`));
+            if (!unit || unit.rel !== rel)
+                return;
+            const h = hashPath(join(worktree, rel));
+            if (h) {
+                m.wrote[rel] = h;
+                writeManifest(dir, m);
+            }
+        },
+        restore,
+        recovered,
+    };
+}
 //# sourceMappingURL=agents.js.map