@join-pantheon/cli 0.30.0 → 0.31.0

package/dist/pins.js

@@ -0,0 +1,161 @@
+import { accessSync, constants as fsConstants, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { readStateFile, withFileLock } from "./file-lock.js";
+import { dirname, join } from "node:path";
+import { CONFIG_PATH } from "./config.js";
+import { canonicalKey, fingerprint } from "./identity.js";
+export const PINS_FILE = "keys.json";
+const home = (h) => h ?? process.env.PANTHEON_HOME ?? dirname(CONFIG_PATH);
+export const pinsPath = (h) => join(home(h), PINS_FILE);
+const isObj = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+export const unsafeKey = (k) => k === "__proto__" || k === "constructor" || k === "prototype";
+const dict = () => Object.create(null);
+export function loadPins(h) {
+    let text;
+    try {
+        const t = readStateFile(pinsPath(h));
+        if (t === null)
+            return { v: 1, teams: dict() };
+        accessSync(pinsPath(h), fsConstants.W_OK);
+        text = t;
+    }
+    catch {
+        return { v: 1, teams: {}, corrupt: true };
+    }
+    try {
+        const raw = JSON.parse(text);
+        if (!isObj(raw) || raw.v !== 1 || !isObj(raw.teams))
+            return { v: 1, teams: {}, corrupt: true };
+        const teams = dict();
+        for (const [id, t] of Object.entries(raw.teams)) {
+            if (!isObj(t) || !isObj(t.members) || unsafeKey(id))
+                return { v: 1, teams: {}, corrupt: true };
+            const members = dict();
+            for (const [m, p] of Object.entries(t.members)) {
+                if (!isObj(p) || typeof p.fp !== "string" || unsafeKey(m))
+                    return { v: 1, teams: {}, corrupt: true };
+                members[m] = p;
+            }
+            teams[id] = { members, ...(typeof t.sigs === "number" ? { sigs: t.sigs } : {}), ...(typeof t.spaceId === "string" ? { spaceId: t.spaceId } : {}) };
+        }
+        return { v: 1, teams };
+    }
+    catch {
+        return { v: 1, teams: {}, corrupt: true };
+    }
+}
+export function savePins(p, h) {
+    if (p.corrupt)
+        throw new Error(`${pinsPath(h)} could not be read, so it is not written over — fix or remove it (pantheon doctor)`);
+    const f = pinsPath(h);
+    mkdirSync(dirname(f), { recursive: true, mode: 0o700 });
+    writeWhole(f, JSON.stringify(p, null, 2) + "\n");
+}
+export function updatePins(fn, h) {
+    return withFileLock(pinsPath(h), () => {
+        const p = loadPins(h);
+        if (fn(p) && !p.corrupt)
+            savePins(p, h);
+        return p;
+    });
+}
+export { withFileLock };
+export function writeWhole(f, text) {
+    const tmp = `${f}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+        writeFileSync(tmp, text, { mode: 0o600, flag: "wx" });
+        renameSync(tmp, f);
+    }
+    catch (e) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch { }
+        throw e;
+    }
+}
+export function observeMembers(p, team, members, me, at = Date.now()) {
+    const t = (p.teams[team] ??= { members: dict() });
+    const out = [];
+    const mine = fingerprint(me.publicKey);
+    if (t.members[me.member]?.fp !== mine)
+        t.members[me.member] = { fp: mine, key: me.publicKey, since: at };
+    for (const m of members) {
+        if (!m.admitted || m.member === me.member || typeof m.member !== "string" || unsafeKey(m.member))
+            continue;
+        const fp = m.fingerprint;
+        const key = m.pubkey && canonicalKey(m.pubkey) && fingerprint(m.pubkey) === fp ? m.pubkey : undefined;
+        const cur = t.members[m.member];
+        if (!cur) {
+            t.members[m.member] = { fp, ...(key ? { key } : {}), since: at };
+            out.push({ member: m.member, kind: "pinned", fp });
+            continue;
+        }
+        if (cur.fp === fp) {
+            if (key && !cur.key)
+                cur.key = key;
+            if (cur.pending)
+                delete cur.pending;
+            continue;
+        }
+        if (cur.pending?.fp !== fp) {
+            cur.pending = { fp, ...(key ? { key } : {}), since: at };
+            out.push({ member: m.member, kind: "changed", fp, was: cur.fp });
+        }
+    }
+    return out;
+}
+export const pinFor = (p, team, member) => p.teams[team]?.members[member];
+export const pinScope = (team, me) => `${team} ${me}`;
+export function joinedSigning(since) {
+    const m = /^(\d+)\.(\d+)\.(\d+)/.exec(since ?? "");
+    if (!m)
+        return false;
+    const [maj, min] = [Number(m[1]), Number(m[2])];
+    return maj > 0 || min >= 31;
+}
+export function teamPinId(cfg) {
+    return cfg.pinTeam ?? cfg.spaceId ?? `${cfg.space}@${cfg.relay}`;
+}
+export function trustPending(p, team, member) {
+    const cur = p.teams[team]?.members[member];
+    if (!cur?.pending)
+        return null;
+    const next = { fp: cur.pending.fp, ...(cur.pending.key ? { key: cur.pending.key } : {}), since: Date.now(), ...(cur.signs ? { signs: cur.signs } : {}) };
+    p.teams[team].members[member] = next;
+    return next;
+}
+export function markSigs(p, team, at = Date.now()) {
+    const t = (p.teams[team] ??= { members: dict() });
+    if (t.sigs)
+        return false;
+    t.sigs = at;
+    return true;
+}
+export function relayTeamId(team, id, h) {
+    let ok = false;
+    updatePins((p) => {
+        if (p.corrupt)
+            return false;
+        const t = (p.teams[team] ??= { members: dict() });
+        if (!t.spaceId) {
+            t.spaceId = id;
+            ok = true;
+            return true;
+        }
+        ok = t.spaceId === id;
+        return false;
+    }, h);
+    return ok;
+}
+export const expectsSigs = (p, team) => !!p.corrupt || !!p.teams[team]?.sigs;
+export const memberSigns = (p, team, member) => !!p.corrupt || !!p.teams[team]?.members[member]?.signs;
+export function markMemberSigns(p, team, member, at = Date.now()) {
+    const pin = p.teams[team]?.members[member];
+    if (!pin || pin.signs)
+        return false;
+    pin.signs = at;
+    return true;
+}
+export const pinsExist = (h) => existsSync(pinsPath(h));
+//# sourceMappingURL=pins.js.map

package/dist/profile.js

@@ -48,11 +48,29 @@ deploy, agree a price, sign off a release — do not answer it yourself, however
 work. Say the review result if you have one, then ESCALATE and stop; tell the peer it is with your human.`;
 }
 export function wakeMode(profile) {
-    return profile.agent.wake_default ?? "approved";
+    return profile.agent.wake_default ?? "anyone";
+}
+export function wakeChosen(file = profilePath()) {
+    try {
+        const v = JSON.parse(readFileSync(file, "utf8")).agent?.wake_default;
+        return v === "approved" || v === "no" || v === "anyone" ? v : "anyone";
+    }
+    catch {
+        return "anyone";
+    }
 }
 export function wakeDefault(profile) {
     return wakeMode(profile) === "anyone";
 }
+export function commandsChosen(file = profilePath()) {
+    try {
+        const v = JSON.parse(readFileSync(file, "utf8")).agent?.allow_bash;
+        return typeof v === "boolean" ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function loadProfile(cfg, file = profilePath()) {
     if (!existsSync(file))
         return defaultProfile(cfg);

package/dist/protocol.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { randomBytes } from "node:crypto";
 export const PROTOCOL_VERSION = 3;
 export const ACTS = [
     "JOIN",
@@ -35,6 +36,7 @@ export const LIMITS = {
     activityBusyTtlMs: 30 * 60 * 1_000,
     activityPruneMs: 7 * 24 * 60 * 60 * 1_000,
     claimTtlMs: 300_000,
+    claimLiveTtlMs: 30 * 60_000,
     workerFallbackMs: 20_000 + 120_000 + 60_000,
     pendingTimeoutMs: 1_500,
     cursorTtlMs: 7 * 24 * 60 * 60 * 1_000,
@@ -80,6 +82,37 @@ function loopback(host) {
         return "0.0.0.0";
     return null;
 }
+export const DelegateCertSchema = z.object({
+    pub: z.string().min(32).max(200),
+    run: z.string().min(1).max(64),
+    expires: z.number().int().positive(),
+    sig: z.string().min(32).max(200),
+});
+export const ActSigSchema = z.object({
+    v: z.literal(1),
+    role: z.enum(["member", "run"]),
+    nonce: z.string().min(8).max(64),
+    ts: z.number().int().positive(),
+    pub: z.string().min(32).max(200),
+    s: z.string().min(32).max(200),
+    meta: z.record(z.unknown()).optional(),
+    repo: z.string().regex(/^[rl]_[0-9a-f]{16}$/).optional(),
+    cert: DelegateCertSchema.optional(),
+});
+export const GoalSigSchema = z.object({
+    v: z.literal(1),
+    role: z.enum(["member", "run"]),
+    nonce: z.string().min(8).max(64),
+    ts: z.number().int().positive(),
+    pub: z.string().min(32).max(200),
+    s: z.string().min(32).max(200),
+    invite: z.array(z.string().min(1).max(48)).max(16).nullable(),
+    budget: z.number().int().nullable().optional(),
+    deadline: z.number().int().nullable().optional(),
+    kind: z.string().max(32).nullable().optional(),
+    cert: DelegateCertSchema.optional(),
+});
+export const RELAY_FEATURES = ["act-sig", "delegate"];
 export const Hello = z.object({
     t: z.literal("hello"),
     v: z.number().int().optional(),
@@ -98,6 +131,7 @@ export const Hello = z.object({
     from_seq: z.number().int().nonnegative().optional(),
     repo: z.string().regex(/^[rl]_[0-9a-f]{16}$/).optional(),
     repo_origin: z.string().max(200).optional(),
+    delegate: DelegateCertSchema.optional(),
 });
 export const OrganizationProfileSchema = z.object({
     version: z.literal(1),
@@ -147,12 +181,14 @@ export const Admit = z.object({
     member: z.string().min(1).max(48),
     may_wake: z.boolean().default(false),
     revoke: z.boolean().default(false),
+    wake_only: z.boolean().optional(),
     forget: z.boolean().default(false),
 });
 export const SendAct = z.object({
     t: z.literal("act"),
     cid: z.string().max(64).optional(),
     after_seq: z.number().int().nonnegative().optional(),
+    id: z.string().regex(/^a_[A-Za-z0-9]{6,48}$/).optional(),
     act: z.enum(ACTS),
     body: z.string().max(LIMITS.bodyChars),
     summary: z.string().max(LIMITS.summaryChars).optional(),
@@ -163,6 +199,7 @@ export const SendAct = z.object({
     affects: z.array(z.string().min(1).max(48)).max(16).optional(),
     meta: z.record(z.unknown()).optional(),
     repo: z.string().regex(/^[rl]_[0-9a-f]{16}$/).optional(),
+    sig: ActSigSchema.optional(),
 });
 export const BindRepo = z.object({
     t: z.literal("bind_repo"),
@@ -174,12 +211,14 @@ export const BindRepo = z.object({
 export const OpenGoal = z.object({
     t: z.literal("open_goal"),
     cid: z.string().max(64).optional(),
+    id: z.string().regex(/^g_[a-z0-9]{8,40}$/).optional(),
     title: z.string().min(1).max(200),
     acceptance: z.string().max(2000).default(""),
     invite: z.array(z.string().min(1).max(48)).max(16).optional(),
     budget: z.number().int().min(4).max(1000).optional(),
     deadline: z.number().int().positive().optional(),
     kind: z.enum(["worklist"]).optional(),
+    sig: GoalSigSchema.optional(),
 });
 export const Ping = z.object({ t: z.literal("ping") });
 export const DeleteSpace = z.object({
@@ -223,6 +262,6 @@ export function isContinuationFor(act, me, ctx) {
         && ctx.goalMembers.includes(me);
 }
 export function newId(prefix) {
-    return `${prefix}_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    return `${prefix}_${Date.now().toString(36)}${randomBytes(5).readUIntBE(0, 5).toString(36).padStart(8, "0").slice(0, 8)}`;
 }
 //# sourceMappingURL=protocol.js.map

package/dist/quickstart.js

@@ -1,24 +1,25 @@
 import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:net";
-import { basename, join as pathJoin } from "node:path";
+import { basename, dirname, join as pathJoin, resolve as resolvePath } from "node:path";
 import { homedir, hostname, platform, userInfo } from "node:os";
 import { lookup } from "node:dns/promises";
 import { describeNetError } from "./network.js";
 import { PantheonClient } from "./client.js";
-import { load, loadAll, identity, save, toInvite, resolveFor, repoInfo, bindRepo, DEFAULT_RELAY } from "./config.js";
-import { loadProfile, wakeDefault } from "./profile.js";
+import { holdsRepo } from "./repo-find.js";
+import { load, loadAll, identity, save, toInvite, resolveFor, repoInfo, bindRepo, bindFolder, folderBinding, DEFAULT_RELAY } from "./config.js";
+import { commandsChosen, loadProfile, wakeChosen, wakeDefault } from "./profile.js";
 import { newKeypair } from "./identity.js";
 import { installForUser } from "./install.js";
 import { writeIntent, installHooks } from "./notify.js";
-import { detectAvailable, agentById } from "./agents.js";
+import { detectAvailable, agentById, agentsNeedingUnsandboxed } from "./agents.js";
 import { installService, servicesUnavailable } from "./service.js";
 import { ensureNativeNotifier } from "./notifier.js";
 import { ensureTrayBinary, writeTrayCommands } from "./tray.js";
 import { desktopUnavailable, ephemeralWarning, hostEnv } from "./host-env.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { localAddresses } from "./machine.js";
-import { grant as grantCap, loadPolicy, policyPath, savePolicy } from "./worker-policy.js";
+import { grant as grantCap, loadPolicy, policyPath, savePolicy, unsandboxedAllowed } from "./worker-policy.js";
 import { Relay } from "./relay.js";
 import { which } from "./which.js";
 const sh = (cmd) => {
@@ -121,23 +122,68 @@ export function wireUp(opts, deps = {}) {
         catch {
             return false;
         } })();
-        if (!isRepo && how === "explicit") {
+        const boundFolder = !isRepo && (() => { try {
+            const f = loadAll();
+            return !!f && !!folderBinding(f, project);
+        }
+        catch {
+            return false;
+        } })();
+        if (boundFolder) {
+            try {
+                const why = notLoaded(installSvc("worker", project, []));
+                if (why) {
+                    tools.push({ tool: "worker", status: `installed, not running: ${why}` });
+                    warnings.push(`the worker is installed but not running (${why}) — this machine cannot answer the team while you are away. Try \`pantheon service restart worker\``);
+                }
+                else {
+                    tools.push({ tool: "worker", status: `on — answers peers from this folder while you are away (it reads it; anything it writes goes to a drafts folder for you)` });
+                    granted.push(`${wakeChosen() === "approved" ? "A teammate you approve from this machine (pantheon wake allow <name>)" : "Your teammates"} can start an agent run that READS ${project} and answers them. It never changes that folder: drafts go to a folder of its own for you to review.`);
+                    const hasClaude = (() => { try {
+                        return detectAvailable().some((a) => a.backend.id === "claude-code");
+                    }
+                    catch {
+                        return true;
+                    } })();
+                    if (!hasClaude)
+                        warnings.push(`answering from a plain folder while you are away needs Claude Code (claude), and it is not installed here — until it is, teammates' requests for this folder wait for your live session`);
+                }
+            }
+            catch (e) {
+                tools.push({ tool: "worker", status: `could not install: ${e.message}` });
+                warnings.push(`the worker did not install: ${e.message}`);
+            }
+        }
+        else if (!isRepo && how === "explicit") {
             tools.push({ tool: "worker", status: `not installed — ${project} is not a git repo` });
             warnings.push(`--unattended needs a git repo to work in; pass --project <a clone>. Nothing was installed.`);
         }
         else if (!isRepo) {
-            tools.push({ tool: "worker", status: `not on — run this from your project's git repo to enable, or later: pantheon service install worker --project <repo>` });
+            tools.push({ tool: "worker", status: `not on yet — nothing here is bound to the team. Bind a repo or docs folder (pantheon repo find, or pantheon use <team> --here), then: pantheon service install worker` });
         }
         else {
             try {
-                const why = notLoaded(installSvc("worker", project, []));
+                const commandsOn = commandsChosen() !== false;
+                const why = notLoaded(installSvc("worker", project, commandsOn ? ["--allow-bash"] : []));
                 if (why) {
                     tools.push({ tool: "worker", status: `installed, not running: ${why}` });
                     warnings.push(`the worker is installed but not running (${why}) — this machine cannot answer the team while you are away. Try \`pantheon service restart worker\``);
                     return { tools, granted, warnings };
                 }
                 tools.push({ tool: "worker", status: `on — answers peers while you are away (${project})` });
-                granted.push(`A teammate you approve from this machine (pantheon admit <name> --may-wake) — or anyone on the team, if you choose wake "anyone" — can start an agent run here, in an isolated worktree under ${project}. Nobody can until then.`);
+                granted.push(wakeChosen() === "approved"
+                    ? `A teammate you approve here can start an agent run on this machine, in an isolated worktree under ${project}: you are asked the first time each one's request needs it (Always / Just this once / No), or approve ahead with pantheon wake allow <name>. Under wake "anyone", every teammate the team lets wake can.`
+                    : `Your teammates can hand work to this machine while you're away, so nothing waits on you: it runs in its own copy of ${project} and delivers on a branch for your review. To approve each teammate first: pantheon setup --wake approved`);
+                if (commandsOn)
+                    granted.push(`That work runs your tests, commits, and pushes to its own branch, so it arrives ready to review. Edits only instead: pantheon setup --commands no`);
+                const away = (() => { try {
+                    return agentsNeedingUnsandboxed();
+                }
+                catch {
+                    return [];
+                } })();
+                if (away.length && unsandboxedAllowed(loadPolicy()))
+                    granted.push(`${away.join(", ")} ${away.length === 1 ? "answers" : "answer"} those requests, so teammates get answers even when you're offline. To have them wait for you instead: pantheon setup --unsandboxed no`);
                 if (!existsSync(policyPath())) {
                     const pol = loadPolicy();
                     grantCap(pol, "self_upgrade", "always", "setup-default");
@@ -357,8 +403,7 @@ export async function start(opts) {
     const reach = chosen
         ? (place === "loopback"
             ? { url: chosen, how: "as given", shareable: false,
-                hint: `That address is this machine only — a teammate cannot reach it.\n` +
-                    `  Use a tailnet address (tailscale ip -4) or a tunnel, then re-run pantheon start.` }
+                hint: `A teammate cannot reach it. Use a tailnet address (tailscale ip -4) or a tunnel, then re-run pantheon start.` }
             : { url: chosen, how: place === "this-machine" ? "this machine's address" : place === "tunnel" ? "a tunnel to this machine" : opts.relay ? "as given" : "your signed-in relay", shareable: true })
         : findReach(opts.port);
     const nothing = (why) => ({ cfg: priorCfg ?? { relay: reach.url }, invite: null, inviteMayWake: false, claimed: false, reach, tools: [], granted: [], relay: null, warnings: [why] });
@@ -430,6 +475,7 @@ export async function start(opts) {
     }
     let invite = null;
     let inviteMayWake = false;
+    let folderBound = null;
     let claimed = false;
     const claim = async (c) => {
         const client = new PantheonClient(c);
@@ -441,6 +487,10 @@ export async function start(opts) {
             if (repo && !client.repos.some((r) => r.fingerprint === repo.fingerprint)) {
                 await client.bindRepo(repo.fingerprint, repo.origin).catch((e) => warnings.push(`could not register this repo with the team: ${e.message}`));
             }
+            if (!repo && c.spaceId && bindableFolder(process.cwd())) {
+                bindFolder(process.cwd(), c.spaceId);
+                folderBound = process.cwd();
+            }
             if (repo && c.spaceId) {
                 const { replaced } = bindRepo(repo, c.spaceId);
                 const was = replaced ?? (here.binding && here.binding.space !== c.spaceId ? here.binding : null);
@@ -449,7 +499,7 @@ export async function start(opts) {
                     warnings.push(`this repo was bound to "${name}"; it now belongs to "${c.space}" — agents opened here speak in "${c.space}" from now on (pantheon use ${name} --here moves it back)`);
                 }
             }
-            opts.log(`  space      ${c.space} ${reuse ? "— reconnected" : "— created, you own it"}${repo ? `   ${repo.origin ?? "local repo"} → bound to it` : ""}`);
+            opts.log(`  space      ${c.space} ${reuse ? "— reconnected" : "— created, you own it"}${repo ? `   ${repo.origin ?? "local repo"} → bound to it` : folderBound ? `   this folder → bound to it` : ""}`);
             const mayWake = opts.wake ? opts.wake === "anyone" : wakeDefault(loadProfile(c));
             const inv = await client.makeInvite(mayWake, opts.ttlMinutes);
             invite = toInvite({ ...c, token: inv.url });
@@ -524,6 +574,10 @@ export async function join(opts) {
         cfg.spaceId = client.spaceId;
     save(cfg);
     const warnings = [];
+    if (!repo && cfg.spaceId && bindableFolder(process.cwd())) {
+        bindFolder(process.cwd(), cfg.spaceId);
+        opts.log(`  folder     ${process.cwd()} → bound to "${cfg.space}"   (agents opened here speak in it; no git needed)`);
+    }
     if (repo && cfg.spaceId) {
         const { replaced } = bindRepo(repo, cfg.spaceId);
         if (replaced)
@@ -544,6 +598,33 @@ export async function join(opts) {
     });
     return { cfg, tools: wired.tools, granted: wired.granted, warnings: [...warnings, ...wired.warnings] };
 }
+export function bindableFolder(dir) {
+    const real = (d) => { try {
+        return realpathSync.native(d);
+    }
+    catch {
+        return resolvePath(d);
+    } };
+    const here = real(dir), home = real(homedir());
+    if (dirname(here) === here || here === home || home.startsWith(here.endsWith("/") ? here : `${here}/`))
+        return false;
+    if (["Downloads", "Desktop", "Documents", "Library", "tmp"].some((n) => here === pathJoin(home, n)))
+        return false;
+    try {
+        if (holdsRepo(here))
+            return false;
+    }
+    catch {
+        return false;
+    }
+    try {
+        const f = loadAll();
+        if (Object.values(f?.bindings ?? {}).some((b) => { const p = real(b.path); return p !== here && p.startsWith(`${here}/`); }))
+            return false;
+    }
+    catch { }
+    return true;
+}
 function detectAgent() {
     const found = detectAvailable();
     return found[0]?.backend.id ?? "unknown";

package/dist/reads.js

@@ -16,7 +16,14 @@ export function signedReadQuery(cfg, path, params, at) {
             full[k] = String(v);
     full.reader = cfg.member;
     full.ts = String(at);
-    const sig = signRead(cfg.privateKey, "GET", path, full);
+    const d = cfg.delegate;
+    if (d) {
+        full.dpub = d.cert.pub;
+        full.drun = d.cert.run;
+        full.dexp = String(d.cert.expires);
+        full.dcert = d.cert.sig;
+    }
+    const sig = signRead(d ? d.privateKey : cfg.privateKey, "GET", path, full);
     return new URLSearchParams({ ...full, sig }).toString();
 }
 export async function signedRead(cfg, path, params = {}, opts = {}) {