@anteros/core 0.0.19 → 0.0.21

package/tests/mcp.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { define, v } from "../index";
+import { cfg } from "../server/config";
+import { syncMcpTools } from "../lib/mcp";
+import { createApp } from "../server/hono";
+
+const TENANT = "mcp-test";
+const TENANT_DIR = "packages/core/tests/fixtures/mcp-tenant";
+
+// @hono/mcp frames every message as Server-Sent Events (MCP Streamable HTTP spec)
+function parseSSE(text: string): any[] {
+    const messages: any[] = [];
+    let data: string[] = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (line.startsWith("data:")) {
+            data.push(line.slice(5).trim());
+        } else if (line === "" && data.length) {
+            messages.push(JSON.parse(data.join("\n")));
+            data = [];
+        }
+    }
+    if (data.length) messages.push(JSON.parse(data.join("\n")));
+    return messages;
+}
+
+function resetConfig() {
+    cfg.server = { ...cfg.server, rateLimit: undefined, cors: undefined, ipRestriction: undefined, trustProxy: undefined };
+    cfg.mcpTools = [];
+    cfg.tenants = [];
+}
+
+beforeEach(() => {
+    resetConfig();
+    delete process.env.REDIS_URL;
+    delete process.env.REDIS_HOST;
+    delete process.env.REDIS_PORT;
+    delete process.env.REDIS_PASSWORD;
+});
+
+describe("define.McpTool", () => {
+    it("marks the tool and enables it by default", () => {
+        const tool = define.McpTool({
+            name: "greet",
+            description: "greets",
+            inputSchema: v.object({ name: v.string().required() }),
+            exec: async () => ({ content: [{ type: "text", text: "hi" }] }),
+        });
+        expect(tool._isMcpTool_).toBe(true);
+        expect(tool.enabled).toBe(true);
+    });
+});
+
+describe("syncMcpTools", () => {
+    it("loads tools + resources from mcp/tools and mcp/resources", async () => {
+        cfg.tenants = [{ id: TENANT, dir: TENANT_DIR, database: { uri: "mongodb://localhost:27017/none" } }];
+        await syncMcpTools();
+        expect(cfg.mcpTools?.length).toBe(2);
+        expect(cfg.mcpTools?.map((t) => t.name).sort()).toEqual(["badge", "echo"]);
+        expect(cfg.mcpResources?.length).toBe(2);
+        expect(cfg.mcpResources?.map((r) => r.uri).sort()).toEqual(["orders://summary", "users://{id}"]);
+        expect(cfg.mcpTools?.[0]?._tenant_).toBe(TENANT);
+    });
+});
+
+describe("MCP protocol (GET/POST /mcp/:tenant_id)", () => {
+    it("serves tools/list and tools/call over JSON-RPC", async () => {
+        cfg.tenants = [{ id: TENANT, dir: TENANT_DIR, database: { uri: "mongodb://localhost:27017/none" } }];
+        await syncMcpTools();
+
+        const app = createApp();
+        const server = Bun.serve({ port: 0, fetch: app.fetch });
+        const url = server.url.href.replace(/\/$/, "");
+
+        // 1. tools/list
+        const listRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }),
+        });
+        expect(listRes.status).toBe(200);
+        const list = parseSSE(await listRes.text())[0];
+        const tools = list?.result?.tools ?? [];
+        expect(tools.some((t: any) => t.name === "echo")).toBe(true);
+        expect(tools.some((t: any) => t.name === "badge")).toBe(true);
+
+        // 1b. resources/list — static resources
+        const resListRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 9, method: "resources/list", params: {} }),
+        });
+        const resList = parseSSE(await resListRes.text())[0];
+        const resources = resList?.result?.resources ?? [];
+        expect(resources.some((r: any) => r.uri === "orders://summary")).toBe(true);
+
+        // 1c. resources/templates/list
+        const tmplRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 10, method: "resources/templates/list", params: {} }),
+        });
+        const tmplList = parseSSE(await tmplRes.text())[0];
+        const templates = tmplList?.result?.resourceTemplates ?? [];
+        expect(templates.some((t: any) => t.uriTemplate === "users://{id}")).toBe(true);
+
+        // 1d. resources/read — static URI
+        const readRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 11, method: "resources/read", params: { uri: "orders://summary" } }),
+        });
+        const read = parseSSE(await readRes.text())[0];
+        const readText = read?.result?.contents?.[0]?.text ?? "";
+        expect(readText).toContain("\"total\":42");
+
+        // 1e. resources/read — template URI with params
+        const readTplRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 12, method: "resources/read", params: { uri: "users://abc123" } }),
+        });
+        const readTpl = parseSSE(await readTplRes.text())[0];
+        expect(readTpl?.result?.contents?.[0]?.text ?? "").toContain("\"id\":\"abc123\"");
+
+        // 1f. resources/read — unknown URI → error
+        const readBadRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 13, method: "resources/read", params: { uri: "nope://x" } }),
+        });
+        const readBad = parseSSE(await readBadRes.text())[0];
+        expect(readBad?.error).toBeDefined();
+
+        // 2. tools/call (valid args + Joi defaults)
+        const callRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0", id: 2, method: "tools/call",
+                params: { name: "echo", arguments: { msg: "hello mcp" } },
+            }),
+        });
+        const call = parseSSE(await callRes.text())[0];
+        const block = call?.result?.content?.[0] ?? {};
+        expect(block.type).toBe("text");
+        expect(block.text ?? "").toContain("hello mcp");
+        // Joi default applied (times=1)
+        expect(block.text ?? "").toContain("\"times\":1");
+
+        // 2b. protocol content blocks pass through unchanged (image block)
+        const badgeRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0", id: 3, method: "tools/call",
+                params: { name: "badge", arguments: {} },
+            }),
+        });
+        const badge = parseSSE(await badgeRes.text())[0];
+        expect(badge?.result?.content?.[0]?.type).toBe("image");
+        expect(badge?.result?.content?.[0]?.mimeType).toBe("image/png");
+
+        // 2b. invalid args → isError (Joi validation)
+        const badRes = await fetch(`${url}/mcp/${TENANT}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0", id: 3, method: "tools/call",
+                params: { name: "echo", arguments: { msg: 123 } },
+            }),
+        });
+        const bad = parseSSE(await badRes.text())[0];
+        expect(bad?.result?.isError).toBe(true);
+        expect(bad?.result?.content?.[0]?.text ?? "").toContain("Invalid arguments");
+
+        // 3. unknown tenant → 404
+        const notFound = await fetch(`${url}/mcp/ghost`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 4, method: "tools/list", params: {} }),
+        });
+        expect(notFound.status).toBe(404);
+
+        server.stop(true);
+    });
+});

package/tests/metrics-cluster.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "bun:test";
+import path from "node:path";
+import { getMetrics, registerMetrics, trackRequest } from "../server/metrics";
+import { startMaster, aggregateMetrics, type MasterMetrics } from "../server/cluster";
+
+// ─── metrics ────────────────────────────────────────────────────────────
+
+describe("metrics", () => {
+    it("returns a snapshot with pid, memory and cpu", () => {
+        const m = getMetrics();
+        expect(m.pid).toBe(process.pid);
+        expect(m.uptime).toBeGreaterThanOrEqual(0);
+        expect(typeof m.memory.rss).toBe("number");
+        expect(typeof m.cpu.percent).toBe("number");
+        expect(m.cpu.cores).toBeGreaterThanOrEqual(1);
+        expect(typeof m.requests.total).toBe("number");
+    });
+
+    it("trackRequest counts requests by method and status", () => {
+        const before = getMetrics().requests.total;
+        trackRequest(new Request("http://localhost/", { method: "POST" }), new Response("ok", { status: 201 }));
+        const after = getMetrics().requests.total;
+        expect(after).toBe(before + 1);
+        expect(getMetrics().requests.byMethod.POST).toBeGreaterThanOrEqual(1);
+        expect(getMetrics().requests.byStatus["201"]).toBeGreaterThanOrEqual(1);
+    });
+
+    it("trackRequest counts 5xx as errors", () => {
+        const before = getMetrics().requests.errors;
+        trackRequest(new Request("http://localhost/x"), new Response("boom", { status: 500 }));
+        expect(getMetrics().requests.errors).toBe(before + 1);
+    });
+
+    it("registerMetrics exposes pendingRequests", () => {
+        const server = Bun.serve({ port: 0, fetch: () => new Response("ok") });
+        registerMetrics(server as any);
+        expect(typeof getMetrics().pendingRequests).toBe("number");
+        server.stop(true);
+    });
+});
+
+// ─── aggregateMetrics ───────────────────────────────────────────────────
+
+function fakeSnapshot(pid: number, total: number, rss: number): MasterMetrics[number] {
+    return {
+        pid,
+        startedAt: Date.now(),
+        uptime: 10,
+        env: "test",
+        connections: 0,
+        pendingRequests: 0,
+        pendingWebSockets: 0,
+        requests: { total, active: 0, errors: total > 10 ? 1 : 0, byMethod: { GET: total }, byStatus: { "200": total } },
+        memory: { rss, heapUsed: rss / 2, heapTotal: rss, external: 0 },
+        cpu: { percent: 10, cores: 8, user: 100, system: 50 },
+    };
+}
+
+describe("aggregateMetrics", () => {
+    it("returns an empty aggregate without workers", () => {
+        const agg = aggregateMetrics({});
+        expect(agg.workers).toBe(0);
+        expect(agg.requests.total).toBe(0);
+        expect(agg.pids).toEqual([]);
+    });
+
+    it("sums worker snapshots", () => {
+        const agg = aggregateMetrics({ 1: fakeSnapshot(1, 5, 1000), 2: fakeSnapshot(2, 5, 1000) });
+        expect(agg.workers).toBe(2);
+        expect(agg.requests.total).toBe(10);
+        expect(agg.memory.rss).toBe(2000);
+        expect(agg.cpu.percent).toBe(10);
+        expect(agg.pids).toHaveLength(2);
+        expect(agg.requests.perSecond).toBe(1);
+    });
+});
+
+// ─── startMaster (real subprocess + IPC) ────────────────────────────────
+
+describe("startMaster", () => {
+    it("spawns workers, collects IPC metrics and shutdown kills them", async () => {
+        const workerPath = path.join(import.meta.dir, "fixtures", "metrics-worker.ts");
+        const master = startMaster({
+            workers: 1,
+            argv: [process.execPath, workerPath],
+            env: { ...(process.env as Record<string, string>) },
+        });
+
+        // Wait for the worker to start and report its metrics
+        await new Promise((r) => setTimeout(r, 1500));
+
+        expect(master.workers.length).toBe(1);
+
+        const metrics = master.metrics();
+        const pids = Object.keys(metrics);
+        expect(pids.length).toBe(1);
+        expect(metrics[Number(pids[0])]!.requests.total).toBe(7);
+
+        master.shutdown();
+        await new Promise((r) => setTimeout(r, 300));
+        expect(master.workers.length).toBe(0);
+    }, 10_000);
+});

package/tests/scripts-heavy.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { MongoClient } from "mongodb";
+import { cfg } from "../server/config";
+import { runScripts } from "../lib/scripts";
+
+const DB_URI = "mongodb://localhost:27017/anteros_heavy_test";
+const TENANT_DIR = "packages/core/tests/fixtures/heavy";
+
+let mongoAvailable = false;
+let client: MongoClient;
+
+beforeAll(async () => {
+    // Gracefully skip when MongoDB is not reachable
+    try {
+        client = new MongoClient(DB_URI, { serverSelectionTimeoutMS: 1500 });
+        await client.connect();
+        mongoAvailable = true;
+    } catch {
+        mongoAvailable = false;
+    }
+});
+
+afterAll(async () => {
+    if (mongoAvailable && client) {
+        try { await client.db().dropDatabase(); } catch {}
+        await client.close();
+    }
+});
+
+describe("heavy scripts (subprocess)", () => {
+    it("runs a heavy:true script in a worker process and persists data", async () => {
+        if (!mongoAvailable) {
+            console.warn("Skipping: MongoDB unavailable");
+            return;
+        }
+
+        cfg.tenants = [{ id: "heavy-test", dir: TENANT_DIR, database: { uri: DB_URI } }];
+
+        await runScripts();
+
+        const count = await client.db().collection("items").countDocuments();
+        expect(count).toBe(20);
+
+        const sample: any = await client.db().collection("items").findOne();
+        expect(sample.name).toBeString();
+        expect(sample.createdAt).toBeInstanceOf(Date);
+        expect(sample.updatedAt).toBeInstanceOf(Date);
+    }, 30_000);
+});

package/tests/security.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "bun:test";
+import { Hono } from "hono";
+import { createMemoryStore, createRedisStore, rateLimit } from "../server/security";
+
+// ─── createMemoryStore ───────────────────────────────────────────────────
+
+describe("createMemoryStore", () => {
+    it("increments within a window", async () => {
+        const store = createMemoryStore();
+        expect((await store.increment("k", 60_000)).count).toBe(1);
+        expect((await store.increment("k", 60_000)).count).toBe(2);
+        store.dispose();
+    });
+
+    it("resets after the window expires", async () => {
+        const store = createMemoryStore();
+        await store.increment("k", 1);
+        expect((await store.increment("k", 1)).count).toBe(2);
+        // window (1ms) expired → resets to 1
+        await Bun.sleep(5);
+        const r = await store.increment("k", 1);
+        expect(r.count).toBe(1);
+        store.dispose();
+    });
+});
+
+// ─── createRedisStore (mocked RedisClient) ───────────────────────────────
+
+describe("createRedisStore", () => {
+    it("uses incr / pexpire / pttl", async () => {
+        const calls: string[] = [];
+        const mock: any = {
+            incr: async (k: string) => { calls.push(`incr:${k}`); return 1; },
+            pexpire: async (k: string, ms: number) => { calls.push(`pexpire:${k}:${ms}`); return 1; },
+            pttl: async (k: string) => { calls.push(`pttl:${k}`); return 4000; },
+        };
+        const store = createRedisStore(mock);
+        const r = await store.increment("key", 60_000);
+        expect(r.count).toBe(1);
+        expect(r.resetAt).toBeGreaterThan(Date.now());
+        expect(calls).toContain("incr:key");
+        expect(calls).toContain("pexpire:key:60000");
+        expect(calls).toContain("pttl:key");
+    });
+
+    it("only sets expiry on the first increment of a window", async () => {
+        let incrCount = 0;
+        let pexpireCalls = 0;
+        const mock: any = {
+            incr: async () => ++incrCount,
+            pexpire: async () => { pexpireCalls++; return 1; },
+            pttl: async () => 5000,
+        };
+        const store = createRedisStore(mock);
+        await store.increment("k", 1000); // count=1 → pexpire
+        await store.increment("k", 1000); // count=2 → no pexpire
+        expect(pexpireCalls).toBe(1);
+    });
+});
+
+// ─── rateLimit middleware ────────────────────────────────────────────────
+
+describe("rateLimit middleware", () => {
+    it("adds headers and blocks with 429 + Retry-After", async () => {
+        const app = new Hono();
+        app.use(rateLimit({ windowMs: 60_000, max: 2 }));
+        app.get("/", (c) => c.text("ok"));
+
+        const r1 = await app.request("/");
+        expect(r1.headers.get("X-RateLimit-Limit")).toBe("2");
+        expect(r1.headers.get("X-RateLimit-Remaining")).toBe("1");
+
+        await app.request("/");
+        const r3 = await app.request("/");
+        expect(r3.status).toBe(429);
+        expect(r3.headers.get("Retry-After")).toBeTruthy();
+        const body: any = await r3.json();
+        expect(body.code).toBe("RATE_LIMIT_EXCEEDED");
+    });
+
+    it("respects a custom keyGenerator", async () => {
+        const app = new Hono();
+        app.use(rateLimit({ windowMs: 60_000, max: 1, keyGenerator: () => "fixed-key" }));
+        app.get("/", (c) => c.text("ok"));
+        await app.request("/");
+        expect((await app.request("/")).status).toBe(429);
+    });
+
+    it("uses a shared Redis store when provided", async () => {
+        const calls: string[] = [];
+        const store = createRedisStore({
+            incr: async (k: string) => { calls.push(`incr:${k}`); return 5; },
+            pexpire: async () => 1,
+            pttl: async () => 3000,
+        } as any);
+        const app = new Hono();
+        app.use(rateLimit({ windowMs: 60_000, max: 2, store }));
+        app.get("/", (c) => c.text("ok"));
+        await app.request("/");
+        expect(calls.some((c) => c.startsWith("incr:"))).toBe(true);
+    });
+});

package/tests/ts1011-test.ts

@@ -0,0 +1,15 @@
+import type { Document, ChangeStreamOptions, ChangeStream } from "mongodb";
+
+export class Test {
+  #tenant!: { id: string };
+  @Check()
+  async watch(collection: string, pipeline: any[], options: ChangeStreamOptions): Promise<ChangeStream> {
+    return undefined as any;
+  }
+  @Check()
+  async find(collection: string, params: any = {}, options = {}): Promise<Document[]> {
+    return [];
+  }
+}
+
+function Check() { return (target: any, key: string) => {} }

package/tests/utils.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import * as func from "../utils/func";
+import utils from "../utils";
+import { cfg } from "../server/config";
+
+afterEach(() => {
+    cfg.server.jwt = undefined;
+});
+
+describe("omit", () => {
+    it("removes keys and regex patterns", () => {
+        const out = func.omit({ a: 1, b: 2, password: "x", secret_key: "y" }, ["a", /^secret_/]);
+        expect(out).toEqual({ b: 2, password: "x" });
+    });
+});
+
+describe("pick", () => {
+    it("picks simple keys", () => {
+        expect(func.pick({ a: 1, b: 2, c: 3 }, ["a", "c"])).toEqual({ a: 1, c: 3 });
+    });
+});
+
+describe("cleanDeep", () => {
+    it("removes null / undefined / empty recursively", () => {
+        expect(func.cleanDeep({ a: 1, b: null, c: undefined, d: [], e: {}, f: { g: null } })).toEqual({ a: 1 });
+    });
+});
+
+describe("clone / deepCopy", () => {
+    it("clone deep-copies plain objects", () => {
+        const src = { a: { b: [1, 2] } };
+        const copy = func.clone(src);
+        expect(copy).toEqual(src);
+        expect(copy).not.toBe(src);
+        copy.a!.b.push(3);
+        expect(src.a!.b).toEqual([1, 2]);
+    });
+
+    it("deepCopy preserves Date / Map / Set", () => {
+        const src = { d: new Date("2024-01-01"), m: new Map([["k", { v: 1 }]]), s: new Set([1, 2]) };
+        const copy = func.deepCopy(src);
+        expect(copy.d).toBeInstanceOf(Date);
+        expect(copy.m).toBeInstanceOf(Map);
+        expect(copy.s).toBeInstanceOf(Set);
+        expect((copy.m as Map<string, any>).get("k")).toEqual({ v: 1 });
+    });
+});
+
+describe("deepEquals", () => {
+    it("compares deeply", () => {
+        expect(utils.deepEquals({ a: 1, b: { c: [1, 2] } }, { a: 1, b: { c: [1, 2] } })).toBe(true);
+        expect(utils.deepEquals({ a: 1 }, { a: 2 })).toBe(false);
+    });
+});
+
+describe("isSlug / slugify", () => {
+    it("isSlug validates the slug pattern", () => {
+        expect(func.isSlug("my-product")).toBe(true);
+        expect(func.isSlug("My-Product")).toBe(false);
+        expect(func.isSlug("")).toBe(false);
+    });
+
+    it("slugify converts text", () => {
+        expect(func.slugify("Hello World!")).toBe("hello-world");
+    });
+});
+
+describe("jwt", () => {
+    it("signs and verifies", async () => {
+        cfg.server.jwt = { secret: "test-secret" };
+        const token = await func.jwt.sign({ sub: "u1", role: "admin" });
+        const { value, error } = await func.jwt.verify(token);
+        expect(error).toBeNull();
+        expect(value).not.toBeNull();
+        expect(value?.role).toBe("admin");
+        expect(value?.sub).toBe("u1");
+    });
+
+    it("detects expired tokens", async () => {
+        cfg.server.jwt = { secret: "s" };
+        const token = await func.jwt.sign({ sub: "u1" }, { expiresIn: "1s" });
+        await Bun.sleep(1100);
+        const { value, expired } = await func.jwt.verify(token);
+        expect(value).toBeNull();
+        expect(expired).toBe(true);
+    }, 5000);
+
+    it("rejects invalid tokens", async () => {
+        cfg.server.jwt = { secret: "s" };
+        const { value, error, expired } = await func.jwt.verify("not-a-jwt");
+        expect(value).toBeNull();
+        expect(error).not.toBeNull();
+        expect(expired).toBe(false);
+    });
+
+    it("rejects a token signed with a different secret", async () => {
+        cfg.server.jwt = { secret: "secret-a" };
+        const token = await func.jwt.sign({ sub: "u1" });
+        cfg.server.jwt = { secret: "secret-b" };
+        const { value, error } = await func.jwt.verify(token);
+        expect(value).toBeNull();
+        expect(error).not.toBeNull();
+    });
+});
+
+describe("password", () => {
+    it("hashes and verifies", () => {
+        const hash = utils.password.hashSync("hunter2");
+        expect(hash).not.toBe("hunter2");
+        expect(utils.password.verifySync("hunter2", hash)).toBe(true);
+        expect(utils.password.verifySync("wrong", hash)).toBe(false);
+    });
+});

package/types/api.d.ts

@@ -32,6 +32,17 @@ export type ActionsApiList =
     | "login"
     | "logout"
     | "aggregate"
+    | "watch"
+    | "countDocuments"
+    | "bulkWrite"
+    | "bulkUpdate"
+    | "replaceOne"
+    | "findOneAndUpdate"
+    | "dropCollection"
+    | "dropIndex"
+    | "dropIndexes"
+    | "stats"
+    | "workflows"
     | "*"
 
 

package/types/collection.d.ts

@@ -7,6 +7,25 @@ import type { Context } from "hono";
 import type { useRest } from "../database/rest";
 import type { jwt } from "../utils/func";
 import type { ActionsApiList, ApiAccess, ApiActions } from "./api";
+import type { Server as SocketIO } from "socket.io";
+
+/** Context passed to a collection custom action (`define.Action`). */
+export type CollectionActionContext = {
+    rest: InstanceType<typeof useRest>;
+    data: any;
+    error: typeof fn.error;
+    io: SocketIO;
+    jwt: typeof jwt;
+    token: {
+        value: string | null;
+        decoded: Record<string, unknown> | null;
+        provided: boolean;
+        expired: boolean;
+    };
+};
+
+/** A custom action on a collection — `define.Action(fn)`. */
+export type CollectionAction = (ctx: CollectionActionContext) => Promise<any>;
 export type Collection = {
     type?: "document" | "file";
     slug: string;
@@ -58,11 +77,7 @@ export type Collection = {
         readOnlyFields?: (string | RegExp)[];
     };
     actions?: {
-        [key: string]: (ctx: {
-            rest: InstanceType<typeof useRest>;
-            data: any;
-            error: typeof fn.error;
-        }) => Promise<any>;
+        [key: string]: CollectionAction;
     };
     /**
      * The tenant id of the collection

package/types/config.d.ts

@@ -6,14 +6,21 @@ import type { Route } from "./route";
 import type { Service } from "./service";
 import type { Script } from "./scripts";
 import type { FileCollection } from "./file";
+import type { McpTool, McpResource } from "./mcp";
 export type ServerConfig = {
     debug?: boolean;
     version?: string;
-    clusterMode?: boolean;
     server: {
         name?: string;
         port: number;
-        reusePort?: boolean;  // override Bun's reusePort (default: clusterMode && not dev)
+        /** Bun's SO_REUSEPORT — allows multiple processes to bind the same port. Spawn them yourself. */
+        reusePort?: boolean;
+        /** Number of worker processes when reusePort is on (default: CPU count) */
+        workers?: number;
+        /** Master supervision port exposing aggregated /health (default: port + 1) */
+        metricsPort?: number;
+        /** When true, trusts proxy headers (CF-Connecting-IP / X-Forwarded-For) as the client IP. Default: false. */
+        trustProxy?: boolean;
         body?: {
             maxSize?: number;
         };
@@ -35,8 +42,16 @@ export type ServerConfig = {
             enabled?: boolean;
             windowMs?: number;
             max?: number;
-            /** If true, uses Redis store (requires ioredis client available) */
+            /** Redis store override: unset = auto (Redis when `redis` block or REDIS_* env vars are present), false = force in-memory, true = force Redis */
             useRedis?: boolean;
+            /** Redis connection used when useRedis is true (env fallbacks: REDIS_URL / REDIS_HOST / REDIS_PORT / REDIS_PASSWORD) */
+            redis?: {
+                /** redis:// connection string (takes precedence over host/port/password) */
+                url?: string;
+                host?: string;
+                port?: number;
+                password?: string;
+            };
             /** Stricter limits for login endpoints */
             login?: {
                 windowMs?: number;
@@ -54,4 +69,6 @@ export type Config = ServerConfig & {
     services?: Service[]
     scripts?: Script[]
     fileCollections?: FileCollection[]
+    mcpTools?: McpTool[]
+    mcpResources?: McpResource[]
 }