brane 0.1.1 → 0.3.0

package/dist/test/session-affinity.test.js

@@ -0,0 +1,295 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, writeFileSync, mkdirSync, existsSync, statSync, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { withSessionAffinity, shellAffinityEnv, isFireworksBaseUrl, claudeSessionAffinityPath, ensureClaudeSessionAffinity, ensureSessionAffinityConfig, } from "../session-affinity.js";
+const FIREWORKS = "https://api.fireworks.ai/inference";
+function tempDir(prefix) {
+    return mkdtempSync(join(tmpdir(), prefix));
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(value, null, 2) + "\n");
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+function affinityFileHeaders(path) {
+    const config = readJson(path);
+    return config.env?.ANTHROPIC_CUSTOM_HEADERS;
+}
+/** Run a tmux-style env prefix through POSIX sh, the way tmux runs the
+ *  session command, and report what the child sees. */
+function headersUnderShell(prefix, inherited) {
+    const env = { ...process.env };
+    if (inherited === undefined)
+        delete env.ANTHROPIC_CUSTOM_HEADERS;
+    else
+        env.ANTHROPIC_CUSTOM_HEADERS = inherited;
+    const out = spawnSync("/bin/sh", ["-c", `${prefix} node -e 'process.stdout.write(process.env.ANTHROPIC_CUSTOM_HEADERS)'`], {
+        env,
+        encoding: "utf-8",
+    });
+    assert.equal(out.status, 0, out.stderr);
+    return out.stdout;
+}
+/** Pin every env var the implementation consults, so a host that exports
+ *  CLAUDE_CONFIG_DIR, ANTHROPIC_BASE_URL, or ANTHROPIC_CUSTOM_HEADERS can't
+ *  leak into the assertions. */
+function withCleanEnv(fn) {
+    const keys = ["CLAUDE_CONFIG_DIR", "ANTHROPIC_BASE_URL", "ANTHROPIC_CUSTOM_HEADERS"];
+    const saved = Object.fromEntries(keys.map((k) => [k, process.env[k]]));
+    for (const k of keys)
+        delete process.env[k];
+    try {
+        fn();
+    }
+    finally {
+        for (const [key, value] of Object.entries(saved)) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+    }
+}
+function dirs() {
+    return {
+        fold: tempDir("brane-affinity-fold-"),
+        home: tempDir("brane-affinity-home-"),
+        braneDir: tempDir("brane-affinity-dir-"),
+    };
+}
+describe("withSessionAffinity", () => {
+    it("appends to an empty or absent blob", () => {
+        assert.equal(withSessionAffinity(undefined, "claude-abc123"), "X-Session-Affinity: claude-abc123");
+        assert.equal(withSessionAffinity("", "claude-abc123"), "X-Session-Affinity: claude-abc123");
+    });
+    it("preserves unrelated lines verbatim and in order", () => {
+        const existing = "Authorization: Bearer fw-key-123\nX-Other: keepme";
+        assert.equal(withSessionAffinity(existing, "claude-abc123"), "Authorization: Bearer fw-key-123\nX-Other: keepme\nX-Session-Affinity: claude-abc123");
+    });
+    it("replaces a prior affinity line rather than accumulating", () => {
+        const first = withSessionAffinity("Authorization: Bearer k", "claude-aaa111");
+        const second = withSessionAffinity(first, "claude-bbb222");
+        assert.equal(second, "Authorization: Bearer k\nX-Session-Affinity: claude-bbb222");
+    });
+    it("matches the header name case-insensitively, the way Claude Code parses", () => {
+        const out = withSessionAffinity("x-session-affinity: stale\nAuthorization: Bearer k", "claude-abc123");
+        assert.equal(out, "Authorization: Bearer k\nX-Session-Affinity: claude-abc123");
+    });
+    it("tolerates CRLF input without emitting CR", () => {
+        const out = withSessionAffinity("Authorization: Bearer k\r\nX-Other: v", "claude-abc123");
+        assert.equal(out, "Authorization: Bearer k\nX-Other: v\nX-Session-Affinity: claude-abc123");
+    });
+});
+describe("isFireworksBaseUrl", () => {
+    it("matches fireworks.ai hosts only", () => {
+        assert.equal(isFireworksBaseUrl("https://api.fireworks.ai/inference"), true);
+        assert.equal(isFireworksBaseUrl("https://fireworks.ai"), true);
+        assert.equal(isFireworksBaseUrl("https://api.anthropic.com"), false);
+        assert.equal(isFireworksBaseUrl("https://proxy.example.com/fireworks.ai/v1"), false);
+        assert.equal(isFireworksBaseUrl("https://notfireworks.ai"), false);
+        assert.equal(isFireworksBaseUrl("not a url"), false);
+        assert.equal(isFireworksBaseUrl(undefined), false);
+    });
+});
+describe("shellAffinityEnv", () => {
+    it("appends to the headers the session's shell inherited", () => {
+        assert.equal(headersUnderShell(shellAffinityEnv("claude-sh1"), "Authorization: Bearer shell-only"), "Authorization: Bearer shell-only\nX-Session-Affinity: claude-sh1");
+    });
+    it("adds no leading newline when nothing was inherited", () => {
+        assert.equal(headersUnderShell(shellAffinityEnv("claude-sh2"), undefined), "X-Session-Affinity: claude-sh2");
+        assert.equal(headersUnderShell(shellAffinityEnv("claude-sh3"), ""), "X-Session-Affinity: claude-sh3");
+    });
+});
+describe("ensureClaudeSessionAffinity", () => {
+    it("does nothing when the session does not talk to Fireworks", () => {
+        const { fold, home, braneDir } = dirs();
+        writeJson(join(fold, ".claude", "settings.local.json"), {
+            env: { ANTHROPIC_CUSTOM_HEADERS: "Authorization: Bearer k" },
+        });
+        withCleanEnv(() => {
+            assert.deepEqual(ensureClaudeSessionAffinity(fold, "claude-anth01", { homeDir: home, braneDir }), {
+                args: [],
+                env: "",
+            });
+            process.env.ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+            assert.deepEqual(ensureClaudeSessionAffinity(fold, "claude-anth01", { homeDir: home, braneDir }), {
+                args: [],
+                env: "",
+            });
+        });
+        assert.equal(existsSync(join(braneDir, "session-affinity")), false);
+    });
+    it("uses the shell prefix, not a file, when no settings file defines the headers", () => {
+        const { fold, home, braneDir } = dirs();
+        writeJson(join(fold, ".claude", "settings.local.json"), { env: { ANTHROPIC_BASE_URL: FIREWORKS } });
+        withCleanEnv(() => {
+            // A daemon-side value must not be pinned: the session inherits from tmux.
+            process.env.ANTHROPIC_CUSTOM_HEADERS = "X-Daemon-Only: yes";
+            const launch = ensureClaudeSessionAffinity(fold, "claude-shell1", { homeDir: home, braneDir });
+            assert.deepEqual(launch, { args: [], env: shellAffinityEnv("claude-shell1") });
+        });
+        assert.equal(existsSync(join(braneDir, "session-affinity")), false);
+    });
+    it("takes the Fireworks base URL from the daemon env when no settings file sets one", () => {
+        const { fold, home, braneDir } = dirs();
+        withCleanEnv(() => {
+            process.env.ANTHROPIC_BASE_URL = FIREWORKS;
+            const launch = ensureClaudeSessionAffinity(fold, "claude-envurl", { homeDir: home, braneDir });
+            assert.equal(launch.env, shellAffinityEnv("claude-envurl"));
+        });
+    });
+    it("writes a private per-narrative --settings file when a settings file defines the headers", () => {
+        const { fold, home, braneDir } = dirs();
+        writeJson(join(fold, ".claude", "settings.local.json"), {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "Authorization: Bearer fw-secret" },
+        });
+        withCleanEnv(() => {
+            const launch = ensureClaudeSessionAffinity(fold, "claude-new123", { homeDir: home, braneDir });
+            const path = join(braneDir, "session-affinity", "claude-new123.json");
+            assert.deepEqual(launch, { args: ["--settings", path], env: "" });
+            assert.equal(affinityFileHeaders(path), "Authorization: Bearer fw-secret\nX-Session-Affinity: claude-new123");
+            assert.equal(statSync(path).mode & 0o777, 0o600);
+            assert.equal(statSync(dirname(path)).mode & 0o777, 0o700);
+        });
+    });
+    it("tightens a file and directory written with looser permissions", () => {
+        const { fold, home, braneDir } = dirs();
+        writeJson(join(fold, ".claude", "settings.local.json"), {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "Authorization: Bearer k" },
+        });
+        const path = claudeSessionAffinityPath("claude-loose1", { braneDir });
+        withCleanEnv(() => {
+            ensureClaudeSessionAffinity(fold, "claude-loose1", { homeDir: home, braneDir });
+            chmodSync(path, 0o644);
+            chmodSync(dirname(path), 0o755);
+            ensureClaudeSessionAffinity(fold, "claude-loose1", { homeDir: home, braneDir });
+        });
+        assert.equal(statSync(path).mode & 0o777, 0o600);
+        assert.equal(statSync(dirname(path)).mode & 0o777, 0o700);
+    });
+    it("gives concurrent same-fold narratives distinct files and leaves the fold file alone", () => {
+        const { fold, home, braneDir } = dirs();
+        const localPath = join(fold, ".claude", "settings.local.json");
+        writeJson(localPath, {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "Authorization: Bearer fw-secret" },
+        });
+        const before = readFileSync(localPath, "utf-8");
+        withCleanEnv(() => {
+            const a = ensureClaudeSessionAffinity(fold, "claude-aaa111", { homeDir: home, braneDir }).args[1];
+            const b = ensureClaudeSessionAffinity(fold, "claude-bbb222", { homeDir: home, braneDir }).args[1];
+            assert.notEqual(a, b);
+            assert.equal(affinityFileHeaders(a), "Authorization: Bearer fw-secret\nX-Session-Affinity: claude-aaa111");
+            assert.equal(affinityFileHeaders(b), "Authorization: Bearer fw-secret\nX-Session-Affinity: claude-bbb222");
+        });
+        assert.equal(readFileSync(localPath, "utf-8"), before);
+    });
+    it("prefers local over project over user, for both variables independently", () => {
+        const { fold, home, braneDir } = dirs();
+        writeJson(join(home, ".claude", "settings.json"), {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "X-Source: user" },
+        });
+        writeJson(join(fold, ".claude", "settings.json"), { env: { ANTHROPIC_CUSTOM_HEADERS: "X-Source: project" } });
+        withCleanEnv(() => {
+            // Base URL from user settings, headers from project: project beats user.
+            let path = ensureClaudeSessionAffinity(fold, "claude-src111", { homeDir: home, braneDir }).args[1];
+            assert.match(affinityFileHeaders(path), /^X-Source: project\n/);
+            writeJson(join(fold, ".claude", "settings.local.json"), { env: { ANTHROPIC_CUSTOM_HEADERS: "X-Source: local" } });
+            path = ensureClaudeSessionAffinity(fold, "claude-src111", { homeDir: home, braneDir }).args[1];
+            assert.match(affinityFileHeaders(path), /^X-Source: local\n/);
+            // A higher-precedence non-Fireworks base URL turns it off.
+            writeJson(join(fold, ".claude", "settings.local.json"), {
+                env: { ANTHROPIC_BASE_URL: "https://api.anthropic.com", ANTHROPIC_CUSTOM_HEADERS: "X-Source: local" },
+            });
+            assert.deepEqual(ensureClaudeSessionAffinity(fold, "claude-src111", { homeDir: home, braneDir }).args, []);
+        });
+    });
+    it("treats a broken candidate file as absent and never writes to it", () => {
+        const { fold, home, braneDir } = dirs();
+        const localPath = join(fold, ".claude", "settings.local.json");
+        mkdirSync(dirname(localPath), { recursive: true });
+        writeFileSync(localPath, "{ not json — operator will fix by hand");
+        writeJson(join(fold, ".claude", "settings.json"), {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "X-Source: project" },
+        });
+        withCleanEnv(() => {
+            const path = ensureClaudeSessionAffinity(fold, "claude-nope00", { homeDir: home, braneDir }).args[1];
+            assert.equal(affinityFileHeaders(path), "X-Source: project\nX-Session-Affinity: claude-nope00");
+        });
+        assert.equal(readFileSync(localPath, "utf-8"), "{ not json — operator will fix by hand");
+    });
+    it("is idempotent: a second identical call does not rewrite the file", () => {
+        const { fold, home, braneDir } = dirs();
+        writeJson(join(fold, ".claude", "settings.local.json"), {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "Authorization: Bearer k" },
+        });
+        const path = claudeSessionAffinityPath("claude-same1", { braneDir });
+        withCleanEnv(() => ensureClaudeSessionAffinity(fold, "claude-same1", { homeDir: home, braneDir }));
+        const before = statSync(path).mtimeMs;
+        withCleanEnv(() => ensureClaudeSessionAffinity(fold, "claude-same1", { homeDir: home, braneDir }));
+        assert.equal(statSync(path).mtimeMs, before);
+    });
+});
+describe("ensureSessionAffinityConfig", () => {
+    function fireworksFold() {
+        const d = dirs();
+        writeJson(join(d.fold, ".claude", "settings.local.json"), {
+            env: { ANTHROPIC_BASE_URL: FIREWORKS, ANTHROPIC_CUSTOM_HEADERS: "Authorization: Bearer k" },
+        });
+        return d;
+    }
+    it("returns claude's --settings args", () => {
+        const { fold, home, braneDir } = fireworksFold();
+        withCleanEnv(() => {
+            const launch = ensureSessionAffinityConfig("claude", fold, "claude-entry1", { enabled: true, homeDir: home, braneDir });
+            assert.deepEqual(launch, { args: ["--settings", claudeSessionAffinityPath("claude-entry1", { braneDir })], env: "" });
+        });
+    });
+    it("does nothing when opted out", () => {
+        const { fold, home, braneDir } = fireworksFold();
+        withCleanEnv(() => {
+            const launch = ensureSessionAffinityConfig("claude", fold, "claude-off1", { enabled: false, homeDir: home, braneDir });
+            assert.deepEqual(launch, { args: [], env: "" });
+        });
+        assert.equal(existsSync(join(braneDir, "session-affinity")), false);
+    });
+    it("does nothing for other agents — crush sends its own affinity header", () => {
+        const { fold, home, braneDir } = fireworksFold();
+        withCleanEnv(() => {
+            for (const agent of ["crush", "goose", "codex", "gemini"]) {
+                assert.deepEqual(ensureSessionAffinityConfig(agent, fold, "x-other1", { enabled: true, homeDir: home, braneDir }), {
+                    args: [],
+                    env: "",
+                });
+            }
+        });
+    });
+    it("degrades to no affinity, not a failed launch, when the file cannot be written", () => {
+        const { fold, home } = fireworksFold();
+        // A regular file where the brane dir should be makes the mkdir throw.
+        const blocked = join(tempDir("brane-affinity-blocked-"), "not-a-dir");
+        writeFileSync(blocked, "");
+        const logged = [];
+        const original = console.error;
+        console.error = (...args) => logged.push(args);
+        try {
+            withCleanEnv(() => {
+                const launch = ensureSessionAffinityConfig("claude", fold, "claude-err1", {
+                    enabled: true,
+                    homeDir: home,
+                    braneDir: blocked,
+                });
+                assert.deepEqual(launch, { args: [], env: "" });
+            });
+        }
+        finally {
+            console.error = original;
+        }
+        assert.equal(logged.length, 1);
+    });
+});
+//# sourceMappingURL=session-affinity.test.js.map

package/dist/test/signal-source.test.js

@@ -0,0 +1,32 @@
+/**
+ * Who a human_signal is from (src/daemon/signal-source.ts): decided by the
+ * token's kind, never by a `source` the request names, and refused to an
+ * agent's token.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { AGENT_SIGNAL_REFUSAL, signalEventFields, signalStanding } from "../daemon/signal-source.js";
+describe("signalStanding", () => {
+    it("stamps a device's signal as the app's", () => {
+        assert.deepEqual(signalStanding({ kind: "device" }), { source: "web" });
+    });
+    it("stamps this account's signal as local", () => {
+        assert.deepEqual(signalStanding({ kind: "local" }), { source: "local" });
+    });
+    it("refuses an agent's token, pointing it at narrate", () => {
+        const standing = signalStanding({ kind: "agent" });
+        assert.deepEqual(standing, { refused: AGENT_SIGNAL_REFUSAL });
+        assert.match(AGENT_SIGNAL_REFUSAL, /narrate/);
+    });
+});
+describe("signalEventFields", () => {
+    it("ignores a source the request names", () => {
+        const fields = signalEventFields({ source: "web" }, { content: "hi", source: "claude-abcd1234", re: [3] });
+        assert.deepEqual(fields, { content: "hi", source: "web", re: [3] });
+    });
+    it("carries stored payload paths, and nothing else from the request", () => {
+        const fields = signalEventFields({ source: "local" }, { content: "see attached", type: "human_signal", meta: { forged: true } }, ["claude-abcd1234/1_0.png"]);
+        assert.deepEqual(fields, { content: "see attached", source: "local", re: undefined, payloads: ["claude-abcd1234/1_0.png"] });
+    });
+});
+//# sourceMappingURL=signal-source.test.js.map

package/dist/test/socket-account.test.js

@@ -0,0 +1,268 @@
+/**
+ * A request over `daemon.sock` with no token acts as this Unix account — the
+ * live `local` row — while the brane dir is owned by the daemon's uid with no
+ * group or other bits. No token anywhere else is still refused, and clients
+ * go tokenless only when they have nothing to present and a socket to use.
+ */
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { createServer as createHttpServer } from "node:http";
+import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createServer as createNetServer, connect as netConnect } from "node:net";
+import { createTestDb } from "./helpers.js";
+import { accountDirTrust, markUnixConnection } from "../daemon/local-socket.js";
+import { authenticateRequest } from "../daemon/server.js";
+import { MemoryTokenStore, TokenRing, hashToken } from "../daemon/token-ring.js";
+import { bootstrapTokens, DbTokenStore } from "../db/tokens.js";
+import { daemonRequest, resolveCredential } from "../daemon/client.js";
+import { mcpDialTarget } from "../commands/mcp.js";
+import { leftoverTokenFile, shellReachProblem, tokenFileCheck } from "../commands/doctor.js";
+const unixOnly = process.getuid === undefined ? "no Unix uids on this platform" : false;
+function privateDir() {
+    const dir = mkdtempSync(join(tmpdir(), "brane-acct-"));
+    chmodSync(dir, 0o700);
+    return dir;
+}
+/** A request as the CLI and bridge send one: `Host: localhost`, no Origin. */
+function request(opts) {
+    const socket = opts.overSocket ? {} : { remoteAddress: opts.remoteAddress ?? "127.0.0.1" };
+    if (opts.overSocket)
+        markUnixConnection(socket);
+    return { headers: { host: "localhost", ...opts.headers }, socket };
+}
+describe("accountDirTrust", { skip: unixOnly }, () => {
+    it("trusts a directory this uid owns with no group or other bits", () => {
+        assert.deepEqual(accountDirTrust(privateDir()), { ok: true });
+    });
+    it("refuses one other accounts can search, and says so", () => {
+        const dir = privateDir();
+        chmodSync(dir, 0o755);
+        const trust = accountDirTrust(dir);
+        assert.equal(trust.ok, false);
+        assert.match(trust.reason, /mode 755/);
+    });
+    it("refuses a directory that is not there", () => {
+        assert.equal(accountDirTrust(join(privateDir(), "gone")).ok, false);
+    });
+});
+describe("authenticateRequest", { skip: unixOnly }, () => {
+    const ring = () => new TokenRing(new MemoryTokenStore([{ token: "local-tok", kind: "local", label: "this machine" }]), () => "minted");
+    it("acts as the local row for a tokenless request over the socket", () => {
+        const heard = [];
+        const result = authenticateRequest(ring(), null, request({ overSocket: true }), privateDir(), (r) => heard.push(r));
+        assert.equal(result.ok, true);
+        assert.equal(result.ok && result.record.kind, "local");
+        // Told it was let in, so a later refusal is reported again.
+        assert.deepEqual(heard, [null]);
+    });
+    it("treats an empty token as no token", () => {
+        assert.equal(authenticateRequest(ring(), "", request({ overSocket: true }), privateDir(), () => { }).ok, true);
+    });
+    it("refuses a browser's request relayed to the socket: an Origin, or a Host other than localhost", () => {
+        const reasons = [];
+        const relayed = [
+            request({ overSocket: true, headers: { origin: "https://evil.example" } }),
+            request({ overSocket: true, headers: { host: "evil.example:9000" } }),
+            request({ overSocket: true, headers: { host: "" } }),
+        ];
+        for (const req of relayed) {
+            assert.deepEqual(authenticateRequest(ring(), null, req, privateDir(), (r) => reasons.push(r)), { ok: false });
+        }
+        assert.equal(reasons.filter((r) => r !== null).length, 3);
+        // A presented token is still just checked: a relay with a token was
+        // always as good as the token.
+        const withToken = request({ overSocket: true, headers: { origin: "https://evil.example" } });
+        assert.equal(authenticateRequest(ring(), "local-tok", withToken, privateDir(), () => { }).ok, true);
+    });
+    it("refuses the same request over TCP, loopback included", () => {
+        const result = authenticateRequest(ring(), null, request({ overSocket: false, remoteAddress: "127.0.0.1" }), privateDir(), () => { });
+        assert.deepEqual(result, { ok: false });
+    });
+    it("refuses it, and says why, when the brane dir is open to others", () => {
+        const dir = privateDir();
+        chmodSync(dir, 0o750);
+        const reasons = [];
+        const result = authenticateRequest(ring(), null, request({ overSocket: true }), dir, (r) => reasons.push(r));
+        assert.deepEqual(result, { ok: false });
+        assert.equal(reasons.length, 1);
+        assert.match(reasons[0] ?? "", /mode 750/);
+    });
+    it("still checks a presented token, over the socket too", () => {
+        const r = ring();
+        assert.equal(authenticateRequest(r, "nope", request({ overSocket: true }), privateDir(), () => { }).ok, false);
+        assert.equal(authenticateRequest(r, "local-tok", request({ overSocket: true }), privateDir(), () => { }).ok, true);
+    });
+    it("refuses when there is no live local row to act as", () => {
+        const empty = new TokenRing(new MemoryTokenStore(), () => "minted");
+        assert.deepEqual(authenticateRequest(empty, null, request({ overSocket: true }), privateDir(), () => { }), { ok: false });
+    });
+});
+describe("DbTokenStore.account", () => {
+    it("is the live local row, stamped with where it was seen, and nothing once revoked", () => {
+        const db = createTestDb();
+        const store = new DbTokenStore(db);
+        // Last-used is stamped at most once a minute, so use a clock past that.
+        const t = 10 * 60_000;
+        const local = store.insert(hashToken("x"), "local", "this machine", 1000);
+        const found = store.account(t, { userAgent: "node", remoteAddr: "daemon.sock" });
+        assert.equal(found?.id, local.id);
+        const row = db.prepare("SELECT remote_addr, last_used_at FROM tokens WHERE id = ?").get(local.id);
+        assert.equal(row.remote_addr, "daemon.sock");
+        assert.equal(row.last_used_at, t);
+        store.revoke([local.id], t + 1);
+        assert.equal(store.account(t + 2), null);
+    });
+});
+describe("clients without a token", () => {
+    const closers = [];
+    after(async () => {
+        for (const close of closers)
+            await close();
+    });
+    it("present nothing outside an agent session, and that session's token inside one", () => {
+        assert.equal(resolveCredential({}), null);
+        assert.equal(resolveCredential({ BRANE_NARRATIVE_SECRET: "" }), null);
+        assert.equal(resolveCredential({ BRANE_NARRATIVE_SECRET: "agent-secret" }), "agent-secret");
+    });
+    it("say what is wrong when there is no socket to present nothing on", async () => {
+        const noSocket = { baseUrl: "http://127.0.0.1:1", token: null, port: "1" };
+        await assert.rejects(daemonRequest(noSocket, "/api/status"), /running without its socket.*brane daemon logs/);
+        const gone = { ...noSocket, socketPath: join(privateDir(), "daemon.sock") };
+        await assert.rejects(daemonRequest(gone, "/api/status"), /could not connect to the daemon's socket.*brane daemon restart/);
+    });
+    it("send no Authorization over the socket", async () => {
+        const socketPath = join(privateDir(), "daemon.sock");
+        const seen = [];
+        const server = createHttpServer((req, res) => {
+            seen.push(req.headers.authorization);
+            res.end("{}");
+        });
+        await new Promise((r) => server.listen(socketPath, r));
+        closers.push(() => new Promise((r) => server.close(() => r())));
+        await daemonRequest({ baseUrl: "http://127.0.0.1:1", token: null, port: "1", socketPath }, "/api/status");
+        assert.deepEqual(seen, [undefined]);
+    });
+    it("never fall back to TCP, where no token is only a 401", async () => {
+        let tcpHits = 0;
+        const tcp = createHttpServer((_req, res) => {
+            tcpHits++;
+            res.end("{}");
+        });
+        await new Promise((r) => tcp.listen(0, "127.0.0.1", r));
+        closers.push(() => new Promise((r) => tcp.close(() => r())));
+        const port = tcp.address().port;
+        const endpoint = {
+            baseUrl: `http://127.0.0.1:${port}`,
+            token: null,
+            port: String(port),
+            socketPath: join(privateDir(), "daemon.sock"),
+        };
+        await assert.rejects(daemonRequest(endpoint, "/api/status"), /could not connect to the daemon's socket/);
+        assert.equal(tcpHits, 0);
+    });
+    it("dial the bridge with no token in the URL", () => {
+        assert.deepEqual(mcpDialTarget({ port: "4000", tls: true, token: null, socketPath: "/s" }), {
+            url: "ws://localhost/ws/mcp?",
+            socketPath: "/s",
+        });
+    });
+});
+describe("tokenless over a real socket", { skip: unixOnly }, () => {
+    it("is let in while the dir is private, refused with a hint when it is not, and refused through a relay", async () => {
+        const dir = privateDir();
+        const socketPath = join(dir, "daemon.sock");
+        const ring = new TokenRing(new MemoryTokenStore([{ token: "local-tok", kind: "local" }]), () => "minted");
+        // The daemon's shape: mark socket connections, decide, answer.
+        const server = createHttpServer((req, res) => {
+            const auth = authenticateRequest(ring, null, req, dir, () => { });
+            res.writeHead(auth.ok ? 200 : 401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(auth.ok ? { kind: auth.record.kind } : { error: "Unauthorized" }));
+        });
+        server.on("connection", (s) => markUnixConnection(s));
+        await new Promise((r) => server.listen(socketPath, r));
+        // A plain TCP relay in front of the socket, as `ssh -L` or socat would be.
+        const piped = new Set();
+        const relay = createNetServer((c) => {
+            const upstream = netConnect(socketPath);
+            piped.add(c).add(upstream);
+            c.pipe(upstream).pipe(c);
+        });
+        await new Promise((r) => relay.listen(0, "127.0.0.1", r));
+        const relayPort = relay.address().port;
+        try {
+            const endpoint = { baseUrl: "http://127.0.0.1:1", token: null, port: "1", socketPath };
+            assert.deepEqual(await daemonRequest(endpoint, "/api/status"), { kind: "local" });
+            chmodSync(dir, 0o755);
+            await assert.rejects(daemonRequest(endpoint, "/api/status"), /chmod 700 ~\/\.brane/);
+            chmodSync(dir, 0o700);
+            assert.deepEqual(await daemonRequest(endpoint, "/api/status"), { kind: "local" });
+            // What a web page can send with no preflight, through the relay.
+            const res = await fetch(`http://127.0.0.1:${relayPort}/api/spawn`, {
+                method: "POST",
+                headers: { Origin: "https://evil.example", "Content-Type": "text/plain" },
+                body: "{}",
+            });
+            assert.equal(res.status, 401);
+        }
+        finally {
+            chmodSync(dir, 0o700);
+            // fetch keeps its connection alive; don't wait for it to idle out.
+            for (const sock of piped)
+                sock.destroy();
+            await new Promise((r) => relay.close(() => r()));
+            server.closeAllConnections();
+            await new Promise((r) => server.close(() => r()));
+        }
+    });
+});
+describe("doctor's reach check", { skip: unixOnly }, () => {
+    it("passes with a secret; without one it needs a socket and a private dir, and a token file is no way in", () => {
+        const dir = privateDir();
+        const base = { secret: undefined, socketPath: undefined, braneDir: dir };
+        assert.equal(shellReachProblem({ ...base, secret: "agent" }), null);
+        assert.match(shellReachProblem(base) ?? "", /not listening on its socket/);
+        writeFileSync(join(dir, ".daemon_token"), "tok\n");
+        assert.match(shellReachProblem(base) ?? "", /not listening on its socket/);
+        assert.equal(shellReachProblem({ ...base, socketPath: join(dir, "daemon.sock") }), null);
+        chmodSync(dir, 0o755);
+        assert.match(shellReachProblem({ ...base, socketPath: join(dir, "daemon.sock") }) ?? "", /chmod 700/);
+    });
+});
+describe("doctor's token file check", () => {
+    it("says nothing without a file, or before this version's daemon has started once", () => {
+        const db = createTestDb();
+        const path = join(privateDir(), ".daemon_token");
+        assert.equal(tokenFileCheck(db, path), null);
+        // An older brane's file, its token still the live local row: the next
+        // daemon start retires it, and until then there is nothing to report.
+        new DbTokenStore(db).insert(hashToken("old-local"), "local", "this machine", 1);
+        writeFileSync(path, "old-local\n");
+        assert.equal(tokenFileCheck(db, path), null);
+    });
+    it("reports the emptied leftover, and a file the daemon could not empty by how its token stands", () => {
+        const db = createTestDb();
+        const path = join(privateDir(), ".daemon_token");
+        const store = new DbTokenStore(db);
+        store.insert(hashToken("old-local"), "local", "this machine", 1);
+        store.insert(hashToken("legacy"), "device", "melded before hashing", 1, { used: true });
+        writeFileSync(path, "old-local\n");
+        bootstrapTokens(db, { tokenFile: path, now: 2 });
+        assert.match(tokenFileCheck(db, path)?.detail ?? "", /empty leftover/);
+        writeFileSync(path, "old-local\n");
+        assert.match(tokenFileCheck(db, path)?.detail ?? "", /could not empty.*no longer works/);
+        writeFileSync(path, "legacy\n");
+        assert.match(tokenFileCheck(db, path)?.detail ?? "", /still holds a token that works/);
+    });
+});
+describe("doctor on a leftover .daemon_token", () => {
+    it("says the empty file can go, and warns when one still holds a token", () => {
+        const empty = leftoverTokenFile("/b/.daemon_token", "empty");
+        assert.equal(empty.status, "warn");
+        assert.match(empty.detail, /empty leftover.*rm \/b\/\.daemon_token/);
+        assert.match(leftoverTokenFile("/b/.daemon_token", "dead").detail, /could not empty.*no longer works.*rm /);
+        assert.match(leftoverTokenFile("/b/.daemon_token", "live").detail, /still holds a token that works.*rm /);
+    });
+});
+//# sourceMappingURL=socket-account.test.js.map