@aria-cli/tools 1.0.8 → 1.0.10

package/tests/mcp/lifecycle.test.ts

@@ -1,879 +0,0 @@
-/**
- * MCP Server Connection Lifecycle Tests
- *
- * Tests the full lifecycle of MCPServerConnection:
- * init -> listTools -> callTool -> shutdown
- *
- * Uses a mock child process with PassThrough streams to simulate
- * an MCP server without spawning a real process.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { PassThrough } from "stream";
-import { EventEmitter } from "events";
-
-// ---------------------------------------------------------------------------
-// Mock child_process.spawn — must be before importing connection.ts
-// ---------------------------------------------------------------------------
-
-/** Fake child process that mimics ChildProcess enough for MCPServerConnection */
-class FakeChildProcess extends EventEmitter {
-  readonly stdin = new PassThrough();
-  readonly stdout = new PassThrough();
-  readonly stderr = new PassThrough();
-  killed = false;
-  pid = 12345;
-
-  kill(signal?: string): boolean {
-    this.killed = true;
-    if (signal === "SIGKILL") {
-      // SIGKILL always succeeds immediately
-      this.emit("exit", null, "SIGKILL");
-    }
-    // For SIGTERM the test controls when exit fires
-    return true;
-  }
-}
-
-let fakeProcess: FakeChildProcess;
-
-// vi.hoisted ensures mockSpawn is available when vi.mock factory runs (hoisted)
-const { mockSpawn } = vi.hoisted(() => ({
-  mockSpawn: vi.fn(),
-}));
-
-vi.mock("child_process", () => ({
-  spawn: mockSpawn,
-}));
-
-// Import AFTER mock setup so it gets the mocked spawn
-import { MCPServerConnection } from "../../src/mcp/connection.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Intercept JSON-RPC requests on fake stdin and auto-respond.
- */
-function autoRespond(
-  proc: FakeChildProcess,
-  handler: (method: string, params: unknown, id: string) => unknown,
-) {
-  proc.stdin.on("data", (chunk: Buffer) => {
-    const lines = chunk.toString().split("\n").filter(Boolean);
-    for (const line of lines) {
-      const msg = JSON.parse(line);
-      // Only respond to requests (have an id), skip notifications
-      if (msg.id === undefined) continue;
-      const result = handler(msg.method, msg.params, msg.id);
-      if (result !== undefined) {
-        proc.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: msg.id, result }) + "\n");
-      }
-    }
-  });
-}
-
-/** Standard MCP initialize response */
-const INIT_RESULT = {
-  protocolVersion: "2024-11-05",
-  capabilities: {
-    tools: { listChanged: true },
-    resources: { subscribe: false, listChanged: true },
-  },
-  serverInfo: { name: "test-server", version: "0.1.0" },
-};
-
-/**
- * Configure mockSpawn to create a FakeChildProcess with an auto-responder
- * attached immediately on creation (before the RPC request is sent).
- */
-function setupAutoResponder(handler: (method: string, params: unknown, id: string) => unknown) {
-  mockSpawn.mockImplementation(() => {
-    fakeProcess = new FakeChildProcess();
-    autoRespond(fakeProcess, handler);
-    return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("MCPServerConnection lifecycle", () => {
-  let conn: MCPServerConnection;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    fakeProcess = undefined as unknown as FakeChildProcess;
-    mockSpawn.mockImplementation(() => {
-      fakeProcess = new FakeChildProcess();
-      return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-    });
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  // =========================================================================
-  // Initialization
-  // =========================================================================
-
-  describe("initialize()", () => {
-    it("should spawn process and complete MCP handshake", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-        args: ["--stdio"],
-      });
-
-      const capabilities = await conn.initialize();
-
-      expect(conn.initialized).toBe(true);
-      expect(conn.name).toBe("test-mcp");
-      expect(capabilities).toEqual(INIT_RESULT.capabilities);
-    });
-
-    it("should send initialized notification after handshake", async () => {
-      const sentMessages: Array<{ method: string; id?: string }> = [];
-
-      mockSpawn.mockImplementation(() => {
-        fakeProcess = new FakeChildProcess();
-        fakeProcess.stdin.on("data", (chunk: Buffer) => {
-          const lines = chunk.toString().split("\n").filter(Boolean);
-          for (const line of lines) {
-            const msg = JSON.parse(line);
-            sentMessages.push({ method: msg.method, id: msg.id });
-            if (msg.id !== undefined && msg.method === "initialize") {
-              fakeProcess.stdout.write(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  id: msg.id,
-                  result: INIT_RESULT,
-                }) + "\n",
-              );
-            }
-          }
-        });
-        return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const methods = sentMessages.map((m) => m.method);
-      expect(methods).toContain("initialize");
-      expect(methods).toContain("notifications/initialized");
-
-      // The initialized notification should NOT have an id (it is a notification)
-      const initNotification = sentMessages.find((m) => m.method === "notifications/initialized");
-      expect(initNotification?.id).toBeUndefined();
-    });
-
-    it("should send correct protocol version and client info", async () => {
-      let capturedParams: unknown;
-
-      mockSpawn.mockImplementation(() => {
-        fakeProcess = new FakeChildProcess();
-        fakeProcess.stdin.on("data", (chunk: Buffer) => {
-          const lines = chunk.toString().split("\n").filter(Boolean);
-          for (const line of lines) {
-            const msg = JSON.parse(line);
-            if (msg.method === "initialize" && msg.id !== undefined) {
-              capturedParams = msg.params;
-              fakeProcess.stdout.write(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  id: msg.id,
-                  result: INIT_RESULT,
-                }) + "\n",
-              );
-            }
-          }
-        });
-        return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      expect(capturedParams).toEqual({
-        protocolVersion: "2024-11-05",
-        capabilities: {
-          roots: { listChanged: true },
-        },
-        clientInfo: {
-          name: "aria-cli",
-          version: "1.0.0",
-        },
-      });
-    });
-
-    it("should throw if URL is missing for sse transport", async () => {
-      conn = new MCPServerConnection({
-        name: "test-sse",
-        transport: "sse",
-      });
-
-      await expect(conn.initialize()).rejects.toThrow("URL required for sse transport");
-    });
-
-    it("should throw if command is missing for stdio transport", async () => {
-      conn = new MCPServerConnection({ name: "test-no-cmd" });
-
-      await expect(conn.initialize()).rejects.toThrow("Command required for stdio transport");
-    });
-
-    it("should emit exit event when process exits", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const exitPromise = new Promise<number | null>((resolve) => {
-        conn.on("exit", resolve);
-      });
-
-      fakeProcess.emit("exit", 1);
-
-      const code = await exitPromise;
-      expect(code).toBe(1);
-      expect(conn.initialized).toBe(false);
-    });
-
-    it("should emit log events from stderr", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const logPromise = new Promise<{ level: string; message: string }>((resolve) => {
-        conn.on("log", resolve);
-      });
-
-      fakeProcess.stderr.write("Something went wrong\n");
-
-      const log = await logPromise;
-      expect(log.level).toBe("error");
-      expect(log.message).toContain("Something went wrong");
-    });
-
-    it("should pass environment variables to spawned process", async () => {
-      let spawnEnv: Record<string, string> | undefined;
-
-      mockSpawn.mockImplementation(((
-        _cmd: string,
-        _args: string[],
-        opts: { env: Record<string, string> },
-      ) => {
-        spawnEnv = opts.env;
-        fakeProcess = new FakeChildProcess();
-        autoRespond(fakeProcess, (method) => {
-          if (method === "initialize") return INIT_RESULT;
-          return undefined;
-        });
-        return fakeProcess;
-      }) as unknown as typeof mockSpawn);
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-        env: { MCP_TOKEN: "secret-123" },
-      });
-
-      await conn.initialize();
-
-      expect(spawnEnv).toBeDefined();
-      expect(spawnEnv!.MCP_TOKEN).toBe("secret-123");
-    });
-  });
-
-  // =========================================================================
-  // listTools
-  // =========================================================================
-
-  describe("listTools()", () => {
-    it("should return parsed tool list from server", async () => {
-      const mockTools = [
-        {
-          name: "read_file",
-          description: "Read a file",
-          inputSchema: {
-            type: "object" as const,
-            properties: { path: { type: "string" as const } },
-            required: ["path"],
-          },
-        },
-        {
-          name: "write_file",
-          description: "Write a file",
-          inputSchema: {
-            type: "object" as const,
-            properties: {
-              path: { type: "string" as const },
-              content: { type: "string" as const },
-            },
-            required: ["path", "content"],
-          },
-        },
-      ];
-
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "tools/list") return { tools: mockTools };
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-      const tools = await conn.listTools();
-
-      expect(tools).toHaveLength(2);
-      expect(tools[0].name).toBe("read_file");
-      expect(tools[1].name).toBe("write_file");
-      expect(tools[0].inputSchema).toEqual({
-        type: "object",
-        properties: { path: { type: "string" } },
-        required: ["path"],
-      });
-    });
-
-    it("should return empty array when server has no tools", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "tools/list") return { tools: [] };
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-      const tools = await conn.listTools();
-
-      expect(tools).toEqual([]);
-    });
-  });
-
-  // =========================================================================
-  // callTool
-  // =========================================================================
-
-  describe("callTool()", () => {
-    it("should send tool call and return success result", async () => {
-      setupAutoResponder((method, params) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "tools/call") {
-          const p = params as { name: string; arguments: unknown };
-          if (p.name === "read_file") {
-            return {
-              content: [{ type: "text", text: "file contents here" }],
-              isError: false,
-            };
-          }
-        }
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-      const result = await conn.callTool("read_file", {
-        path: "/tmp/test.txt",
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("file contents here");
-    });
-
-    it("should concatenate multiple text content blocks", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "tools/call") {
-          return {
-            content: [
-              { type: "text", text: "line 1" },
-              { type: "image", data: "base64data", mimeType: "image/png" },
-              { type: "text", text: "line 2" },
-            ],
-            isError: false,
-          };
-        }
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-      const result = await conn.callTool("multi_output", {});
-
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("line 1\nline 2");
-      expect(result.data).toHaveLength(3);
-    });
-
-    it("should return isError=true as success=false", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "tools/call") {
-          return {
-            content: [{ type: "text", text: "Permission denied" }],
-            isError: true,
-          };
-        }
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-      const result = await conn.callTool("write_file", {
-        path: "/etc/passwd",
-        content: "hacked",
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.message).toBe("Permission denied");
-    });
-
-    it("should handle JSON-RPC errors gracefully", async () => {
-      mockSpawn.mockImplementation(() => {
-        fakeProcess = new FakeChildProcess();
-        fakeProcess.stdin.on("data", (chunk: Buffer) => {
-          const lines = chunk.toString().split("\n").filter(Boolean);
-          for (const line of lines) {
-            const msg = JSON.parse(line);
-            if (msg.id === undefined) continue;
-            if (msg.method === "initialize") {
-              fakeProcess.stdout.write(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  id: msg.id,
-                  result: INIT_RESULT,
-                }) + "\n",
-              );
-            } else if (msg.method === "tools/call") {
-              fakeProcess.stdout.write(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  id: msg.id,
-                  error: { code: -32601, message: "Method not found" },
-                }) + "\n",
-              );
-            }
-          }
-        });
-        return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-      const result = await conn.callTool("nonexistent", {});
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Method not found");
-    });
-  });
-
-  // =========================================================================
-  // Shutdown
-  // =========================================================================
-
-  describe("shutdown()", () => {
-    it("should send shutdown request and exit notification then kill", async () => {
-      const sentMethods: string[] = [];
-
-      mockSpawn.mockImplementation(() => {
-        fakeProcess = new FakeChildProcess();
-        fakeProcess.stdin.on("data", (chunk: Buffer) => {
-          const lines = chunk.toString().split("\n").filter(Boolean);
-          for (const line of lines) {
-            const msg = JSON.parse(line);
-            sentMethods.push(msg.method);
-            if (msg.id === undefined) continue;
-            if (msg.method === "initialize") {
-              fakeProcess.stdout.write(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  id: msg.id,
-                  result: INIT_RESULT,
-                }) + "\n",
-              );
-            } else if (msg.method === "shutdown") {
-              fakeProcess.stdout.write(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  id: msg.id,
-                  result: {},
-                }) + "\n",
-              );
-            }
-          }
-        });
-        return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      // Override kill to also emit exit (simulating normal graceful shutdown)
-      const origKill = fakeProcess.kill.bind(fakeProcess);
-      fakeProcess.kill = vi.fn((signal?: string) => {
-        origKill(signal);
-        if (signal === "SIGTERM") {
-          setTimeout(() => fakeProcess.emit("exit", 0, "SIGTERM"), 50);
-        }
-        return true;
-      }) as unknown as typeof fakeProcess.kill;
-
-      const shutdownPromise = conn.shutdown();
-      await vi.advanceTimersByTimeAsync(600);
-      await shutdownPromise;
-
-      expect(sentMethods).toContain("shutdown");
-      expect(sentMethods).toContain("notifications/exit");
-      expect(fakeProcess.kill).toHaveBeenCalledWith("SIGTERM");
-      expect(conn.initialized).toBe(false);
-    });
-
-    it("should noop if not initialized", async () => {
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-        const shutdownPromise = conn.shutdown();
-        await vi.advanceTimersByTimeAsync(600);
-        await shutdownPromise;
-        expect(conn.initialized).toBe(false);
-      });
-
-    it("should await process exit before resolving", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "shutdown") return {};
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      let shutdownResolved = false;
-
-      // Override kill to NOT auto-emit exit
-      fakeProcess.kill = vi.fn((_signal?: string) => {
-        return true;
-      }) as unknown as typeof fakeProcess.kill;
-
-      const shutdownPromise = conn.shutdown().then(() => {
-        shutdownResolved = true;
-      });
-
-      // Advance past the 500ms setTimeout in shutdown
-      await vi.advanceTimersByTimeAsync(600);
-
-      // Shutdown should still be pending because process has not exited
-      expect(shutdownResolved).toBe(false);
-
-      // Now emit exit
-      fakeProcess.emit("exit", 0);
-
-      await shutdownPromise;
-      expect(shutdownResolved).toBe(true);
-    });
-
-    it("should escalate to SIGKILL after 5s timeout", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        if (method === "shutdown") return {};
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const killCalls: string[] = [];
-      fakeProcess.kill = vi.fn((signal?: string) => {
-        killCalls.push(signal || "default");
-        if (signal === "SIGKILL") {
-          process.nextTick(() => fakeProcess.emit("exit", null, "SIGKILL"));
-        }
-        return true;
-      }) as unknown as typeof fakeProcess.kill;
-
-      const shutdownPromise = conn.shutdown();
-
-      // Advance past the 500ms delay + SIGTERM
-      await vi.advanceTimersByTimeAsync(600);
-
-      expect(killCalls).toContain("SIGTERM");
-      expect(killCalls).not.toContain("SIGKILL");
-
-      // Advance to 5s timeout for SIGKILL escalation
-      await vi.advanceTimersByTimeAsync(5000);
-
-      expect(killCalls).toContain("SIGKILL");
-
-      await shutdownPromise;
-    });
-
-    it("should handle shutdown when rpc request fails", async () => {
-      // Simulate a scenario where the shutdown RPC request fails (e.g. process
-      // already dead / broken pipe). The shutdown() catch block should proceed
-      // to kill the process anyway.
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        // Don't respond to "shutdown" at all -- it will timeout from JSONRPCClient
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const killCalls: string[] = [];
-      fakeProcess.kill = vi.fn((signal?: string) => {
-        killCalls.push(signal || "default");
-        // Process exits immediately on any signal
-        process.nextTick(() => fakeProcess.emit("exit", 1));
-        return true;
-      }) as unknown as typeof fakeProcess.kill;
-
-      const shutdownPromise = conn.shutdown();
-
-      // Advance past the RPC timeout (30s default) + 500ms delay
-      // The shutdown request will timeout, catch fires, kill is called
-      await vi.advanceTimersByTimeAsync(31000);
-
-      await shutdownPromise;
-
-      expect(conn.initialized).toBe(false);
-      expect(killCalls).toContain("SIGTERM");
-    });
-  });
-
-  // =========================================================================
-  // Full lifecycle
-  // =========================================================================
-
-  describe("full lifecycle: init -> listTools -> callTool -> shutdown", () => {
-    it("should complete a full interaction cycle", async () => {
-      const mockTools = [
-        {
-          name: "echo",
-          description: "Echo input back",
-          inputSchema: {
-            type: "object" as const,
-            properties: { text: { type: "string" as const } },
-          },
-        },
-      ];
-
-      mockSpawn.mockImplementation(() => {
-        fakeProcess = new FakeChildProcess();
-        fakeProcess.stdin.on("data", (chunk: Buffer) => {
-          const lines = chunk.toString().split("\n").filter(Boolean);
-          for (const line of lines) {
-            const msg = JSON.parse(line);
-            if (msg.id === undefined) continue;
-
-            let result: unknown;
-            switch (msg.method) {
-              case "initialize":
-                result = INIT_RESULT;
-                break;
-              case "tools/list":
-                result = { tools: mockTools };
-                break;
-              case "tools/call": {
-                const p = msg.params as {
-                  name: string;
-                  arguments: { text: string };
-                };
-                result = {
-                  content: [{ type: "text", text: `echo: ${p.arguments.text}` }],
-                  isError: false,
-                };
-                break;
-              }
-              case "shutdown":
-                result = {};
-                break;
-            }
-
-            if (result !== undefined) {
-              fakeProcess.stdout.write(
-                JSON.stringify({ jsonrpc: "2.0", id: msg.id, result }) + "\n",
-              );
-            }
-          }
-        });
-
-        // Override kill to emit exit
-        const origKill = fakeProcess.kill.bind(fakeProcess);
-        fakeProcess.kill = vi.fn((signal?: string) => {
-          origKill(signal);
-          if (signal === "SIGTERM") {
-            setTimeout(() => fakeProcess.emit("exit", 0), 10);
-          }
-          return true;
-        }) as unknown as typeof fakeProcess.kill;
-
-        return fakeProcess as unknown as ReturnType<typeof mockSpawn>;
-      });
-
-      conn = new MCPServerConnection({
-        name: "echo-server",
-        command: "/usr/bin/echo-mcp",
-        args: ["--stdio"],
-        env: { DEBUG: "true" },
-      });
-
-      // 1. Initialize
-      const caps = await conn.initialize();
-      expect(conn.initialized).toBe(true);
-      expect(caps.tools).toEqual({ listChanged: true });
-
-      // 2. List tools
-      const tools = await conn.listTools();
-      expect(tools).toHaveLength(1);
-      expect(tools[0].name).toBe("echo");
-
-      // 3. Call tool
-      const result = await conn.callTool("echo", { text: "hello world" });
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("echo: hello world");
-
-      // 4. Shutdown
-      const shutdownPromise = conn.shutdown();
-      await vi.advanceTimersByTimeAsync(600);
-      await shutdownPromise;
-      expect(conn.initialized).toBe(false);
-    });
-  });
-
-  // =========================================================================
-  // Notification forwarding
-  // =========================================================================
-
-  describe("notification forwarding", () => {
-    it("should forward tools/list_changed notification", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const notifPromise = new Promise<void>((resolve) => {
-        conn.on("tools/list_changed", resolve);
-      });
-
-      fakeProcess.stdout.write(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          method: "notifications/tools/list_changed",
-          params: {},
-        }) + "\n",
-      );
-
-      await notifPromise;
-    });
-
-    it("should forward resources/list_changed notification", async () => {
-      setupAutoResponder((method) => {
-        if (method === "initialize") return INIT_RESULT;
-        return undefined;
-      });
-
-      conn = new MCPServerConnection({
-        name: "test-mcp",
-        command: "/usr/bin/fake-mcp",
-      });
-
-      await conn.initialize();
-
-      const notifPromise = new Promise<void>((resolve) => {
-        conn.on("resources/list_changed", resolve);
-      });
-
-      fakeProcess.stdout.write(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          method: "notifications/resources/list_changed",
-          params: {},
-        }) + "\n",
-      );
-
-      await notifPromise;
-    });
-  });
-});