pombus 0.1.0 → 0.1.2

package/dist/installer.test.js

@@ -1,344 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, writeFileSync, rmSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { runInit } from "./init.js";
-import { runDoctor } from "./doctor.js";
-import { clientTargets, writeJsonConfig, isInsideHome, printableJson, printableCodexToml, ConfigWriteError, } from "./clients.js";
-import { FakeCore, authMeInbox, authMePod, createdInbox } from "./testutil.js";
-// Obviously-fake tokens — never a real secret (AGENTS.md §9).
-const BROAD_KEY = "pk_test_broad_pod_scope_FAKE";
-const BASE = "https://core.test/v0";
-/** A temp HOME, cleaned up after each use. */
-function tempHome() {
-    const home = mkdtempSync(join(tmpdir(), "pombus-home-"));
-    return { home, cleanup: () => rmSync(home, { recursive: true, force: true }) };
-}
-/** A line sink that records init/doctor human output for assertions. */
-function sink() {
-    const lines = [];
-    return { lines, out: (l) => lines.push(l) };
-}
-// ---------------------------------------------------------------------------------------------------
-// clients.ts — the write is the sharp edge: merge, idempotent, atomic-ish, 0600, never outside HOME.
-// ---------------------------------------------------------------------------------------------------
-test("writeJsonConfig MERGES — preserves every existing key, adds only mcpServers.pombus", () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const path = join(home, ".claude.json");
-        writeFileSync(path, JSON.stringify({
-            projects: { "/some/proj": { history: [1, 2, 3] } },
-            theme: "dark",
-            mcpServers: { other: { command: "node", args: ["x.js"] } },
-        }));
-        writeJsonConfig(path, home, BROAD_KEY);
-        const after = JSON.parse(readFileSync(path, "utf8"));
-        // Untouched keys survive byte-for-value.
-        assert.deepEqual(after["projects"], { "/some/proj": { history: [1, 2, 3] } });
-        assert.equal(after["theme"], "dark");
-        // The pre-existing OTHER server survives; ours is added alongside.
-        assert.deepEqual(after["mcpServers"]["other"], { command: "node", args: ["x.js"] });
-        assert.deepEqual(after["mcpServers"]["pombus"], {
-            command: "npx",
-            args: ["-y", "pombus", "mcp"],
-            env: { POMBUS_API_KEY: BROAD_KEY },
-        });
-    }
-    finally {
-        cleanup();
-    }
-});
-test("writeJsonConfig is IDEMPOTENT — running twice yields exactly one pombus entry", () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const path = join(home, ".cursor", "mcp.json");
-        writeJsonConfig(path, home, BROAD_KEY);
-        writeJsonConfig(path, home, BROAD_KEY);
-        const after = JSON.parse(readFileSync(path, "utf8"));
-        const servers = after["mcpServers"];
-        assert.deepEqual(Object.keys(servers), ["pombus"]);
-    }
-    finally {
-        cleanup();
-    }
-});
-test("writeJsonConfig creates a fresh file when none exists (and its parent dir)", () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const path = join(home, ".gemini", "settings.json");
-        writeJsonConfig(path, home, BROAD_KEY);
-        const after = JSON.parse(readFileSync(path, "utf8"));
-        assert.equal(after["mcpServers"]["pombus"]["env"]["POMBUS_API_KEY"], BROAD_KEY);
-    }
-    finally {
-        cleanup();
-    }
-});
-test("writeJsonConfig REFUSES to clobber a corrupt existing config (never destroys real state)", () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const path = join(home, ".claude.json");
-        writeFileSync(path, "{ this is not valid json ");
-        assert.throws(() => writeJsonConfig(path, home, BROAD_KEY), (e) => e instanceof ConfigWriteError && e.code === "corrupt_config");
-        // The broken file is left exactly as it was — not overwritten.
-        assert.equal(readFileSync(path, "utf8"), "{ this is not valid json ");
-    }
-    finally {
-        cleanup();
-    }
-});
-test("writeJsonConfig REFUSES a target outside HOME (never writes into a project repo)", () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const outside = join(tmpdir(), "not-home-" + process.pid, "mcp.json");
-        assert.throws(() => writeJsonConfig(outside, home, BROAD_KEY), (e) => e instanceof ConfigWriteError && e.code === "outside_home");
-    }
-    finally {
-        cleanup();
-    }
-});
-test("isInsideHome accepts HOME and children, rejects siblings and the project tree", () => {
-    const home = join(tmpdir(), "h");
-    assert.ok(isInsideHome(join(home, ".cursor", "mcp.json"), home));
-    assert.ok(isInsideHome(home, home));
-    assert.ok(!isInsideHome(join(tmpdir(), "hother", "x.json"), home));
-    assert.ok(!isInsideHome("/etc/mcp.json", home));
-});
-test("the config file carrying the key is 0600 on POSIX (owner-only)", { skip: process.platform === "win32" }, () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const path = join(home, ".cursor", "mcp.json");
-        writeJsonConfig(path, home, BROAD_KEY);
-        const mode = statSync(path).mode & 0o777;
-        assert.equal(mode, 0o600, `expected 0600, got ${mode.toString(8)}`);
-    }
-    finally {
-        cleanup();
-    }
-});
-test("the client table: claude-code/cursor/gemini are WRITE (json), codex is PRINT (toml)", () => {
-    const home = join(tmpdir(), "h");
-    const t = clientTargets(home);
-    const by = Object.fromEntries(t.map((c) => [c.id, c]));
-    assert.equal(by["claude-code"].mode, "json");
-    assert.equal(by["cursor"].mode, "json");
-    assert.equal(by["gemini"].mode, "json");
-    assert.equal(by["codex"].mode, "print");
-    // Every target carries a cited source and a path under HOME.
-    for (const c of t) {
-        assert.ok(c.source.length > 0, `${c.id} missing source`);
-        assert.ok(isInsideHome(c.path, home), `${c.id} path escapes HOME`);
-    }
-});
-test("printable blocks: JSON has the standard mcpServers wrapper; Codex TOML is a [mcp_servers.pombus] table", () => {
-    const j = JSON.parse(printableJson("<KEY>"));
-    assert.deepEqual(j.mcpServers.pombus, {
-        command: "npx",
-        args: ["-y", "pombus", "mcp"],
-        env: { POMBUS_API_KEY: "<KEY>" },
-    });
-    const toml = printableCodexToml("<KEY>");
-    assert.ok(toml.includes("[mcp_servers.pombus]"));
-    assert.ok(toml.includes('command = "npx"'));
-    assert.ok(toml.includes("POMBUS_API_KEY = '<KEY>'"));
-});
-// ---------------------------------------------------------------------------------------------------
-// runInit key contract (option A): the key the user provided is persisted verbatim — no mint, no
-// narrowing. The agent is the account's full operator and runs with the key the user chose to give.
-// ---------------------------------------------------------------------------------------------------
-test("init persists EXACTLY the provided key — never mints a new one (no POST /api-keys)", async () => {
-    const { home, cleanup } = tempHome();
-    try {
-        // --create-inbox on a pod key: an inbox is created, but the key written is still the given one.
-        const fake = new FakeCore()
-            .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMePod())
-            .on("POST", (u) => u.pathname.endsWith("/inboxes"), createdInbox("inb_new", "agent@pombus.com"));
-        const { out } = sink();
-        const res = await runInit({
-            apiKey: BROAD_KEY,
-            createInbox: true,
-            client: "cursor",
-            home,
-            baseUrl: BASE,
-            fetchImpl: fake.fetch,
-            locale: "en-US",
-            out,
-        });
-        assert.deepEqual(res.written, ["cursor"]);
-        assert.equal(res.inboxId, "inb_new"); // --create-inbox still works, independent of the key
-        const cfg = JSON.parse(readFileSync(join(home, ".cursor", "mcp.json"), "utf8"));
-        assert.equal(cfg.mcpServers.pombus.env.POMBUS_API_KEY, BROAD_KEY, "the provided key is persisted as-is");
-        // No key was minted — the installer never hits POST /api-keys.
-        assert.ok(!fake.requests.some((r) => r.method === "POST" && r.url.includes("/api-keys")));
-    }
-    finally {
-        cleanup();
-    }
-});
-test("init with an inbox-scoped key persists it as-is (no /api-keys call)", async () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const fake = new FakeCore().on("GET", (u) => u.pathname.endsWith("/auth/me"), authMeInbox("inb_fixed"));
-        const { out } = sink();
-        const res = await runInit({
-            apiKey: BROAD_KEY, // the value is opaque to init; it is written verbatim
-            client: "cursor",
-            home,
-            baseUrl: BASE,
-            fetchImpl: fake.fetch,
-            locale: "en-US",
-            out,
-        });
-        assert.deepEqual(res.written, ["cursor"]);
-        assert.ok(!fake.requests.some((r) => r.url.includes("/api-keys")));
-        const cfg = JSON.parse(readFileSync(join(home, ".cursor", "mcp.json"), "utf8"));
-        assert.equal(cfg.mcpServers.pombus.env.POMBUS_API_KEY, BROAD_KEY);
-    }
-    finally {
-        cleanup();
-    }
-});
-// ---------------------------------------------------------------------------------------------------
-// --print writes NOTHING.
-// ---------------------------------------------------------------------------------------------------
-test("init --print writes NO file and emits the block", async () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const fake = new FakeCore().on("GET", (u) => u.pathname.endsWith("/auth/me"), authMeInbox("inb_fixed"));
-        const { lines, out } = sink();
-        const res = await runInit({
-            apiKey: BROAD_KEY,
-            print: true,
-            client: "cursor",
-            home,
-            baseUrl: BASE,
-            fetchImpl: fake.fetch,
-            locale: "en-US",
-            out,
-        });
-        assert.equal(res.printed, true);
-        assert.deepEqual(res.written, []);
-        // No config file was created.
-        assert.throws(() => readFileSync(join(home, ".cursor", "mcp.json"), "utf8"));
-        assert.ok(lines.some((l) => l.includes('"pombus"')));
-    }
-    finally {
-        cleanup();
-    }
-});
-test("init --print with NO key emits a placeholder block, makes no network call, writes nothing", async () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const fake = new FakeCore().on("GET", () => true, { json: {} });
-        const { lines, out } = sink();
-        const res = await runInit({
-            print: true,
-            client: "cursor",
-            home,
-            baseUrl: BASE,
-            fetchImpl: fake.fetch,
-            locale: "en-US",
-            out,
-        });
-        assert.equal(res.printed, true);
-        assert.equal(fake.requests.length, 0, "no network call without a key");
-        assert.ok(lines.some((l) => l.includes("<YOUR_POMBUS_API_KEY>")));
-    }
-    finally {
-        cleanup();
-    }
-});
-test("init on a PRINT-only client (codex) prints TOML and writes no file", async () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const fake = new FakeCore().on("GET", (u) => u.pathname.endsWith("/auth/me"), authMeInbox("inb_fixed"));
-        const { lines, out } = sink();
-        const res = await runInit({
-            apiKey: BROAD_KEY,
-            client: "codex",
-            home,
-            baseUrl: BASE,
-            fetchImpl: fake.fetch,
-            locale: "en-US",
-            out,
-        });
-        assert.deepEqual(res.written, []);
-        assert.deepEqual(res.printedFor, ["codex"]);
-        assert.throws(() => readFileSync(join(home, ".codex", "config.toml"), "utf8"));
-        assert.ok(lines.some((l) => l.includes("[mcp_servers.pombus]")));
-    }
-    finally {
-        cleanup();
-    }
-});
-// ---------------------------------------------------------------------------------------------------
-// doctor — reports scope / errors, read-only.
-// ---------------------------------------------------------------------------------------------------
-test("doctor reports the scope of a valid key", async () => {
-    const fake = new FakeCore().on("GET", (u) => u.pathname.endsWith("/auth/me"), authMePod());
-    const { lines, out } = sink();
-    const res = await runDoctor({ apiKey: BROAD_KEY, baseUrl: BASE, fetchImpl: fake.fetch, locale: "en-US", out });
-    assert.equal(res.ok, true);
-    assert.equal(res.scope, "pod");
-    assert.ok(lines.some((l) => l.includes("pod")));
-    // Read-only: the single request was the /auth/me GET.
-    assert.equal(fake.requests.length, 1);
-    assert.equal(fake.requests[0].method, "GET");
-});
-test("doctor with no key reports no_api_key and makes no network call", async () => {
-    const fake = new FakeCore().on("GET", () => true, { json: {} });
-    const { out } = sink();
-    const res = await runDoctor({ baseUrl: BASE, fetchImpl: fake.fetch, locale: "en-US", out });
-    assert.equal(res.ok, false);
-    assert.equal(res.code, "no_api_key");
-    assert.equal(fake.requests.length, 0);
-});
-test("doctor with an invalid key reports auth_failed (401/403/404 collapse to not_found -> auth_failed)", async () => {
-    const fake = new FakeCore().on("GET", (u) => u.pathname.endsWith("/auth/me"), { status: 401, json: { code: "unauthorized" } });
-    const { out } = sink();
-    const res = await runDoctor({ apiKey: "pk_test_bad_FAKE", baseUrl: BASE, fetchImpl: fake.fetch, locale: "en-US", out });
-    assert.equal(res.ok, false);
-    assert.equal(res.code, "auth_failed");
-});
-test("doctor with an unreachable core reports network", async () => {
-    const fetchImpl = async () => {
-        throw new TypeError("fetch failed");
-    };
-    const { out } = sink();
-    const res = await runDoctor({ apiKey: "pk_test_x_FAKE", baseUrl: BASE, fetchImpl, locale: "en-US", out });
-    assert.equal(res.ok, false);
-    assert.equal(res.code, "network");
-});
-// ---------------------------------------------------------------------------------------------------
-// the key never leaks into human output (log hygiene, AGENTS.md §5).
-// ---------------------------------------------------------------------------------------------------
-test("no human line printed by init or doctor ever contains the BROAD key", async () => {
-    const { home, cleanup } = tempHome();
-    try {
-        const fake = new FakeCore()
-            .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMePod())
-            .on("POST", (u) => u.pathname.endsWith("/inboxes"), createdInbox("inb_new", "agent@pombus.com"));
-        const initSink = sink();
-        await runInit({
-            apiKey: BROAD_KEY,
-            createInbox: true,
-            client: "cursor",
-            home,
-            baseUrl: BASE,
-            fetchImpl: fake.fetch,
-            locale: "pt-BR",
-            out: initSink.out,
-        });
-        for (const l of initSink.lines)
-            assert.ok(!l.includes(BROAD_KEY), `broad key leaked: ${l}`);
-        const docSink = sink();
-        const fake2 = new FakeCore().on("GET", (u) => u.pathname.endsWith("/auth/me"), authMePod());
-        await runDoctor({ apiKey: BROAD_KEY, baseUrl: BASE, fetchImpl: fake2.fetch, locale: "es-419", out: docSink.out });
-        for (const l of docSink.lines)
-            assert.ok(!l.includes(BROAD_KEY), `broad key leaked (doctor): ${l}`);
-    }
-    finally {
-        cleanup();
-    }
-});

package/dist/security.test.js

@@ -1,111 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { CoreClient, CoreError } from "./client.js";
-import { ScopeBinding } from "./scope.js";
-import { specByName, callTool } from "./tools.js";
-import { buildServer } from "./server.js";
-import { FakeCore, authMeInbox, authMePod } from "./testutil.js";
-const KEY = "pk_live_secret_do_not_log_abcdef";
-async function ctxFor(fake) {
-    const client = new CoreClient({ apiKey: KEY, baseUrl: "https://core.test/v0", fetchImpl: fake.fetch });
-    const scope = await ScopeBinding.resolve(client);
-    return { client, scope };
-}
-test("the API key rides ONLY in the Authorization header — never in a URL", async () => {
-    const fake = new FakeCore()
-        .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMeInbox("inb_x"))
-        .on("GET", () => true, { json: { ok: true } });
-    const ctx = await ctxFor(fake);
-    await callTool(specByName("list_messages", ctx.scope), {}, ctx);
-    await callTool(specByName("get_message", ctx.scope), { message_id: "m1" }, ctx);
-    assert.ok(fake.requests.length >= 2);
-    for (const r of fake.requests) {
-        assert.ok(!r.url.includes(KEY), `key leaked into URL: ${r.url}`);
-        assert.equal(r.headers["authorization"], `Bearer ${KEY}`);
-        // No other header carries it.
-        for (const [k, v] of Object.entries(r.headers)) {
-            if (k !== "authorization")
-                assert.ok(!v.includes(KEY), `key leaked into header ${k}`);
-        }
-    }
-});
-test("a transport error message never contains the key or the URL", async () => {
-    const fetchImpl = async () => {
-        throw new TypeError("fetch failed: connect ECONNREFUSED https://core.test/v0?api_key=" + KEY);
-    };
-    const client = new CoreClient({ apiKey: KEY, baseUrl: "https://core.test/v0", fetchImpl });
-    await assert.rejects(() => client.get("/inboxes"), (e) => {
-        assert.ok(e instanceof CoreError);
-        assert.ok(!e.message.includes(KEY), "key must not appear in the error");
-        assert.ok(!e.message.includes("core.test"), "URL must not appear in the error");
-        assert.equal(e.code, "network");
-        return true;
-    });
-});
-test("auth failure does NOT reveal whether an inbox exists (403 and 404 collapse to not_found)", async () => {
-    const forbidden = new FakeCore()
-        .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMePod())
-        .on("GET", (u) => /\/inboxes\/inb_q$/.test(u.pathname), { status: 403, json: { code: "forbidden" } });
-    const missing = new FakeCore()
-        .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMePod())
-        .on("GET", (u) => /\/inboxes\/inb_q$/.test(u.pathname), { status: 404, json: { code: "not_found" } });
-    const errOf = async (fake) => {
-        const ctx = await ctxFor(fake);
-        try {
-            await callTool(specByName("get_thread", ctx.scope), { inbox_id: "inb_q", thread_id: "t1" }, ctx);
-            return "no-error";
-        }
-        catch (e) {
-            return e.code ?? "unknown";
-        }
-    };
-    // A key denied the inbox (403) and a key facing a missing inbox (404) get the IDENTICAL answer, so
-    // the model can never use the error to enumerate which inboxes exist.
-    assert.equal(await errOf(forbidden), "not_found");
-    assert.equal(await errOf(missing), "not_found");
-});
-test("end-to-end over MCP: list tools and call one through the real server adapter", async () => {
-    const fake = new FakeCore()
-        .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMeInbox("inb_e2e"))
-        .on("GET", (u) => /\/inboxes\/inb_e2e\/threads$/.test(u.pathname), {
-        json: { threads: [{ tid: "thr_1" }] },
-    });
-    const core = new CoreClient({ apiKey: KEY, baseUrl: "https://core.test/v0", fetchImpl: fake.fetch });
-    const server = await buildServer(core);
-    const [clientT, serverT] = InMemoryTransport.createLinkedPair();
-    const client = new Client({ name: "test-client", version: "0" });
-    await Promise.all([server.connect(serverT), client.connect(clientT)]);
-    const listed = await client.listTools();
-    assert.ok(listed.tools.some((t) => t.name === "list_threads"));
-    // Single-inbox key: no tool exposes inbox_id.
-    for (const t of listed.tools) {
-        const props = (t.inputSchema?.properties ?? {});
-        assert.ok(!("inbox_id" in props));
-    }
-    const res = await client.callTool({ name: "list_threads", arguments: {} });
-    assert.equal(res.isError ?? false, false);
-    const content = res.content;
-    const payload = JSON.parse(content[0].text);
-    assert.equal(payload.threads[0].tid, "thr_1");
-    await client.close();
-    await server.close();
-});
-test("end-to-end: a core error surfaces as an isError tool result with a stable code (no leak)", async () => {
-    const fake = new FakeCore()
-        .on("GET", (u) => u.pathname.endsWith("/auth/me"), authMeInbox("inb_e2e"))
-        .on("GET", () => true, { status: 404, json: { code: "not_found" } });
-    const core = new CoreClient({ apiKey: KEY, baseUrl: "https://core.test/v0", fetchImpl: fake.fetch });
-    const server = await buildServer(core);
-    const [clientT, serverT] = InMemoryTransport.createLinkedPair();
-    const client = new Client({ name: "test-client", version: "0" });
-    await Promise.all([server.connect(serverT), client.connect(clientT)]);
-    const res = await client.callTool({ name: "get_message", arguments: { message_id: "m_x" } });
-    assert.equal(res.isError, true);
-    const content = res.content;
-    assert.equal(content[0].text, "error: not_found");
-    assert.ok(!content[0].text.includes(KEY));
-    await client.close();
-    await server.close();
-});

package/dist/testutil.js

@@ -1,117 +0,0 @@
-// Test doubles — a fake core (a FetchLike that records every request and returns programmed replies)
-// and a captured-request shape the tests assert against. Not a *.test.ts, so the test runner does not
-// execute it as a suite. All fixtures are written from scratch (AGENTS.md §9): invented ids, no real
-// data.
-export class FakeCore {
-    requests = [];
-    routes = [];
-    /** Register a route. Routes are matched in order; the first match wins. */
-    on(method, match, reply) {
-        this.routes.push({ method, match, reply });
-        return this;
-    }
-    /** A FetchLike bound to this fake. Records the request, then returns the first matching route's
-     *  reply, or a 404 when nothing matches (so an unexpected call fails closed, like the real core). */
-    fetch = async (rawUrl, init) => {
-        const url = new URL(rawUrl);
-        const headers = lowerHeaders(init.headers);
-        let body;
-        if (typeof init.body === "string" && init.body.length > 0) {
-            try {
-                body = JSON.parse(init.body);
-            }
-            catch {
-                body = init.body;
-            }
-        }
-        const captured = { method: init.method ?? "GET", url: rawUrl, headers, body };
-        this.requests.push(captured);
-        const route = this.routes.find((r) => r.method === captured.method && r.match(url));
-        const reply = route
-            ? typeof route.reply === "function"
-                ? route.reply(captured, url)
-                : route.reply
-            : { status: 404, json: { code: "not_found" } };
-        return makeResponse(reply);
-    };
-}
-function lowerHeaders(h) {
-    const out = {};
-    if (!h)
-        return out;
-    if (h instanceof Headers) {
-        h.forEach((v, k) => (out[k.toLowerCase()] = v));
-    }
-    else if (Array.isArray(h)) {
-        for (const pair of h) {
-            const k = pair[0];
-            const v = pair[1];
-            if (k !== undefined && v !== undefined)
-                out[k.toLowerCase()] = v;
-        }
-    }
-    else {
-        for (const [k, v] of Object.entries(h))
-            out[k.toLowerCase()] = String(v);
-    }
-    return out;
-}
-function makeResponse(reply) {
-    const status = reply.status ?? 200;
-    const hasBody = reply.json !== undefined;
-    // A 204/205 MUST have a null body (undici throws on any body, even ""), matching the real core's
-    // no-content replies (e.g. a DELETE).
-    const nullBodyStatus = status === 204 || status === 205 || status === 304;
-    const body = hasBody ? JSON.stringify(reply.json) : nullBodyStatus ? null : "";
-    return new Response(body, {
-        status,
-        headers: hasBody ? { "content-type": "application/json" } : {},
-    });
-}
-/** An /auth/me reply for an inbox-scoped key (single implied inbox). */
-export function authMeInbox(inboxId) {
-    return {
-        json: {
-            scope_type: "inbox",
-            scope_id: inboxId,
-            organization_id: "org_test",
-            pod_id: "pod_test",
-            inbox_id: inboxId,
-            api_key_id: "key_test",
-            permissions: null,
-        },
-    };
-}
-/** An /auth/me reply for a pod-scoped key (reaches many inboxes). */
-export function authMePod() {
-    return {
-        json: {
-            scope_type: "pod",
-            scope_id: "pod_test",
-            organization_id: "org_test",
-            pod_id: "pod_test",
-            inbox_id: null,
-            api_key_id: "key_test",
-            permissions: null,
-        },
-    };
-}
-/** A POST /v0/inboxes reply (the shape the core returns: inbox_id + email). Invented ids only (§9). */
-export function createdInbox(inboxId, email) {
-    return { json: { inbox_id: inboxId, email } };
-}
-/** An /auth/me reply for a SCOPED pod key — a real permissions object drives the catalog gate. Pass
- *  the permissions the human granted the key; everything else uses invented ids (§9). */
-export function authMeScoped(permissions, overrides = {}) {
-    return {
-        json: {
-            scope_type: overrides.scope_type ?? "pod",
-            scope_id: "pod_test",
-            organization_id: "org_test",
-            pod_id: overrides.pod_id === undefined ? "pod_test" : overrides.pod_id,
-            inbox_id: overrides.inbox_id ?? null,
-            api_key_id: "key_test",
-            permissions,
-        },
-    };
-}