@join-pantheon/cli 0.33.3 → 0.33.4

package/dist/disk-writer.js

@@ -0,0 +1,404 @@
+import { promises as fsp, readFileSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { noteDiskWait, slowDiskMs, waitsForDisk } from "./store.js";
+export function supersedeFor(file) {
+    return file.endsWith(".state.json") ? "mark" : file.endsWith(".jsonl") ? "first" : "carry";
+}
+export class DiskBusy extends Error {
+    bytes;
+    cap;
+    code = "STORAGE_BUSY";
+    constructor(bytes, cap) {
+        super(`the relay's disk is ${(bytes / 1e6).toFixed(1)} MB behind on this team's writes`);
+        this.bytes = bytes;
+        this.cap = cap;
+        this.name = "DiskBusy";
+    }
+}
+export function backlogCap() {
+    const n = Number(process.env.PANTHEON_RELAY_WRITE_BACKLOG_BYTES ?? "");
+    return Number.isFinite(n) && n > 0 ? n : 8 * 1024 * 1024;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const APPEND_HOLD_MS = 2_000;
+export function retryDelayMs(attempt) {
+    return Math.min(5_000, 50 * 2 ** Math.max(0, attempt - 1));
+}
+const reporters = new Set();
+export function onWriteError(dir, fn) {
+    const r = { dir: resolve(dir), fn };
+    reporters.add(r);
+    return () => { reporters.delete(r); };
+}
+export class SpaceWriter {
+    dir;
+    stem;
+    key;
+    queue = [];
+    inflight = null;
+    issued = 0;
+    open = new Set();
+    waiters = [];
+    running = false;
+    failing = null;
+    backlogBytes = 0;
+    constructor(dir, stem, key) {
+        this.dir = dir;
+        this.stem = stem;
+        this.key = key;
+    }
+    get ticket() { return this.issued; }
+    get doneThrough() {
+        let low = Infinity;
+        for (const t of this.open)
+            if (t < low)
+                low = t;
+        return low === Infinity ? this.issued : low - 1;
+    }
+    get idle() { return !this.inflight && this.queue.length === 0; }
+    whenWritten(ticket = this.issued) {
+        if (this.doneThrough >= ticket)
+            return Promise.resolve();
+        return new Promise((done) => this.waiters.push({ ticket, done }));
+    }
+    append(file, data, offset) {
+        return this.push({ kind: "append", file, data, offset, tickets: [] });
+    }
+    replace(file, data, mode = 0o600, how = supersedeFor(file)) {
+        return this.push({ kind: "replace", file, data: typeof data === "string" ? Buffer.from(data) : data, mode, tickets: [] }, how);
+    }
+    remove(file) {
+        if (this.idle && this.appendHandle?.file !== file) {
+            try {
+                rmSync(file, { force: true });
+            }
+            catch { }
+            return this.issued;
+        }
+        return this.push({ kind: "remove", file, tickets: [] });
+    }
+    push(op, how = "carry") {
+        const t = ++this.issued;
+        this.open.add(t);
+        op.tickets.push(t);
+        if ("data" in op)
+            this.backlogBytes += op.data.length;
+        for (const r of recorders)
+            r.set(this, t);
+        if (op.kind === "append")
+            this.queue.push(op);
+        else {
+            const next = [];
+            let at = -1;
+            for (const [i, q] of this.queue.entries()) {
+                if (q.file !== op.file || q.kind === "noop") {
+                    next.push(q);
+                    continue;
+                }
+                if (how === "mark" && i === 0) {
+                    next.push(q);
+                    continue;
+                }
+                if ("data" in q)
+                    this.backlogBytes -= q.data.length;
+                if (how === "mark") {
+                    next.push({ kind: "noop", file: q.file, tickets: q.tickets });
+                    continue;
+                }
+                op.tickets.push(...q.tickets);
+                if (how === "first" && at < 0)
+                    at = next.length;
+            }
+            if (at < 0)
+                next.push(op);
+            else
+                next.splice(at, 0, op);
+            this.queue = next;
+        }
+        if (!this.running)
+            void this.pump();
+        return t;
+    }
+    view(file) {
+        const ops = [this.inflight, ...this.queue].filter((o) => !!o && o.file === file && o.kind !== "noop");
+        if (!ops.length)
+            return undefined;
+        let i = ops.length - 1;
+        while (i >= 0 && ops[i].kind === "append")
+            i--;
+        const tail = ops.slice(i + 1).map((o) => o.data);
+        let head;
+        if (i >= 0) {
+            const last = ops[i];
+            if (last.kind === "remove" && !tail.length)
+                return null;
+            head = last.kind === "replace" ? last.data : Buffer.alloc(0);
+        }
+        else {
+            const first = ops[0];
+            let disk = Buffer.alloc(0);
+            try {
+                disk = readFileSync(file);
+            }
+            catch { }
+            head = disk.subarray(0, first.offset);
+        }
+        return Buffer.concat([head, ...tail]);
+    }
+    async pump() {
+        this.running = true;
+        try {
+            while (this.queue.length) {
+                let op = this.queue.shift();
+                if (op.kind === "append") {
+                    const parts = [op.data];
+                    let end = op.offset + op.data.length;
+                    const tickets = [...op.tickets];
+                    for (let q = this.queue[0]; q && (q.kind === "noop" || (q.kind === "append" && q.file === op.file && q.offset === end)); q = this.queue[0]) {
+                        this.queue.shift();
+                        tickets.push(...q.tickets);
+                        if (q.kind === "append") {
+                            parts.push(q.data);
+                            end += q.data.length;
+                        }
+                    }
+                    if (tickets.length > op.tickets.length)
+                        op = { kind: "append", file: op.file, data: Buffer.concat(parts), offset: op.offset, tickets };
+                }
+                this.inflight = op;
+                for (let attempt = 0; op.kind !== "noop"; attempt++) {
+                    try {
+                        const slow = slowDiskMs();
+                        if (slow)
+                            await sleep(slow);
+                        await this.perform(op, attempt);
+                        break;
+                    }
+                    catch (e) {
+                        this.failing = e;
+                        if (attempt < 3 || attempt % 12 === 0)
+                            report(this.dir, this.stem, `writing ${op.file}${attempt ? ` (attempt ${attempt + 1})` : ""}`, e);
+                        await sleep(retryDelayMs(attempt + 1));
+                    }
+                }
+                this.failing = null;
+                if ("data" in op)
+                    this.backlogBytes -= op.data.length;
+                this.inflight = null;
+                for (const t of op.tickets)
+                    this.open.delete(t);
+                this.wake();
+            }
+        }
+        finally {
+            this.running = false;
+            this.forgetIfDone();
+        }
+    }
+    forget() { this.forgetIfDone(); }
+    forgetIfDone() {
+        if (this.idle && !this.running && !this.appendHandle && writers.get(this.key) === this)
+            writers.delete(this.key);
+    }
+    appendHandle = null;
+    async closeAppendHandle() {
+        const h = this.appendHandle;
+        if (!h)
+            return;
+        this.appendHandle = null;
+        clearTimeout(h.timer);
+        await h.fh.close().catch(() => { });
+    }
+    async perform(op, attempt) {
+        if (this.appendHandle && (op.kind !== "append" || op.file !== this.appendHandle.file || attempt > 0))
+            await this.closeAppendHandle();
+        if (op.kind === "remove") {
+            await fsp.rm(op.file, { force: true });
+            await fsp.rm(`${op.file}.tmp`, { force: true });
+            return;
+        }
+        if (op.kind === "replace")
+            return replaceAtomic(op.file, op.data, op.mode);
+        if (op.kind === "noop")
+            return;
+        if (attempt > 0) {
+            try {
+                const st = await fsp.stat(op.file);
+                if (st.size > op.offset)
+                    await fsp.truncate(op.file, op.offset);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+            }
+        }
+        if (!this.appendHandle)
+            this.appendHandle = { file: op.file, fh: await fsp.open(op.file, "a", 0o600) };
+        const h = this.appendHandle;
+        clearTimeout(h.timer);
+        try {
+            await writeAll(h.fh, op.data);
+            await syncHandle(h.fh);
+        }
+        catch (e) {
+            await this.closeAppendHandle();
+            throw e;
+        }
+        if (process.platform === "win32")
+            return this.closeAppendHandle();
+        h.timer = setTimeout(() => {
+            if (this.appendHandle !== h || this.inflight)
+                return;
+            void this.closeAppendHandle().then(() => this.forgetIfDone());
+        }, APPEND_HOLD_MS);
+        h.timer.unref?.();
+    }
+    wake() {
+        const through = this.doneThrough;
+        const ready = this.waiters.filter((w) => w.ticket <= through);
+        if (!ready.length)
+            return;
+        this.waiters = this.waiters.filter((w) => w.ticket > through);
+        for (const w of ready)
+            w.done();
+    }
+}
+function report(dir, stem, where, e) {
+    let heard = false;
+    for (const r of reporters) {
+        if (r.dir !== dir)
+            continue;
+        heard = true;
+        try {
+            r.fn(where, e, stem);
+        }
+        catch { }
+    }
+    if (!heard)
+        console.error(`! storage: ${where} failed: ${e.message}`);
+}
+async function writeAll(fh, data) {
+    for (let off = 0; off < data.length;) {
+        const { bytesWritten } = await fh.write(data, off, data.length - off);
+        off += bytesWritten;
+    }
+}
+async function syncHandle(fh) {
+    if (!waitsForDisk())
+        return;
+    const t = Date.now();
+    await fh.sync();
+    noteDiskWait(Date.now() - t);
+}
+async function replaceAtomic(file, data, mode) {
+    const tmp = `${file}.tmp`;
+    let fh;
+    try {
+        fh = await fsp.open(tmp, "w", mode);
+    }
+    catch (e) {
+        if (e.code !== "ENOENT")
+            throw e;
+        await fsp.mkdir(dirname(file), { recursive: true, mode: 0o700 });
+        fh = await fsp.open(tmp, "w", mode);
+    }
+    try {
+        await writeAll(fh, data);
+        await syncHandle(fh);
+    }
+    finally {
+        await fh.close();
+    }
+    await renameRetrying(tmp, file);
+    if (waitsForDisk()) {
+        let dh = null;
+        try {
+            dh = await fsp.open(dirname(file), "r");
+            await syncHandle(dh);
+        }
+        catch { }
+        finally {
+            await dh?.close().catch(() => { });
+        }
+    }
+}
+async function renameRetrying(from, to) {
+    for (let i = 0;; i++) {
+        try {
+            await fsp.rename(from, to);
+            return;
+        }
+        catch (e) {
+            if (process.platform !== "win32" || i >= 20 || !["EPERM", "EACCES", "EBUSY"].includes(e.code ?? ""))
+                throw e;
+            await sleep(10);
+        }
+    }
+}
+const writers = new Map();
+const keyOf = (dir, stem) => join(resolve(dir), stem);
+export function writerFor(dir, stem) {
+    const key = keyOf(dir, stem);
+    let w = writers.get(key);
+    if (!w) {
+        w = new SpaceWriter(resolve(dir), stem, key);
+        writers.set(key, w);
+    }
+    return w;
+}
+export function busyWriter(dir, stem) {
+    const w = writers.get(keyOf(dir, stem));
+    return w && !w.idle ? w : null;
+}
+export function pendingView(dir, stem, file) {
+    return busyWriter(dir, stem)?.view(file);
+}
+export function readLatest(dir, stem, file) {
+    const v = pendingView(dir, stem, file);
+    if (v === undefined)
+        return readFileSync(file, "utf8");
+    if (v === null)
+        throw Object.assign(new Error(`ENOENT: no such file, open '${file}'`), { code: "ENOENT" });
+    return v.toString("utf8");
+}
+export async function flushWrites(dir, timeoutMs = 30_000) {
+    const root = dir ? resolve(dir) : null;
+    const end = Date.now() + timeoutMs;
+    for (;;) {
+        const busy = [...writers.values()].filter((w) => !w.idle && (!root || w.dir === root));
+        if (!busy.length) {
+            await Promise.all([...writers.values()].filter((w) => !root || w.dir === root).map((w) => w.closeAppendHandle()));
+            for (const w of [...writers.values()])
+                if (w.idle && (!root || w.dir === root))
+                    w.forget();
+            return true;
+        }
+        const left = end - Date.now();
+        if (left <= 0)
+            return false;
+        let timer;
+        await Promise.race([Promise.all(busy.map((w) => w.whenWritten())), new Promise((r) => { timer = setTimeout(r, left); })]);
+        clearTimeout(timer);
+    }
+}
+const recorders = new Set();
+export function recordWrites() {
+    const got = new Map();
+    recorders.add(got);
+    const t = setImmediate(() => recorders.delete(got));
+    return () => { clearImmediate(t); recorders.delete(got); return got; };
+}
+export async function whenLanded(writes, timeoutMs = 10_000) {
+    const waits = [...writes].map(([w, t]) => ({ w, t }));
+    const end = Date.now() + timeoutMs;
+    for (;;) {
+        if (waits.every(({ w, t }) => w.doneThrough >= t))
+            return true;
+        if (waits.some(({ w, t }) => w.failing && w.doneThrough < t) || Date.now() >= end)
+            return false;
+        let timer;
+        await Promise.race([Promise.all(waits.map(({ w, t }) => w.whenWritten(t))), new Promise((r) => { timer = setTimeout(r, 100); })]);
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=disk-writer.js.map

package/dist/doctor.js

@@ -15,7 +15,7 @@ import { expectedLauncher, managedLayout, runtimeNodeFit, runtimeVerdict } from
 import { compareVersions } from "./installer.js";
 import { PKG_NAME } from "./upgrade.js";
 import { PantheonClient } from "./client.js";
-import { load, resolveFor, loadAll, CONFIG_PATH } from "./config.js";
+import { load, resolveFor, loadAll, configFor, CONFIG_PATH } from "./config.js";
 import { fingerprint, signChallenge, verifyChallenge } from "./identity.js";
 import { approvalSummary, chosenApproval, copilotMcpConfigFile, kiroMcpConfigFile, onPath } from "./install.js";
 import { hookState, readIntent, agentHookStates, repairNote } from "./notify.js";
@@ -204,7 +204,7 @@ export async function doctor(projectDir) {
     }
     let cfg = null;
     try {
-        cfg = load();
+        cfg = load() ?? (() => { const f = loadAll(); const m = Object.values(f?.spaces ?? {})[0]; return f && m ? configFor(f, m, null) : null; })();
     }
     catch (e) {
         add("fail", "config", `unreadable: ${e.message}`, undefined, "unreadable");
@@ -215,7 +215,10 @@ export async function doctor(projectDir) {
         }
         return out;
     }
-    add("pass", "config", `${cfg.member} in "${cfg.space}" via ${cfg.relay}  (${CONFIG_PATH})`, undefined, "present");
+    const teamNames = Object.values(loadAll()?.spaces ?? {}).map((m) => m.name);
+    add("pass", "config", resolveFor(projectDir).cfg || teamNames.length < 2
+        ? `${cfg.member} in "${cfg.space}" via ${cfg.relay}  (${CONFIG_PATH})`
+        : `${cfg.member} in ${teamNames.length} teams (${teamNames.join(", ")}), none picked for this folder  (${CONFIG_PATH})`, undefined, "present");
     const here = resolveFor(projectDir, { strict: true });
     const nTeams = Object.keys(loadAll()?.spaces ?? {}).length;
     const folderHere = here.reason === "binding" && !here.repo;

package/dist/ledger.js

@@ -1,7 +1,8 @@
-import { mkdirSync, existsSync, openSync, readSync, writeSync, fsyncSync, closeSync, fstatSync, copyFileSync, truncateSync, chmodSync } from "node:fs";
+import { mkdirSync, existsSync, openSync, readSync, fsyncSync, closeSync, fstatSync, copyFileSync, truncateSync, chmodSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { load } from "./config.js";
-import { fsyncDir, renameRetrying, syncFd, writeFileAtomic } from "./store.js";
+import { fsyncDir, renameRetrying } from "./store.js";
+import { backlogCap, busyWriter, DiskBusy, pendingView, writerFor } from "./disk-writer.js";
 export class SpaceFull extends Error {
     bytes;
     cap;
@@ -14,6 +15,8 @@ export class SpaceFull extends Error {
 }
 import { signedRead } from "./reads.js";
 export class Ledger {
+    dir;
+    stem;
     records = [];
     byId = new Map();
     seq = 0;
@@ -21,12 +24,25 @@ export class Ledger {
     outOfOrder = 0;
     firstOutOfOrder = null;
     file;
-    constructor(dir, space) {
-        this.file = join(dir, `${space}.jsonl`);
+    constructor(dir, stem) {
+        this.dir = dir;
+        this.stem = stem;
+        this.file = join(dir, `${stem}.jsonl`);
         mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 });
-        if (existsSync(this.file))
+        const pending = pendingView(dir, stem, this.file);
+        if (pending !== undefined)
+            this.readPending(pending ?? Buffer.alloc(0));
+        else if (existsSync(this.file))
             this.read();
     }
+    readPending(buf) {
+        let start = 0;
+        for (let i = buf.indexOf(10); i !== -1; i = buf.indexOf(10, start)) {
+            this.take(buf.subarray(start, i).toString("utf8"));
+            start = i + 1;
+        }
+        this.fileBytes = buf.length;
+    }
     read() {
         const fd = openSync(this.file, "r");
         let size = 0, lastNl = -1;
@@ -100,24 +116,25 @@ export class Ledger {
         return this.fileBytes;
     }
     append(rec, cap = 0) {
+        const w = writerFor(this.dir, this.stem);
+        if (w.failing)
+            throw w.failing;
         const full = { ...rec, seq: this.seq + 1 };
         const line = Buffer.from(JSON.stringify(full) + "\n");
         if (cap > 0 && this.fileBytes + line.length > cap)
             throw new SpaceFull(this.fileBytes, cap);
-        const fd = openSync(this.file, "a", 0o600);
-        try {
-            writeSync(fd, line);
-            syncFd(fd);
-        }
-        finally {
-            closeSync(fd);
-        }
+        w.append(this.file, line, this.fileBytes);
         this.seq = full.seq;
         this.fileBytes += line.length;
         this.records.push(full);
         this.byId.set(full.id, full);
         return full;
     }
+    checkBacklog() {
+        const w = busyWriter(this.dir, this.stem);
+        if (w && w.backlogBytes > backlogCap())
+            throw new DiskBusy(w.backlogBytes, backlogCap());
+    }
     since(seq, limit = 500) {
         return this.records.filter((r) => r.seq > seq).slice(0, limit);
     }
@@ -146,7 +163,7 @@ export class Ledger {
         if (dropped === 0)
             return { dropped: 0, kept: kept.length };
         const text = kept.map((r) => JSON.stringify(r)).join("\n") + "\n";
-        writeFileAtomic(this.file, text);
+        writerFor(this.dir, this.stem).replace(this.file, text);
         this.records = kept;
         this.byId = new Map();
         for (const r of kept)

package/dist/notifier.js

@@ -167,7 +167,7 @@ export class HumanNotifier {
             const peerOf = (from) => from ? { member: from, agent: client.roster.find((m) => m.id === from)?.agent } : undefined;
             const withLabel = (n) => {
                 const labelled = this.opts.label ? { ...n, context: n.context ? `${this.opts.label} · ${n.context}` : this.opts.label } : n;
-                return platform() === "darwin" ? labelled : { ...labelled, space: this.cfg.space };
+                return { ...labelled, space: this.cfg.space };
             };
             let asks = {};
             try {

package/dist/quickstart.js

@@ -9,6 +9,7 @@ import { PantheonClient } from "./client.js";
 import { holdsRepo } from "./repo-find.js";
 import { folderFacts, folderRefusal, folderRefusalHere, isInside, isTemporaryRefusal } from "./folder-guard.js";
 import { load, loadAll, identity, save, toInvite, resolveFor, repoInfo, bindRepo, bindFolder, folderBinding, DEFAULT_RELAY } from "./config.js";
+import { looksLikePlaceholder, teamSlug } from "./team-name.js";
 import { commandsChosen, loadProfile, wakeChosen, wakeDefault } from "./profile.js";
 import { newKeypair } from "./identity.js";
 import { installForUser } from "./install.js";
@@ -268,7 +269,16 @@ export function deviceLabel(plat = platform(), env = process.env, info, host = h
 }
 export function teamNameFor(dir, repo = repoInfo(dir)) {
     const fromOrigin = repo?.origin ? (repo.origin.replace(/\.git$/i, "").split(/[/:]/).filter(Boolean).pop() ?? "") : "";
-    return slugName(fromOrigin || basename(repo?.root ?? dir), "team");
+    const slug = teamSlug(slugName(fromOrigin || basename(repo?.root ?? dir), "team")) || "team";
+    if (!looksLikePlaceholder(slug))
+        return slug;
+    return ["team", "project", "folder"].map((w) => teamSlug(`${slug}-${w}`)).find((n) => n && !looksLikePlaceholder(n)) ?? "team";
+}
+export function startReconnects(opts, here = resolveFor(process.cwd())) {
+    const existing = here.cfg;
+    return !!existing && !opts.reset && !!existing.space && !!existing.token
+        && (here.reason === "binding" || here.reason === "single" || here.reason === "env")
+        && (!opts.space || opts.space === existing.space);
 }
 export function isLocalRelay(url) {
     let host = "";
@@ -421,6 +431,7 @@ export async function start(opts) {
             : { 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] });
+    const reuse = startReconnects(opts, here);
     let relay = null;
     if (chosen && !hostHere) {
         const probe = await probeRelay(reach.url, opts.remoteTimeoutMs ?? 10_000, opts.fetchImpl);
@@ -453,9 +464,6 @@ export async function start(opts) {
             rememberHosted(opts.dataDir, chosen);
     }
     const existing = priorCfg;
-    const hasOwnSpace = !!existing?.space && !!existing?.token;
-    const reuse = !!existing && !opts.reset && hasOwnSpace && (here.reason === "binding" || here.reason === "single" || here.reason === "env")
-        && (!opts.space || opts.space === existing.space);
     const keepIdentity = !!existing && !opts.reset && !!existing.publicKey && !!existing.privateKey;
     let cfg = reuse
         ? { ...existing, relay: reach.url, agent: detectAgent() }
@@ -534,8 +542,12 @@ export async function start(opts) {
     catch (e) {
         const msg = (await interceptedText(e, cfg.relay)) ?? e.message;
         const nameTaken = !reuse && /BAD_TOKEN/.test(msg);
-        if (nameTaken && !opts.space) {
-            const alt = `${cfg.space}-${cfg.member}`;
+        const ownSeat = nameTaken && /already a member of/i.test(msg);
+        if (ownSeat) {
+            warnings.push(msg.replace(/^BAD_TOKEN:\s*/, ""));
+        }
+        else if (nameTaken && !opts.space) {
+            const alt = teamSlug(`${cfg.space}-${cfg.member}`) || cfg.space;
             opts.log(`  space      "${cfg.space}" is already another team's space on this relay — using "${alt}"`);
             cfg = { ...cfg, space: alt };
             try {