@meetlark/mcp-server 1.0.0

package/test/cli.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliPath = resolve(__dirname, "..", "bin", "cli.ts");
+
+describe("cli entry point", () => {
+  it("file exists and is readable", () => {
+    const content = readFileSync(cliPath, "utf-8");
+    assert.ok(content.length > 0, "cli.ts should not be empty");
+  });
+
+  it("has shebang line", () => {
+    const content = readFileSync(cliPath, "utf-8");
+    assert.ok(content.startsWith("#!/usr/bin/env node"), "cli.ts should start with shebang");
+  });
+
+  it("imports StdioServerTransport", () => {
+    const content = readFileSync(cliPath, "utf-8");
+    assert.ok(
+      content.includes("StdioServerTransport"),
+      "cli.ts should import StdioServerTransport",
+    );
+  });
+
+  it("imports createMeetLarkServer", () => {
+    const content = readFileSync(cliPath, "utf-8");
+    assert.ok(
+      content.includes("createMeetLarkServer"),
+      "cli.ts should import createMeetLarkServer",
+    );
+  });
+
+  it("connects server to transport", () => {
+    const content = readFileSync(cliPath, "utf-8");
+    assert.ok(
+      content.includes("server.connect(transport)"),
+      "cli.ts should connect server to transport",
+    );
+  });
+});

package/test/client.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { MeetLarkClient } from "../src/client.ts";
+
+let originalFetch: typeof globalThis.fetch;
+
+beforeEach(() => {
+  originalFetch = globalThis.fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("MeetLarkClient", () => {
+  it("createPoll sends POST with autoVerify=true", async () => {
+    let capturedUrl = "";
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = async (input, init) => {
+      capturedUrl = String(input);
+      capturedInit = init;
+      return new Response(
+        JSON.stringify({ data: { id: "poll_1" }, meta: { requestId: "r1" } }),
+        { status: 201 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    await client.createPoll({ title: "Test" });
+
+    assert.ok(capturedUrl.includes("?autoVerify=true"));
+    assert.strictEqual(capturedInit?.method, "POST");
+  });
+
+  it("createPoll returns parsed response on success", async () => {
+    const responseData = {
+      id: "poll_1",
+      adminToken: "adm_abc",
+      participateToken: "prt_abc",
+    };
+
+    globalThis.fetch = async () => {
+      return new Response(
+        JSON.stringify({ data: responseData, meta: { requestId: "r1" } }),
+        { status: 201 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    const result = await client.createPoll({ title: "Test" });
+
+    assert.deepStrictEqual(result.data, responseData);
+    assert.strictEqual(result.error, undefined);
+  });
+
+  it("createPoll returns verification error on 403", async () => {
+    globalThis.fetch = async () => {
+      return new Response(
+        JSON.stringify({
+          error: {
+            code: "email_not_verified",
+            message: "Email not verified",
+            details: { verificationSent: true, email: "test@example.com" },
+          },
+          meta: { requestId: "r1" },
+        }),
+        { status: 403 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    const result = await client.createPoll({ title: "Test" });
+
+    assert.strictEqual(result.error?.status, 403);
+    assert.strictEqual(result.error?.code, "email_not_verified");
+    assert.strictEqual(result.error?.message, "Email not verified");
+    assert.strictEqual(result.data, undefined);
+  });
+
+  it("getResults sends GET to correct path", async () => {
+    let capturedUrl = "";
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = async (input, init) => {
+      capturedUrl = String(input);
+      capturedInit = init;
+      return new Response(
+        JSON.stringify({
+          data: { poll: { id: "poll_1" } },
+          meta: { requestId: "r1" },
+        }),
+        { status: 200 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    await client.getResults("prt_abc123");
+
+    assert.strictEqual(
+      capturedUrl,
+      "https://api.test/api/v1/vote/participate/prt_abc123",
+    );
+    assert.strictEqual(capturedInit?.method, undefined); // GET is default
+  });
+
+  it("vote sends POST with body", async () => {
+    let capturedUrl = "";
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = async (input, init) => {
+      capturedUrl = String(input);
+      capturedInit = init;
+      return new Response(
+        JSON.stringify({
+          data: { success: true, participant: { id: "p1" } },
+          meta: { requestId: "r1" },
+        }),
+        { status: 200 },
+      );
+    };
+
+    const voteData = { name: "Alice", votes: [{ timeSlotId: "ts1", value: "yes" }] };
+    const client = new MeetLarkClient("https://api.test");
+    await client.vote("prt_abc123", voteData);
+
+    assert.strictEqual(
+      capturedUrl,
+      "https://api.test/api/v1/vote/participate/prt_abc123",
+    );
+    assert.strictEqual(capturedInit?.method, "POST");
+    assert.strictEqual(capturedInit?.body, JSON.stringify(voteData));
+  });
+
+  it("getAdminView sends GET to admin path", async () => {
+    let capturedUrl = "";
+
+    globalThis.fetch = async (input) => {
+      capturedUrl = String(input);
+      return new Response(
+        JSON.stringify({
+          data: { id: "poll_1", title: "Test" },
+          meta: { requestId: "r1" },
+        }),
+        { status: 200 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    await client.getAdminView("adm_abc123");
+
+    assert.strictEqual(
+      capturedUrl,
+      "https://api.test/api/v1/polls/admin/adm_abc123",
+    );
+  });
+
+  it("closePoll sends POST to close path", async () => {
+    let capturedUrl = "";
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = async (input, init) => {
+      capturedUrl = String(input);
+      capturedInit = init;
+      return new Response(
+        JSON.stringify({ data: { success: true }, meta: { requestId: "r1" } }),
+        { status: 200 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    await client.closePoll("adm_abc123");
+
+    assert.strictEqual(
+      capturedUrl,
+      "https://api.test/api/v1/polls/admin/adm_abc123/close",
+    );
+    assert.strictEqual(capturedInit?.method, "POST");
+  });
+
+  it("reopenPoll sends POST to reopen path", async () => {
+    let capturedUrl = "";
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = async (input, init) => {
+      capturedUrl = String(input);
+      capturedInit = init;
+      return new Response(
+        JSON.stringify({ data: { success: true }, meta: { requestId: "r1" } }),
+        { status: 200 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    await client.reopenPoll("adm_abc123");
+
+    assert.strictEqual(
+      capturedUrl,
+      "https://api.test/api/v1/polls/admin/adm_abc123/reopen",
+    );
+    assert.strictEqual(capturedInit?.method, "POST");
+  });
+
+  it("handles network error gracefully", async () => {
+    globalThis.fetch = async () => {
+      throw new Error("Connection refused");
+    };
+
+    const client = new MeetLarkClient("https://api.test");
+    const result = await client.createPoll({ title: "Test" });
+
+    assert.strictEqual(result.error?.status, 0);
+    assert.strictEqual(result.error?.code, "network_error");
+    assert.strictEqual(result.error?.message, "Connection refused");
+    assert.strictEqual(result.data, undefined);
+  });
+
+  it("uses custom API URL from config", async () => {
+    let capturedUrl = "";
+
+    globalThis.fetch = async (input) => {
+      capturedUrl = String(input);
+      return new Response(
+        JSON.stringify({ data: { id: "poll_1" }, meta: { requestId: "r1" } }),
+        { status: 201 },
+      );
+    };
+
+    const client = new MeetLarkClient("https://custom.example.com");
+    await client.createPoll({ title: "Test" });
+
+    assert.ok(capturedUrl.startsWith("https://custom.example.com"));
+  });
+});

package/test/route.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { createMeetLarkServer } from "../src/server.ts";
+
+let originalFetch: typeof globalThis.fetch;
+
+beforeEach(() => {
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = async () =>
+    new Response(JSON.stringify({ data: {} }), { status: 200 });
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+const MCP_HEADERS = {
+  "Content-Type": "application/json",
+  Accept: "application/json, text/event-stream",
+};
+
+/** Creates a fresh server + transport per request, matching the stateless route handler pattern. */
+async function handleRequest(req: Request): Promise<Response> {
+  const server = createMeetLarkServer("https://api.test");
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: undefined,
+  });
+  await server.connect(transport);
+  return transport.handleRequest(req);
+}
+
+/** Parse response body, handling both SSE and JSON content types. */
+async function parseResponse(
+  res: Response,
+): Promise<Record<string, unknown>> {
+  const text = await res.text();
+  const contentType = res.headers.get("content-type") || "";
+
+  if (contentType.includes("text/event-stream")) {
+    const dataLine = text
+      .split("\n")
+      .find((line) => line.startsWith("data: "));
+    assert.ok(dataLine, "Expected data line in SSE response");
+    return JSON.parse(dataLine!.slice(6));
+  }
+
+  return JSON.parse(text);
+}
+
+describe("HTTP route handler", () => {
+  it("responds to MCP initialize request", async () => {
+    const res = await handleRequest(
+      new Request("http://localhost/mcp", {
+        method: "POST",
+        headers: MCP_HEADERS,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" },
+          },
+        }),
+      }),
+    );
+
+    assert.ok(res.status === 200, `Expected 200, got ${res.status}`);
+    const body = await parseResponse(res);
+    assert.strictEqual(body.jsonrpc, "2.0");
+    assert.strictEqual(body.id, 1);
+    assert.ok(body.result, "Expected result in response");
+    const result = body.result as Record<string, unknown>;
+    assert.ok(result.serverInfo, "Expected serverInfo");
+    const serverInfo = result.serverInfo as Record<string, unknown>;
+    assert.strictEqual(serverInfo.name, "meetlark");
+  });
+
+  it("returns tool list on tools/list request", async () => {
+    const res = await handleRequest(
+      new Request("http://localhost/mcp", {
+        method: "POST",
+        headers: MCP_HEADERS,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/list",
+          params: {},
+        }),
+      }),
+    );
+
+    assert.ok(res.status === 200, `Expected 200, got ${res.status}`);
+    const body = await parseResponse(res);
+    assert.strictEqual(body.jsonrpc, "2.0");
+    assert.strictEqual(body.id, 1);
+    const result = body.result as { tools: { name: string }[] };
+    assert.ok(result.tools, "Expected tools in result");
+
+    const toolNames = result.tools.map((t) => t.name).sort();
+    assert.deepStrictEqual(toolNames, [
+      "meetlark_close_poll",
+      "meetlark_create_poll",
+      "meetlark_get_admin_view",
+      "meetlark_get_results",
+      "meetlark_reopen_poll",
+      "meetlark_vote",
+    ]);
+  });
+});

package/test/server.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createMeetLarkServer } from "../src/server.ts";
+
+let originalFetch: typeof globalThis.fetch;
+let client: Client;
+
+beforeEach(() => {
+  originalFetch = globalThis.fetch;
+  // Stub fetch so tool registration doesn't hit real network
+  globalThis.fetch = async () => new Response(JSON.stringify({ data: {} }), { status: 200 });
+});
+
+afterEach(async () => {
+  globalThis.fetch = originalFetch;
+  await client?.close();
+});
+
+describe("createMeetLarkServer", () => {
+  it("returns an McpServer instance", () => {
+    const server = createMeetLarkServer();
+    assert.ok(server instanceof McpServer);
+  });
+
+  it("has all 6 tools registered", async () => {
+    const server = createMeetLarkServer("https://api.test");
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    client = new Client({ name: "test-client", version: "1.0.0" });
+    await Promise.all([
+      client.connect(clientTransport),
+      server.connect(serverTransport),
+    ]);
+
+    const { tools } = await client.listTools();
+    const toolNames = tools.map((t) => t.name).sort();
+
+    assert.deepStrictEqual(toolNames, [
+      "meetlark_close_poll",
+      "meetlark_create_poll",
+      "meetlark_get_admin_view",
+      "meetlark_get_results",
+      "meetlark_reopen_poll",
+      "meetlark_vote",
+    ]);
+  });
+
+  it("uses default API URL when none provided", async () => {
+    const server = createMeetLarkServer();
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    client = new Client({ name: "test-client", version: "1.0.0" });
+    await Promise.all([
+      client.connect(clientTransport),
+      server.connect(serverTransport),
+    ]);
+
+    let capturedUrl = "";
+    globalThis.fetch = async (input) => {
+      capturedUrl = String(input);
+      return new Response(JSON.stringify({ data: { poll: {} }, meta: { requestId: "r1" } }), { status: 200 });
+    };
+
+    await client.callTool({ name: "meetlark_get_results", arguments: { participateToken: "prt_test" } });
+    assert.ok(capturedUrl.startsWith("https://meetlark.ai/"), `Expected default URL, got: ${capturedUrl}`);
+  });
+
+  it("uses custom API URL when provided", async () => {
+    const server = createMeetLarkServer("https://custom.example.com");
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    client = new Client({ name: "test-client", version: "1.0.0" });
+    await Promise.all([
+      client.connect(clientTransport),
+      server.connect(serverTransport),
+    ]);
+
+    let capturedUrl = "";
+    globalThis.fetch = async (input) => {
+      capturedUrl = String(input);
+      return new Response(JSON.stringify({ data: { poll: {} }, meta: { requestId: "r1" } }), { status: 200 });
+    };
+
+    await client.callTool({ name: "meetlark_get_results", arguments: { participateToken: "prt_test" } });
+    assert.ok(capturedUrl.startsWith("https://custom.example.com/"), `Expected custom URL, got: ${capturedUrl}`);
+  });
+});

package/test/setup.test.ts

@@ -0,0 +1,27 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+
+describe("config", () => {
+  it("exports MEETLARK_API_URL default", async () => {
+    const { MEETLARK_API_URL } = await import("../src/config.ts");
+    assert.strictEqual(MEETLARK_API_URL, "https://meetlark.ai");
+  });
+
+  it("respects MEETLARK_API_URL env var", async () => {
+    const original = process.env.MEETLARK_API_URL;
+    process.env.MEETLARK_API_URL = "https://custom.example.com";
+    try {
+      // Dynamic re-import won't re-evaluate the module in the same process,
+      // so we test the env var mechanism directly
+      const url =
+        process.env.MEETLARK_API_URL || "https://meetlark.ai";
+      assert.strictEqual(url, "https://custom.example.com");
+    } finally {
+      if (original === undefined) {
+        delete process.env.MEETLARK_API_URL;
+      } else {
+        process.env.MEETLARK_API_URL = original;
+      }
+    }
+  });
+});