@join-pantheon/cli 0.30.0 → 0.31.0

package/dist/worker-fleet.js

@@ -1,9 +1,11 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve, sep } from "node:path";
+import { holdsRepo } from "./repo-find.js";
 import { CONFIG_DIR, configFor, loadAll, repoInfo } from "./config.js";
-import { Worker } from "./worker.js";
+import { Worker, workspaceOf } from "./worker.js";
 export class WorkerFleet {
     opts;
+    dupSaid = new Set();
     slots = new Map();
     stopped = false;
     constructor(opts) {
@@ -18,14 +20,23 @@ export class WorkerFleet {
         const wanted = new Map();
         if (f) {
             const several = Object.keys(f.spaces ?? {}).length > 1;
-            for (const b of Object.values(f.bindings ?? {})) {
-                const m = f.spaces?.[b.space];
-                if (!m || !existsSync(join(b.path, ".git")))
+            const idCount = new Map();
+            for (const m of Object.values(f.spaces ?? {}))
+                idCount.set(m.id, (idCount.get(m.id) ?? 0) + 1);
+            for (const m of Object.values(f.spaces ?? {})) {
+                if ((idCount.get(m.id) ?? 0) > 1) {
+                    if (!this.dupSaid.has(m.id)) {
+                        this.dupSaid.add(m.id);
+                        this.opts.log(`fleet: two entries in config.json claim team ${m.id} — serving neither until one is removed (pantheon spaces)`);
+                    }
                     continue;
-                if (wanted.has(m.id))
+                }
+                const ws = teamWorkspaces(f, m.id);
+                const home = ws.find((w) => w.kind === "repo") ?? ws[0];
+                if (!home)
                     continue;
-                const repo = repoInfo(b.path);
-                wanted.set(m.id, { path: b.path, cfg: configFor(f, m, repo) });
+                const repo = home.kind === "repo" ? repoInfo(home.path) : null;
+                wanted.set(m.id, { path: home.path, cfg: configFor(f, m, repo) });
                 void several;
             }
             for (const [id, w] of wanted) {
@@ -36,6 +47,7 @@ export class WorkerFleet {
                 const wopts = {
                     ...rest,
                     project: w.path,
+                    workspaces: () => teamWorkspaces((this.opts.readConfig ?? loadAll)(), id),
                     scratch: join(home, "worktrees", encodeURIComponent(id)),
                     home,
                     requirePersonaSpaces: several,
@@ -66,7 +78,7 @@ export class WorkerFleet {
             for (const s of stopped)
                 this.opts.log(`fleet: worker for "${s}" stopped — binding gone`);
             if (!this.slots.size && !started.length)
-                this.opts.log(`fleet: no bound repos on this machine — bind one with \`pantheon use <team> --here\` from its checkout`);
+                this.opts.log(`fleet: nothing bound on this machine — bind a repo or a docs folder with \`pantheon use <team> --here\` from inside it`);
             await new Promise((r) => setTimeout(r, poll));
             if (this.opts.once && this.slots.size === 0)
                 break;
@@ -81,4 +93,13 @@ export class WorkerFleet {
             s.worker.stop();
     }
 }
+export function teamWorkspaces(f, spaceId) {
+    const bound = Object.entries(f?.bindings ?? {}).filter(([, b]) => b.space === spaceId && existsSync(b.path));
+    const repos = bound.filter(([k, b]) => !k.startsWith("d_") && existsSync(join(b.path, ".git"))).map(([, b]) => workspaceOf(b.path));
+    const all = Object.values(f?.bindings ?? {}).map((b) => resolve(b.path));
+    const folders = bound.filter(([k]) => k.startsWith("d_")).map(([, b]) => workspaceOf(b.path))
+        .filter((w) => w.kind === "folder" && !all.some((p) => p !== resolve(w.path) && p.startsWith(`${resolve(w.path)}${sep}`)) && !holdsRepo(w.path));
+    const seen = new Set();
+    return [...repos, ...folders].filter((w) => (seen.has(w.path) ? false : (seen.add(w.path), true)));
+}
 //# sourceMappingURL=worker-fleet.js.map

package/dist/worker-policy.js

@@ -3,6 +3,35 @@ import { dirname, join } from "node:path";
 import { CONFIG_PATH } from "./config.js";
 import { trustWrite } from "./home-guard.js";
 import { parseJsonText } from "./text-file.js";
+export const WAKE_NO_MS = 30 * 24 * 60 * 60 * 1_000;
+export const wakeKey = (team, member) => `${team}|${member}`;
+export function mayAskWake(p, teams, member, now = Date.now()) {
+    const ts = teams.filter((t) => !!t);
+    if (isApprovedWaker(p, ts, member))
+        return false;
+    if (ts.some((t) => (p.wakeNo?.[wakeKey(t, member)] ?? 0) > now - WAKE_NO_MS))
+        return false;
+    return !Object.values(p.wakeAsks ?? {}).some((a) => ts.includes(a.team) && a.member === member && now - a.at < ASK_EXPIRY_MS);
+}
+export function takeWakeOnce(p, teams, member) {
+    for (const t of teams) {
+        if (!t)
+            continue;
+        const k = wakeKey(t, member);
+        const n = p.wakeOnce?.[k] ?? 0;
+        if (n > 0) {
+            if (n > 1)
+                p.wakeOnce[k] = n - 1;
+            else
+                delete p.wakeOnce[k];
+            return true;
+        }
+    }
+    return false;
+}
+export function hasWakeOnce(p, teams, member) {
+    return teams.some((t) => !!t && (p.wakeOnce?.[wakeKey(t, member)] ?? 0) > 0);
+}
 export const ASK_COOLDOWN_MS = 24 * 60 * 60 * 1_000;
 export const ASK_EXPIRY_MS = 14 * 24 * 60 * 60 * 1_000;
 export function policyHome(home) {
@@ -35,6 +64,10 @@ export function loadPolicy(home) {
             ...(wakers ? { wakers } : {}),
             ...(isRecord(raw.wakersCarried) ? { wakersCarried: raw.wakersCarried } : {}),
             ...(isRecord(raw.wakersDeferred) ? { wakersDeferred: raw.wakersDeferred } : {}),
+            ...(isRecord(raw.wakeAsks) ? { wakeAsks: Object.fromEntries(Object.entries(raw.wakeAsks).filter(([, v]) => isRecord(v) && typeof v.team === "string" && typeof v.member === "string" && typeof v.at === "number")) } : {}),
+            ...(isRecord(raw.wakeOnce) ? { wakeOnce: Object.fromEntries(Object.entries(raw.wakeOnce).filter(([, v]) => typeof v === "number" && v > 0 && v < 100)) } : {}),
+            ...(isRecord(raw.wakeNo) ? { wakeNo: Object.fromEntries(Object.entries(raw.wakeNo).filter(([, v]) => typeof v === "number")) } : {}),
+            ...(isRecord(raw.wakeTeamFlag) ? { wakeTeamFlag: Object.fromEntries(Object.entries(raw.wakeTeamFlag).filter(([, v]) => typeof v === "number")) } : {}),
         };
     }
     catch {
@@ -117,14 +150,40 @@ export function setLocalWaker(teams, member, approved, home, env = process.env)
     savePolicy(p, home);
     return { ok: true, changed: true };
 }
+export function markTeamFlagOnYes(team, member, home, env = process.env) {
+    if (inWokenRun(env))
+        return;
+    const p = loadPolicy(home);
+    const k = wakeKey(team, member);
+    (p.wakeTeamFlag ??= {})[k] = Date.now();
+    savePolicy(p, home);
+}
+export function takeTeamFlagOnYes(p, teams, member) {
+    for (const t of teams) {
+        if (!t)
+            continue;
+        const k = wakeKey(t, member);
+        const at = p.wakeTeamFlag?.[k];
+        if (at !== undefined) {
+            delete p.wakeTeamFlag[k];
+            return Date.now() - at < 7 * 24 * 3600_000;
+        }
+    }
+    return false;
+}
 export function isApprovedWaker(p, teams, member) {
     return teams.some((t) => { const list = t ? p.wakers?.[t] : undefined; return Array.isArray(list) && list.includes(member); });
 }
 export function savePolicy(p, home) {
     const file = policyPath(home);
     mkdirSync(dirname(file), { recursive: true });
+    let prev = null;
+    try {
+        prev = readFileSync(file);
+    }
+    catch { }
     writeFileSync(file, JSON.stringify(p, null, 2) + "\n", { mode: 0o600 });
-    trustWrite(file);
+    trustWrite(file, prev);
 }
 export function useGrant(p, cap) {
     const g = p.grants[cap];
@@ -141,6 +200,11 @@ export function grant(p, cap, mode, by) {
 }
 export function revoke(p, cap) {
     delete p.grants[cap];
+    if (cap === "unsandboxed_runs")
+        p.denied[cap] = Date.now();
+}
+export function unsandboxedAllowed(p) {
+    return !!p.grants.unsandboxed_runs || p.denied.unsandboxed_runs === undefined;
 }
 export function mayAsk(p, cap, now = Date.now()) {
     if (p.grants[cap])
@@ -155,22 +219,42 @@ export function recordAsk(p, cap, escalateActId) {
     p.asks[cap] = { act: escalateActId, at: Date.now() };
 }
 export function parseGrantAnswer(body) {
-    const t = body.trim().toLowerCase();
-    if (/^(allow[\s-]?always|always[\s-]?allow|yes[\s-]?always)\b/.test(t))
+    const t = body.trim().toLowerCase().replace(/[.!]+$/, "").replace(/\s+/g, " ").replace(/’/g, "'");
+    if (/^(always|yes always|yes, always|always allow)$/.test(t) || /^(allow[\s-]always)\b/.test(t))
         return "allow-always";
-    if (/^(allow([\s-]?once)?|yes([\s-]?once)?|approve[d]?)\b/.test(t))
+    if (/^(once|just this once|this once|yes once|yes, once|yes|allow|approve|approved)$/.test(t) || /^(allow[\s-](it[\s-])?once)\b/.test(t))
         return "allow-once";
-    if (/^(deny|no|reject(ed)?|don'?t|do not)\b/.test(t))
+    if (/^(deny|denied|no|reject|rejected|don't allow|do not allow|don't|do not|never)\b/.test(t))
         return "deny";
     return null;
 }
 export const WOKEN_RUN_ENV = "PANTHEON_WOKEN_RUN";
 export const inWokenRun = (env = process.env) => !!env[WOKEN_RUN_ENV];
-export const CAPABILITY_ARGS = { self_upgrade: "self-upgrade", run_commands: "run-commands" };
+export const CAPABILITY_ARGS = { self_upgrade: "self-upgrade", run_commands: "run-commands", unsandboxed_runs: "unsandboxed-runs" };
 export function applyLocalAnswer(refActId, body, home, env = process.env) {
     if (!refActId)
         return null;
     const p = loadPolicy(home);
+    const wa = p.wakeAsks?.[refActId];
+    if (wa) {
+        if (inWokenRun(env))
+            return { applied: false, why: "a woken run cannot let anyone wake this machine — a person has to answer it here" };
+        const verdict = parseGrantAnswer(body);
+        if (!verdict)
+            return null;
+        const k = wakeKey(wa.team, wa.member);
+        if (verdict === "allow-always")
+            setWaker(p, wa.team, wa.member, true);
+        else if (verdict === "allow-once")
+            (p.wakeOnce ??= {})[k] = Math.min(99, (p.wakeOnce[k] ?? 0) + 1);
+        else
+            (p.wakeNo ??= {})[k] = Date.now();
+        if (verdict !== "deny" && wa.teamBlocked)
+            (p.wakeTeamFlag ??= {})[k] = Date.now();
+        delete p.wakeAsks[refActId];
+        savePolicy(p, home);
+        return { applied: true, wake: { team: wa.team, member: wa.member }, verdict };
+    }
     if (!Object.values(p.asks).some((a) => a?.act === refActId))
         return null;
     if (inWokenRun(env))
@@ -184,6 +268,12 @@ export function applyLocalAnswer(refActId, body, home, env = process.env) {
 export function describeLocalAnswer(g) {
     if (!g.applied)
         return `not granted: ${g.why}`;
+    if ("wake" in g) {
+        const who = g.wake.member;
+        return g.verdict === "allow-always" ? `${who} may start work on this machine from now on — undo: pantheon wake deny ${who}`
+            : g.verdict === "allow-once" ? `${who} may start work on this machine this once — their request runs now`
+                : `${who} will not start work on this machine; their requests wait for you (not asked again for a month; pantheon wake allow ${who} to change it)`;
+    }
     const name = CAPABILITY_ARGS[g.cap];
     if (g.verdict === "deny")
         return `denied ${name} on this machine — the worker will not ask again for a day`;