@aria-cli/tools 1.0.8 → 1.0.10

package/tests/mcp/connection.test.ts

@@ -1,846 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { PassThrough } from "stream";
-import { EventEmitter } from "events";
-import { MCPServerConnection } from "../../src/mcp/connection.js";
-
-// ---------------------------------------------------------------------------
-// Fake child process that behaves like a spawned stdio MCP server.
-// Incoming requests arrive on fakeStdin; responses are written to fakeStdout.
-// ---------------------------------------------------------------------------
-
-interface FakeProcess extends EventEmitter {
-  stdin: PassThrough;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  pid: number;
-  killed: boolean;
-  kill: ReturnType<typeof vi.fn>;
-  /** Helper: read next JSON-RPC message written by the client */
-  nextRequest: () => Promise<{ jsonrpc: string; id: string; method: string; params?: unknown }>;
-  /** Helper: send a JSON-RPC response back to the client */
-  respond: (id: string, result: unknown) => void;
-  /** Helper: send a JSON-RPC error back to the client */
-  respondError: (id: string, code: number, message: string) => void;
-}
-
-function createFakeProcess(): FakeProcess {
-  const proc = new EventEmitter() as FakeProcess;
-  proc.stdin = new PassThrough();
-  proc.stdout = new PassThrough();
-  proc.stderr = new PassThrough();
-  proc.pid = 12345;
-  proc.killed = false;
-  proc.kill = vi.fn((signal?: string) => {
-    // On SIGKILL or SIGTERM, emit exit after a microtask
-    proc.killed = true;
-    process.nextTick(() => proc.emit("exit", signal === "SIGKILL" ? 137 : 0));
-  });
-
-  // Collect data written to stdin (i.e. client -> server)
-  const incomingBuffer: string[] = [];
-  let waitingResolve: ((line: string) => void) | null = null;
-  let lineBuffer = "";
-
-  proc.stdin.on("data", (chunk: Buffer) => {
-    lineBuffer += chunk.toString();
-    let idx: number;
-    while ((idx = lineBuffer.indexOf("\n")) !== -1) {
-      const line = lineBuffer.slice(0, idx).trim();
-      lineBuffer = lineBuffer.slice(idx + 1);
-      if (line) {
-        if (waitingResolve) {
-          const resolve = waitingResolve;
-          waitingResolve = null;
-          resolve(line);
-        } else {
-          incomingBuffer.push(line);
-        }
-      }
-    }
-  });
-
-  proc.nextRequest = () =>
-    new Promise((resolve) => {
-      if (incomingBuffer.length > 0) {
-        resolve(JSON.parse(incomingBuffer.shift()!));
-      } else {
-        waitingResolve = (line) => resolve(JSON.parse(line));
-      }
-    });
-
-  proc.respond = (id: string, result: unknown) => {
-    proc.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
-  };
-
-  proc.respondError = (id: string, code: number, message: string) => {
-    proc.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
-  };
-
-  return proc;
-}
-
-// ---------------------------------------------------------------------------
-// Mock child_process.spawn so MCPServerConnection uses our fake process
-// ---------------------------------------------------------------------------
-
-let fakeProc: FakeProcess;
-
-vi.mock("child_process", () => ({
-  spawn: vi.fn(() => fakeProc),
-}));
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("MCPServerConnection", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    fakeProc = createFakeProcess();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  // ============================
-  // Helper: perform the initialize handshake
-  // ============================
-  async function doInitialize(
-    conn: MCPServerConnection,
-    capabilities: Record<string, unknown> = { tools: { listChanged: true } },
-  ) {
-    const initPromise = conn.initialize();
-
-    // Server receives initialize request
-    const initReq = await fakeProc.nextRequest();
-    expect(initReq.method).toBe("initialize");
-    expect(initReq.params).toMatchObject({
-      protocolVersion: "2024-11-05",
-      clientInfo: { name: "aria-cli", version: "1.0.0" },
-    });
-
-    // Server responds with capabilities
-    fakeProc.respond(initReq.id, {
-      protocolVersion: "2024-11-05",
-      capabilities,
-      serverInfo: { name: "test-server", version: "0.1.0" },
-    });
-
-    const result = await initPromise;
-
-    // Client should send initialized notification (no id, just method)
-    const initNotif = await fakeProc.nextRequest();
-    expect(initNotif.method).toBe("notifications/initialized");
-
-    return result;
-  }
-
-  // ==========================================================================
-  // initialize()
-  // ==========================================================================
-
-  describe("initialize()", () => {
-    it("should send initialize request and receive capabilities", async () => {
-      const conn = new MCPServerConnection({ name: "test", command: "echo" });
-      const caps = await doInitialize(conn, {
-        tools: { listChanged: true },
-        resources: { subscribe: true },
-      });
-
-      expect(caps).toEqual({
-        tools: { listChanged: true },
-        resources: { subscribe: true },
-      });
-      expect(conn.initialized).toBe(true);
-      expect(conn.name).toBe("test");
-    });
-
-    it("should throw when URL is missing for sse transport", async () => {
-      const conn = new MCPServerConnection({
-        name: "sse-test",
-        transport: "sse",
-      });
-      await expect(conn.initialize()).rejects.toThrow("URL required for sse transport");
-    });
-
-    it("should throw when command is missing for stdio transport", async () => {
-      const conn = new MCPServerConnection({ name: "no-cmd" });
-      await expect(conn.initialize()).rejects.toThrow("Command required for stdio transport");
-    });
-
-    it("should handle empty capabilities from server", async () => {
-      const conn = new MCPServerConnection({ name: "bare", command: "echo" });
-      const initPromise = conn.initialize();
-
-      const initReq = await fakeProc.nextRequest();
-      fakeProc.respond(initReq.id, {
-        protocolVersion: "2024-11-05",
-        serverInfo: { name: "bare-server", version: "0.1.0" },
-        // capabilities omitted -> defaults to {}
-      });
-
-      const caps = await initPromise;
-      expect(caps).toEqual({});
-      expect(conn.initialized).toBe(true);
-    });
-
-    it("should emit 'log' on stderr data", async () => {
-      const conn = new MCPServerConnection({ name: "stderr-test", command: "echo" });
-      const logs: unknown[] = [];
-      conn.on("log", (msg) => logs.push(msg));
-
-      const initPromise = conn.initialize();
-
-      // Write something to stderr before responding to init
-      fakeProc.stderr.write("Server starting up...\n");
-
-      const initReq = await fakeProc.nextRequest();
-      fakeProc.respond(initReq.id, {
-        protocolVersion: "2024-11-05",
-        capabilities: {},
-        serverInfo: { name: "test", version: "0.1.0" },
-      });
-      await initPromise;
-      // Consume initialized notification
-      await fakeProc.nextRequest();
-
-      expect(logs.length).toBeGreaterThan(0);
-      expect(logs[0]).toMatchObject({
-        level: "error",
-        message: expect.stringContaining("Server starting up"),
-      });
-    });
-
-    it("should mark initialized=false and emit 'exit' when process exits", async () => {
-      const conn = new MCPServerConnection({ name: "exit-test", command: "echo" });
-      await doInitialize(conn);
-
-      expect(conn.initialized).toBe(true);
-
-      const exitPromise = new Promise<number | null>((resolve) => {
-        conn.on("exit", resolve);
-      });
-
-      // Simulate process exit
-      fakeProc.emit("exit", 1);
-
-      const exitCode = await exitPromise;
-      expect(exitCode).toBe(1);
-      expect(conn.initialized).toBe(false);
-    });
-
-    it("should forward tools/list_changed notifications", async () => {
-      const conn = new MCPServerConnection({ name: "notif-test", command: "echo" });
-      await doInitialize(conn);
-
-      const notifPromise = new Promise<void>((resolve) => {
-        conn.on("tools/list_changed", resolve);
-      });
-
-      // Server sends a notification
-      fakeProc.stdout.write(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          method: "notifications/tools/list_changed",
-          params: {},
-        }) + "\n",
-      );
-
-      await notifPromise; // should resolve without timeout
-    });
-  });
-
-  // ==========================================================================
-  // listTools()
-  // ==========================================================================
-
-  describe("listTools()", () => {
-    it("should return tool definitions from server", async () => {
-      const conn = new MCPServerConnection({ name: "tools-test", command: "echo" });
-      await doInitialize(conn);
-
-      const listPromise = conn.listTools();
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("tools/list");
-
-      const toolDefs = [
-        {
-          name: "read_file",
-          description: "Read a file",
-          inputSchema: {
-            type: "object",
-            properties: { path: { type: "string" } },
-            required: ["path"],
-          },
-        },
-        {
-          name: "write_file",
-          description: "Write a file",
-          inputSchema: {
-            type: "object",
-            properties: { path: { type: "string" }, content: { type: "string" } },
-            required: ["path", "content"],
-          },
-        },
-      ];
-
-      fakeProc.respond(req.id, { tools: toolDefs });
-
-      const tools = await listPromise;
-      expect(tools).toHaveLength(2);
-      expect(tools[0].name).toBe("read_file");
-      expect(tools[1].name).toBe("write_file");
-      expect(tools[0].inputSchema).toMatchObject({ type: "object" });
-    });
-
-    it("should return empty array when server returns no tools", async () => {
-      const conn = new MCPServerConnection({ name: "empty-tools", command: "echo" });
-      await doInitialize(conn);
-
-      const listPromise = conn.listTools();
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {}); // no tools property
-
-      const tools = await listPromise;
-      expect(tools).toEqual([]);
-    });
-  });
-
-  // ==========================================================================
-  // callTool()
-  // ==========================================================================
-
-  describe("callTool()", () => {
-    it("should send tool call and return successful result", async () => {
-      const conn = new MCPServerConnection({ name: "call-test", command: "echo" });
-      await doInitialize(conn);
-
-      const callPromise = conn.callTool("read_file", { path: "/tmp/test.txt" });
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("tools/call");
-      expect(req.params).toEqual({ name: "read_file", arguments: { path: "/tmp/test.txt" } });
-
-      fakeProc.respond(req.id, {
-        content: [{ type: "text", text: "file contents here" }],
-        isError: false,
-      });
-
-      const result = await callPromise;
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("file contents here");
-      expect(result.data).toEqual([{ type: "text", text: "file contents here" }]);
-    });
-
-    it("should handle tool call with isError=true", async () => {
-      const conn = new MCPServerConnection({ name: "call-err", command: "echo" });
-      await doInitialize(conn);
-
-      const callPromise = conn.callTool("write_file", { path: "/readonly/file" });
-
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {
-        content: [{ type: "text", text: "Permission denied" }],
-        isError: true,
-      });
-
-      const result = await callPromise;
-      expect(result.success).toBe(false);
-      expect(result.message).toBe("Permission denied");
-    });
-
-    it("should concatenate multiple text content blocks", async () => {
-      const conn = new MCPServerConnection({ name: "multi-text", command: "echo" });
-      await doInitialize(conn);
-
-      const callPromise = conn.callTool("multi_tool", {});
-
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {
-        content: [
-          { type: "text", text: "line 1" },
-          { type: "image", data: "base64data", mimeType: "image/png" },
-          { type: "text", text: "line 2" },
-        ],
-      });
-
-      const result = await callPromise;
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("line 1\nline 2");
-    });
-
-    it("should return failure on JSON-RPC error", async () => {
-      const conn = new MCPServerConnection({ name: "rpc-err", command: "echo" });
-      await doInitialize(conn);
-
-      const callPromise = conn.callTool("bad_tool", {});
-
-      const req = await fakeProc.nextRequest();
-      fakeProc.respondError(req.id, -32601, "Method not found");
-
-      const result = await callPromise;
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Method not found");
-    });
-
-    it("should return empty message when content has no text blocks", async () => {
-      const conn = new MCPServerConnection({ name: "no-text", command: "echo" });
-      await doInitialize(conn);
-
-      const callPromise = conn.callTool("image_tool", {});
-
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {
-        content: [{ type: "image", data: "base64data", mimeType: "image/png" }],
-      });
-
-      const result = await callPromise;
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("");
-    });
-  });
-
-  // ==========================================================================
-  // shutdown()
-  // ==========================================================================
-
-  describe("shutdown()", () => {
-    it("should send shutdown request, exit notification, then SIGTERM", async () => {
-      const conn = new MCPServerConnection({ name: "shutdown-test", command: "echo" });
-      await doInitialize(conn);
-
-      // Start shutdown (don't await yet)
-      const shutdownPromise = conn.shutdown();
-
-      // Server receives shutdown request
-      const shutdownReq = await fakeProc.nextRequest();
-      expect(shutdownReq.method).toBe("shutdown");
-
-      // Server responds to shutdown
-      fakeProc.respond(shutdownReq.id, {});
-
-      // Server receives exit notification
-      const exitNotif = await fakeProc.nextRequest();
-      expect(exitNotif.method).toBe("notifications/exit");
-
-      await vi.advanceTimersByTimeAsync(600);
-      await shutdownPromise;
-
-      // Should have called kill with SIGTERM
-      expect(fakeProc.kill).toHaveBeenCalledWith("SIGTERM");
-      expect(conn.initialized).toBe(false);
-    });
-
-    it("should resolve immediately if not initialized", async () => {
-      const conn = new MCPServerConnection({ name: "not-init", command: "echo" });
-      expect(conn.initialized).toBe(false);
-
-      // Should resolve immediately, no error
-      await conn.shutdown();
-    });
-
-    it("should escalate to SIGKILL when process does not exit after SIGTERM", async () => {
-      const conn = new MCPServerConnection({ name: "stubborn", command: "echo" });
-      await doInitialize(conn);
-
-      // Make kill NOT emit exit on SIGTERM (simulate hung process)
-      fakeProc.kill = vi.fn((signal?: string) => {
-        if (signal === "SIGKILL") {
-          // Only SIGKILL actually kills it
-          fakeProc.killed = true;
-          process.nextTick(() => fakeProc.emit("exit", 137));
-        }
-        // SIGTERM is ignored — process stays alive
-      });
-
-      const shutdownPromise = conn.shutdown();
-
-      // Respond to shutdown RPC
-      const shutdownReq = await fakeProc.nextRequest();
-      fakeProc.respond(shutdownReq.id, {});
-
-      // Consume exit notification
-      await fakeProc.nextRequest();
-
-      await vi.advanceTimersByTimeAsync(600);
-      await vi.advanceTimersByTimeAsync(5000);
-      await shutdownPromise;
-
-      // Should have tried SIGTERM first, then SIGKILL
-      expect(fakeProc.kill).toHaveBeenCalledWith("SIGTERM");
-      expect(fakeProc.kill).toHaveBeenCalledWith("SIGKILL");
-    }, 10000);
-
-    it("should handle already-dead process during shutdown gracefully", async () => {
-      const conn = new MCPServerConnection({ name: "dead-proc", command: "echo" });
-      await doInitialize(conn);
-
-      // Make the shutdown RPC fail (process already dead)
-      const shutdownPromise = conn.shutdown();
-
-      const shutdownReq = await fakeProc.nextRequest();
-      // Simulate process dying mid-shutdown by sending an error
-      fakeProc.respondError(shutdownReq.id, -32000, "Connection lost");
-
-      // shutdown() catches this error and proceeds to kill
-      await shutdownPromise;
-
-      expect(fakeProc.kill).toHaveBeenCalledWith("SIGTERM");
-      expect(conn.initialized).toBe(false);
-    });
-
-    it("should resolve only after process exits (not before)", async () => {
-      const conn = new MCPServerConnection({ name: "wait-exit", command: "echo" });
-      await doInitialize(conn);
-
-      let resolved = false;
-
-      // Make kill NOT auto-emit exit — we control when exit happens
-      fakeProc.kill = vi.fn(() => {
-        // Don't emit exit automatically
-      });
-
-      const shutdownPromise = conn.shutdown().then(() => {
-        resolved = true;
-      });
-
-      // Respond to shutdown RPC
-      const shutdownReq = await fakeProc.nextRequest();
-      fakeProc.respond(shutdownReq.id, {});
-
-      // Consume exit notification
-      await fakeProc.nextRequest();
-
-      await vi.advanceTimersByTimeAsync(600);
-
-      expect(fakeProc.kill).toHaveBeenCalledWith("SIGTERM");
-      expect(resolved).toBe(false); // Should NOT have resolved yet
-
-      // Now simulate process finally exiting
-      fakeProc.emit("exit", 0);
-
-      await shutdownPromise;
-      expect(resolved).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // Transport default (aria-rfu.3 fix)
-  // ==========================================================================
-
-  describe("transport default", () => {
-    it("should treat undefined transport as stdio and initialize normally", async () => {
-      // Config with no transport field at all — should default to "stdio"
-      const conn = new MCPServerConnection({ name: "no-transport", command: "echo" });
-      const caps = await doInitialize(conn);
-
-      expect(caps).toEqual({ tools: { listChanged: true } });
-      expect(conn.initialized).toBe(true);
-    });
-
-    it("should treat explicit stdio transport the same as undefined", async () => {
-      const conn = new MCPServerConnection({
-        name: "explicit-stdio",
-        transport: "stdio",
-        command: "echo",
-      });
-      const caps = await doInitialize(conn);
-
-      expect(caps).toEqual({ tools: { listChanged: true } });
-      expect(conn.initialized).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // listResources()
-  // ==========================================================================
-
-  describe("listResources()", () => {
-    it("should return resource definitions from server", async () => {
-      const conn = new MCPServerConnection({ name: "res-test", command: "echo" });
-      await doInitialize(conn);
-
-      const listPromise = conn.listResources();
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("resources/list");
-
-      fakeProc.respond(req.id, {
-        resources: [
-          { uri: "file:///tmp/data.json", name: "data.json", mimeType: "application/json" },
-          { uri: "file:///tmp/config.yaml", name: "config.yaml" },
-        ],
-      });
-
-      const resources = await listPromise;
-      expect(resources).toHaveLength(2);
-      expect(resources[0].uri).toBe("file:///tmp/data.json");
-      expect(resources[0].name).toBe("data.json");
-      expect(resources[1].uri).toBe("file:///tmp/config.yaml");
-    });
-
-    it("should return empty array when server returns no resources", async () => {
-      const conn = new MCPServerConnection({ name: "empty-res", command: "echo" });
-      await doInitialize(conn);
-
-      const listPromise = conn.listResources();
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {}); // no resources property
-
-      const resources = await listPromise;
-      expect(resources).toEqual([]);
-    });
-  });
-
-  // ==========================================================================
-  // readResource()
-  // ==========================================================================
-
-  describe("readResource()", () => {
-    it("should send read request with URI and return contents", async () => {
-      const conn = new MCPServerConnection({ name: "read-res", command: "echo" });
-      await doInitialize(conn);
-
-      const readPromise = conn.readResource("file:///tmp/data.json");
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("resources/read");
-      expect(req.params).toEqual({ uri: "file:///tmp/data.json" });
-
-      fakeProc.respond(req.id, {
-        contents: [
-          { uri: "file:///tmp/data.json", mimeType: "application/json", text: '{"key":"value"}' },
-        ],
-      });
-
-      const contents = await readPromise;
-      expect(contents).toHaveLength(1);
-      expect(contents[0].text).toBe('{"key":"value"}');
-      expect(contents[0].mimeType).toBe("application/json");
-    });
-
-    it("should return empty array when no contents returned", async () => {
-      const conn = new MCPServerConnection({ name: "empty-read", command: "echo" });
-      await doInitialize(conn);
-
-      const readPromise = conn.readResource("file:///missing");
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {}); // no contents property
-
-      const contents = await readPromise;
-      expect(contents).toEqual([]);
-    });
-  });
-
-  // ==========================================================================
-  // listPrompts()
-  // ==========================================================================
-
-  describe("listPrompts()", () => {
-    it("should return prompt definitions from server", async () => {
-      const conn = new MCPServerConnection({ name: "prompts-test", command: "echo" });
-      await doInitialize(conn);
-
-      const listPromise = conn.listPrompts();
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("prompts/list");
-
-      fakeProc.respond(req.id, {
-        prompts: [
-          {
-            name: "summarize",
-            description: "Summarize text",
-            arguments: [{ name: "text", required: true }],
-          },
-          { name: "translate", description: "Translate text" },
-        ],
-      });
-
-      const prompts = await listPromise;
-      expect(prompts).toHaveLength(2);
-      expect(prompts[0].name).toBe("summarize");
-      expect(prompts[0].arguments).toHaveLength(1);
-      expect(prompts[1].name).toBe("translate");
-    });
-
-    it("should return empty array when server returns no prompts", async () => {
-      const conn = new MCPServerConnection({ name: "empty-prompts", command: "echo" });
-      await doInitialize(conn);
-
-      const listPromise = conn.listPrompts();
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {}); // no prompts property
-
-      const prompts = await listPromise;
-      expect(prompts).toEqual([]);
-    });
-  });
-
-  // ==========================================================================
-  // getPrompt()
-  // ==========================================================================
-
-  describe("getPrompt()", () => {
-    it("should send get request with name and args and return messages", async () => {
-      const conn = new MCPServerConnection({ name: "get-prompt", command: "echo" });
-      await doInitialize(conn);
-
-      const getPromise = conn.getPrompt("summarize", { text: "hello world" });
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("prompts/get");
-      expect(req.params).toEqual({ name: "summarize", arguments: { text: "hello world" } });
-
-      fakeProc.respond(req.id, {
-        messages: [{ role: "user", content: { type: "text", text: "Summarize: hello world" } }],
-      });
-
-      const messages = await getPromise;
-      expect(messages).toHaveLength(1);
-      expect(messages[0].role).toBe("user");
-      expect(messages[0].content).toEqual({ type: "text", text: "Summarize: hello world" });
-    });
-
-    it("should return empty array when no messages returned", async () => {
-      const conn = new MCPServerConnection({ name: "empty-prompt", command: "echo" });
-      await doInitialize(conn);
-
-      const getPromise = conn.getPrompt("empty");
-      const req = await fakeProc.nextRequest();
-      fakeProc.respond(req.id, {}); // no messages property
-
-      const messages = await getPromise;
-      expect(messages).toEqual([]);
-    });
-  });
-
-  // ==========================================================================
-  // Full lifecycle
-  // ==========================================================================
-
-  describe("full lifecycle: init -> listTools -> callTool -> shutdown", () => {
-    it("should complete a full interaction cycle", async () => {
-      const conn = new MCPServerConnection({
-        name: "lifecycle-test",
-        command: "echo",
-        args: ["--stdio"],
-        env: { DEBUG: "true" },
-      });
-
-      // 1. Initialize
-      const caps = await doInitialize(conn, { tools: { listChanged: true } });
-      expect(conn.initialized).toBe(true);
-      expect(caps).toEqual({ tools: { listChanged: true } });
-
-      // 2. List tools
-      const listPromise = conn.listTools();
-      const listReq = await fakeProc.nextRequest();
-      expect(listReq.method).toBe("tools/list");
-      fakeProc.respond(listReq.id, {
-        tools: [
-          {
-            name: "echo",
-            description: "Echo input",
-            inputSchema: { type: "object", properties: { text: { type: "string" } } },
-          },
-        ],
-      });
-      const tools = await listPromise;
-      expect(tools).toHaveLength(1);
-      expect(tools[0].name).toBe("echo");
-
-      // 3. Call tool
-      const callPromise = conn.callTool("echo", { text: "hello" });
-      const callReq = await fakeProc.nextRequest();
-      expect(callReq.method).toBe("tools/call");
-      fakeProc.respond(callReq.id, {
-        content: [{ type: "text", text: "echo: hello" }],
-        isError: false,
-      });
-      const result = await callPromise;
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("echo: hello");
-
-      // 4. Shutdown
-      const shutdownPromise = conn.shutdown();
-      const shutdownReq = await fakeProc.nextRequest();
-      expect(shutdownReq.method).toBe("shutdown");
-      fakeProc.respond(shutdownReq.id, {});
-      const exitNotif = await fakeProc.nextRequest();
-      expect(exitNotif.method).toBe("notifications/exit");
-      await vi.advanceTimersByTimeAsync(600);
-      await shutdownPromise;
-
-      expect(conn.initialized).toBe(false);
-    });
-  });
-
-  // ==========================================================================
-  // Error cases
-  // ==========================================================================
-
-  describe("error cases", () => {
-    it("should propagate initialize RPC error", async () => {
-      const conn = new MCPServerConnection({ name: "init-fail", command: "echo" });
-      const initPromise = conn.initialize();
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("initialize");
-
-      fakeProc.respondError(req.id, -32600, "Invalid initialize request");
-
-      await expect(initPromise).rejects.toThrow("Invalid initialize request");
-      expect(conn.initialized).toBe(false);
-    });
-
-    it("should timeout when server never responds to initialize", async () => {
-      // Use a short-timeout RPC client to avoid waiting 30s
-      // MCPServerConnection uses default 30s timeout from JSONRPCClient.
-      // We test this by verifying the init promise rejects on timeout.
-      // To keep test fast, we mock the internal RPC client timeout.
-      const conn = new MCPServerConnection({ name: "timeout", command: "echo" });
-
-      const initPromise = conn.initialize();
-
-      // Read the initialize request but never respond to it
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("initialize");
-
-      // The JSONRPCClient has a 30s default timeout. Instead of waiting,
-      // we verify the request was sent correctly and the connection is
-      // not yet initialized.
-      expect(conn.initialized).toBe(false);
-
-      // Now respond to unblock (we don't actually want to wait 30s)
-      fakeProc.respond(req.id, {
-        protocolVersion: "2024-11-05",
-        capabilities: {},
-        serverInfo: { name: "test", version: "0.1.0" },
-      });
-
-      await initPromise;
-      expect(conn.initialized).toBe(true);
-    });
-
-    it("should handle process crash during tool call", async () => {
-      const conn = new MCPServerConnection({ name: "crash-test", command: "echo" });
-      await doInitialize(conn);
-
-      const callPromise = conn.callTool("dangerous_tool", {});
-
-      const req = await fakeProc.nextRequest();
-      expect(req.method).toBe("tools/call");
-
-      // Simulate process crash — send RPC error back
-      fakeProc.respondError(req.id, -32000, "Server process crashed");
-
-      const result = await callPromise;
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Server process crashed");
-    });
-  });
-});