@join-pantheon/cli 0.33.1 → 0.33.2

package/dist/roster-file.js

@@ -29,6 +29,7 @@ export class Allowlist {
     name = null;
     extra = {};
     repos = new Map();
+    recoveries = new Map();
     file;
     constructor(dir, space) {
         this.file = join(dir, `${space}.members.json`);
@@ -69,7 +70,13 @@ export class Allowlist {
                 this.removedAt = doc.removed_at;
             if (legacyRemoval && this.removedAt === null)
                 this.removedAt = Date.now();
-            const known = new Set(["members", "invites", "tokenHash", "retiredTokenHashes", "removed_at", "id", "name", "repos", "founder", "founder_guessed"]);
+            const known = new Set(["members", "invites", "tokenHash", "retiredTokenHashes", "removed_at", "id", "name", "repos", "founder", "founder_guessed", "recoveries"]);
+            if (Array.isArray(doc.recoveries)) {
+                for (const r of doc.recoveries) {
+                    if (r && typeof r.member === "string" && typeof r.pubkey === "string" && typeof r.due_at === "number")
+                        this.recoveries.set(r.member, r);
+                }
+            }
             if (!Array.isArray(raw))
                 for (const [k, v] of Object.entries(raw))
                     if (!known.has(k))
@@ -123,6 +130,7 @@ export class Allowlist {
             ...(this.retiredHashes.length ? { retiredTokenHashes: this.retiredHashes } : {}),
             ...(this.removedAt !== null ? { removed_at: this.removedAt } : {}),
             ...(this.repos.size ? { repos: [...this.repos.values()] } : {}),
+            ...(this.recoveries.size ? { recoveries: [...this.recoveries.values()] } : {}),
         }, null, 2) + "\n");
     }
     peekId() { return this.id; }
@@ -211,11 +219,12 @@ export class Allowlist {
     get hasToken() {
         return this.tokenHash !== null;
     }
-    mintInvite(by, mayWake, ttlMinutes, token, spaceToken) {
+    mintInvite(by, mayWake, ttlMinutes, token, spaceToken, recoveryFor) {
         const inv = {
             token, created_by: by, created_at: Date.now(),
             expires_at: Date.now() + ttlMinutes * 60_000, may_wake: mayWake,
             ...(spaceToken ? { space_token: spaceToken } : {}),
+            ...(recoveryFor ? { recovery_for: recoveryFor } : {}),
         };
         this.invites.set(token, inv);
         this.flush();
@@ -231,7 +240,16 @@ export class Allowlist {
         if (inv.used_by)
             return { ok: false, why: `that invite was already used by "${inv.used_by}" — ask for a fresh one` };
         if (Date.now() > inv.expires_at)
-            return { ok: false, why: "that invite has expired — ask for a fresh one" };
+            return { ok: false, why: inv.recovery_for ? "that recovery link has expired — run  pantheon recover  again on the new machine" : "that invite has expired — ask for a fresh one" };
+        if (inv.recovery_for) {
+            if (member !== inv.recovery_for || !prior?.admitted || prior.publicKey !== publicKey) {
+                return { ok: false, why: `that link is for ${inv.recovery_for}'s new device after a recovery, and only that device can use it` };
+            }
+            inv.used_by = member;
+            inv.used_at = Date.now();
+            this.flush();
+            return { ok: true, entry: prior };
+        }
         const existing = this.entries.get(member);
         const removedAt = this.removedWhen(member);
         if (removedAt !== null && (inv.created_at <= removedAt || (this.founderName && inv.created_by !== this.founderName))) {
@@ -244,7 +262,8 @@ export class Allowlist {
                     why: `"${member}" founded this team and is registered with a different key — a founder's key cannot be replaced`,
                     fix: [
                         `If you ARE "${member}" on a new machine: restore your original ~/.pantheon/config.json if you still have it — the key is in it — then redeem this same invite again.`,
-                        `  Without it, nobody can let you back in under "${member}": a team's founder is never removed, so the old key cannot be retired.`,
+                        `  Without it, on a relay that verifies email (the hosted one): run  pantheon recover <team>  in a terminal here: it signs you in with your email and moves your seat to this machine.`,
+                        `  Otherwise nobody can let you back in under "${member}": a team's founder is never removed, so the old key cannot be retired.`,
                         `  You can join under another name instead (--me <new-name>, this same invite), or start a new team: pantheon start --space <name>.`,
                         `  If you are not "${member}", join under your own name:  --me <your-name>.`,
                     ].join("\n"),
@@ -256,6 +275,7 @@ export class Allowlist {
                 fix: [
                     `If you are not "${member}", join under your own name:  --me <your-name>   (this same invite is still unused).`,
                     `  If you ARE "${member}" on a new machine: restore your original ~/.pantheon/config.json if you still have it — the key is in it.`,
+                    `  Or, on a relay that verifies email (the hosted one): run  pantheon recover <team>  in a terminal here: it signs you in with your email and moves your seat to this machine.`,
                     `  Failing that, a teammate who has confirmed it is you retires the old key (this removes whoever holds "${member}" now): pantheon admit ${member} --forget`,
                     `  Then redeem this same invite again.`,
                 ].join("\n"),
@@ -273,7 +293,7 @@ export class Allowlist {
         return { ok: true, entry };
     }
     openInvites() {
-        return [...this.invites.values()].filter((i) => !i.used_by && Date.now() < i.expires_at);
+        return [...this.invites.values()].filter((i) => !i.used_by && !i.recovery_for && Date.now() < i.expires_at);
     }
     findInvite(token) {
         const exact = this.invites.get(token);
@@ -418,6 +438,31 @@ export class Allowlist {
         this.flush();
         return true;
     }
+    recoveryOf(member) { return this.recoveries.get(member) ?? null; }
+    recoveryList() { return [...this.recoveries.values()]; }
+    requestRecovery(r) {
+        this.recoveries.set(r.member, r);
+        this.flush();
+    }
+    cancelRecovery(member) {
+        const r = this.recoveries.get(member) ?? null;
+        if (r) {
+            this.recoveries.delete(member);
+            this.flush();
+        }
+        return r;
+    }
+    moveSeat(member, pubkey, move) {
+        const e = this.entries.get(member);
+        if (!e || !e.admitted)
+            return null;
+        e.moved = { from_fp: fingerprint(e.publicKey), ...move };
+        e.publicKey = pubkey;
+        this.recoveries.delete(member);
+        this.cancelInvitesBy(member);
+        this.flush();
+        return e;
+    }
     describe() {
         if (this.empty)
             return "(no members yet)";

package/dist/tray.js

@@ -86,6 +86,16 @@ export function arrangeBoard(items, o) {
     }
     return out.filter((i) => i.lane).sort(boardOrder);
 }
+export function localWakeAsk(ref) {
+    if (!ref)
+        return null;
+    try {
+        return loadPolicy().wakeAsks?.[ref]?.member ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 export function localChoices(ref) {
     if (!ref)
         return null;
@@ -192,7 +202,8 @@ async function trayStatusOne(cfg) {
             const choices = localChoices(o.ref);
             const r = row(o, "decision", !from || from === cfg.member ? "your agent" : from, decisionPrompt(o.id, decisionTitle(o.body)));
             const own = new RegExp(`^${cfg.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} (?:escalated|needs a decision):\\s*`, "i");
-            return { ...r, detail: o.body.replace(own, ""), decider: cfg.member, ...(choices ? { choices } : {}) };
+            const wake = localWakeAsk(o.ref);
+            return { ...r, detail: o.body.replace(own, ""), decider: cfg.member, ...(choices ? { choices } : {}), ...(wake ? { wake } : {}) };
         }),
         ...owed.map((o) => row(o, "owed", "you", owedPrompt(decisionTitle(o.body), o.goal))),
         ...waiting.map((o) => {

package/dist/uninstall.js

@@ -1,5 +1,5 @@
 import { execFileSync, spawnSync } from "node:child_process";
-import { existsSync, lstatSync, readFileSync, readdirSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
 import { platform } from "node:os";
 import { posix, win32 } from "node:path";
 import { expectedLauncher, windowsManagedRoots } from "./managed.js";
@@ -7,6 +7,40 @@ export const BEGIN_MARK = "# >>> pantheon >>>";
 export const END_MARK = "# <<< pantheon <<<";
 export const PROFILES = [".profile", ".bash_profile", ".bash_login", ".bashrc", ".zshrc", ".zprofile"];
 export const FISH_CONF = ".config/fish/conf.d/pantheon.fish";
+export const ZSH_PROFILES = [".zshrc", ".zprofile"];
+export function zshDir(home, env = process.env, ask = () => askZsh(env)) {
+    const z = (ask() ?? env.ZDOTDIR ?? "").replace(/\/+$/, "");
+    if (!z)
+        return home;
+    const rz = realDir(z), rh = realDir(home);
+    return rz && rh && rz.startsWith(`${rh === "/" ? "" : rh}/`) ? posix.join(home, rz.slice(rh.length)) : home;
+}
+function realDir(p) {
+    let d = posix.resolve(p);
+    const rest = [];
+    for (;;) {
+        try {
+            return posix.join(realpathSync(d), ...rest);
+        }
+        catch { }
+        const up = posix.dirname(d);
+        if (up === d)
+            return null;
+        rest.unshift(posix.basename(d));
+        d = up;
+    }
+}
+function askZsh(env) {
+    const mark = "__pantheon_zdotdir__";
+    try {
+        const out = execFileSync("zsh", ["-c", `printf "\\n${mark}%s\\n" "\${ZDOTDIR:-}"`], { encoding: "utf8", env, stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 });
+        const line = out.split("\n").filter((l) => l.startsWith(mark)).at(-1);
+        return line === undefined ? null : line.slice(mark.length);
+    }
+    catch {
+        return null;
+    }
+}
 export function withoutPathBlock(text) {
     const lines = text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
     const bare = (l) => l.replace(/\n$/, "").replace(/\r$/, "");
@@ -161,8 +195,9 @@ export function removeManagedInstall(o) {
         }
     }
     else {
-        for (const name of PROFILES) {
-            const f = p.join(o.home, name);
+        const zdot = o.zdotdir ?? zshDir(o.home, env);
+        const files = [...PROFILES.map((n) => p.join(o.home, n)), ...(p.resolve(zdot) !== p.resolve(o.home) ? ZSH_PROFILES.map((n) => p.join(zdot, n)) : [])];
+        for (const f of files) {
             if (!fs.exists(f))
                 continue;
             let text;

package/dist/uri-handler.js

@@ -5,7 +5,7 @@ import { join, win32 } from "node:path";
 export const URI_SCHEME = "pantheon";
 export const URI_HOSTS = ["board", "done", "explain", "details"];
 const FORMS = {
-    board: { required: [], optional: [] },
+    board: { required: [], optional: ["focus"] },
     done: { required: ["decision", "k"], optional: ["act", "space"] },
     explain: { required: ["decision", "k"], optional: ["act", "space"] },
     details: { required: ["act", "k"], optional: ["decision", "space"] },
@@ -15,6 +15,7 @@ export const URI_VALUE = {
     act: /^a_[A-Za-z0-9]{6,48}$/,
     space: /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/,
     k: /^[0-9a-f]{32}$/,
+    focus: /^[ao]_[A-Za-z0-9]{6,48}$/,
 };
 export const MAX_URI = 400;
 function canonical(host, params) {
@@ -201,7 +202,7 @@ export async function handleUri(args, d) {
         if (d.openBoard) {
             let ok = false;
             try {
-                ok = await d.openBoard();
+                ok = await d.openBoard(p.params.focus);
             }
             catch {
                 ok = false;

package/dist/verify-act.js

@@ -90,6 +90,23 @@ export function verifyGoal(g, teams, pinnedFp, memberKey, at = Date.now()) {
     at = Math.max(sig.ts, g.opened_at || 0);
     return signer(sig, team, g.opened_by, pinnedFp, memberKey, at, "goal");
 }
+export function vouchedMove(m, newFp, teams, pinOf, admitted = () => true) {
+    const mv = m.moved;
+    if (!mv || mv.how !== "confirmed" || typeof mv.by !== "string" || mv.by === m.member)
+        return null;
+    const v = mv.vouch;
+    if (!v || typeof v !== "object" || v.from !== mv.by || v.act !== "NOTE")
+        return null;
+    const r = v.meta?.recovery;
+    if (!r || r.action !== "confirm" || r.member !== m.member || r.fp !== newFp)
+        return null;
+    if (r.from_fp !== pinOf(m.member)?.fp || !admitted(mv.by))
+        return null;
+    const pin = pinOf(mv.by);
+    if (!pin || pin.pending)
+        return null;
+    return verifyAct(v, teams, pin.fp, pin.key).trust === "verified" ? mv.by : null;
+}
 export const trusted = (t) => t === "verified" || t === "verified-run";
 export function trustLabel(r, from) {
     switch (r.trust) {

package/dist/worker-fleet.js

@@ -1,13 +1,20 @@
 import { existsSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
-import { holdsRepo } from "./repo-find.js";
+import { holdsRepo, repoInside } from "./repo-find.js";
 import { CONFIG_DIR, configFor, loadAll, repoInfo } from "./config.js";
 import { Worker, workspaceOf } from "./worker.js";
+import { folderReaderLine } from "./agents.js";
 export class WorkerFleet {
     opts;
     dupSaid = new Set();
     slots = new Map();
     stopped = false;
+    unservedSaid = new Set();
+    idleSaid = "";
+    keeper = null;
+    alertDue = new Map();
+    alertRun = null;
+    alertFailSaid = new Map();
     constructor(opts) {
         this.opts = opts;
     }
@@ -32,6 +39,13 @@ export class WorkerFleet {
                     continue;
                 }
                 const ws = teamWorkspaces(f, m.id);
+                for (const u of unservedFolders(f, m.id, ws)) {
+                    const key = `${m.id}|${u.path}|${u.why}`;
+                    if (this.unservedSaid.has(key))
+                        continue;
+                    this.unservedSaid.add(key);
+                    this.opts.log(`fleet: [${m.name}] ${u.path} is bound but not served: ${u.why}`);
+                }
                 const home = ws.find((w) => w.kind === "repo") ?? ws[0];
                 if (!home)
                     continue;
@@ -39,11 +53,16 @@ export class WorkerFleet {
                 wanted.set(m.id, { path: home.path, cfg: configFor(f, m, repo) });
                 void several;
             }
+            if (wanted.size)
+                this.stopKeeper();
+            else
+                this.startKeeper(f);
+            this.alertChecks(f, Object.values(f.spaces ?? {}).filter((m) => (idCount.get(m.id) ?? 0) === 1 && !wanted.has(m.id) && this.keeper?.id !== m.id));
             for (const [id, w] of wanted) {
                 if (this.slots.has(id))
                     continue;
                 const home = this.opts.home ?? CONFIG_DIR;
-                const { pollMs: _p, readConfig: _r, makeWorker: _m, home: _h, ...rest } = this.opts;
+                const { pollMs: _p, readConfig: _r, makeWorker: _m, home: _h, alertsEveryMs: _a, ...rest } = this.opts;
                 const wopts = {
                     ...rest,
                     project: w.path,
@@ -60,6 +79,8 @@ export class WorkerFleet {
                 started.push(w.cfg.space);
             }
         }
+        else
+            this.stopKeeper();
         for (const [id, s] of this.slots) {
             if (wanted.has(id))
                 continue;
@@ -69,6 +90,65 @@ export class WorkerFleet {
         }
         return { started, stopped };
     }
+    startKeeper(f) {
+        const teams = Object.values(f.spaces ?? {});
+        const m = (f.default_space ? f.spaces?.[f.default_space] : undefined) ?? teams[0];
+        if (!m) {
+            this.stopKeeper();
+            return;
+        }
+        if (this.keeper?.id === m.id)
+            return;
+        this.stopKeeper();
+        const home = this.opts.home ?? CONFIG_DIR;
+        const { pollMs: _p, readConfig: _r, makeWorker: _m, home: _h, alertsEveryMs: _a, ...rest } = this.opts;
+        const cfg = configFor(f, m, null);
+        const wopts = {
+            ...rest, housekeeping: true, once: false, project: home, workspaces: () => [],
+            scratch: join(home, "worktrees", encodeURIComponent(m.id)), home,
+            log: (l) => this.opts.log(`[${cfg.space}] ${l}`),
+        };
+        const worker = (this.opts.makeWorker ?? ((c, o) => new Worker(c, o)))(cfg, wopts);
+        const done = worker.run().catch((e) => this.opts.log(`[${cfg.space}] ! upkeep stopped: ${e.message}`))
+            .finally(() => { if (this.keeper?.worker === worker)
+            this.keeper = null; });
+        this.keeper = { id: m.id, worker, done, path: home, space: cfg.space };
+    }
+    alertChecks(f, teams) {
+        const ids = new Set(teams.map((m) => m.id));
+        for (const id of this.alertDue.keys())
+            if (!ids.has(id))
+                this.alertDue.delete(id);
+        if (this.alertRun || this.stopped)
+            return;
+        const now = Date.now();
+        const m = teams.filter((t) => (this.alertDue.get(t.id) ?? 0) <= now).sort((a, b) => (this.alertDue.get(a.id) ?? 0) - (this.alertDue.get(b.id) ?? 0))[0];
+        if (!m)
+            return;
+        this.alertDue.set(m.id, now + (this.opts.alertsEveryMs ?? 5 * 60_000));
+        const home = this.opts.home ?? CONFIG_DIR;
+        const { pollMs: _p, readConfig: _r, makeWorker: _m, home: _h, alertsEveryMs: _a, ...rest } = this.opts;
+        const cfg = configFor(f, m, null);
+        const wopts = {
+            ...rest, alertsOnly: true, once: false, project: home, workspaces: () => [],
+            scratch: join(home, "worktrees", encodeURIComponent(m.id)), home,
+            log: (l) => this.opts.log(`[${cfg.space}] ${l}`),
+        };
+        const worker = (this.opts.makeWorker ?? ((c, o) => new Worker(c, o)))(cfg, wopts);
+        this.alertRun = worker.run()
+            .then(() => { this.alertFailSaid.delete(m.id); })
+            .catch((e) => { const why = e.message.split("\n")[0] ?? ""; if (this.alertFailSaid.get(m.id) !== why) {
+            this.alertFailSaid.set(m.id, why);
+            this.opts.log(`[${cfg.space}] could not look for key changes or seat moves: ${why}`);
+        } })
+            .finally(() => { this.alertRun = null; });
+    }
+    stopKeeper() {
+        if (!this.keeper)
+            return;
+        this.keeper.worker.stop();
+        this.keeper = null;
+    }
     async run() {
         const poll = this.opts.pollMs ?? 5000;
         while (!this.stopped) {
@@ -77,18 +157,27 @@ export class WorkerFleet {
                 this.opts.log(`fleet: worker for "${s}" started`);
             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: nothing bound on this machine — bind a repo or a docs folder with \`pantheon use <team> --here\` from inside it`);
+            const idle = !this.slots.size && !started.length
+                ? (this.unservedSaid.size
+                    ? `fleet: nothing this worker can serve — the folders bound here are not opened to teammates' runs (said above, with why)`
+                    : `fleet: nothing bound on this machine — bind a repo or a docs folder with \`pantheon use <team> --here\` from inside it; it is served as soon as it is, no restart`)
+                : "";
+            if (idle && idle !== this.idleSaid)
+                this.opts.log(idle);
+            this.idleSaid = idle;
             await new Promise((r) => setTimeout(r, poll));
             if (this.opts.once && this.slots.size === 0)
                 break;
         }
+        const keeper = this.keeper;
+        this.stopKeeper();
         for (const s of this.slots.values())
             s.worker.stop();
-        await Promise.allSettled([...this.slots.values()].map((s) => s.done));
+        await Promise.allSettled([...this.slots.values()].map((s) => s.done).concat(keeper ? [keeper.done] : [], this.alertRun ? [this.alertRun] : []));
     }
     stop() {
         this.stopped = true;
+        this.keeper?.worker.stop();
         for (const s of this.slots.values())
             s.worker.stop();
     }
@@ -102,4 +191,50 @@ export function teamWorkspaces(f, spaceId) {
     const seen = new Set();
     return [...repos, ...folders].filter((w) => (seen.has(w.path) ? false : (seen.add(w.path), true)));
 }
+export function unservedFolders(f, spaceId, served = teamWorkspaces(f, spaceId), inside = (d) => repoInside(d)) {
+    const all = Object.values(f?.bindings ?? {}).map((b) => resolve(b.path));
+    const out = [];
+    for (const [k, b] of Object.entries(f?.bindings ?? {})) {
+        if (b.space !== spaceId || !k.startsWith("d_"))
+            continue;
+        if (served.some((w) => resolve(w.path) === resolve(b.path)))
+            continue;
+        if (!existsSync(b.path)) {
+            out.push({ path: b.path, why: "it is not there any more — bind the folder again from where it is now (pantheon use <team> --here)" });
+            continue;
+        }
+        const nested = all.find((p) => p !== resolve(b.path) && p.startsWith(`${resolve(b.path)}${sep}`));
+        if (nested) {
+            out.push({ path: b.path, why: `another bound folder is inside it (${nested}), so it is not opened whole — the one inside is served` });
+            continue;
+        }
+        const r = inside(b.path);
+        if (r === "too-large")
+            out.push({ path: b.path, why: "it is too large to check for repos inside it (over 20,000 files and folders), so it is not opened to teammates' runs — bind the folder of documents itself, not one above it" });
+        else if (r)
+            out.push({ path: b.path, why: `it holds a git repo (${r}), and a folder with repos in it is never opened to a teammate's run — bind the repo itself (pantheon use <team> --here inside it), or a folder of documents only` });
+    }
+    return out;
+}
+export function workerServesReport(f, available) {
+    const out = [];
+    const teams = Object.values(f?.spaces ?? {});
+    let folders = false;
+    for (const m of teams) {
+        const ws = teamWorkspaces(f, m.id);
+        const lead = teams.length > 1 ? `${m.name}: ` : "";
+        if (ws.length)
+            out.push({ line: `serves    ${lead}${ws.map((w) => `${w.name}${w.kind === "folder" ? " (folder)" : ""}`).join(", ")}`, warn: false });
+        for (const u of unservedFolders(f, m.id, ws))
+            out.push({ line: `not served ${lead}${u.path} — ${u.why}`, warn: true });
+        folders ||= ws.some((w) => w.kind === "folder");
+    }
+    if (teams.length && !out.length)
+        out.push({ line: "serves    nothing yet — teammates' requests wait for you. Bind a repo or docs folder from inside it: pantheon use <team> --here (served at once, no restart)", warn: true });
+    if (folders) {
+        const r = folderReaderLine(available);
+        out.push({ line: `folders   ${r.line}`, warn: !r.ok });
+    }
+    return out;
+}
 //# sourceMappingURL=worker-fleet.js.map