@aria-cli/tools 1.0.0

package/tests/mcp/lifecycle.test.ts

@@ -0,0 +1,879 @@
+/**
+ * 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;
+    });
+  });
+});