@join-pantheon/cli 0.29.1 → 0.31.0

package/dist/config.js

@@ -1,8 +1,10 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { readFileSync, mkdirSync, existsSync, openSync, writeSync, fsyncSync, closeSync, renameSync, rmSync, statSync, chmodSync, realpathSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
+import { VERSION } from "./version.js";
+import { repoName } from "./repo-route.js";
 export const CONFIG_DIR = process.env.PANTHEON_HOME ?? join(homedir(), ".pantheon");
 export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 export const DEFAULT_RELAY = process.env.PANTHEON_DEFAULT_RELAY
@@ -60,13 +62,34 @@ function sameRepo(host, path) {
     return [host, path];
 }
 const repoCache = new Map();
+const gitUnanswered = new Set();
+export function repoUnknown(dir = process.cwd()) {
+    const key = resolve(dir);
+    if (!gitUnanswered.has(key))
+        return false;
+    for (let d = key;; d = resolve(d, "..")) {
+        if (existsSync(join(d, ".git")))
+            return true;
+        if (resolve(d, "..") === d)
+            return false;
+    }
+}
 export function repoInfo(dir = process.cwd()) {
     const key = resolve(dir);
     if (repoCache.has(key))
         return repoCache.get(key);
     let info = null;
     try {
-        const root = execFileSync("git", ["-C", key, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000 }).trim();
+        let root;
+        try {
+            root = execFileSync("git", ["-C", key, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim();
+        }
+        catch (e) {
+            if (e.status !== 128)
+                gitUnanswered.add(key);
+            throw e;
+        }
+        gitUnanswered.delete(key);
         let origin = null;
         try {
             origin = normalizeOrigin(execFileSync("git", ["-C", root, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000 }));
@@ -90,7 +113,10 @@ export function migrate(raw) {
     f.bindings ??= {};
     if (!raw.version && f.space && f.token && !Object.values(f.spaces).some((m) => m.name === f.space && m.relay === f.relay)) {
         const id = legacySpaceId(f.relay, f.space);
-        f.spaces[id] = { id, name: f.space, relay: f.relay, token: f.token, joined_at: Date.now() };
+        f.spaces[id] = {
+            id, name: f.space, relay: f.relay, token: f.token, joined_at: Date.now(),
+            ...(raw.pinTeam ? { pin_team: raw.pinTeam } : {}), ...(raw.joinedWith ? { since: raw.joinedWith } : {}),
+        };
         f.default_space ??= id;
     }
     if (f.default_space && !f.spaces[f.default_space])
@@ -103,7 +129,9 @@ export function migrate(raw) {
 export function loadAll() {
     if (!existsSync(CONFIG_PATH))
         return null;
-    return migrate(JSON.parse(readFileSync(CONFIG_PATH, "utf8")));
+    if (!statSync(CONFIG_PATH).isFile())
+        throw new Error(`${CONFIG_PATH} is not a plain file — remove it and set up again (pantheon doctor)`);
+    return migrate(JSON.parse(readFileSync(CONFIG_PATH, "utf8").replace(/^\uFEFF/, "")));
 }
 export function saveAll(f) {
     const out = { ...f, version: 2, spaces: f.spaces ?? {}, bindings: f.bindings ?? {} };
@@ -114,10 +142,113 @@ export function saveAll(f) {
     const def = out.default_space ? out.spaces[out.default_space] : undefined;
     out.space = def?.name ?? "";
     out.token = def?.token ?? "";
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_PATH, JSON.stringify(out, null, 2) + "\n", { mode: 0o600 });
+    writeConfigAtomic(JSON.stringify(out, null, 2) + "\n");
     return CONFIG_PATH;
 }
+function privateDir() {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    if (process.platform === "win32")
+        return;
+    try {
+        if ((statSync(CONFIG_DIR).mode & 0o077) !== 0)
+            chmodSync(CONFIG_DIR, 0o700);
+    }
+    catch { }
+}
+function writeConfigAtomic(data) {
+    privateDir();
+    const tmp = `${CONFIG_PATH}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    try {
+        const fd = openSync(tmp, "w", 0o600);
+        try {
+            writeSync(fd, data);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        if (process.platform !== "win32")
+            chmodSync(tmp, 0o600);
+        for (let i = 0;; i++) {
+            try {
+                renameSync(tmp, CONFIG_PATH);
+                break;
+            }
+            catch (e) {
+                if (i >= 20 || !["EPERM", "EACCES", "EBUSY"].includes(e.code ?? ""))
+                    throw e;
+                sleepSync(10);
+            }
+        }
+    }
+    catch (e) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch { }
+        throw e;
+    }
+    let dfd = null;
+    try {
+        dfd = openSync(CONFIG_DIR, "r");
+        fsyncSync(dfd);
+    }
+    catch { }
+    finally {
+        if (dfd !== null)
+            try {
+                closeSync(dfd);
+            }
+            catch { }
+    }
+}
+const CONFIG_LOCK_STALE_MS = 5_000;
+const CONFIG_LOCK_WAIT_MS = 15_000;
+const sleepSync = (ms) => { try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+catch { } };
+export function withConfigLock(fn) {
+    privateDir();
+    const lock = `${CONFIG_PATH}.lock`;
+    const t0 = Date.now();
+    let fd = null;
+    while (fd === null) {
+        try {
+            fd = openSync(lock, "wx", 0o600);
+        }
+        catch (e) {
+            const code = e.code;
+            if (code !== "EEXIST" && !(process.platform === "win32" && (code === "EPERM" || code === "EACCES" || code === "EBUSY")))
+                throw e;
+            try {
+                if (Date.now() - statSync(lock).mtimeMs > CONFIG_LOCK_STALE_MS) {
+                    rmSync(lock, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - t0 > CONFIG_LOCK_WAIT_MS)
+                throw new Error(`config.json is locked by another pantheon process (${lock})`);
+            sleepSync(2 + Math.floor(Math.random() * 8));
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch { }
+        try {
+            rmSync(lock, { force: true });
+        }
+        catch { }
+    }
+}
 export function configFor(f, m, repo) { return view(f, m, repo); }
 function view(f, m, repo) {
     return {
@@ -125,7 +256,10 @@ function view(f, m, repo) {
         publicKey: f.publicKey, privateKey: f.privateKey,
         ...(f.display ? { display: f.display } : {}), ...(f.agent ? { agent: f.agent } : {}),
         ...(f.account ? { account: f.account } : {}), ...(f.pendingAuth ? { pendingAuth: f.pendingAuth } : {}),
-        ...(m.id.startsWith("legacy:") ? {} : { spaceId: m.id }),
+        ...(f.delegate ? { delegate: f.delegate } : {}),
+        ...(m.since ? { joinedWith: m.since } : {}),
+        ...(m.pin_team ? { pinTeam: m.pin_team } : {}),
+        ...(m.id.startsWith("legacy:") ? (f.spaceId ? { spaceId: f.spaceId } : {}) : { spaceId: m.id }),
         ...(repo ? { repo: repo.fingerprint, ...(repo.origin ? { repoOrigin: repo.origin } : {}) } : {}),
     };
 }
@@ -134,15 +268,25 @@ function cwdRepo(repo) {
 }
 function envView(onDisk) {
     const e = process.env;
-    if (!(e.PANTHEON_RELAY && e.PANTHEON_SPACE && e.PANTHEON_TOKEN && e.PANTHEON_MEMBER))
+    if (!(e.PANTHEON_RELAY && e.PANTHEON_SPACE && e.PANTHEON_MEMBER))
+        return null;
+    const mine = onDisk?.member === e.PANTHEON_MEMBER
+        ? Object.values(onDisk.spaces ?? {}).find((m) => (e.PANTHEON_SPACE_ID && m.id === e.PANTHEON_SPACE_ID) || (m.relay === e.PANTHEON_RELAY && m.name === e.PANTHEON_SPACE))
+        : undefined;
+    const token = e.PANTHEON_TOKEN ?? mine?.token;
+    if (!token)
         return null;
     const pub = e.PANTHEON_PUBKEY ?? onDisk?.publicKey;
     const priv = e.PANTHEON_PRIVKEY ?? onDisk?.privateKey;
-    if (!pub || !priv)
+    const delegate = onDisk?.member === e.PANTHEON_MEMBER ? onDisk?.delegate : undefined;
+    if (!pub || (!priv && !delegate))
         return null;
     return {
-        relay: e.PANTHEON_RELAY, space: e.PANTHEON_SPACE, token: e.PANTHEON_TOKEN, member: e.PANTHEON_MEMBER,
-        publicKey: pub, privateKey: priv, display: e.PANTHEON_DISPLAY, agent: e.PANTHEON_AGENT,
+        relay: e.PANTHEON_RELAY, space: e.PANTHEON_SPACE, token, member: e.PANTHEON_MEMBER,
+        publicKey: pub, privateKey: priv ?? "", display: e.PANTHEON_DISPLAY, agent: e.PANTHEON_AGENT,
+        ...(delegate ? { delegate } : {}),
+        ...(mine?.pin_team ? { pinTeam: mine.pin_team } : {}),
+        ...(mine?.since ? { joinedWith: mine.since } : {}),
         ...(e.PANTHEON_SPACE_ID ? { spaceId: e.PANTHEON_SPACE_ID } : {}),
         ...(e.PANTHEON_REPO ? { repo: e.PANTHEON_REPO } : {}),
     };
@@ -165,7 +309,26 @@ export function resolveFor(cwd = process.cwd(), opts = {}) {
                 return { cfg: applyAgentEnv(view(f, m, repo)), reason: "binding", memberships: n, binding: { ...b, fingerprint: repo.fingerprint }, repo };
             return { cfg: null, reason: "stale", memberships: n, binding: { ...b, fingerprint: repo.fingerprint }, repo };
         }
+        const owners = f.unbound?.includes(repo.fingerprint) ? [] : Object.values(spaces).filter((m) => m.repos?.some((r) => r.fp === repo.fingerprint));
+        if (owners.length === 1) {
+            const m = owners[0];
+            const binding = { space: m.id, path: repo.root, origin: repo.origin, bound_at: 0, fingerprint: repo.fingerprint };
+            return { cfg: applyAgentEnv(view(f, m, repo)), reason: "binding", memberships: n, binding, repo, autoBound: true };
+        }
+        if (owners.length > 1)
+            return { cfg: null, reason: "unbound", memberships: n, repo, claimedBy: owners.map((m) => m.name) };
+    }
+    if (!repo) {
+        const fb = folderBinding(f, cwd);
+        if (fb) {
+            const m = spaces[fb.space];
+            if (m)
+                return { cfg: applyAgentEnv(view(f, m, null)), reason: "binding", memberships: n, binding: { ...fb, fingerprint: fb.key }, repo };
+            return { cfg: null, reason: "stale", memberships: n, binding: { ...fb, fingerprint: fb.key }, repo };
+        }
     }
+    if (!repo && n > 1 && repoUnknown(cwd))
+        return { cfg: null, reason: "unbound", memberships: n, repo, repoUnknown: true };
     if (n === 1) {
         const m = Object.values(spaces)[0];
         return { cfg: applyAgentEnv({ ...view(f, m, null), ...cwdRepo(repo) }), reason: "single", memberships: 1, repo };
@@ -255,12 +418,86 @@ export function save(cfg) {
         }
         else {
             const id = cfg.spaceId ?? legacySpaceId(cfg.relay, cfg.space);
-            f.spaces[id] = { id, name: cfg.space, relay: cfg.relay, token: cfg.token, joined_at: Date.now() };
+            f.spaces[id] = { id, name: cfg.space, relay: cfg.relay, token: cfg.token, joined_at: Date.now(), since: VERSION };
             f.default_space = id;
         }
     }
     return saveAll(f);
 }
+export function rememberTeamRepos(team, repos) {
+    if (!existsSync(CONFIG_PATH))
+        return false;
+    const next = repos.map((r) => ({ fp: r.fingerprint, name: r.origin ? teamRepoName(r.origin) : r.fingerprint })).sort((a, b) => a.fp.localeCompare(b.fp));
+    try {
+        return withConfigLock(() => {
+            let f;
+            try {
+                f = loadAll();
+            }
+            catch {
+                return false;
+            }
+            const m = f && Object.values(f.spaces ?? {}).find((x) => (team.spaceId && x.id === team.spaceId) || (x.name === team.space && x.relay === team.relay));
+            if (!f || !m)
+                return false;
+            if (JSON.stringify(m.repos ?? []) === JSON.stringify(next))
+                return false;
+            m.repos = next;
+            saveAll(f);
+            return true;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+export const teamRepoName = (origin) => repoName(origin);
+export function updateMembershipToken(space, oldToken, newToken) {
+    if (!space || !oldToken || !newToken || oldToken === newToken)
+        return false;
+    if (!existsSync(CONFIG_PATH))
+        return false;
+    return withConfigLock(() => {
+        let f;
+        try {
+            f = loadAll();
+        }
+        catch {
+            return false;
+        }
+        if (!f)
+            return false;
+        let hit = false;
+        for (const m of Object.values(f.spaces ?? {})) {
+            if (m.name === space && m.token === oldToken) {
+                m.token = newToken;
+                hit = true;
+            }
+        }
+        if (!hit)
+            return false;
+        saveAll(f);
+        return true;
+    });
+}
+export function adoptSpaceId(relay, name, id) {
+    if (!/^[A-Za-z0-9_:.-]{1,64}$/.test(id) || !existsSync(CONFIG_PATH))
+        return false;
+    const f = loadAll();
+    if (!f?.spaces)
+        return false;
+    const legacy = legacySpaceId(relay, name);
+    const m = f.spaces[legacy];
+    if (!m)
+        return false;
+    if (f.spaces[id])
+        return "conflict";
+    delete f.spaces[legacy];
+    f.spaces[id] = { ...m, id, pin_team: m.pin_team ?? `${name}@${relay}` };
+    adoptId(f, legacy, id);
+    saveAll(f);
+    return true;
+}
 function adoptId(f, oldId, newId) {
     for (const b of Object.values(f.bindings ?? {}))
         if (b.space === oldId)
@@ -268,6 +505,38 @@ function adoptId(f, oldId, newId) {
     if (f.default_space === oldId)
         f.default_space = newId;
 }
+export function bindFolder(dir, spaceId) {
+    const f = loadAll();
+    if (!f)
+        throw new Error("not configured");
+    f.bindings ??= {};
+    const path = canonDir(dir);
+    const key = `d_${sha16(path)}`;
+    const prev = f.bindings[key] ?? null;
+    f.bindings[key] = { space: spaceId, path, origin: null, bound_at: Date.now() };
+    saveAll(f);
+    return { key, replaced: prev && prev.space !== spaceId ? prev : null };
+}
+function canonDir(dir) {
+    try {
+        return realpathSync.native(dir);
+    }
+    catch {
+        return resolve(dir);
+    }
+}
+export function folderBinding(f, dir) {
+    const here = canonDir(dir);
+    let best = null;
+    for (const [key, b] of Object.entries(f.bindings ?? {})) {
+        if (!key.startsWith("d_"))
+            continue;
+        const inside = here === b.path || here.startsWith(b.path.endsWith(sep) ? b.path : b.path + sep);
+        if (inside && (!best || b.path.length > best.path.length))
+            best = { ...b, key };
+    }
+    return best;
+}
 export function bindRepo(repo, spaceId) {
     const f = loadAll();
     if (!f)
@@ -275,6 +544,8 @@ export function bindRepo(repo, spaceId) {
     f.bindings ??= {};
     const prev = f.bindings[repo.fingerprint] ?? null;
     f.bindings[repo.fingerprint] = { space: spaceId, path: repo.root, origin: repo.origin, bound_at: Date.now() };
+    if (f.unbound?.includes(repo.fingerprint))
+        f.unbound = f.unbound.filter((x) => x !== repo.fingerprint);
     saveAll(f);
     return { replaced: prev && prev.space !== spaceId ? prev : null };
 }
@@ -283,6 +554,8 @@ export function unbindRepo(fingerprint) {
     if (!f?.bindings?.[fingerprint])
         return false;
     delete f.bindings[fingerprint];
+    if (/^[rl]_/.test(fingerprint))
+        f.unbound = [...new Set([...(f.unbound ?? []), fingerprint])].slice(-200);
     saveAll(f);
     return true;
 }

package/dist/continued.js

@@ -1,16 +1,18 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
+import { readStateFile, withFileLock } from "./file-lock.js";
+import { writeWhole } from "./pins.js";
 const KEEP = 500;
 export function continuedPath(home) {
     return join(home ?? CONFIG_DIR, "continued.json");
 }
 function readAll(home) {
     try {
-        const p = continuedPath(home);
-        if (!existsSync(p))
+        const t = readStateFile(continuedPath(home));
+        if (t === null)
             return {};
-        const v = JSON.parse(readFileSync(p, "utf8"));
+        const v = JSON.parse(t);
         return v && typeof v === "object" ? v : {};
     }
     catch {
@@ -20,15 +22,45 @@ function readAll(home) {
 export function loadContinued(space, home) {
     return new Set(readAll(home)[space] ?? []);
 }
+export function handledIn(h) {
+    return [...new Set(Object.values(readAll(h)).flatMap((l) => (Array.isArray(l) ? l : [])).filter((x) => typeof x === "string" && x.startsWith("handled:")))];
+}
 export function markContinued(space, id, home) {
     try {
-        const all = readAll(home);
-        const list = (all[space] ?? []).filter((x) => x !== id);
-        list.push(id);
-        all[space] = list.slice(-KEEP);
         const p = continuedPath(home);
-        mkdirSync(dirname(p), { recursive: true });
-        writeFileSync(p, JSON.stringify(all));
+        const write = () => {
+            const all = readAll(home);
+            const list = (all[space] ?? []).filter((x) => x !== id);
+            list.push(id);
+            all[space] = list.slice(-KEEP);
+            mkdirSync(dirname(p), { recursive: true });
+            writeWhole(p, JSON.stringify(all));
+        };
+        try {
+            withFileLock(p, write);
+        }
+        catch {
+            write();
+        }
+    }
+    catch { }
+}
+export function unmarkContinued(space, id, home) {
+    try {
+        const p = continuedPath(home);
+        const write = () => {
+            const all = readAll(home);
+            if (!(all[space] ?? []).includes(id))
+                return;
+            all[space] = (all[space] ?? []).filter((x) => x !== id);
+            writeWhole(p, JSON.stringify(all));
+        };
+        try {
+            withFileLock(p, write);
+        }
+        catch {
+            write();
+        }
     }
     catch { }
 }