Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

test/e2e/qa-lab/runtime/mcp-gateway-transport.e2e.test.ts

@@ -0,0 +1,185 @@
+// QA Lab MCP gateway transport tests cover script-backed MCP client state.
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  connectMcpClientWithPairingReconnect,
+  connectMcpWithTimeout,
+  createMcpClientTempState,
+  type McpClientTempState,
+} from "./mcp-client-temp-state.fixture.ts";
+
+describe("MCP gateway transport fixture", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("creates unique client temp state and removes token files on cleanup", () => {
+    const tempRoot = mkdtempSync(path.join(tmpdir(), "openclaw-mcp-harness-test-"));
+    try {
+      const first = createMcpClientTempState({ gatewayToken: "first-token", tempRoot });
+      const second = createMcpClientTempState({ gatewayToken: "second-token", tempRoot });
+
+      expect(first.root).not.toBe(second.root);
+      expect(first.stateDir).toBe(path.join(first.root, "state"));
+      expect(readFileSync(first.tokenFile, "utf8")).toBe("first-token\n");
+      expect(statSync(first.tokenFile).mode & 0o777).toBe(0o600);
+      expect(readFileSync(second.tokenFile, "utf8")).toBe("second-token\n");
+
+      first.cleanup();
+      second.cleanup();
+
+      expect(existsSync(first.root)).toBe(false);
+      expect(existsSync(second.root)).toBe(false);
+    } finally {
+      rmSync(tempRoot, { force: true, recursive: true });
+    }
+  });
+
+  it("reuses one MCP temp state across the pairing reconnect path", async () => {
+    const tempState = createMcpClientTempState({ gatewayToken: "pairing-token" });
+    const firstHandle = {
+      cleanup: vi.fn(),
+      client: { close: vi.fn(async () => undefined) },
+      transport: { close: vi.fn(async () => undefined) },
+    };
+    const secondHandle = {
+      cleanup: vi.fn(),
+      client: { close: vi.fn(async () => undefined) },
+      transport: { close: vi.fn(async () => undefined) },
+    };
+    const connectCalls: McpClientTempState[] = [];
+    const connect = vi.fn(async (state: McpClientTempState) => {
+      connectCalls.push(state);
+      return connectCalls.length === 1 ? firstHandle : secondHandle;
+    });
+
+    try {
+      await expect(
+        connectMcpClientWithPairingReconnect({
+          connect,
+          maybeApprovePairing: async () => true,
+          tempState,
+        }),
+      ).resolves.toBe(secondHandle);
+
+      expect(connect).toHaveBeenCalledTimes(2);
+      expect(connectCalls).toEqual([tempState, tempState]);
+      expect(firstHandle.client.close).toHaveBeenCalledOnce();
+      expect(firstHandle.transport.close).toHaveBeenCalledOnce();
+      expect(firstHandle.cleanup).toHaveBeenCalledOnce();
+      expect(secondHandle.cleanup).not.toHaveBeenCalled();
+    } finally {
+      tempState.cleanup();
+    }
+  });
+
+  it("cleans up the first MCP client when pairing approval fails", async () => {
+    const tempState = createMcpClientTempState({ gatewayToken: "pairing-token" });
+    const handle = {
+      cleanup: vi.fn(),
+      client: { close: vi.fn(async () => undefined) },
+      transport: { close: vi.fn(async () => undefined) },
+    };
+    const failure = new Error("pairing approval failed");
+
+    try {
+      await expect(
+        connectMcpClientWithPairingReconnect({
+          connect: async () => handle,
+          maybeApprovePairing: async () => {
+            throw failure;
+          },
+          tempState,
+        }),
+      ).rejects.toBe(failure);
+
+      expect(handle.client.close).toHaveBeenCalledOnce();
+      expect(handle.transport.close).toHaveBeenCalledOnce();
+      expect(handle.cleanup).toHaveBeenCalledOnce();
+    } finally {
+      tempState.cleanup();
+    }
+  });
+
+  it("resolves when the MCP client connects before the timeout", async () => {
+    const client = {
+      connect: vi.fn(async () => undefined),
+    };
+    const transport = {
+      close: vi.fn(),
+    };
+
+    await expect(connectMcpWithTimeout(client, transport, 1000)).resolves.toBeUndefined();
+
+    expect(client.connect).toHaveBeenCalledWith(transport);
+    expect(transport.close).not.toHaveBeenCalled();
+  });
+
+  it("closes the transport when MCP initialize hangs", async () => {
+    vi.useFakeTimers();
+    const client = {
+      connect: vi.fn(() => new Promise<void>(() => {})),
+    };
+    const transport = {
+      close: vi.fn(),
+    };
+
+    const result = connectMcpWithTimeout(client, transport, 100);
+    const rejection = expect(result).rejects.toThrow("MCP stdio connect timed out after 100ms");
+
+    await vi.advanceTimersByTimeAsync(100);
+    await rejection;
+    expect(transport.close).toHaveBeenCalledOnce();
+  });
+
+  it("waits for timed-out transport cleanup before rejecting", async () => {
+    vi.useFakeTimers();
+    let closeSettled = false;
+    const client = {
+      connect: vi.fn(() => new Promise<void>(() => {})),
+    };
+    const transport = {
+      close: vi.fn(
+        () =>
+          new Promise<void>((resolve) => {
+            setTimeout(() => {
+              closeSettled = true;
+              resolve();
+            }, 25);
+          }),
+      ),
+    };
+
+    const result = connectMcpWithTimeout(client, transport, 100);
+    const rejection = expect(result).rejects.toThrow("MCP stdio connect timed out after 100ms");
+
+    await vi.advanceTimersByTimeAsync(100);
+    expect(transport.close).toHaveBeenCalledOnce();
+    expect(closeSettled).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(25);
+    await rejection;
+    expect(closeSettled).toBe(true);
+  });
+
+  it("keeps the original timeout error when cleanup rejects", async () => {
+    vi.useFakeTimers();
+    const client = {
+      connect: vi.fn(() => new Promise<void>(() => {})),
+    };
+    const transport = {
+      close: vi.fn(async () => {
+        throw new Error("close failed");
+      }),
+    };
+
+    const result = connectMcpWithTimeout(client, transport, 100);
+    const rejection = expect(result).rejects.toThrow("MCP stdio connect timed out after 100ms");
+
+    await vi.advanceTimersByTimeAsync(100);
+    await rejection;
+    expect(transport.close).toHaveBeenCalledOnce();
+  });
+});