brane 0.0.2 → 0.3.0

package/dist/test/agent-scope.test.js

@@ -0,0 +1,193 @@
+/**
+ * What an agent's token may reach (src/daemon/agent-scope.ts): a
+ * default-deny list of routes, and only from this machine.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { AGENT_LOOPBACK_REFUSAL, AGENT_REVIVE_REFUSAL, AGENT_ROUTES, AGENT_SCOPE_REFUSAL, agentMayUse, agentRefusal, agentReviveRefusal, } from "../daemon/agent-scope.js";
+import { markUnixConnection } from "../daemon/local-socket.js";
+import { agentRequestRefusal, reviveNarrative } from "../daemon/server.js";
+import { createTestDb } from "./helpers.js";
+describe("agentMayUse", () => {
+    it("opens reading brane and the session lifecycle agents drive", () => {
+        for (const [method, path] of [
+            ["GET", "/api/status"],
+            ["GET", "/api/narratives"],
+            ["GET", "/api/narratives/recent"],
+            ["GET", "/api/narratives/claude-abcd1234"],
+            ["GET", "/api/narratives/claude-abcd1234/events"],
+            ["GET", "/api/narratives/claude-abcd1234/tool_uses/k1"],
+            ["GET", "/api/payloads/claude-abcd1234/42_0.png"],
+            ["GET", "/api/payloads/claude-abcd1234/nested/file.txt"],
+            ["GET", "/api/files/find"],
+            ["POST", "/api/search"],
+            ["POST", "/api/spawn"],
+            ["POST", "/api/revive/claude-abcd1234"],
+            ["GET", "/ws/mcp"],
+        ]) {
+            assert.equal(agentMayUse(method, path), true, `${method} ${path}`);
+        }
+    });
+    it("closes the app's channels, signals, the operator's housekeeping and gated acts", () => {
+        for (const [method, path] of [
+            ["GET", "/ws/terminal/claude-abcd1234"],
+            ["GET", "/ws/control"],
+            ["POST", "/api/narratives/claude-abcd1234/signal"],
+            ["GET", "/api/tokens"],
+            ["POST", "/api/tokens"],
+            ["POST", "/api/tokens/t1/revoke"],
+            ["POST", "/api/token/rotate"],
+            ["POST", "/api/presence/cancel"],
+            ["POST", "/api/folds"],
+            ["PATCH", "/api/folds/archive"],
+            ["PATCH", "/api/narratives/claude-abcd1234/archive"],
+            ["POST", "/api/absorb"],
+            ["GET", "/api/absorb/survey"],
+            ["POST", "/api/cost/backfill"],
+            ["POST", "/api/cost/reprice"],
+            ["POST", "/api/run"],
+        ]) {
+            assert.equal(agentMayUse(method, path), false, `${method} ${path}`);
+        }
+    });
+    it("denies a route it does not know: default-deny", () => {
+        assert.equal(agentMayUse("GET", "/api/something-new"), false);
+        assert.equal(agentMayUse("POST", "/api/narratives"), false, "the method is part of the route");
+    });
+    it("does not let a parameter match an empty or extra segment", () => {
+        assert.equal(agentMayUse("GET", "/api/narratives/"), false);
+        assert.equal(agentMayUse("POST", "/api/revive/"), false);
+        assert.equal(agentMayUse("GET", "/api/narratives/x/events/extra"), false);
+        assert.equal(agentMayUse("GET", "/api/payloads/x/"), false);
+        assert.equal(agentMayUse("GET", "/api/status/"), false);
+    });
+    it("matches the method case-insensitively", () => {
+        assert.equal(agentMayUse("get", "/api/status"), true);
+    });
+});
+describe("agentRefusal", () => {
+    const listed = { method: "GET", path: "/api/narratives" };
+    it("lets an agent's token in from this machine only", () => {
+        assert.equal(agentRefusal({ ...listed, loopback: true }), null);
+        assert.equal(agentRefusal({ ...listed, loopback: false }), AGENT_LOOPBACK_REFUSAL);
+    });
+    it("refuses off this machine before looking at the route", () => {
+        assert.equal(agentRefusal({ method: "GET", path: "/ws/control", loopback: false }), AGENT_LOOPBACK_REFUSAL);
+    });
+    it("names a utility session, not a CLI command, as the way to do a closed act", () => {
+        assert.equal(agentRefusal({ method: "POST", path: "/api/absorb", loopback: true }), AGENT_SCOPE_REFUSAL);
+        assert.match(AGENT_SCOPE_REFUSAL, /utility session/);
+        assert.doesNotMatch(AGENT_SCOPE_REFUSAL, /brane run/);
+    });
+});
+describe("agentReviveRefusal", () => {
+    it("refuses a utility session, whose env carries no agent token", () => {
+        assert.equal(agentReviveRefusal("utility"), AGENT_REVIVE_REFUSAL);
+    });
+    it("leaves reviving and prompting agents open", () => {
+        for (const role of ["worker", "twin", "keeper", "absorbed", null, undefined]) {
+            assert.equal(agentReviveRefusal(role), null, String(role));
+        }
+    });
+});
+describe("reviveNarrative, asked by an agent", () => {
+    // Refused before anything reaches tmux, so no tmux is needed here.
+    function dbWith(role) {
+        const db = createTestDb();
+        db.prepare("INSERT INTO narratives (id, brane_id, agent_type, role, status, fold_path, created_at) VALUES ('zsh-0001', 'brane-test', 'zsh', ?, 'active', '/tmp', ?)").run(role, Date.now());
+        return db;
+    }
+    it("refuses a utility session, with or without a prompt", () => {
+        assert.throws(() => reviveNarrative(dbWith("utility"), "zsh-0001", { prompt: "brane absorb", byAgent: true }), {
+            message: AGENT_REVIVE_REFUSAL,
+        });
+        assert.throws(() => reviveNarrative(dbWith("utility"), "zsh-0001", { byAgent: true }), { message: AGENT_REVIVE_REFUSAL });
+    });
+});
+/** A request as the daemon sees one: over `daemon.sock`, or from an address. */
+function request(method, from) {
+    const socket = from === "socket" ? {} : { remoteAddress: from };
+    if (from === "socket")
+        markUnixConnection(socket);
+    return { method, headers: { host: "localhost" }, socket };
+}
+describe("agentRequestRefusal, as the HTTP handler and the upgrade ask it", () => {
+    const agent = { kind: "agent" };
+    it("lets an agent's token in over the socket and loopback, on an open route", () => {
+        assert.equal(agentRequestRefusal(agent, request("GET", "socket"), "/api/narratives"), null);
+        assert.equal(agentRequestRefusal(agent, request("GET", "127.0.0.1"), "/api/narratives"), null);
+        assert.equal(agentRequestRefusal(agent, request("GET", "::ffff:127.0.0.1"), "/ws/mcp"), null);
+    });
+    it("refuses an agent's token from a tailnet address", () => {
+        assert.equal(agentRequestRefusal(agent, request("GET", "100.64.1.2"), "/api/narratives"), AGENT_LOOPBACK_REFUSAL);
+    });
+    it("refuses an agent's token on a closed route, even from the socket", () => {
+        assert.equal(agentRequestRefusal(agent, request("GET", "socket"), "/ws/terminal/claude-abcd1234"), AGENT_SCOPE_REFUSAL);
+        assert.equal(agentRequestRefusal(agent, request("POST", "socket"), "/api/narratives/x/signal"), AGENT_SCOPE_REFUSAL);
+    });
+    it("never refuses a device or this account", () => {
+        assert.equal(agentRequestRefusal({ kind: "device" }, request("GET", "100.64.1.2"), "/ws/terminal/x"), null);
+        assert.equal(agentRequestRefusal({ kind: "local" }, request("POST", "socket"), "/api/absorb"), null);
+    });
+});
+// Every route the daemon serves, read from its `// Route:` and `// WS:`
+// comments, must be decided here: open to agents (and listed in
+// AGENT_ROUTES) or closed. A new route then fails this test until someone
+// writes down which it is, and a renamed one shows up as a stale entry.
+// Reads source, which an installed package does not ship (`brane doctor`).
+const serverSource = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "src", "daemon", "server.ts");
+const CLOSED_TO_AGENTS = new Set([
+    "GET /api/absorb/survey",
+    "POST /api/absorb",
+    "POST /api/cost/backfill",
+    "POST /api/cost/reprice",
+    "POST /api/folds",
+    "PATCH /api/folds/archive",
+    "PATCH /api/narratives/:/archive",
+    "POST /api/narratives/:/signal",
+    "POST /api/presence/cancel",
+    "POST /api/run",
+    "POST /api/token/rotate",
+    "GET /api/tokens",
+    "POST /api/tokens",
+    "POST /api/tokens/remote",
+    "POST /api/tokens/:/revoke",
+    "GET /ws/control",
+    "GET /ws/terminal/:",
+    // Before authentication, with its own check (agent token, loopback only).
+    "POST /api/hooks/tool-use",
+]);
+/** `METHOD /path` with every parameter (`:id`, `*`) spelled `:`. */
+function normalize(route) {
+    const [method, path] = route.split(" ");
+    return `${method} ${path.split("/").map((s) => (s.startsWith(":") || s === "*" ? ":" : s)).join("/")}`;
+}
+describe("every daemon route is open or closed to agents, on purpose", { skip: existsSync(serverSource) ? false : "src not shipped" }, () => {
+    const served = new Set();
+    for (const m of readFileSync(serverSource, "utf8").matchAll(/\/\/ (Route|WS): (?:([A-Z]+) )?(\/[^\s?]+)/g)) {
+        served.add(normalize(`${m[2] ?? "GET"} ${m[3]}`));
+    }
+    const open = new Set(AGENT_ROUTES.map(normalize));
+    it("finds the route table", () => {
+        assert.ok(served.size > 30, `only ${served.size} routes found`);
+    });
+    it("decides each one", () => {
+        const undecided = [...served].filter((r) => !open.has(r) && !CLOSED_TO_AGENTS.has(r));
+        assert.deepEqual(undecided, [], "add each to AGENT_ROUTES or to CLOSED_TO_AGENTS");
+    });
+    it("lists nothing the daemon does not serve", () => {
+        assert.deepEqual([...open].filter((r) => !served.has(r)), [], "stale AGENT_ROUTES entries");
+        assert.deepEqual([...CLOSED_TO_AGENTS].filter((r) => !served.has(r)), [], "stale CLOSED_TO_AGENTS entries");
+    });
+    it("asks on both ways in: the HTTP handler and the WebSocket upgrade", () => {
+        const calls = readFileSync(serverSource, "utf8").match(/refuseAgent\(auth\.record, req, path\)/g) ?? [];
+        assert.equal(calls.length, 2);
+    });
+    it("never lists a route as both", () => {
+        assert.deepEqual([...open].filter((r) => CLOSED_TO_AGENTS.has(r)), []);
+    });
+});
+//# sourceMappingURL=agent-scope.test.js.map

package/dist/test/agents.test.js

@@ -0,0 +1,55 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join } from "node:path";
+import { getAgentAdapter } from "../agents.js";
+describe("claudeAdapter.resumeArgs", () => {
+    // Regression: previously, resumeArgs fell back to discoverSessionId(foldPath),
+    // which scans the fold-wide project dir and returns the most-recently-modified
+    // .jsonl. Two narratives sharing a fold could revive each other's sessions.
+    it("returns [] when sessionId is missing (does not fall back to fold-wide discovery)", () => {
+        const adapter = getAgentAdapter("claude");
+        assert.deepEqual(adapter.resumeArgs({ foldPath: "/Users/nobody/nonexistent" }), []);
+        assert.deepEqual(adapter.resumeArgs({ sessionId: undefined, foldPath: "/Users/nobody/nonexistent" }), []);
+    });
+    it("returns [] when sessionId points at a non-existent .jsonl", () => {
+        const adapter = getAgentAdapter("claude");
+        const args = adapter.resumeArgs({
+            sessionId: "00000000-0000-0000-0000-000000000000",
+            foldPath: "/Users/nobody/nonexistent",
+        });
+        assert.deepEqual(args, []);
+    });
+    // Regression: a plain `--resume` rotates to a fresh session id that the
+    // daemon never learns, stranding agent_session_id on the dead predecessor
+    // (frozen cost readings; next revive resumes the pre-revive fork point).
+    // With a daemon-minted newSessionId, every launch shape must pin it.
+    it("pins newSessionId on a fresh start (no resumable session)", () => {
+        const adapter = getAgentAdapter("claude");
+        assert.deepEqual(adapter.resumeArgs({ foldPath: "/Users/nobody/nonexistent", newSessionId: "new-id" }), ["--session-id", "new-id"]);
+        assert.deepEqual(adapter.resumeArgs({
+            sessionId: "00000000-0000-0000-0000-000000000000",
+            foldPath: "/Users/nobody/nonexistent",
+            newSessionId: "new-id",
+        }), ["--session-id", "new-id"]);
+    });
+    it("resumes fork-style with a pinned id whenever newSessionId is supplied", (t) => {
+        const adapter = getAgentAdapter("claude");
+        const foldPath = mkdtempSync(join(tmpdir(), "brane-agents-test-"));
+        const cwdEncoded = foldPath.replace(/\//g, "-");
+        const projectDir = join(homedir(), ".claude", "projects", cwdEncoded);
+        mkdirSync(projectDir, { recursive: true });
+        const sessionId = "11111111-1111-1111-1111-111111111111";
+        writeFileSync(join(projectDir, `${sessionId}.jsonl`), "");
+        t.after(() => rmSync(projectDir, { recursive: true, force: true }));
+        // Pinned resume always forks, live or dead — rotation happens either way,
+        // and forking is the shape that lets the daemon own the successor's id.
+        assert.deepEqual(adapter.resumeArgs({ sessionId, foldPath, newSessionId: "new-id" }), ["--resume", sessionId, "--fork-session", "--session-id", "new-id"]);
+        assert.deepEqual(adapter.resumeArgs({ sessionId, foldPath, forkSession: true, newSessionId: "new-id" }), ["--resume", sessionId, "--fork-session", "--session-id", "new-id"]);
+        // Un-pinned shapes are unchanged (no daemon-minted id supplied).
+        assert.deepEqual(adapter.resumeArgs({ sessionId, foldPath, forkSession: true }), ["--resume", sessionId, "--fork-session"]);
+        assert.deepEqual(adapter.resumeArgs({ sessionId, foldPath }), ["--resume", sessionId]);
+    });
+});
+//# sourceMappingURL=agents.test.js.map

package/dist/test/api-request.test.js

@@ -0,0 +1,122 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { DEFAULT_TIMEOUT_MS, JSON_HEADERS, MAX_ATTEMPTS, NO_HEADERS, isRetryableError, isRetryableMethod, requiresPreflight, retryDelayMs, withToken, } from "../shared/api-request.js";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+describe("requiresPreflight", () => {
+    test("a bare GET is simple — the case the whole design turns on", () => {
+        assert.equal(requiresPreflight("GET", NO_HEADERS), false);
+        assert.equal(requiresPreflight("GET"), false);
+    });
+    test("an Authorization header forces a preflight", () => {
+        // This is the regression. It is why the token rides in the query string:
+        // on a LAN this header costs a millisecond, at 741ms RTT it cost the app.
+        assert.equal(requiresPreflight("GET", { Authorization: "Bearer abc" }), true);
+    });
+    test("application/json forces a preflight even on a POST", () => {
+        assert.equal(requiresPreflight("POST", JSON_HEADERS), true);
+    });
+    test("safelisted content types do not", () => {
+        assert.equal(requiresPreflight("POST", { "Content-Type": "text/plain" }), false);
+        assert.equal(requiresPreflight("POST", { "Content-Type": "text/plain;charset=UTF-8" }), false);
+    });
+    test("PATCH and DELETE always preflight, headers or not", () => {
+        assert.equal(requiresPreflight("PATCH", NO_HEADERS), true);
+        assert.equal(requiresPreflight("DELETE", NO_HEADERS), true);
+    });
+    test("header names are matched case-insensitively", () => {
+        assert.equal(requiresPreflight("GET", { "content-type": "application/json" }), true);
+        assert.equal(requiresPreflight("GET", { "CONTENT-TYPE": "text/plain" }), false);
+    });
+});
+describe("withToken", () => {
+    test("appends to a bare path", () => {
+        assert.equal(withToken("/api/status", "abc"), "/api/status?token=abc");
+    });
+    test("joins an existing query string with & rather than a second ?", () => {
+        assert.equal(withToken("/api/narratives?archived=1", "abc"), "/api/narratives?archived=1&token=abc");
+    });
+    test("escapes tokens that would otherwise break the query string", () => {
+        assert.equal(withToken("/api/status", "a b&c=d"), "/api/status?token=a%20b%26c%3Dd");
+    });
+    test("stays in front of a fragment, which is never sent to the server", () => {
+        assert.equal(withToken("/api/files?path=x#L10", "abc"), "/api/files?path=x&token=abc#L10");
+        assert.equal(withToken("/api/status#top", "abc"), "/api/status?token=abc#top");
+    });
+});
+describe("retry policy", () => {
+    test("replays only what cannot have had an effect", () => {
+        assert.equal(isRetryableMethod("GET"), true);
+        assert.equal(isRetryableMethod("head"), true);
+        // A timed-out spawn may have spawned. Asking twice is worse than failing.
+        assert.equal(isRetryableMethod("POST"), false);
+        assert.equal(isRetryableMethod("PATCH"), false);
+    });
+    test("retries transport failures, not answers", () => {
+        const abort = new Error("aborted");
+        abort.name = "AbortError";
+        assert.equal(isRetryableError(abort), true);
+        assert.equal(isRetryableError(new TypeError("Failed to fetch")), true);
+        // An HTTP error is an answer; the caller decides what it means.
+        assert.equal(isRetryableError(new Error("Status 404")), false);
+    });
+    test("backs off exponentially", () => {
+        assert.equal(retryDelayMs(0), 500);
+        assert.equal(retryDelayMs(1), 1000);
+        assert.equal(retryDelayMs(2), 2000);
+    });
+    test("a ceiling that clears a satellite link's fixed costs", () => {
+        // ~0.75s TCP + ~1.5s TLS + ~10 RTT of slow start is ~10s before a large
+        // response can be moving at speed. The old 10s budget was spent before the
+        // transfer began.
+        assert.ok(DEFAULT_TIMEOUT_MS >= 30_000, "must survive a high-RTT link");
+        assert.ok(MAX_ATTEMPTS >= 2, "one attempt is not a retry policy");
+    });
+});
+// The three checks below read `expo/lib/api.ts` as text. The tarball ships
+// `expo/dist/` (the built app) but not the source, so from an installed
+// package — `brane doctor` — there is nothing to lint and the whole block
+// skips with a reason rather than failing on ENOENT.
+const apiSourcePath = join(repoRoot, "expo", "lib", "api.ts");
+describe("the app's own request layer obeys the rules", { skip: existsSync(apiSourcePath) ? false : "expo source not shipped" }, () => {
+    // Guards against the regression that a browser on a fast network cannot
+    // show you: reinstating a header that quietly reintroduces a preflight.
+    const api = existsSync(apiSourcePath) ? readFileSync(apiSourcePath, "utf8") : "";
+    test("no request sets an Authorization header", () => {
+        // Matches an object key, not the word in prose — the module explains
+        // itself in comments and should be allowed to name what it avoids.
+        assert.equal(/["']?Authorization["']?\s*:/i.test(api), false, "auth belongs in the query string; a header would force a preflight");
+    });
+    test("every request's headers come from the two shared constants", () => {
+        const headerValues = [...api.matchAll(/headers:\s*([A-Za-z_$][\w$]*)/g)].map((m) => m[1]);
+        assert.ok(headerValues.length > 0, "expected to find request call sites");
+        for (const v of headerValues) {
+            assert.ok(v === "NO_HEADERS" || v === "JSON_HEADERS", `unexpected headers value ${v} — use NO_HEADERS or JSON_HEADERS`);
+        }
+    });
+    test("nothing appends its own token — apiUrl already did", () => {
+        // Caught in review: `payloadUrl` and `wikiAssetUrl` built their own query
+        // strings, so once apiUrl started supplying the token they appended a
+        // second one and the URL stopped authenticating. Images silently broke.
+        // Matches a token being *put into* a URL or param bag, not the word
+        // appearing as an interface field or a function argument.
+        const stray = [
+            ...api.matchAll(/token:\s*conn\.token/g),
+            ...api.matchAll(/token=\$\{/g),
+        ].map((m) => m[0]);
+        assert.deepEqual(stray, [], "let apiUrl supply the token; a second one breaks auth");
+    });
+    test("bodied requests are the only ones carrying JSON_HEADERS", () => {
+        // JSON_HEADERS on a bodiless request would buy a preflight for nothing.
+        const blocks = api.split("fetchWithTimeout(");
+        for (const b of blocks.slice(1)) {
+            const head = b.slice(0, b.indexOf("});") + 1);
+            if (head.includes("JSON_HEADERS")) {
+                assert.ok(head.includes("body:"), `JSON_HEADERS without a body:\n${head}`);
+            }
+        }
+    });
+});
+//# sourceMappingURL=api-request.test.js.map

package/dist/test/awaiting-glow.test.js

@@ -0,0 +1,54 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { awaitingGlow, isAwaiting } from "../shared/narrative-status.js";
+describe("awaiting glow", () => {
+    it("is honoured only while bridged", () => {
+        assert.equal(isAwaiting({ mcpConnected: true, awaiting: true }), true);
+        assert.equal(isAwaiting({ mcpConnected: true, awaiting: false }), false);
+        // A parked call cannot outlive its socket: a stale bit is not a fact.
+        assert.equal(isAwaiting({ mcpConnected: false, awaiting: true }), false);
+        assert.equal(isAwaiting({}), false);
+    });
+    it("is inset only, so it takes no layout and never spills", () => {
+        for (const layer of awaitingGlow(271).split(/,\s*(?=inset)/)) {
+            assert.match(layer, /^inset /);
+        }
+    });
+    it("wears the hue it is given", () => {
+        for (const h of [0, 90, 271, 359]) {
+            for (const layer of awaitingGlow(h).split(/,\s*(?=inset)/)) {
+                assert.match(layer, new RegExp(`oklch\\([\\d.]+ [\\d.]+ ${h} /`));
+            }
+        }
+    });
+});
+describe("awaiting glow layers", () => {
+    // The layers centred on the box, i.e. all but the one-sided top band.
+    const centred = (h) => awaitingGlow(h).split(/,\s*(?=inset)/).filter((l) => l.startsWith("inset 0 0 "));
+    it("are near-opaque at the rim, so the hue survives a dark row", () => {
+        const alphas = centred(271).map((l) => Number(/\/ ([\d.]+)\)/.exec(l)[1]));
+        assert.ok(alphas[0] >= 0.9, `rim alpha ${alphas[0]}`);
+        for (let i = 1; i < alphas.length; i++)
+            assert.ok(alphas[i] < alphas[i - 1], `alphas ${alphas}`);
+    });
+    it("hold lightness and chroma fixed across hues", () => {
+        const lc = (h) => awaitingGlow(h).replace(new RegExp(` ${h} /`, "g"), " H /");
+        for (const h of [0, 90, 180, 271])
+            assert.equal(lc(h), lc(0));
+    });
+    it("are all blurred: no solid edge line", () => {
+        for (const layer of awaitingGlow(271).split(/,\s*(?=inset)/)) {
+            const [, , blur] = layer.replace(/^inset /, "").split(" ");
+            assert.notEqual(blur, "0", layer);
+        }
+    });
+    it("thicken the top edge by one pixel, and only the top", () => {
+        const [top] = awaitingGlow(271).split(/,\s*(?=inset)/).filter((l) => !l.startsWith("inset 0 0 "));
+        const [, y, blur, spread] = top.replace(/^inset /, "").split(" ").map(parseFloat);
+        // The hole, grown by -spread on every side, sits y + spread below the
+        // top, and -spread past the sides, out of the blur's reach.
+        assert.equal(y + spread, 1);
+        assert.ok(-spread >= blur, top);
+    });
+});
+//# sourceMappingURL=awaiting-glow.test.js.map

package/dist/test/awaiting.test.js

@@ -0,0 +1,122 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { AwaitingTracker } from "../daemon/awaiting.js";
+import { cancelMcpCall, handleMcpNarrate, startMcpListen } from "../daemon/server.js";
+import { appendEvent } from "../db/events.js";
+// AGOG: a narrative parked in a blocking listen, or a waiting narrate, is
+// waiting for direction. The tracker turns parks and resolutions into one
+// boolean per narrative and reports only its edges.
+const SELF = "claude-aaaaaaaa";
+const BRANE = "brane-home";
+function tracker() {
+    const edges = [];
+    const tr = new AwaitingTracker((nid, a) => edges.push([nid, a]));
+    return { tr, edges };
+}
+describe("AwaitingTracker", () => {
+    it("is awaiting while parked, and a delivery ends it at once", () => {
+        const { tr, edges } = tracker();
+        tr.parked(SELF);
+        assert.equal(tr.isAwaiting(SELF), true);
+        tr.resolved(SELF, "delivered");
+        assert.equal(tr.isAwaiting(SELF), false);
+        assert.deepEqual(edges, [[SELF, true], [SELF, false]]);
+    });
+    it("ends at once on a timeout too, and the re-park glows again", () => {
+        // The flicker is the agent's turn between the two calls, shown as it is.
+        const { tr, edges } = tracker();
+        tr.parked(SELF);
+        tr.resolved(SELF, "timeout");
+        assert.equal(tr.isAwaiting(SELF), false);
+        tr.parked(SELF);
+        assert.deepEqual(edges, [[SELF, true], [SELF, false], [SELF, true]]);
+    });
+    it("ends at once on a cancel: the harness stopped waiting", () => {
+        const { tr, edges } = tracker();
+        tr.parked(SELF);
+        tr.resolved(SELF, "cancelled");
+        assert.equal(tr.isAwaiting(SELF), false);
+        assert.deepEqual(edges, [[SELF, true], [SELF, false]]);
+    });
+    it("stays awaiting while any bridge of the narrative is still parked", () => {
+        const { tr, edges } = tracker();
+        tr.parked(SELF);
+        tr.parked(SELF);
+        tr.resolved(SELF, "closed");
+        assert.equal(tr.isAwaiting(SELF), true);
+        tr.resolved(SELF, "closed");
+        assert.equal(tr.isAwaiting(SELF), false);
+        assert.deepEqual(edges, [[SELF, true], [SELF, false]]);
+    });
+    it("ignores a resolution it never saw park", () => {
+        const { tr, edges } = tracker();
+        tr.resolved(SELF, "delivered");
+        assert.deepEqual(edges, []);
+    });
+});
+// The wiring: startMcpListen is what parks, so drive it as the dispatcher does.
+function db() {
+    const d = createTestDb();
+    d.prepare("INSERT INTO narratives (id, brane_id, created_at, status) VALUES (?, ?, 0, 'active')").run(SELF, BRANE);
+    return d;
+}
+function client(tr) {
+    const ws = { readyState: 1, send: () => { } };
+    return { ws: ws, narrativeId: SELF, agentType: "claude", pendingListens: new Map(), awaiting: tr };
+}
+describe("AGOG wiring", () => {
+    it("a blocking listen parks as awaiting; the signal that wakes it ends it", () => {
+        const d = db();
+        const { tr, edges } = tracker();
+        const c = client(tr);
+        const waiters = new Map();
+        startMcpListen(c, d, "1", { after: 0 }, waiters, () => { }, BRANE);
+        assert.deepEqual(edges, [[SELF, true]]);
+        appendEvent(d, SELF, "human_signal", { content: "go", source: "web" });
+        for (const wake of waiters.get(SELF) ?? [])
+            wake();
+        assert.deepEqual(edges, [[SELF, true], [SELF, false]]);
+    });
+    it("a waiting narrate parks as awaiting too", () => {
+        const d = db();
+        const { tr, edges } = tracker();
+        const c = client(tr);
+        const result = handleMcpNarrate({ say: "done", wait: true }, d, SELF, () => { });
+        const { park, ...extra } = result;
+        startMcpListen(c, d, "1", { after: park.after }, new Map(), () => { }, BRANE, { omit: park.omit, extra });
+        assert.deepEqual(edges, [[SELF, true]]);
+    });
+    it("neither a non-blocking read nor a listen answered at once counts as parking", () => {
+        const d = db();
+        const { tr, edges } = tracker();
+        const c = client(tr);
+        startMcpListen(c, d, "1", { after: 0, wait: false }, new Map(), () => { }, BRANE);
+        appendEvent(d, SELF, "human_signal", { content: "hi", source: "web" });
+        startMcpListen(c, d, "2", { after: 0 }, new Map(), () => { }, BRANE);
+        assert.deepEqual(edges, []);
+        assert.equal(tr.isAwaiting(SELF), false);
+    });
+    it("a cancelled listen ends it now, is settled, and never answers", () => {
+        const d = db();
+        const { tr, edges } = tracker();
+        const sent = [];
+        const c = client(tr);
+        c.ws.send = (m) => sent.push(m);
+        const waiters = new Map();
+        const settled = [];
+        startMcpListen(c, d, "1", { after: 0 }, waiters, () => { }, BRANE);
+        assert.equal(cancelMcpCall(c, "1", (_nid, name) => settled.push(name)), true);
+        assert.deepEqual(edges, [[SELF, true], [SELF, false]]);
+        assert.deepEqual(settled, ["mcp__brane__listen"]);
+        assert.equal(c.pendingListens.size, 0);
+        assert.equal(waiters.get(SELF)?.size ?? 0, 0, "its wakeup is unregistered");
+        // The next signal finds nobody to answer.
+        appendEvent(d, SELF, "human_signal", { content: "go", source: "web" });
+        for (const wake of waiters.get(SELF) ?? [])
+            wake();
+        assert.deepEqual(sent, []);
+        assert.equal(cancelMcpCall(c, "1", () => { }), false, "a second cancel is a no-op");
+    });
+});
+//# sourceMappingURL=awaiting.test.js.map

package/dist/test/bind-token.test.js

@@ -0,0 +1,88 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { adoptBindTokens, mintAgentToken, settleAgentLaunch, verifyAgentToken } from "../db/tokens.js";
+import { braneTmuxEnv, ensureBindToken, buildGooseExtensionArg } from "../commands/spawn.js";
+describe("braneTmuxEnv", () => {
+    it("emits BRANE_NARRATIVE_ID and BRANE_NARRATIVE_SECRET when a token is present", () => {
+        const env = braneTmuxEnv("claude-abc123", "tok-xyz");
+        assert.equal(env, "BRANE_NARRATIVE_ID=claude-abc123 BRANE_NARRATIVE_SECRET=tok-xyz");
+    });
+    it("omits the secret assignment when the token is absent (migration grace)", () => {
+        assert.equal(braneTmuxEnv("claude-abc123", null), "BRANE_NARRATIVE_ID=claude-abc123");
+        assert.equal(braneTmuxEnv("claude-abc123"), "BRANE_NARRATIVE_ID=claude-abc123");
+        assert.equal(braneTmuxEnv("claude-abc123", ""), "BRANE_NARRATIVE_ID=claude-abc123");
+    });
+});
+describe("ensureBindToken", () => {
+    // Every launch hands its session a fresh agent token and revokes the one
+    // its previous launch held; the daemon keeps only the hash.
+    function insert(db, id, token) {
+        db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, created_at, status, bind_token)
+       VALUES (?, 'brane-test', 'claude', 'worker', 0, 'active', ?)`).run(id, token);
+    }
+    it("mints an agent token for the narrative, kept only as a hash", () => {
+        const db = createTestDb();
+        insert(db, "claude-alpha", null);
+        const secret = ensureBindToken(db, "claude-alpha");
+        assert.ok(verifyAgentToken(db, "claude-alpha", secret));
+        assert.equal(verifyAgentToken(db, "claude-beta", secret), false, "bound to its own narrative");
+        const row = db.prepare("SELECT bind_token FROM narratives WHERE id = ?").get("claude-alpha");
+        assert.equal(row.bind_token, null, "no plaintext on the narrative");
+        const stored = db.prepare("SELECT COUNT(*) AS n FROM tokens WHERE hash = ?").get(secret);
+        assert.equal(stored.n, 0, "the table holds its hash, not the secret");
+    });
+    it("revokes the previous launch's token, so one is live per narrative", () => {
+        const db = createTestDb();
+        insert(db, "claude-alpha", "existing-token");
+        adoptBindTokens(db);
+        assert.ok(verifyAgentToken(db, "claude-alpha", "existing-token"), "an adopted pre-agent-token secret works");
+        const next = ensureBindToken(db, "claude-alpha");
+        assert.notEqual(next, "existing-token");
+        assert.equal(verifyAgentToken(db, "claude-alpha", "existing-token"), false);
+        assert.ok(verifyAgentToken(db, "claude-alpha", next));
+        const live = db
+            .prepare("SELECT COUNT(*) AS n FROM tokens WHERE kind = 'agent' AND owner_nid = ? AND revoked_at IS NULL")
+            .get("claude-alpha");
+        assert.equal(live.n, 1);
+    });
+    it("a revive that fails to launch leaves the running session's token alone", () => {
+        const db = createTestDb();
+        insert(db, "claude-alpha", null);
+        const running = ensureBindToken(db, "claude-alpha");
+        const loser = mintAgentToken(db, "claude-alpha", Date.now(), undefined, false);
+        assert.ok(verifyAgentToken(db, "claude-alpha", running), "still live while the launch is pending");
+        settleAgentLaunch(db, "claude-alpha", loser, false);
+        assert.ok(verifyAgentToken(db, "claude-alpha", running));
+        assert.equal(verifyAgentToken(db, "claude-alpha", loser), false);
+    });
+    it("a revive that launches retires the previous token", () => {
+        const db = createTestDb();
+        insert(db, "claude-alpha", null);
+        const old = ensureBindToken(db, "claude-alpha");
+        const fresh = mintAgentToken(db, "claude-alpha", Date.now(), undefined, false);
+        settleAgentLaunch(db, "claude-alpha", fresh, true);
+        assert.equal(verifyAgentToken(db, "claude-alpha", old), false);
+        assert.ok(verifyAgentToken(db, "claude-alpha", fresh));
+    });
+    it("adopting twice adds nothing, and never brings back a revoked secret", () => {
+        const db = createTestDb();
+        insert(db, "claude-alpha", "existing-token");
+        assert.equal(adoptBindTokens(db), 1);
+        ensureBindToken(db, "claude-alpha");
+        assert.equal(adoptBindTokens(db), 0);
+        assert.equal(verifyAgentToken(db, "claude-alpha", "existing-token"), false);
+    });
+});
+describe("buildGooseExtensionArg", () => {
+    it("carries the bind secret inline in the goose extension env", () => {
+        const arg = buildGooseExtensionArg("goose-xyz", "tok-goose");
+        assert.match(arg, /^BRANE_NARRATIVE_ID=goose-xyz BRANE_NARRATIVE_SECRET=tok-goose /);
+    });
+    it("omits the secret when absent", () => {
+        const arg = buildGooseExtensionArg("goose-xyz");
+        assert.match(arg, /^BRANE_NARRATIVE_ID=goose-xyz /);
+        assert.ok(!arg.includes("BRANE_NARRATIVE_SECRET"));
+    });
+});
+//# sourceMappingURL=bind-token.test.js.map