@anteros/core 0.0.44 → 0.0.47

package/tests/tool-runtime.test.ts

@@ -0,0 +1,291 @@
+import { describe, it, expect, afterAll } from "bun:test";
+import { Agent, define, v } from "../index";
+import { cfg } from "../server/config";
+import { createAgents, syncAgents } from "../lib/agents";
+import { AppError } from "../lib/error";
+import { joiToJsonSchema } from "../lib/jsonSchema";
+import {
+    anthropicText,
+    anthropicTool,
+    anthropicToolCalls,
+    at,
+    fakeProvider,
+    openaiText,
+    openaiTool,
+    openaiToolCalls,
+    request,
+    type Fake,
+} from "./fixtures/fake-provider";
+
+/**
+ * The tool runtime — what a tool receives, what the model reads back, and the
+ * guards around it (codes, media, bounded concurrency, counters, descriptions).
+ */
+
+const servers: Fake[] = [];
+function track(fake: Fake): Fake {
+    servers.push(fake);
+    return fake;
+}
+
+afterAll(() => {
+    for (const server of servers) server.stop();
+});
+
+function makeAgent(
+    tools: Record<string, any>,
+    provider: { baseUrl: string; protocol?: "openai" | "anthropic" },
+    overrides: Record<string, any> = {},
+) {
+    return new Agent({
+        id: "tools",
+        description: "Tool runtime test agent.",
+        instructions: "Use the tools.",
+        provider: {
+            model: "test-model",
+            apiKey: "test-key",
+            protocol: provider.protocol ?? "openai",
+            baseUrl: provider.baseUrl,
+            options: { retries: 0 },
+        },
+        tools,
+        ...overrides,
+    } as any);
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe("tool errors carry a code", () => {
+    it("serializes the AppError code for the model, and counts it", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("order", { id: "A-1" }) : openaiText("sorry")));
+
+        const agent = makeAgent({
+            order: define.Tool({
+                id: "order",
+                description: "Reads an order",
+                inputSchema: v.object({ id: v.string().required() }),
+                execute: () => {
+                    throw new AppError("No order 'A-1'", { status: 404, code: "ORDER_NOT_FOUND" });
+                },
+            }),
+        }, { baseUrl: provider.url });
+
+        const result = await agent.generate("go");
+
+        expect(at(result.toolResults, 0).errorCode).toBe("ORDER_NOT_FOUND");
+        expect(request(provider, 1).body.messages[3].content).toBe("Error [ORDER_NOT_FOUND]: No order 'A-1'");
+        expect(result.toolStats).toMatchObject({ calls: 1, errors: 1, byCode: { ORDER_NOT_FOUND: 1 }, timeouts: 0 });
+    });
+
+    it("codes a timeout, and keeps the run going", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("slow", {}) : openaiText("gave up")));
+
+        const agent = makeAgent({
+            slow: define.Tool({
+                id: "slow",
+                description: "Never answers in time",
+                inputSchema: v.object({}),
+                timeoutMs: 5,
+                execute: () => sleep(50),
+            }),
+        }, { baseUrl: provider.url });
+
+        const result = await agent.generate("go");
+
+        expect(at(result.toolResults, 0).errorCode).toBe("AGENT_TOOL_TIMEOUT");
+        expect(result.toolStats.timeouts).toBe(1);
+        expect(result.finishReason).toBe("stop");
+    });
+});
+
+describe("tool media results", () => {
+    const chart = () => define.Tool({
+        id: "chart",
+        description: "Builds a chart",
+        inputSchema: v.object({}),
+        execute: () => ({
+            content: [
+                { type: "text", text: "Here is the chart" },
+                { type: "image", data: "QUJD", mimeType: "image/png" },
+            ],
+        }),
+    });
+
+    it("hands an image to Anthropic as a tool_result block", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? anthropicTool("chart", {}) : anthropicText("done")));
+
+        const agent = makeAgent({ chart: chart() }, { baseUrl: provider.url, protocol: "anthropic" });
+        await agent.generate("go");
+
+        const messages = request(provider, 1).body.messages;
+        const toolResult = messages
+            .flatMap((message: any) => Array.isArray(message.content) ? message.content : [])
+            .find((block: any) => block.type === "tool_result");
+
+        expect(toolResult.content).toEqual([
+            { type: "text", text: "Here is the chart" },
+            { type: "image", source: { type: "base64", media_type: "image/png", data: "QUJD" } },
+        ]);
+    });
+
+    it("degrades to a text marker on OpenAI, whose tool message is text-only", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("chart", {}) : openaiText("done")));
+
+        const agent = makeAgent({ chart: chart() }, { baseUrl: provider.url });
+        await agent.generate("go");
+
+        expect(request(provider, 1).body.messages[3].content).toBe("Here is the chart\n[image: image/png]");
+    });
+});
+
+describe("bounded tool parallelism", () => {
+    it("runs read-only tools together, at most `maxParallelToolCalls` at a time", async () => {
+        const state = { running: 0, peak: 0 };
+        const provider = track(fakeProvider((_body, _req, hits) => hits === 1
+            ? openaiToolCalls(Array.from({ length: 6 }, (_, index) => ({ name: "read", args: {}, id: `c${index}` })))
+            : openaiText("done")));
+
+        const agent = makeAgent({
+            read: define.Tool({
+                id: "read",
+                description: "Reads something",
+                readOnly: true,
+                inputSchema: v.object({}),
+                execute: async () => {
+                    state.running += 1;
+                    state.peak = Math.max(state.peak, state.running);
+                    await sleep(10);
+                    state.running -= 1;
+                    return { ok: true };
+                },
+            }),
+        }, { baseUrl: provider.url }, { maxParallelToolCalls: 2 });
+
+        const result = await agent.generate("go");
+
+        expect(result.toolResults).toHaveLength(6);
+        expect(state.peak).toBe(2);
+    });
+
+    it("keeps writes sequential, even in a batch", async () => {
+        const state = { running: 0, peak: 0 };
+        const provider = track(fakeProvider((_body, _req, hits) => hits === 1
+            ? openaiToolCalls([{ name: "write", args: {} }, { name: "write", args: {} }, { name: "write", args: {} }])
+            : openaiText("done")));
+
+        const agent = makeAgent({
+            write: define.Tool({
+                id: "write",
+                description: "Writes something",
+                inputSchema: v.object({}),
+                execute: async () => {
+                    state.running += 1;
+                    state.peak = Math.max(state.peak, state.running);
+                    await sleep(5);
+                    state.running -= 1;
+                    return { ok: true };
+                },
+            }),
+        }, { baseUrl: provider.url });
+
+        await agent.generate("go");
+
+        expect(state.peak).toBe(1);
+    });
+
+    it("bounds the calls of a step that forced parallelism", async () => {
+        const state = { running: 0, peak: 0 };
+        const provider = track(fakeProvider((_body, _req, hits) => hits === 1
+            ? openaiToolCalls(Array.from({ length: 5 }, (_, index) => ({ name: "job", args: {}, id: `j${index}` })))
+            : openaiText("done")));
+
+        const agent = makeAgent({
+            job: define.Tool({
+                id: "job",
+                description: "Runs a job",
+                inputSchema: v.object({}),
+                execute: async () => {
+                    state.running += 1;
+                    state.peak = Math.max(state.peak, state.running);
+                    await sleep(10);
+                    state.running -= 1;
+                    return { ok: true };
+                },
+            }),
+        }, { baseUrl: provider.url }, { parallelTools: true, maxParallelToolCalls: 2 });
+
+        await agent.generate("go");
+
+        expect(state.peak).toBe(2);
+    });
+});
+
+describe("tool stats", () => {
+    it("aggregates calls, errors and duration", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) => hits === 1
+            ? openaiToolCalls([{ name: "ok", args: {} }, { name: "boom", args: {} }])
+            : openaiText("done")));
+
+        const agent = makeAgent({
+            ok: define.Tool({
+                id: "ok",
+                description: "Works",
+                inputSchema: v.object({}),
+                execute: () => ({ ok: true }),
+            }),
+            boom: define.Tool({
+                id: "boom",
+                description: "Fails",
+                inputSchema: v.object({}),
+                execute: () => {
+                    throw new AppError("kaput", { status: 500, code: "KAPUT" });
+                },
+            }),
+        }, { baseUrl: provider.url });
+
+        const result = await agent.generate("go");
+
+        expect(result.toolStats.calls).toBe(2);
+        expect(result.toolStats.errors).toBe(1);
+        expect(result.toolStats.byCode).toEqual({ KAPUT: 1 });
+        expect(result.toolStats.durationMs).toBeGreaterThanOrEqual(0);
+    });
+});
+
+describe("tool schema fidelity", () => {
+    it("closes the object and publishes defaults", () => {
+        const schema = joiToJsonSchema(v.object({
+            city: v.string().required(),
+            days: v.number().default(1),
+        }));
+        expect(schema.additionalProperties).toBe(false);
+        expect(schema.properties.days.default).toBe(1);
+        expect(schema.required).toEqual(["city"]);
+    });
+
+    it("keeps the object open when Joi allows unknown keys", () => {
+        const schema = joiToJsonSchema(v.object({ a: v.string() }).unknown());
+        expect(schema.additionalProperties).toBe(true);
+    });
+});
+
+describe("tool descriptions at load time", () => {
+    it("skips a file tool without a description, and keeps the described one", async () => {
+        const previous = cfg.tenants;
+        try {
+            cfg.tenants = [{ id: "tool-tenant", dir: "packages/core/tests/fixtures/tool-tenant", database: { uri: "mongodb://localhost:27017/none" } }] as any;
+            await syncAgents();
+
+            const report = createAgents("tool-tenant").get("report")!;
+            expect(report.hasTool("chart")).toBe(true);
+            expect(report.hasTool("hidden")).toBe(false);
+        } finally {
+            cfg.tenants = previous;
+            await syncAgents().catch(() => { });
+        }
+    });
+});

package/tests/tool-types.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { define, v } from "../index";
+
+/**
+ * Compile-time contract of `define.Tool` — checked by `tsc`, not by `bun test`.
+ *
+ * Every `@ts-expect-error` fails the type-check when the error disappears, so a
+ * regression in the exported types is caught even though nothing runs.
+ */
+
+// The description is required: a tool the model cannot understand is not usable.
+// @ts-expect-error — `description` is missing
+define.Tool({ id: "no-description", execute: () => 1 });
+
+// A zod schema types the handler's input (`z.output`).
+const typed = define.Tool({
+    id: "typed",
+    description: "Typed by its schema",
+    inputSchema: z.object({ city: z.string(), days: z.number().optional() }),
+    execute: ({ city, days }) => city.toUpperCase() + (days ?? 0),
+});
+// @ts-expect-error — `city` is a string, not a number
+typed.execute!({ city: 42 }, {} as any);
+
+// Joi cannot infer types, so an explicit parameter does the job.
+const explicit = define.Tool<{ city: string }>({
+    id: "explicit",
+    description: "Explicit input type",
+    inputSchema: v.object({ city: v.string().required() }),
+    execute: ({ city }) => city.length,
+});
+// @ts-expect-error — `city` is a string, not a number
+explicit.execute!({ city: 1 }, {} as any);

package/tests/upload.test.ts

@@ -6,6 +6,7 @@ import { syncTenants } from "../database/tenant";
 import { getFileCollection } from "../database/file";
 import { useRest } from "../database/rest";
 import { createApi } from "../lib/api";
+import { jwt } from "../utils/func";
 
 const TENANT = "up-test";
 const DB = "mongodb://localhost:27017/_DB_UP_TEST";
@@ -14,10 +15,11 @@ const SLUG = "photos";
 let rest: InstanceType<typeof useRest>;
 let server: any;
 let url = "";
+let token = "";
 
 beforeAll(async () => {
     formatConfig({
-        server: { port: 4000 },
+        server: { port: 4000, jwt: { secret: "upload-test-secret" } },
         tenants: [{ id: TENANT, dir: "up-tenant", database: { uri: DB } }],
     });
     await syncTenants();
@@ -27,13 +29,34 @@ beforeAll(async () => {
         _tenant_: TENANT,
         _isFileCollection_: true,
         slug: SLUG,
-        fields: [{ name: "label", type: "string" }, { name: "takenAt", type: "date" }],
-        upload: { allowedMimeTypes: ["image/png", "text/plain"], maxSize: 5 * 1024 * 1024 },
+        fields: [
+            { name: "label", type: "string" },
+            { name: "takenAt", type: "date" },
+            { name: "owner", type: "string" },
+        ],
+        upload: { allowedMimeTypes: ["image/png", "text/plain", "text/html"], maxSize: 5 * 1024 * 1024 },
+        storage: { driver: "disk" },
+        api: { access: { "*": true }, readOnlyFields: ["owner"] },
+    }, {
+        _tenant_: TENANT,
+        _isFileCollection_: true,
+        slug: "private-photos",
+        fields: [{ name: "label", type: "string" }],
+        upload: { allowedMimeTypes: ["image/png"], maxSize: 5 * 1024 * 1024 },
+        storage: { driver: "disk" },
+        api: { access: { upload: true, read: (ctx: any) => !!ctx.token?.value } },
+    }, {
+        _tenant_: TENANT,
+        _isFileCollection_: true,
+        slug: "large-photos",
+        fields: [{ name: "label", type: "string" }],
+        upload: { allowedMimeTypes: ["image/png"], maxSize: 100 * 1024 * 1024 },
         storage: { driver: "disk" },
         api: { access: { "*": true } },
     }];
 
     rest = new useRest({ internal: false, tenant_id: TENANT });
+    token = await jwt.sign({ sub: "upload-tester" });
     const app = createApp();
     server = Bun.serve({ port: 0, fetch: app.fetch });
     url = server.url.href.replace(/\/$/, "");
@@ -45,6 +68,8 @@ afterAll(async () => {
     try {
         const fs = await import("node:fs/promises");
         await fs.rm(`${process.cwd()}/storage/${TENANT}/${SLUG}`, { recursive: true, force: true });
+        await fs.rm(`${process.cwd()}/storage/${TENANT}/private-photos`, { recursive: true, force: true });
+        await fs.rm(`${process.cwd()}/storage/${TENANT}/large-photos`, { recursive: true, force: true });
     } catch {}
     try { server.stop(true); } catch {}
 });
@@ -269,3 +294,150 @@ describe("api.files — the in-process facade", () => {
         expect((await fs.readdir(dir)).some((name) => name.startsWith(uploaded._id))).toBe(false);
     });
 });
+
+describe("upload — reserved metadata fields (#31)", () => {
+    async function statusFor(fields: Record<string, string>) {
+        const form = new FormData();
+        form.append("file", pngFile("reserved.png"));
+        for (const [key, value] of Object.entries(fields)) form.append(key, value);
+        const before = await rest.db.collection(SLUG).countDocuments();
+        const res = await fetch(`${url}/api/${TENANT}/upload/${SLUG}`, { method: "POST", body: form });
+        const body: any = await res.json();
+        const after = await rest.db.collection(SLUG).countDocuments();
+        return { status: res.status, code: body.code, before, after };
+    }
+
+    it("refuses a client-provided `_id` (path traversal vector)", async () => {
+        const result = await statusFor({ _id: "../../../../v1/routes/pwn" });
+        expect(result.status).toBe(400);
+        expect(result.code).toBe("UPLOAD_FIELD_RESERVED");
+        expect(result.after).toBe(result.before); // nothing written
+    });
+
+    it("refuses `_file` and server timestamps", async () => {
+        for (const field of ["_file", "createdAt", "updatedAt"]) {
+            const result = await statusFor({ [field]: "x" });
+            expect({ field, status: result.status, code: result.code })
+                .toEqual({ field, status: 400, code: "UPLOAD_FIELD_RESERVED" });
+        }
+    });
+
+    it("refuses `$`-prefixed metadata keys", async () => {
+        const result = await statusFor({ "$set": "x" });
+        expect(result.status).toBe(400);
+        expect(result.code).toBe("UPLOAD_FIELD_RESERVED");
+    });
+});
+
+describe("serve — inline only for safe images (#37)", () => {
+    async function uploadAndServe(file: File) {
+        const form = new FormData();
+        form.append("file", file);
+        const res = await fetch(`${url}/api/${TENANT}/upload/${SLUG}`, { method: "POST", body: form });
+        const uploaded: any = await res.json();
+        if (!uploaded?._file) throw new Error(`upload failed: ${res.status} ${JSON.stringify(uploaded)}`);
+        return fetch(`${url}${uploaded._file.url}`);
+    }
+
+    it("serves an uploaded HTML file as an attachment, never inline", async () => {
+        const html = new File(
+            [Buffer.from("<html><script>alert('xss')</script></html>")],
+            "evil.html",
+            { type: "text/html" },
+        );
+        const res = await uploadAndServe(html);
+        expect(res.status).toBe(200);
+        expect(res.headers.get("content-disposition")).toMatch(/^attachment/i);
+        expect(res.headers.get("content-type")).toContain("text/html");
+    });
+
+    it("keeps a raster image inline", async () => {
+        const res = await uploadAndServe(pngFile("inline.png"));
+        expect(res.status).toBe(200);
+        expect(res.headers.get("content-disposition")).toBeNull();
+        expect(res.headers.get("content-type")).toContain("image/png");
+    });
+});
+
+describe("upload — declared/read-only metadata (#46)", () => {
+    it("refuses an undeclared metadata field", async () => {
+        const form = new FormData();
+        form.append("file", pngFile("unknown.png"));
+        form.append("nope", "x");
+        const res = await fetch(`${url}/api/${TENANT}/upload/${SLUG}`, { method: "POST", body: form });
+        expect(res.status).toBe(400);
+        expect(((await res.json()) as any).code).toBe("UPLOAD_FIELD_UNKNOWN");
+    });
+
+    it("refuses a read-only metadata field", async () => {
+        const form = new FormData();
+        form.append("file", pngFile("readonly.png"));
+        form.append("owner", "someone-else");
+        const res = await fetch(`${url}/api/${TENANT}/upload/${SLUG}`, { method: "POST", body: form });
+        expect(res.status).toBe(400);
+        expect(((await res.json()) as any).code).toBe("READONLY_FIELD");
+    });
+});
+
+describe("serve — cache policy follows the read rule (#49)", () => {
+    async function uploadTo(collection: string) {
+        const form = new FormData();
+        form.append("file", pngFile("cache.png"));
+        const res = await fetch(`${url}/api/${TENANT}/upload/${collection}`, { method: "POST", body: form });
+        return (await res.json()) as any;
+    }
+
+    it("caches publicly when `read` is `true`", async () => {
+        const uploaded = await uploadTo(SLUG);
+        const res = await fetch(`${url}${uploaded._file.url}`);
+        expect(res.status).toBe(200);
+        expect(res.headers.get("cache-control")).toBe("public, max-age=31536000, immutable");
+    });
+
+    it("never caches a token-dependent read rule", async () => {
+        const uploaded = await uploadTo("private-photos");
+        expect(uploaded._file?.url).toBeString();
+
+        const anonymous = await fetch(`${url}${uploaded._file.url}`);
+        expect(anonymous.status).toBe(401);
+
+        const res = await fetch(`${url}${uploaded._file.url}`, { headers: { Authorization: `Bearer ${token}` } });
+        expect(res.status).toBe(200);
+        expect(res.headers.get("cache-control")).toBe("private, no-store");
+        expect(res.headers.get("vary")).toContain("Authorization");
+    });
+});
+
+describe("upload — size is rejected before buffering (#51)", () => {
+    it("refuses a file larger than `upload.maxSize`", async () => {
+        const png = Buffer.from(
+            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+            "base64",
+        );
+        const big = new File([Buffer.concat([png, Buffer.alloc(6 * 1024 * 1024)])], "big.png", { type: "image/png" });
+        const form = new FormData();
+        form.append("file", big);
+        const res = await fetch(`${url}/api/${TENANT}/upload/${SLUG}`, { method: "POST", body: form });
+        expect(res.status).toBe(413);
+        expect(((await res.json()) as any).code).toBe("FILE_TOO_LARGE");
+    });
+});
+
+describe("upload — 100MB per-file allowance, 16MB normal body (#51)", () => {
+    it("accepts a 20MB upload even though normal bodies default to 16MB", async () => {
+        const header = Buffer.from(
+            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+            "base64",
+        );
+        const file = new File([header, Buffer.alloc(20 * 1024 * 1024)], "large.png", { type: "image/png" });
+        expect(file.size).toBeGreaterThan(16 * 1024 * 1024);
+
+        const form = new FormData();
+        form.append("file", file);
+        const res = await fetch(`${url}/api/${TENANT}/upload/large-photos`, { method: "POST", body: form });
+
+        expect(res.status).toBe(200);
+        const body = (await res.json()) as any;
+        expect(body._file.size).toBe(file.size);
+    });
+});

package/tests/vars-api.test.ts

@@ -5,6 +5,7 @@ import { formatConfig, cfg } from "../server/config";
 import { syncTenants } from "../database/tenant";
 import { syncVars } from "../database/vars";
 import { useRest } from "../database/rest";
+import { jwt } from "../utils/func";
 
 const TENANT = "vars-api";
 const DB = "mongodb://localhost:27017/_VARS_API_TEST";
@@ -13,16 +14,18 @@ const DIR = "packages/core/tests/fixtures/vars-tenant";
 let rest: InstanceType<typeof useRest>;
 let server: any;
 let url = "";
+let token = "";
 
 beforeAll(async () => {
     formatConfig({
-        server: { port: 4000 },
+        server: { port: 4000, jwt: { secret: "vars-api-test-secret" } },
         tenants: [{ id: TENANT, dir: DIR, database: { uri: DB } }],
     });
     await syncTenants();
     await syncVars();
 
     rest = new useRest({ internal: false, tenant_id: TENANT });
+    token = await jwt.sign({ sub: "vars-tester" });
     const app = createApp();
     server = Bun.serve({ port: 0, fetch: app.fetch });
     url = server.url.href.replace(/\/$/, "");
@@ -45,6 +48,16 @@ const json = async (action: string, body: any) => {
     return { status: res.status, body: await res.json() as any };
 };
 
+/** A function access rule requires a valid token — used by the `open` namespace `all` rule. */
+const authedJson = async (action: string, body: any) => {
+    const res = await fetch(`${url}/api/${TENANT}/vars/${action}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify(body),
+    });
+    return { status: res.status, body: await res.json() as any };
+};
+
 describe("vars HTTP API — access control", () => {
     it("denies a namespace without api.access", async () => {
         const res = await json("get", { ns: "private", key: "secret" });
@@ -121,3 +134,62 @@ describe("vars HTTP API — CRUD", () => {
         expect(res.status).toBe(400);
     });
 });
+
+describe("vars HTTP API — scope cannot be a Mongo operator (#34)", () => {
+    it("refuses an operator scope on every read/delete action", async () => {
+        // Seed a real scoped value in the unscoped namespace.
+        expect((await json("set", { ns: "open", key: "token", value: "alice-secret", scope: "alice" })).status).toBe(200);
+
+        for (const action of ["all", "entries", "clear"]) {
+            const res = await authedJson(action, { ns: "open", scope: { $ne: null } });
+            expect({ action, status: res.status }).toEqual({ action, status: 400 });
+            expect(res.body.code).toBe("VALIDATION_ERROR");
+        }
+
+        // Nothing was deleted and the scoped value is intact.
+        const got = await json("get", { ns: "open", key: "token", scope: "alice" });
+        expect(got.body.value).toBe("alice-secret");
+    });
+
+    it("refuses an operator scope on writes too", async () => {
+        for (const action of ["set", "del"]) {
+            const res = await json(action, { ns: "open", key: "token", value: "x", scope: { $ne: null } });
+            expect({ action, status: res.status }).toEqual({ action, status: 400 });
+        }
+    });
+
+    it("still accepts a string scope on an unscoped namespace", async () => {
+        const set = await json("set", { ns: "open", key: "token", value: "bob-secret", scope: "bob" });
+        expect(set.status).toBe(200);
+        const all = await authedJson("all", { ns: "open", scope: "bob" });
+        expect(all.status).toBe(200);
+        expect(all.body.vars.token).toBe("bob-secret");
+    });
+
+    it("gives the access rule the namespace and the body", async () => {
+        // The `open` namespace rule only allows `all` when it receives `{ namespace, body }`.
+        const res = await authedJson("all", { ns: "open", scope: "alice" });
+        expect(res.status).toBe(200);
+    });
+
+    it("refuses operators in the `where` meta filter", async () => {
+        const res = await json("entries", { ns: "open", where: { note: { $ne: null } } });
+        expect(res.status).toBe(400);
+        expect(res.body.code).toBe("VALIDATION_ERROR");
+    });
+});
+
+describe("vars HTTP API — audit (#50)", () => {
+    it("never stores the values returned by a read", async () => {
+        await json("set", { ns: "config", key: "audit-secret", value: "super-secret-value" });
+        await json("get", { ns: "config", key: "audit-secret" });
+
+        const logged: any = await rest.db.collection("_audit_").findOne(
+            { "operation.action": "get", "operation.collection": "_vars_:config" },
+            { sort: { ts: -1 } },
+        );
+        expect(logged).not.toBeNull();
+        expect(logged.operation.result == null).toBe(true);
+        expect(JSON.stringify(logged)).not.toContain("super-secret-value");
+    });
+});

package/tests/vars.test.ts

@@ -48,7 +48,7 @@ describe("define.Vars", () => {
 describe("vars loading & seeding", () => {
     it("loads the definitions from vars/*.var.ts", () => {
         const namespaces = (cfg.vars ?? []).map((v) => v.namespace).sort();
-        expect(namespaces).toEqual(["config", "private"]);
+        expect(namespaces).toEqual(["config", "open", "private"]);
         expect((cfg.vars ?? []).every((v) => v._tenant_ === TEST_TENANT)).toBe(true);
     });