@join-pantheon/cli 0.29.1 → 0.31.0

package/dist/repo-find.js

@@ -0,0 +1,127 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join, resolve } from "node:path";
+import { repoInfo } from "./config.js";
+const SKIP = new Set(["node_modules", "vendor", "dist", "build", "target", "out", ".next", "Pods", "DerivedData", "venv", ".venv", "__pycache__", "Library", "Applications"]);
+export function reposUnder(dir, depth = 3, budget = { left: 4000 }) {
+    const out = [];
+    const seen = new Set();
+    const walk = (d, level) => {
+        if (budget.left-- <= 0)
+            return;
+        if (existsSync(join(d, ".git"))) {
+            const r = repoInfo(d);
+            if (r && !seen.has(r.root)) {
+                seen.add(r.root);
+                out.push(r);
+            }
+            return;
+        }
+        if (level >= depth)
+            return;
+        let entries = [];
+        try {
+            entries = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.startsWith(".") || SKIP.has(e))
+                continue;
+            const p = join(d, e);
+            try {
+                if (!statSync(p).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            walk(p, level + 1);
+        }
+    };
+    walk(resolve(dir), 0);
+    return out;
+}
+export function holdsRepo(dir, budget = 20_000) {
+    let left = budget;
+    const stack = [resolve(dir)];
+    while (stack.length) {
+        const d = stack.pop();
+        if (left-- <= 0)
+            return true;
+        let entries = [];
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.name === ".git")
+                return true;
+            if (e.isDirectory())
+                stack.push(join(d, e.name));
+        }
+    }
+    return false;
+}
+export function commonCodeRoots(home = homedir()) {
+    return ["code", "Code", "src", "dev", "Developer", "projects", "Projects", "workspace", "work", "repos", "git", "github", "GitHub", "Documents/GitHub", "Documents/code", "Sites"]
+        .map((d) => join(home, d)).filter((d) => { try {
+        return statSync(d).isDirectory();
+    }
+    catch {
+        return false;
+    } });
+}
+export function openedFolders(home = homedir(), os = platform()) {
+    const out = new Set();
+    const add = (p) => { if (typeof p === "string" && (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p)))
+        out.add(p); };
+    try {
+        for (const k of Object.keys(JSON.parse(readFileSync(join(home, ".claude.json"), "utf8")).projects ?? {}))
+            add(k);
+    }
+    catch { }
+    const appData = os === "darwin" ? join(home, "Library", "Application Support") : os === "win32" ? (process.env["APPDATA"] ?? join(home, "AppData", "Roaming")) : join(home, ".config");
+    for (const app of ["Code", "Cursor", "Code - Insiders", "Windsurf"]) {
+        try {
+            const text = readFileSync(join(appData, app, "User", "globalStorage", "storage.json"), "utf8");
+            for (const m of text.matchAll(/"file:\/\/([^"]+)"/g)) {
+                try {
+                    add(decodeURIComponent(m[1]).replace(/^\/([A-Za-z]:)/, "$1"));
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    return [...out];
+}
+export function findTeamClones(teamFps, opts = {}) {
+    const want = new Set(teamFps);
+    const found = new Map();
+    const consider = (r, how) => { if (r && want.has(r.fingerprint) && !found.has(r.fingerprint))
+        found.set(r.fingerprint, { repo: r, how }); };
+    const home = opts.home ?? homedir();
+    if (opts.recents)
+        for (const d of openedFolders(home, opts.os)) {
+            if (found.size === want.size)
+                break;
+            try {
+                if (existsSync(d))
+                    consider(repoInfo(d), "opened in your editor or agent");
+            }
+            catch { }
+        }
+    const budget = { left: 6000 };
+    for (const root of [...(opts.extra ?? []), ...commonCodeRoots(home)]) {
+        if (found.size === want.size)
+            break;
+        for (const r of reposUnder(root, 3, budget))
+            consider(r, `found in ${root.startsWith(home) ? `~${root.slice(home.length)}` : root}`);
+    }
+    return [...found.values()];
+}
+//# sourceMappingURL=repo-find.js.map

package/dist/repo-route.js

@@ -0,0 +1,70 @@
+import { basename } from "node:path";
+export function repoName(originOrPath) {
+    const s = originOrPath.trim().replace(/[\\/]+$/, "").replace(/\.git$/i, "");
+    return safeName(basename(s.replace(/^.*[:/]([^:/]+)$/, "$1")) || s);
+}
+export function safeName(n) {
+    return n.normalize("NFKC").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+|-+$/g, "").slice(0, 64) || "repo";
+}
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+export function names(text, name, origin, strict = false) {
+    if (!name)
+        return false;
+    const t = text.toLowerCase();
+    const n = name.toLowerCase();
+    if (origin) {
+        const slug = origin.toLowerCase().replace(/\.git$/, "").replace(/^.*?[:/]([^:/]+\/[^:/]+)$/, "$1");
+        if (slug.includes("/") && t.includes(slug))
+            return true;
+    }
+    const word = `(?<![\\w./-])${esc(n)}(?![\\w-])`;
+    if (n.length >= 5 && !strict && new RegExp(word, "i").test(t))
+        return true;
+    return new RegExp(`\`${esc(n)}\`|${word}\\s+(?:repo|repository|codebase|app|service|project)\\b|\\b(?:repo|repository|codebase)\\s+${esc(n)}(?![\\w-])|${word}/[\\w.-]`, "i").test(t);
+}
+export function explicitlyNames(text, name) {
+    if (!name)
+        return false;
+    const n = esc(name.toLowerCase());
+    const word = `(?<![\\w./-])${n}(?![\\w-])`;
+    return new RegExp(`${word}\\s+(?:repo|repository)\\b|\\b(?:repo|repository)\\s+${n}(?![\\w-])`, "i").test(text.toLowerCase());
+}
+export function routeRequest(i) {
+    const ws = i.workspaces;
+    if (!ws.length)
+        return { kind: "none", why: "no folder on this machine is bound to this team" };
+    const byFp = (fp) => (fp ? ws.find((w) => w.fp === fp) : undefined);
+    const teamName = (fp) => i.teamRepos.find((r) => r.fp === fp)?.name ?? fp;
+    const here = ws.map((w) => w.name);
+    const localFps = new Set(ws.map((w) => w.fp).filter(Boolean));
+    const notHere = i.teamRepos.filter((r) => !localFps.has(r.fp)).map((r) => r.name);
+    const max = i.maxContext ?? 2;
+    const activity = i.activity ?? (() => 0);
+    const withContext = (primary, why, prefer = []) => {
+        const others = ws.filter((w) => w !== primary && w.kind === "repo");
+        const ordered = [...prefer.filter((w) => w !== primary), ...others.filter((w) => !prefer.includes(w)).sort((a, b) => activity(b) - activity(a))];
+        return { kind: "run", primary, context: ordered.filter((w) => w.kind === "repo").slice(0, max), why, notHere };
+    };
+    const strict = (n) => !!i.teamName && n.toLowerCase() === i.teamName.toLowerCase();
+    const namedLocal = ws.filter((w) => names(i.text, w.name, w.origin, strict(w.name))).sort((a, b) => b.name.length - a.name.length);
+    const namedTeam = i.teamRepos.filter((r) => !localFps.has(r.fp) && explicitlyNames(i.ask ?? i.text, r.name)).sort((a, b) => b.name.length - a.name.length);
+    if (namedLocal.length) {
+        return withContext(namedLocal[0], `the request names ${namedLocal.map((w) => w.name).join(" and ")}`, namedLocal.slice(1));
+    }
+    if (namedTeam.length) {
+        return { kind: "missing", name: namedTeam[0].name, why: `the request is about ${namedTeam[0].name}, which is not on this machine`, here };
+    }
+    const delivered = byFp(i.deliveredRepo);
+    if (delivered)
+        return withContext(delivered, `this goal's work was delivered in ${delivered.name}`);
+    const sender = byFp(i.senderRepo);
+    if (sender)
+        return withContext(sender, `the request was sent from ${sender.name}`);
+    if (ws.length === 1) {
+        const note = i.senderRepo && !sender ? ` (it was sent from ${teamName(i.senderRepo)}, which is not on this machine)` : "";
+        return { kind: "run", primary: ws[0], context: [], why: `the only folder on this machine bound to this team${note}`, notHere };
+    }
+    const primary = [...ws].sort((a, b) => activity(b) - activity(a))[0];
+    return withContext(primary, `nothing in the request says which, so the most recently active (${primary.name}), with the others open to read`);
+}
+//# sourceMappingURL=repo-route.js.map

package/dist/roster-file.js

@@ -1,8 +1,19 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { createHash, timingSafeEqual } from "node:crypto";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { fingerprint } from "./identity.js";
+import { writeFileAtomic } from "./store.js";
+export class RosterUnreadable extends Error {
+    file;
+    constructor(file, detail) {
+        super(`the member list ${file} cannot be read (${detail})`);
+        this.file = file;
+        this.name = "RosterUnreadable";
+    }
+}
+export const PENDING_CAP = 50;
+export const PENDING_TTL_MS = 7 * 24 * 3_600_000;
 function hashToken(token) {
     return createHash("sha256").update(token).digest("hex");
 }
@@ -10,35 +21,109 @@ export class Allowlist {
     entries = new Map();
     invites = new Map();
     tokenHash = null;
+    retiredHashes = [];
+    removedAt = null;
     id = null;
+    founderName = null;
+    founderGuessed = null;
+    name = null;
+    extra = {};
     repos = new Map();
     file;
     constructor(dir, space) {
         this.file = join(dir, `${space}.members.json`);
         if (existsSync(this.file)) {
-            const raw = JSON.parse(readFileSync(this.file, "utf8"));
-            const doc = Array.isArray(raw) ? { members: raw, invites: [] } : raw;
-            for (const e of doc.members ?? [])
-                this.entries.set(e.member, e);
+            let raw;
+            try {
+                raw = JSON.parse(readFileSync(this.file, "utf8"));
+            }
+            catch (e) {
+                throw new RosterUnreadable(this.file, e.message);
+            }
+            if (!raw || typeof raw !== "object")
+                throw new RosterUnreadable(this.file, "not a member list");
+            const doc = (Array.isArray(raw) ? { members: raw, invites: [] } : raw);
+            if ((doc.members !== undefined && !Array.isArray(doc.members)) || (doc.invites !== undefined && !Array.isArray(doc.invites))) {
+                throw new RosterUnreadable(this.file, "not a member list");
+            }
             for (const i of doc.invites ?? [])
                 this.invites.set(i.token, i);
+            let legacyRemoval = false;
+            for (const e of doc.members ?? []) {
+                if (!e.admitted && e.admitted_by && !e.revoked_at) {
+                    e.revoked_at = Date.now();
+                    e.may_wake = false;
+                    legacyRemoval = true;
+                }
+                this.entries.set(e.member, e);
+            }
+            if (legacyRemoval) {
+                for (const e of this.entries.values())
+                    if (e.revoked_at && !e.admitted)
+                        this.cancelInvitesBy(e.member);
+            }
             this.tokenHash = doc.tokenHash ?? null;
+            if ("retiredTokenHashes" in doc && Array.isArray(doc.retiredTokenHashes))
+                this.retiredHashes = doc.retiredTokenHashes.filter((h) => typeof h === "string");
+            if ("removed_at" in doc && typeof doc.removed_at === "number")
+                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"]);
+            if (!Array.isArray(raw))
+                for (const [k, v] of Object.entries(raw))
+                    if (!known.has(k))
+                        this.extra[k] = v;
             this.id = doc.id ?? null;
+            this.name = typeof doc.name === "string" && doc.name ? doc.name : null;
             for (const r of doc.repos ?? [])
                 this.repos.set(r.fingerprint, r);
+            if (typeof doc.founder === "string" && doc.founder) {
+                this.founderName = doc.founder;
+                const g = raw.founder_guessed;
+                if (typeof g === "string" && g)
+                    this.founderGuessed = g;
+            }
+            else if (this.entries.size) {
+                const d = Allowlist.deriveFounderHow([...this.entries.values()]);
+                this.founderName = d?.member ?? null;
+                if (d?.how === "earliest")
+                    this.founderGuessed = "no member was admitted by themselves, so the earliest member to connect was taken";
+                if (this.founderName) {
+                    try {
+                        this.flush();
+                    }
+                    catch { }
+                }
+            }
         }
     }
+    static deriveFounder(entries) {
+        return Allowlist.deriveFounderHow(entries)?.member ?? null;
+    }
+    static deriveFounderHow(entries) {
+        const byAge = [...entries].sort((a, b) => a.first_seen - b.first_seen);
+        const self = byAge.find((e) => e.admitted && (e.admitted_by === e.member || e.admitted_by === undefined));
+        if (self)
+            return { member: self.member, how: "self" };
+        const m = byAge.find((e) => e.admitted_by !== undefined || e.admitted)?.member;
+        return m ? { member: m, how: "earliest" } : null;
+    }
+    founderGuess() { return this.founderGuessed; }
     flush() {
-        mkdirSync(dirname(this.file), { recursive: true });
-        const tmp = `${this.file}.tmp`;
-        writeFileSync(tmp, JSON.stringify({
+        writeFileAtomic(this.file, JSON.stringify({
+            ...this.extra,
             ...(this.id ? { id: this.id } : {}),
+            ...(this.founderName ? { founder: this.founderName } : {}),
+            ...(this.founderName && this.founderGuessed ? { founder_guessed: this.founderGuessed } : {}),
+            ...(this.name ? { name: this.name } : {}),
             members: [...this.entries.values()],
             invites: [...this.invites.values()],
             ...(this.tokenHash ? { tokenHash: this.tokenHash } : {}),
+            ...(this.retiredHashes.length ? { retiredTokenHashes: this.retiredHashes } : {}),
+            ...(this.removedAt !== null ? { removed_at: this.removedAt } : {}),
             ...(this.repos.size ? { repos: [...this.repos.values()] } : {}),
-        }, null, 2) + "\n", { mode: 0o600 });
-        renameSync(tmp, this.file);
+        }, null, 2) + "\n");
     }
     peekId() { return this.id; }
     spaceId() {
@@ -48,6 +133,13 @@ export class Allowlist {
         }
         return this.id;
     }
+    recordedName() { return this.name; }
+    recordName(name) {
+        if (this.name || !name)
+            return;
+        this.name = name;
+        this.flush();
+    }
     repoList() { return [...this.repos.values()]; }
     repoCount() { return this.repos.size; }
     hasRepo(fingerprint) { return this.repos.has(fingerprint); }
@@ -80,6 +172,42 @@ export class Allowlist {
         this.tokenHash = h;
         this.flush();
     }
+    tokenRetired(token) {
+        if (!token)
+            return false;
+        const a = Buffer.from(hashToken(token), "hex");
+        return this.retiredHashes.some((h) => { const b = Buffer.from(h, "hex"); return a.length === b.length && timingSafeEqual(a, b); });
+    }
+    tokenHashes() {
+        return [...(this.tokenHash ? [this.tokenHash] : []), ...this.retiredHashes];
+    }
+    static RETIRED_KEPT = 64;
+    rotateToken(next) {
+        if (this.tokenHash) {
+            this.retiredHashes.push(this.tokenHash);
+            if (this.retiredHashes.length > Allowlist.RETIRED_KEPT)
+                this.retiredHashes = this.retiredHashes.slice(-Allowlist.RETIRED_KEPT);
+        }
+        this.tokenHash = hashToken(next);
+        for (const i of this.invites.values())
+            if (!i.used_by && i.space_token)
+                i.space_token = next;
+        this.flush();
+    }
+    currentTokenFromInvites() {
+        for (const i of this.invites.values()) {
+            if (i.space_token && this.tokenMatches(i.space_token) === true)
+                return i.space_token;
+        }
+        return null;
+    }
+    noteRemoval(at = Date.now()) {
+        this.removedAt = at;
+        this.flush();
+    }
+    removalRecorded() {
+        return this.removedAt !== null || [...this.entries.values()].some((e) => !!e.revoked_at);
+    }
     get hasToken() {
         return this.tokenHash !== null;
     }
@@ -102,28 +230,29 @@ export class Allowlist {
         if (Date.now() > inv.expires_at)
             return { ok: false, why: "that invite has expired — ask for a fresh one" };
         const existing = this.entries.get(member);
-        if (existing?.revoked_at && inv.created_at <= existing.revoked_at) {
-            return { ok: false, why: `"${member}" was removed from this team${existing.revoked_by ? ` by ${existing.revoked_by}` : ""}, so an invite from before that cannot bring them back — ask the founder for a new one` };
+        const removedAt = this.removedWhen(member);
+        if (removedAt !== null && (inv.created_at <= removedAt || (this.founderName && inv.created_by !== this.founderName))) {
+            return { ok: false, why: `"${member}" was removed from this team${existing?.revoked_by ? ` by ${existing.revoked_by}` : ""}, so only an invite from the founder${this.founderName ? ` (${this.founderName})` : ""}, made since, can bring them back` };
         }
         if (existing && existing.publicKey !== publicKey) {
             return {
                 ok: false,
-                why: `"${member}" is registered here with a different key, so this machine cannot claim that name`,
+                why: `"${member}" is registered here with a different key — the name is taken in this team`,
                 fix: [
-                    `If you still have the original ~/.pantheon/config.json, restore it — the key is in there and nothing else needs to change.`,
-                    `  Otherwise an admitted member retires the old key, after checking your new fingerprint with you out of band:`,
-                    `    pantheon admit ${member} --forget`,
-                    `  Then redeem this same invite again; it is still unused.`,
-                    `  Joining as --me <another-name> also works, but you would leave behind every goal and obligation held by "${member}".`,
+                    `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.`,
+                    `  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"),
             };
         }
         const entry = {
-            member, publicKey, admitted: true, admitted_by: inv.created_by,
+            member, publicKey, admitted: true, admitted_by: this.founderName === member ? member : inv.created_by,
             first_seen: existing?.first_seen ?? Date.now(), may_wake: inv.may_wake,
         };
         this.entries.set(member, entry);
         inv.used_by = member;
+        this.clearForgotten(member);
         inv.used_at = Date.now();
         this.flush();
         return { ok: true, entry };
@@ -168,9 +297,9 @@ export class Allowlist {
         return true;
     }
     admittedCount() { return [...this.entries.values()].filter((e) => e.admitted).length; }
+    pendingCount() { return [...this.entries.values()].filter((e) => !e.admitted && !e.revoked_at && !e.admitted_by).length; }
     founder() {
-        const f = [...this.entries.values()].filter((e) => e.admitted && (e.admitted_by === e.member || e.admitted_by === undefined)).sort((a, b) => a.first_seen - b.first_seen)[0];
-        return f?.member ?? null;
+        return this.founderName;
     }
     get(member) {
         return this.entries.get(member);
@@ -181,15 +310,30 @@ export class Allowlist {
     get empty() {
         return this.entries.size === 0;
     }
-    present(member, publicKey) {
+    present(member, publicKey, now = Date.now()) {
         const cur = this.entries.get(member);
         if (!cur) {
             const founder = this.empty;
+            if (!founder) {
+                let expired = false;
+                for (const [k, e] of this.entries) {
+                    if (!e.admitted && !e.revoked_at && !e.admitted_by && now - e.first_seen > PENDING_TTL_MS) {
+                        this.entries.delete(k);
+                        expired = true;
+                    }
+                }
+                if (expired)
+                    this.flush();
+                if (this.pendingCount() >= PENDING_CAP)
+                    return "pending-full";
+            }
             this.entries.set(member, {
                 member, publicKey, admitted: founder,
                 ...(founder ? { admitted_by: member } : {}),
                 first_seen: Date.now(), may_wake: founder,
             });
+            if (founder)
+                this.founderName = member;
             this.flush();
             return founder ? "founder" : "new";
         }
@@ -201,8 +345,10 @@ export class Allowlist {
         const e = this.entries.get(member);
         if (!e)
             return null;
+        if (!e.admitted || e.admitted_by === undefined)
+            e.admitted_by = by;
         e.admitted = true;
-        e.admitted_by = by;
+        this.clearForgotten(member);
         e.may_wake = mayWake;
         delete e.revoked_at;
         delete e.revoked_by;
@@ -218,11 +364,29 @@ export class Allowlist {
             if (i.created_by === member && !i.used_by)
                 this.invites.delete(t);
     }
+    removedWhen(member) {
+        const e = this.entries.get(member);
+        if (e?.revoked_at && !e.admitted)
+            return e.revoked_at;
+        const f = this.extra["forgotten"]?.[member];
+        return typeof f === "number" ? f : null;
+    }
+    clearForgotten(member) {
+        const f = this.extra["forgotten"];
+        if (f && member in f)
+            delete f[member];
+    }
     forget(member) {
         const gone = this.entries.delete(member);
+        if (gone) {
+            const f = (this.extra["forgotten"] ??= {});
+            f[member] = Date.now();
+        }
         this.cancelInvitesBy(member);
-        if (gone)
+        if (gone) {
+            this.removedAt = Date.now();
             this.flush();
+        }
         return gone;
     }
     revoke(member, by) {
@@ -232,6 +396,7 @@ export class Allowlist {
         e.admitted = false;
         e.may_wake = false;
         e.revoked_at = Date.now();
+        this.removedAt = e.revoked_at;
         if (by)
             e.revoked_by = by;
         this.cancelInvitesBy(member);