brane 0.1.1 → 0.3.1

package/dist/test/spawn-toml.test.js

@@ -0,0 +1,72 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { replaceTomlTable } from "../commands/spawn.js";
+const HEADER = "[mcp_servers.brane]";
+const NEW_SECTION = `[mcp_servers.brane]
+command = "/usr/local/bin/brane"
+args = ["mcp"]
+env_vars = ["BRANE_NARRATIVE_ID"]
+tool_timeout_sec = 3600
+`;
+describe("replaceTomlTable", () => {
+    // Regression: the original implementation used
+    //   existing.replace(/\[mcp_servers\.brane\][^\[]*(?=\[|$)/s, braneSection)
+    // The [^\[]* halts at the first '[' *anywhere* — including the one inside
+    // `args = ["mcp"]`. That truncated the match mid-table and left the tail
+    // (`["mcp"]\nenv_vars = [...]`) orphaned in ~/.codex/config.toml as a bogus
+    // table header, corrupting the operator's global codex config.
+    it("does not orphan the tail when a value contains '['", () => {
+        const source = `[model]
+name = "gpt-5"
+
+${HEADER}
+command = "/old/brane"
+args = ["mcp"]
+env_vars = ["BRANE_NARRATIVE_ID"]
+
+[other]
+x = 1
+`;
+        const out = replaceTomlTable(source, HEADER, NEW_SECTION);
+        assert.ok(!/^\["mcp"\]/m.test(out), "orphaned array literal became a table header");
+        assert.equal((out.match(/env_vars/g) ?? []).length, 1, "env_vars duplicated");
+        assert.equal((out.match(/\[mcp_servers\.brane\]/g) ?? []).length, 1);
+    });
+    it("preserves sibling tables on both sides", () => {
+        const source = `[model]
+name = "gpt-5"
+
+${HEADER}
+command = "/old/brane"
+args = ["mcp"]
+
+[other]
+x = 1
+`;
+        const out = replaceTomlTable(source, HEADER, NEW_SECTION);
+        assert.match(out, /\[model\]\nname = "gpt-5"/);
+        assert.match(out, /\[other\]\nx = 1/);
+        assert.match(out, /tool_timeout_sec = 3600/);
+        assert.ok(!out.includes("/old/brane"), "stale command survived the replace");
+    });
+    it("replaces a trailing table with no following header", () => {
+        const source = `[model]\nname = "gpt-5"\n\n${HEADER}\ncommand = "/old/brane"\nargs = ["mcp"]\n`;
+        const out = replaceTomlTable(source, HEADER, NEW_SECTION);
+        assert.match(out, /\[model\]/);
+        assert.match(out, /tool_timeout_sec = 3600/);
+        assert.ok(!out.includes("/old/brane"));
+    });
+    it("appends when the table is absent", () => {
+        const source = `[model]\nname = "gpt-5"\n`;
+        const out = replaceTomlTable(source, HEADER, NEW_SECTION);
+        assert.match(out, /\[model\]\nname = "gpt-5"/);
+        assert.equal((out.match(/\[mcp_servers\.brane\]/g) ?? []).length, 1);
+    });
+    it("is idempotent across repeated spawns", () => {
+        const source = `[model]\nname = "gpt-5"\n\n${HEADER}\ncommand = "/old"\nargs = ["mcp"]\n\n[other]\nx = 1\n`;
+        const once = replaceTomlTable(source, HEADER, NEW_SECTION);
+        const twice = replaceTomlTable(once, HEADER, NEW_SECTION);
+        assert.equal(once, twice, "second application changed the file");
+    });
+});
+//# sourceMappingURL=spawn-toml.test.js.map

package/dist/test/speaker-color.test.js

@@ -0,0 +1,90 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { speakerHue, speakerColor, speakerBgColor, parseRecolorSalt, } from "../shared/speaker-color.js";
+// The function the app shipped with, verbatim — salt 0 must reproduce it so a
+// narrative nobody has recolored keeps the colors it has always had.
+function shippedHue(speaker) {
+    let hash = 0;
+    for (let i = 0; i < speaker.length; i++) {
+        hash = speaker.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    return Math.abs(hash) % 360;
+}
+// Same shape as real nids: `{type}-{8hex}`, so every one is the same length,
+// which is the case a linear reshuffle gets wrong.
+const SPEAKERS = Array.from({ length: 40 }, (_, i) => {
+    const hex = ((i + 1) * 0x9e3779b1 >>> 0).toString(16).padStart(8, "0");
+    return `claude-${hex}`;
+});
+const gap = (a, b) => Math.min(Math.abs(a - b), 360 - Math.abs(a - b));
+describe("speakerHue", () => {
+    it("is the shipped hash at salt 0", () => {
+        for (const s of [...SPEAKERS, "goose-aa11bb22", "web", "x", "brane"]) {
+            assert.equal(speakerHue(s), shippedHue(s), s);
+            assert.equal(speakerHue(s, 0), shippedHue(s), s);
+        }
+    });
+    it("stays in [0, 360) for every salt", () => {
+        for (let salt = 0; salt < 32; salt++) {
+            for (const s of SPEAKERS) {
+                const h = speakerHue(s, salt);
+                assert.ok(Number.isInteger(h) && h >= 0 && h < 360, `${s} @${salt} → ${h}`);
+            }
+        }
+    });
+    it("reshuffles per speaker, not by rotating the whole palette", () => {
+        // Under a uniform rotation every pairwise gap survives. Under a real
+        // reshuffle most of them change — that is what lets two close hues part.
+        const before = SPEAKERS.map((s) => speakerHue(s, 0));
+        const after = SPEAKERS.map((s) => speakerHue(s, 1));
+        let moved = 0, pairs = 0;
+        for (let i = 0; i < SPEAKERS.length; i++) {
+            for (let j = i + 1; j < SPEAKERS.length; j++) {
+                pairs++;
+                if (gap(before[i], before[j]) !== gap(after[i], after[j]))
+                    moved++;
+            }
+        }
+        assert.ok(moved > pairs * 0.9, `${moved}/${pairs} pairwise gaps changed`);
+    });
+    it("separates a colliding pair within a few recolors", () => {
+        // The operator's case: two speakers that hash within 15° of each other.
+        // Find such a pair in the fixture, then show that some salt in the first
+        // handful puts them at least 60° apart — a tap or two, not a lottery.
+        let pair = null;
+        outer: for (let i = 0; i < SPEAKERS.length; i++) {
+            for (let j = i + 1; j < SPEAKERS.length; j++) {
+                if (gap(speakerHue(SPEAKERS[i]), speakerHue(SPEAKERS[j])) <= 15) {
+                    pair = [SPEAKERS[i], SPEAKERS[j]];
+                    break outer;
+                }
+            }
+        }
+        assert.ok(pair, "fixture should contain a colliding pair");
+        const [a, b] = pair;
+        const salts = [1, 2, 3, 4, 5].filter((salt) => gap(speakerHue(a, salt), speakerHue(b, salt)) >= 60);
+        assert.ok(salts.length > 0, `no salt in 1..5 separates ${a} and ${b}`);
+    });
+});
+describe("speakerColor / speakerBgColor", () => {
+    it("share one hue and differ only in lightness", () => {
+        for (const salt of [0, 3]) {
+            const h = speakerHue("goose-aa11bb22", salt);
+            assert.equal(speakerColor("goose-aa11bb22", salt), `hsl(${h}, 60%, 80%)`);
+            assert.equal(speakerBgColor("goose-aa11bb22", salt), `hsl(${h}, 30%, 20%)`);
+        }
+    });
+});
+describe("parseRecolorSalt", () => {
+    it("reads a stored count and treats anything else as the default palette", () => {
+        assert.equal(parseRecolorSalt("3"), 3);
+        assert.equal(parseRecolorSalt("0"), 0);
+        assert.equal(parseRecolorSalt(null), 0);
+        assert.equal(parseRecolorSalt(undefined), 0);
+        assert.equal(parseRecolorSalt(""), 0);
+        assert.equal(parseRecolorSalt("-2"), 0);
+        assert.equal(parseRecolorSalt("1.5"), 0);
+        assert.equal(parseRecolorSalt("purple"), 0);
+    });
+});
+//# sourceMappingURL=speaker-color.test.js.map

package/dist/test/tailscale-rebind.test.js

@@ -0,0 +1,79 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { addressesToBind, nextProbeDelay, TAILSCALE_PROBE_INITIAL_MS, TAILSCALE_PROBE_MAX_MS, TAILSCALE_PROBE_STEADY_MS, } from "../daemon/tailscale-rebind.js";
+import { parseTailscaleIps } from "../tailscale.js";
+describe("nextProbeDelay", () => {
+    it("starts the not-found backoff at the initial delay", () => {
+        assert.equal(nextProbeDelay(null, false), TAILSCALE_PROBE_INITIAL_MS);
+        assert.equal(nextProbeDelay(0, false), TAILSCALE_PROBE_INITIAL_MS);
+    });
+    // The daemon seeds its first timer with nextProbeDelay(null, …) and keeps
+    // `probeDelay` at null until the first probe runs, so the first *computed*
+    // step is the initial delay again. That extra 5 s tick is deliberate — one
+    // quick retry for a Tailscale that is merely still launching — and this
+    // pins the sequence the daemon actually runs, not an idealized one.
+    it("runs 5, 5, 10, 20, 40, 60 while nothing is found, then holds the cap", () => {
+        const seen = [nextProbeDelay(null, false)];
+        let d = null;
+        for (let i = 0; i < 7; i++) {
+            d = nextProbeDelay(d, false);
+            seen.push(d);
+        }
+        assert.deepEqual(seen, [5_000, 5_000, 10_000, 20_000, 40_000, 60_000, 60_000, 60_000]);
+        assert.equal(Math.max(...seen), TAILSCALE_PROBE_MAX_MS);
+    });
+    // A found probe resets to the steady cadence no matter how deep the
+    // backoff had gone — the daemon should notice a later address change in
+    // a minute, not in whatever the backoff had climbed to.
+    it("returns to the steady cadence once Tailscale is seen", () => {
+        assert.equal(nextProbeDelay(60_000, true), TAILSCALE_PROBE_STEADY_MS);
+        assert.equal(nextProbeDelay(null, true), TAILSCALE_PROBE_STEADY_MS);
+    });
+});
+describe("addressesToBind", () => {
+    it("returns only addresses not already bound, in probe order", () => {
+        const bound = ["127.0.0.1", "::1"];
+        assert.deepEqual(addressesToBind(bound, ["100.64.167.92", "fd7a:115c:a1e0::4401:a76f"]), ["100.64.167.92", "fd7a:115c:a1e0::4401:a76f"]);
+    });
+    // The scenario this module exists for: the daemon came up blind, Tailscale
+    // recovered, and a later probe reports the same two addresses every
+    // minute. The first such probe binds them; every later one must be a no-op.
+    it("is a no-op once the probed addresses are bound", () => {
+        const ips = ["100.64.167.92", "fd7a:115c:a1e0::4401:a76f"];
+        const bound = new Set(["127.0.0.1", "::1"]);
+        for (const a of addressesToBind(bound, ips))
+            bound.add(a);
+        assert.deepEqual(addressesToBind(bound, ips), []);
+    });
+    it("drops blanks and duplicates within one probe", () => {
+        assert.deepEqual(addressesToBind([], ["", " 100.64.1.1 ", "100.64.1.1"]), ["100.64.1.1"]);
+    });
+    it("picks up an address that changed since the last probe", () => {
+        const bound = ["127.0.0.1", "::1", "100.64.167.92"];
+        assert.deepEqual(addressesToBind(bound, ["100.64.200.7"]), ["100.64.200.7"]);
+    });
+});
+describe("parseTailscaleIps", () => {
+    it("reads Self.TailscaleIPs", () => {
+        const out = JSON.stringify({ Self: { TailscaleIPs: ["100.64.167.92", "fd7a:115c:a1e0::4401:a76f"] } });
+        assert.deepEqual(parseTailscaleIps(out), ["100.64.167.92", "fd7a:115c:a1e0::4401:a76f"]);
+    });
+    // The three ways the CLI's answer can be wrong, each of which must read
+    // as "no Tailscale" rather than throw: a hung/killed CLI leaves partial or
+    // empty output; a version skew can drop the field; a corrupt value must
+    // not smuggle a non-string into a bind address.
+    it("is empty on non-JSON (timeout, partial output)", () => {
+        assert.deepEqual(parseTailscaleIps(""), []);
+        assert.deepEqual(parseTailscaleIps('{"Self":{"TailscaleIPs":["100.64.'), []);
+    });
+    it("is empty when Self or TailscaleIPs is absent", () => {
+        assert.deepEqual(parseTailscaleIps("{}"), []);
+        assert.deepEqual(parseTailscaleIps(JSON.stringify({ Self: {} })), []);
+        assert.deepEqual(parseTailscaleIps(JSON.stringify({ Self: { TailscaleIPs: null } })), []);
+    });
+    it("keeps only string entries", () => {
+        const out = JSON.stringify({ Self: { TailscaleIPs: ["100.64.1.1", 7, null, "fd7a::1"] } });
+        assert.deepEqual(parseTailscaleIps(out), ["100.64.1.1", "fd7a::1"]);
+    });
+});
+//# sourceMappingURL=tailscale-rebind.test.js.map

package/dist/test/terminal-cursor.test.js

@@ -0,0 +1,61 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseTerminalStatus, terminalCursorFrom } from "../daemon/server.js";
+// The mirror sends a pane's text; the cursor is the one thing about a pane
+// that isn't in its text. These two functions are the whole translation from
+// what tmux reports to what a client can draw, and both halves are pure — the
+// arithmetic is the part that can be wrong without anyone noticing, since a
+// cursor one row off still looks like a cursor.
+describe("parseTerminalStatus", () => {
+    it("reads the five fields display-message emits", () => {
+        assert.deepEqual(parseTerminalStatus("39 23 1 0 24"), {
+            cursorX: 39,
+            cursorY: 23,
+            cursorVisible: true,
+            alternateOn: false,
+            paneHeight: 24,
+        });
+    });
+    it("treats flags as flags — only 1 is on", () => {
+        const status = parseTerminalStatus("0 0 0 1 24");
+        assert.equal(status?.cursorVisible, false);
+        assert.equal(status?.alternateOn, true);
+    });
+    it("returns null rather than NaN for a line it can't read", () => {
+        // A tmux that fails, a truncated read, an error string where a status
+        // line was expected: better no cursor than one at NaN.
+        assert.equal(parseTerminalStatus(""), null);
+        assert.equal(parseTerminalStatus("no server running"), null);
+        assert.equal(parseTerminalStatus("39 23 1 0"), null);
+        assert.equal(parseTerminalStatus("39 x 1 0 24"), null);
+    });
+});
+describe("terminalCursorFrom", () => {
+    // Measured against a real session: 798 rows of history under a 24-row pane
+    // captures 822 lines, and the shell prompt sits on the last of them.
+    it("places the cursor below the scrollback a frame carries", () => {
+        const status = parseTerminalStatus("39 23 1 0 24");
+        assert.deepEqual(terminalCursorFrom(status, 822), { line: 821, col: 39 });
+    });
+    it("is the row itself when there is no history (alternate screen)", () => {
+        const status = parseTerminalStatus("2 31 1 1 34");
+        assert.deepEqual(terminalCursorFrom(status, 34), { line: 31, col: 2 });
+    });
+    // cursor_flag is the pane's own DECTCEM state. An application that hides the
+    // cursor — Claude Code with a dialog up, lazygit throughout — means it, and a
+    // block drawn anyway would be a cursor the operator's real terminal doesn't
+    // show. Nothing is more misleading than a caret in the wrong place.
+    it("draws nothing when the pane has hidden its cursor", () => {
+        assert.equal(terminalCursorFrom(parseTerminalStatus("1 81 0 1 85"), 85), null);
+    });
+    it("draws nothing when the status line was unreadable", () => {
+        assert.equal(terminalCursorFrom(null, 822), null);
+    });
+    // Defensive: a capture that raced a resize can report fewer rows than the
+    // pane height, which would put the cursor above the frame's first line.
+    it("declines a line that would fall off the top of the frame", () => {
+        assert.equal(terminalCursorFrom(parseTerminalStatus("0 0 1 1 40"), 10), null);
+        assert.equal(terminalCursorFrom(parseTerminalStatus("0 0 1 1 0"), 10), null);
+    });
+});
+//# sourceMappingURL=terminal-cursor.test.js.map

package/dist/test/terminal-resync.test.js

@@ -0,0 +1,23 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import { isResyncDue } from "../daemon/server.js";
+// The mirror records what it *sent*, not what the browser *rendered*, and a
+// quiet pane never speaks again — so a dropped frame used to persist until the
+// operator reloaded the page. The heartbeat is what bounds that to one
+// interval; these pin the boundary it turns on.
+test("a viewer just sent a frame is not due", () => {
+    assert.equal(isResyncDue(1_000, 1_000, 2_000), false);
+    assert.equal(isResyncDue(1_000, 2_999, 2_000), false);
+});
+test("a viewer that has gone an interval without content is due", () => {
+    assert.equal(isResyncDue(1_000, 3_000, 2_000), true);
+    assert.equal(isResyncDue(1_000, 9_999, 2_000), true);
+});
+test("a viewer that has never been sent anything is due immediately", () => {
+    // `lastSentAt: 0` is the state of a fresh socket and of one whose DOM was
+    // just wiped by `refresh`. Both want content on the very next tick, and the
+    // sentinel gets that for free against a real epoch clock — which is the only
+    // clock the capture loop ever passes.
+    assert.equal(isResyncDue(0, 1_787_598_000_000, 2_000), true);
+});
+//# sourceMappingURL=terminal-resync.test.js.map

package/dist/test/terminal-size.test.js

@@ -0,0 +1,36 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseTerminalSize, newSessionLine } from "../tmux.js";
+// The grid a spawn or run request carries: the size the requesting viewer's
+// pane last measured, so the session starts at the width it will be watched at
+// and a TUI's launch screen isn't redrawn — and left in scrollback — at each
+// width it is resized through.
+test("parseTerminalSize accepts a positive integer grid", () => {
+    assert.deepEqual(parseTerminalSize({ cols: 80, rows: 24 }), { cols: 80, rows: 24 });
+});
+test("parseTerminalSize drops extra fields", () => {
+    assert.deepEqual(parseTerminalSize({ cols: 120, rows: 40, dpr: 2 }), { cols: 120, rows: 40 });
+});
+test("parseTerminalSize rejects anything that isn't a usable grid", () => {
+    for (const bad of [
+        undefined,
+        null,
+        "80x24",
+        [80, 24],
+        {},
+        { cols: 80 },
+        { cols: 0, rows: 24 },
+        { cols: 80, rows: -1 },
+        { cols: 80.5, rows: 24 },
+        { cols: "80", rows: "24" },
+        { cols: 80, rows: 100000 },
+    ]) {
+        assert.equal(parseTerminalSize(bad), null, JSON.stringify(bad));
+    }
+});
+test("a parsed size reaches new-session as -x/-y", () => {
+    const size = parseTerminalSize({ cols: 93, rows: 41 });
+    const line = newSessionLine({ name: "claude-abc", cwd: "/tmp", size, command: "claude" });
+    assert.match(line, / -x 93 -y 41 /);
+});
+//# sourceMappingURL=terminal-size.test.js.map