@foundation0/api 1.1.1 → 1.1.3

package/mcp/server.test.ts

@@ -1,117 +1,464 @@
-import { describe, expect, it } from 'bun:test'
-import { createExampleMcpServer } from './server'
-
-describe('createExampleMcpServer endpoint whitelist', () => {
-  it('exposes all root endpoints by default', () => {
-    const instance = createExampleMcpServer()
-    const names = instance.tools.map((tool) => tool.name)
-
-    expect(names.some((name) => name.startsWith('agents.'))).toBe(true)
-    expect(names.some((name) => name.startsWith('projects.'))).toBe(true)
-    expect(names).not.toContain('projects.syncTasks')
-    expect(names).not.toContain('projects.clearIssues')
-  })
-
-  it('filters tools to selected root endpoints', () => {
-    const instance = createExampleMcpServer({
-      allowedRootEndpoints: ['projects'],
-    })
-    const names = instance.tools.map((tool) => tool.name)
-
-    expect(names.length).toBeGreaterThan(0)
-    expect(names.every((name) => name.startsWith('projects.'))).toBe(true)
-    expect(names.some((name) => name.startsWith('agents.'))).toBe(false)
-  })
-
-  it('throws on unknown root endpoints', () => {
-    expect(() => createExampleMcpServer({
-      allowedRootEndpoints: ['unknown-root'],
-    })).toThrow('Unknown root endpoints')
-  })
-
-  it('disables write-capable tools when disableWrite=true', () => {
-    const instance = createExampleMcpServer({
-      disableWrite: true,
-    })
-    const names = instance.tools.map((tool) => tool.name)
-
-    expect(names).toContain('projects.readGitTask')
-    expect(names).toContain('projects.listProjects')
-    expect(names).toContain('agents.listAgents')
-    expect(names).not.toContain('projects.writeGitTask')
-    expect(names).not.toContain('projects.syncTasks')
-    expect(names).not.toContain('projects.clearIssues')
-    expect(names).not.toContain('projects.generateSpec')
-    expect(names).not.toContain('projects.setActive')
-    expect(names).not.toContain('projects.main')
-    expect(names).not.toContain('agents.createAgent')
-    expect(names).not.toContain('agents.setActive')
-    expect(names).not.toContain('agents.setActiveLink')
-    expect(names).not.toContain('agents.runAgent')
-    expect(names).not.toContain('agents.main')
-  })
-
-  it('applies disableWrite with root endpoint whitelist', () => {
-    const instance = createExampleMcpServer({
-      allowedRootEndpoints: ['projects'],
-      disableWrite: true,
-    })
-    const names = instance.tools.map((tool) => tool.name)
-
-    expect(names.length).toBeGreaterThan(0)
-    expect(names.every((name) => name.startsWith('projects.'))).toBe(true)
-    expect(names).toContain('projects.readGitTask')
-    expect(names).toContain('projects.fetchGitTasks')
-    expect(names).not.toContain('projects.writeGitTask')
-    expect(names).not.toContain('projects.syncTasks')
-  })
-
-  it('re-enables issue write endpoints when enableIssues=true with disableWrite', () => {
-    const instance = createExampleMcpServer({
-      disableWrite: true,
-      enableIssues: true,
-    })
-    const names = instance.tools.map((tool) => tool.name)
-
-    expect(names).toContain('projects.fetchGitTasks')
-    expect(names).toContain('projects.readGitTask')
-    expect(names).toContain('projects.writeGitTask')
-    expect(names).not.toContain('projects.syncTasks')
-    expect(names).not.toContain('projects.clearIssues')
-    expect(names).not.toContain('projects.generateSpec')
-    expect(names).not.toContain('projects.setActive')
-    expect(names).not.toContain('agents.createAgent')
-    expect(names).not.toContain('agents.runAgent')
-  })
-
-  it('exposes syncTasks and clearIssues only when admin=true', () => {
-    const defaultInstance = createExampleMcpServer()
-    const defaultNames = defaultInstance.tools.map((tool) => tool.name)
-    expect(defaultNames).not.toContain('projects.syncTasks')
-    expect(defaultNames).not.toContain('projects.clearIssues')
-
-    const adminInstance = createExampleMcpServer({ admin: true })
-    const adminNames = adminInstance.tools.map((tool) => tool.name)
-    expect(adminNames).toContain('projects.syncTasks')
-    expect(adminNames).toContain('projects.clearIssues')
-  })
-
-  it('requires admin along with enableIssues for destructive issue endpoints under disableWrite', () => {
-    const nonAdmin = createExampleMcpServer({
-      disableWrite: true,
-      enableIssues: true,
-    })
-    const nonAdminNames = nonAdmin.tools.map((tool) => tool.name)
-    expect(nonAdminNames).not.toContain('projects.syncTasks')
-    expect(nonAdminNames).not.toContain('projects.clearIssues')
-
-    const admin = createExampleMcpServer({
-      disableWrite: true,
-      enableIssues: true,
-      admin: true,
-    })
-    const adminNames = admin.tools.map((tool) => tool.name)
-    expect(adminNames).toContain('projects.syncTasks')
-    expect(adminNames).toContain('projects.clearIssues')
-  })
-})
+import { describe, expect, it } from "bun:test";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createExampleMcpServer } from "./server";
+
+describe("createExampleMcpServer endpoint whitelist", () => {
+	it("exposes all root endpoints by default", () => {
+		const instance = createExampleMcpServer();
+		const names = instance.tools.map((tool) => tool.name);
+
+		expect(names.some((name) => name.startsWith("agents."))).toBe(true);
+		expect(names.some((name) => name.startsWith("net."))).toBe(true);
+		expect(names.some((name) => name.startsWith("projects."))).toBe(true);
+		expect(names).toContain("projects.createGitIssue");
+		expect(names).not.toContain("projects.syncTasks");
+		expect(names).not.toContain("projects.clearIssues");
+	});
+
+	it("exposes openai-safe alias net_curl for net.curl", () => {
+		const instance = createExampleMcpServer();
+		const names = instance.tools.map((tool) => tool.name);
+
+		expect(names).toContain("net.curl");
+		expect(names).toContain("net_curl");
+	});
+
+	it("filters tools to selected root endpoints", () => {
+		const instance = createExampleMcpServer({
+			allowedRootEndpoints: ["projects"],
+		});
+		const names = instance.tools.map((tool) => tool.name);
+
+		expect(names.length).toBeGreaterThan(0);
+		expect(names.every((name) => name.startsWith("projects."))).toBe(true);
+		expect(names.some((name) => name.startsWith("agents."))).toBe(false);
+		expect(names.some((name) => name.startsWith("net."))).toBe(false);
+	});
+
+	it("throws on unknown root endpoints", () => {
+		expect(() =>
+			createExampleMcpServer({
+				allowedRootEndpoints: ["unknown-root"],
+			}),
+		).toThrow("Unknown root endpoints");
+	});
+
+	it("disables write-capable tools when disableWrite=true", () => {
+		const instance = createExampleMcpServer({
+			disableWrite: true,
+		});
+		const names = instance.tools.map((tool) => tool.name);
+
+		expect(names).toContain("projects.readGitTask");
+		expect(names).toContain("projects.listProjects");
+		expect(names).toContain("agents.listAgents");
+		expect(names).toContain("net.curl");
+		expect(names).not.toContain("projects.createGitIssue");
+		expect(names).not.toContain("projects.writeGitTask");
+		expect(names).not.toContain("projects.syncTasks");
+		expect(names).not.toContain("projects.clearIssues");
+		expect(names).not.toContain("projects.generateSpec");
+		expect(names).not.toContain("projects.setActive");
+		expect(names).not.toContain("projects.main");
+		expect(names).not.toContain("agents.createAgent");
+		expect(names).not.toContain("agents.setActive");
+		expect(names).not.toContain("agents.setActiveLink");
+		expect(names).not.toContain("agents.runAgent");
+		expect(names).not.toContain("agents.main");
+	});
+
+	it("applies disableWrite with root endpoint whitelist", () => {
+		const instance = createExampleMcpServer({
+			allowedRootEndpoints: ["projects"],
+			disableWrite: true,
+		});
+		const names = instance.tools.map((tool) => tool.name);
+
+		expect(names.length).toBeGreaterThan(0);
+		expect(names.every((name) => name.startsWith("projects."))).toBe(true);
+		expect(names).toContain("projects.readGitTask");
+		expect(names).toContain("projects.fetchGitTasks");
+		expect(names).not.toContain("projects.createGitIssue");
+		expect(names).not.toContain("projects.writeGitTask");
+		expect(names).not.toContain("projects.syncTasks");
+	});
+
+	it("re-enables issue write endpoints when enableIssues=true with disableWrite", () => {
+		const instance = createExampleMcpServer({
+			disableWrite: true,
+			enableIssues: true,
+		});
+		const names = instance.tools.map((tool) => tool.name);
+
+		expect(names).toContain("projects.fetchGitTasks");
+		expect(names).toContain("projects.readGitTask");
+		expect(names).toContain("projects.createGitIssue");
+		expect(names).toContain("projects.writeGitTask");
+		expect(names).not.toContain("projects.syncTasks");
+		expect(names).not.toContain("projects.clearIssues");
+		expect(names).not.toContain("projects.generateSpec");
+		expect(names).not.toContain("projects.setActive");
+		expect(names).not.toContain("agents.createAgent");
+		expect(names).not.toContain("agents.runAgent");
+	});
+
+	it("exposes syncTasks and clearIssues only when admin=true", () => {
+		const defaultInstance = createExampleMcpServer();
+		const defaultNames = defaultInstance.tools.map((tool) => tool.name);
+		expect(defaultNames).not.toContain("projects.syncTasks");
+		expect(defaultNames).not.toContain("projects.clearIssues");
+
+		const adminInstance = createExampleMcpServer({ admin: true });
+		const adminNames = adminInstance.tools.map((tool) => tool.name);
+		expect(adminNames).toContain("projects.syncTasks");
+		expect(adminNames).toContain("projects.clearIssues");
+	});
+
+	it("requires admin along with enableIssues for destructive issue endpoints under disableWrite", () => {
+		const nonAdmin = createExampleMcpServer({
+			disableWrite: true,
+			enableIssues: true,
+		});
+		const nonAdminNames = nonAdmin.tools.map((tool) => tool.name);
+		expect(nonAdminNames).not.toContain("projects.syncTasks");
+		expect(nonAdminNames).not.toContain("projects.clearIssues");
+
+		const admin = createExampleMcpServer({
+			disableWrite: true,
+			enableIssues: true,
+			admin: true,
+		});
+		const adminNames = admin.tools.map((tool) => tool.name);
+		expect(adminNames).toContain("projects.syncTasks");
+		expect(adminNames).toContain("projects.clearIssues");
+	});
+});
+
+describe("createExampleMcpServer request handling", () => {
+	const getToolHandler = (
+		instance: ReturnType<typeof createExampleMcpServer>,
+	) => {
+		const handler = (instance.server as any)._requestHandlers?.get(
+			"tools/call",
+		);
+		if (!handler) {
+			throw new Error("tools/call handler not registered");
+		}
+		return handler as (request: any, extra: any) => Promise<any>;
+	};
+
+	it("passes structured args without stringifying", async () => {
+		const tempDir = await fs.mkdtemp(
+			path.join(os.tmpdir(), "f0-mcp-server-test-"),
+		);
+		try {
+			await fs.writeFile(
+				path.join(tempDir, "boot.v0.0.1.md"),
+				"# boot\n",
+				"utf8",
+			);
+			const instance = createExampleMcpServer();
+			const handler = getToolHandler(instance);
+
+			const result = await handler(
+				{
+					method: "tools/call",
+					params: {
+						name: "agents.resolveTargetFile",
+						arguments: {
+							args: [
+								tempDir,
+								{ parts: [], base: "boot", version: "v0.0.1", ext: "md" },
+							],
+						},
+					},
+				},
+				{},
+			);
+
+			const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+			expect(payload.ok).toBe(true);
+			expect(payload.result).toBe("boot.v0.0.1.md");
+		} finally {
+			await fs.rm(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it('parses continueOnError from string "false" (fails fast)', async () => {
+		const instance = createExampleMcpServer();
+		const handler = getToolHandler(instance);
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "batch",
+					arguments: {
+						calls: [{ tool: "projects.usage" }, { tool: "unknown.tool" }],
+						continueOnError: "false",
+					},
+				},
+			},
+			{},
+		);
+
+		expect(result.isError).toBe(true);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(false);
+		expect(payload.error?.message).toContain("Unknown tool");
+	});
+
+	it('parses continueOnError from string "true" (returns per-call errors)', async () => {
+		const instance = createExampleMcpServer();
+		const handler = getToolHandler(instance);
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "batch",
+					arguments: {
+						calls: [{ tool: "projects.usage" }, { tool: "unknown.tool" }],
+						continueOnError: "true",
+						maxConcurrency: 2,
+					},
+				},
+			},
+			{},
+		);
+
+		expect(result.isError).toBe(true);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(false);
+		expect(payload.error?.message).toContain("batch calls failed");
+		expect(Array.isArray(payload.error?.details?.results)).toBe(true);
+		expect(payload.error.details.results[1].isError).toBe(true);
+	});
+
+	it("accepts unprefixed tool name when toolsPrefix is set", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "api" });
+		const handler = getToolHandler(instance);
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "projects.usage",
+					arguments: {},
+				},
+			},
+			{},
+		);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(typeof payload.result).toBe("string");
+		expect(payload.result).toContain("Usage");
+	});
+
+	it("exposes mcp.describeTool for tool discovery", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "api" });
+		const handler = getToolHandler(instance);
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "mcp.describeTool",
+					arguments: {
+						args: ["projects.usage"],
+					},
+				},
+			},
+			{},
+		);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.name).toBe("api.projects.usage");
+		expect(payload.result.unprefixedName).toBe("projects.usage");
+		expect(payload.result.access).toBe("read");
+	});
+
+	it("exposes net.curl under toolsPrefix", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "f0" });
+		const handler = getToolHandler(instance);
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "mcp.describeTool",
+					arguments: {
+						args: ["net.curl"],
+					},
+				},
+			},
+			{},
+		);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.name).toBe("f0.net.curl");
+		expect(payload.result.unprefixedName).toBe("net.curl");
+		expect(payload.result.access).toBe("read");
+	});
+
+	it("exposes net_curl under toolsPrefix", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "f0" });
+		const handler = getToolHandler(instance);
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "mcp.describeTool",
+					arguments: {
+						args: ["net_curl"],
+					},
+				},
+			},
+			{},
+		);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.name).toBe("f0.net_curl");
+		expect(payload.result.unprefixedName).toBe("net_curl");
+		expect(payload.result.access).toBe("read");
+	});
+
+	it("can execute net.curl with curl-style args", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "f0" });
+		const handler = getToolHandler(instance);
+
+		const server = Bun.serve({
+			port: 0,
+			fetch: () => new Response("ok", { headers: { "x-test": "1" } }),
+		});
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "f0.net.curl",
+					arguments: {
+						args: [`http://127.0.0.1:${server.port}/hello`],
+					},
+				},
+			},
+			{},
+		);
+
+		server.stop(true);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.exitCode).toBe(0);
+		expect(String(payload.result.stdout ?? "")).toBe("ok");
+		expect(payload.result.results?.[0]?.httpCode).toBe(200);
+	});
+
+	it("can execute net_curl with curl-style args", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "f0" });
+		const handler = getToolHandler(instance);
+
+		const server = Bun.serve({
+			port: 0,
+			fetch: () => new Response("ok", { headers: { "x-test": "1" } }),
+		});
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "f0.net_curl",
+					arguments: {
+						args: [`http://127.0.0.1:${server.port}/hello`],
+					},
+				},
+			},
+			{},
+		);
+
+		server.stop(true);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.exitCode).toBe(0);
+		expect(String(payload.result.stdout ?? "")).toBe("ok");
+		expect(payload.result.results?.[0]?.httpCode).toBe(200);
+	});
+
+	it("can execute net.curl in structured mode (url/method)", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "f0" });
+		const handler = getToolHandler(instance);
+
+		const server = Bun.serve({
+			port: 0,
+			fetch: (req) => Response.json({ ok: true, method: req.method }),
+		});
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "f0.net.curl",
+					arguments: {
+						url: `http://127.0.0.1:${server.port}/json`,
+						method: "GET",
+					},
+				},
+			},
+			{},
+		);
+
+		server.stop(true);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.exitCode).toBe(0);
+		expect(JSON.parse(payload.result.stdout).method).toBe("GET");
+	});
+
+	it("can execute net_curl in structured mode (url/method)", async () => {
+		const instance = createExampleMcpServer({ toolsPrefix: "f0" });
+		const handler = getToolHandler(instance);
+
+		const server = Bun.serve({
+			port: 0,
+			fetch: (req) => Response.json({ ok: true, method: req.method }),
+		});
+
+		const result = await handler(
+			{
+				method: "tools/call",
+				params: {
+					name: "f0.net_curl",
+					arguments: {
+						url: `http://127.0.0.1:${server.port}/json`,
+						method: "GET",
+					},
+				},
+			},
+			{},
+		);
+
+		server.stop(true);
+
+		expect(result.isError).toBe(false);
+		const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+		expect(payload.ok).toBe(true);
+		expect(payload.result.exitCode).toBe(0);
+		expect(JSON.parse(payload.result.stdout).method).toBe("GET");
+	});
+});