AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
import { describe, expect, test } from "bun:test";
import { Hono } from "hono";
import { AppError } from "./app-error.ts";
import { isAllowedMcpOrigin, registerMcpRoutes } from "./mcp-routes.ts";
const auth = {
kind: "agent",
actorType: "agent",
actorId: "tok_mcp",
username: "mcp-agent",
displayName: null,
scopes: ["read:memos"],
workspaceId: "ws_1",
role: "member",
};
const createApp = (overrides = {}) => {
const app = new Hono();
registerMcpRoutes(app, {
authenticateRequest: async () => auth,
callTool: async (_context, _auth, name, arguments_) => ({ name, arguments: arguments_ }),
...overrides,
});
return app;
};
test("poster previews emit MCP image content without duplicating base64 in metadata", async () => {
const app = createApp({ callTool: async () => ({ available: true, revision: 1, image: { data: "AQID", mimeType: "image/png" } }) });
const response = await app.request("/mcp", mcpRequest({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "get_poster_preview", arguments: { memoId: "poster" } } }, { "MCP-Protocol-Version": "2025-11-25" }));
const result = (await response.json()).result;
expect(result.content[1]).toEqual({ type: "image", data: "AQID", mimeType: "image/png" });
expect(result.content[0].text).not.toContain("AQID");
expect(result.structuredContent.image).toBeUndefined();
});
const mcpRequest = (payload, headers = {}) => ({
method: "POST",
headers: {
"Content-Type": "application/json",
Accept: "application/json, text/event-stream",
...headers,
},
body: JSON.stringify(payload),
});
const modernMcpRequest = (payload, headers = {}) => {
const params = {
...payload.params,
_meta: {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientInfo": { name: "edgeever-test", version: "1.0.0" },
"io.modelcontextprotocol/clientCapabilities": {},
...payload.params?._meta,
},
};
const name = payload.method === "resources/read" ? params.uri : params.name;
return mcpRequest(
{ ...payload, params },
{
"MCP-Protocol-Version": "2026-07-28",
"Mcp-Method": payload.method,
...(["tools/call", "resources/read", "prompts/get"].includes(payload.method) && name
? { "Mcp-Name": name }
: {}),
...headers,
},
);
};
describe("MCP HTTP routes", () => {
test("accepts only same-origin browser requests", async () => {
expect(isAllowedMcpOrigin("https://notes.example.com/mcp", "https://notes.example.com")).toBe(true);
expect(isAllowedMcpOrigin("https://notes.example.com/mcp", "https://evil.example.com")).toBe(false);
const response = await createApp().request(
"https://notes.example.com/mcp",
mcpRequest(
{ jsonrpc: "2.0", id: 1, method: "initialize" },
{ Origin: "https://evil.example.com" },
),
);
expect(response.status).toBe(403);
});
test("returns initialization metadata with a supported protocol", async () => {
const response = await createApp().request(
"/mcp",
mcpRequest({
jsonrpc: "2.0",
id: 1,
method: "initialize",
params: { protocolVersion: "2025-06-18" },
}),
);
expect(response.status).toBe(200);
const body = await response.json();
expect(body).toMatchObject({
jsonrpc: "2.0",
id: 1,
result: {
protocolVersion: "2025-06-18",
serverInfo: { name: "edgeever" },
capabilities: { tools: { listChanged: false } },
},
});
expect(body.result.resultType).toBeUndefined();
});
test("discovers and serves the stateless 2026 protocol without changing legacy responses", async () => {
let response = await createApp().request(
"/mcp",
modernMcpRequest({ jsonrpc: "2.0", id: "discover", method: "server/discover" }),
);
expect(response.status).toBe(200);
let body = await response.json();
expect(body).toMatchObject({
id: "discover",
result: {
resultType: "complete",
supportedVersions: ["2026-07-28"],
capabilities: { tools: { listChanged: false } },
ttlMs: 3_600_000,
cacheScope: "public",
_meta: {
"io.modelcontextprotocol/serverInfo": { name: "edgeever" },
},
},
});
expect(body.result.serverInfo).toBeUndefined();
response = await createApp().request(
"/mcp",
modernMcpRequest({ jsonrpc: "2.0", id: "tools", method: "tools/list" }),
);
body = await response.json();
expect(body.result).toMatchObject({
resultType: "complete",
ttlMs: 3_600_000,
cacheScope: "public",
_meta: { "io.modelcontextprotocol/serverInfo": { name: "edgeever" } },
});
expect(body.result.tools).toEqual(expect.arrayContaining([expect.objectContaining({ name: "get_current_user" })]));
expect(body.result.tools).toEqual(expect.arrayContaining([
expect.objectContaining({ name: "get_table_records", annotations: expect.objectContaining({ readOnlyHint: true }) }),
expect.objectContaining({ name: "add_table_record" }),
expect.objectContaining({ name: "update_table_record" }),
expect.objectContaining({ name: "delete_table_record" }),
expect.objectContaining({ name: "create_table_memo" }),
expect.objectContaining({ name: "update_table_schema" }),
]));
});
test("requires matching 2026 transport headers and per-request metadata", async () => {
const payload = {
jsonrpc: "2.0",
id: 20,
method: "tools/call",
params: {
name: "get_current_user",
arguments: {},
_meta: {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {},
},
},
};
let response = await createApp().request(
"/mcp",
mcpRequest(payload, {
"MCP-Protocol-Version": "2026-07-28",
"Mcp-Method": "tools/call",
}),
);
expect(response.status).toBe(400);
expect(await response.json()).toMatchObject({ error: { code: -32020 } });
response = await createApp().request(
"/mcp",
modernMcpRequest(payload, { "Mcp-Method": "tools/list" }),
);
expect(response.status).toBe(400);
expect(await response.json()).toMatchObject({ error: { code: -32020 } });
response = await createApp().request(
"/mcp",
modernMcpRequest({
...payload,
params: {
...payload.params,
_meta: { "io.modelcontextprotocol/clientCapabilities": [] },
},
}),
);
expect(response.status).toBe(400);
expect(await response.json()).toMatchObject({ error: { code: -32602 } });
});
test("reports unsupported protocol versions with the modern negotiation error", async () => {
const response = await createApp().request(
"/mcp",
mcpRequest(
{
jsonrpc: "2.0",
id: 21,
method: "server/discover",
params: {
_meta: {
"io.modelcontextprotocol/protocolVersion": "1900-01-01",
"io.modelcontextprotocol/clientCapabilities": {},
},
},
},
{ "MCP-Protocol-Version": "1900-01-01", "Mcp-Method": "server/discover" },
),
);
expect(response.status).toBe(400);
expect(await response.json()).toMatchObject({
error: {
code: -32022,
data: { requested: "1900-01-01", supported: expect.arrayContaining(["2026-07-28", "2025-11-25"]) },
},
});
});
test("returns an authentication challenge when credentials are missing", async () => {
const response = await createApp({ authenticateRequest: async () => null }).request(
"/mcp",
mcpRequest({ jsonrpc: "2.0", id: 2, method: "tools/list" }),
);
expect(response.status).toBe(401);
expect(response.headers.get("WWW-Authenticate")).toBe('Bearer realm="EdgeEver MCP"');
expect(await response.json()).toMatchObject({ error: { code: -32001 } });
});
test("delegates known tool calls and preserves structured output", async () => {
let received;
const response = await createApp({
callTool: async (...args) => {
received = args;
return { username: "owner" };
},
}).request(
"/mcp",
mcpRequest({
jsonrpc: "2.0",
id: 3,
method: "tools/call",
params: { name: "get_current_user", arguments: {} },
}),
);
expect(response.status).toBe(200);
expect(received[2]).toBe("get_current_user");
expect(await response.json()).toMatchObject({
result: { structuredContent: { username: "owner" }, isError: false },
});
});
test("adds the modern result envelope to 2026 tool calls", async () => {
const response = await createApp().request(
"/mcp",
modernMcpRequest({
jsonrpc: "2.0",
id: 30,
method: "tools/call",
params: { name: "get_current_user", arguments: {} },
}),
);
expect(response.status).toBe(200);
expect(await response.json()).toMatchObject({
result: {
resultType: "complete",
structuredContent: { name: "get_current_user" },
isError: false,
_meta: { "io.modelcontextprotocol/serverInfo": { name: "edgeever" } },
},
});
});
test("maps application failures into MCP tool results", async () => {
const response = await createApp({
callTool: async () => {
throw new AppError("forbidden", "Write scope required", 403);
},
}).request(
"/mcp",
mcpRequest({
jsonrpc: "2.0",
id: 4,
method: "tools/call",
params: { name: "create_memo", arguments: {} },
}),
);
expect(response.status).toBe(200);
expect(await response.json()).toMatchObject({
result: {
isError: true,
structuredContent: { error: { code: "forbidden", message: "Write scope required" } },
},
});
});
});