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

extensions/qa-lab/src/gateway-rpc-client.test.ts

@@ -0,0 +1,229 @@
+// Qa Lab tests cover gateway rpc client plugin behavior.
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const gatewayRpcMock = vi.hoisted(() => {
+  const callGatewayFromCli = vi.fn(async () => ({ ok: true }));
+  return {
+    callGatewayFromCli,
+    reset() {
+      callGatewayFromCli.mockReset().mockResolvedValue({ ok: true });
+    },
+  };
+});
+
+vi.mock("openclaw/plugin-sdk/gateway-runtime", () => ({
+  callGatewayFromCli: gatewayRpcMock.callGatewayFromCli,
+}));
+
+import { startQaGatewayRpcClient } from "./gateway-rpc-client.js";
+
+function expectRequestResolver(
+  callback: ((value: { ok: boolean }) => void) | null,
+): (value: { ok: boolean }) => void {
+  if (callback === null) {
+    throw new Error("Expected first request resolver callback to be captured");
+  }
+  return callback;
+}
+
+function expectReleaseCallback(callback: (() => void) | null): () => void {
+  if (callback === null) {
+    throw new Error("Expected first request release callback to be captured");
+  }
+  return callback;
+}
+
+describe("startQaGatewayRpcClient", () => {
+  beforeEach(() => {
+    gatewayRpcMock.reset();
+  });
+
+  it("calls the in-process gateway cli helper without mutating process.env", async () => {
+    const originalHome = process.env.OPENCLAW_HOME;
+    delete process.env.OPENCLAW_HOME;
+
+    try {
+      gatewayRpcMock.callGatewayFromCli.mockImplementationOnce(async () => {
+        expect(process.env.OPENCLAW_HOME).toBeUndefined();
+        return { ok: true };
+      });
+
+      const client = await startQaGatewayRpcClient({
+        wsUrl: "ws://127.0.0.1:18789",
+        token: "qa-token",
+        logs: () => "qa logs",
+      });
+
+      await expect(
+        client.request("agent.run", { prompt: "hi" }, { expectFinal: true, timeoutMs: 45_000 }),
+      ).resolves.toEqual({ ok: true });
+
+      expect(gatewayRpcMock.callGatewayFromCli).toHaveBeenCalledWith(
+        "agent.run",
+        {
+          url: "ws://127.0.0.1:18789",
+          token: "qa-token",
+          timeout: "45000",
+          expectFinal: true,
+          json: true,
+        },
+        { prompt: "hi" },
+        {
+          clientName: "gateway-client",
+          deviceIdentity: null,
+          expectFinal: true,
+          mode: "backend",
+          progress: false,
+          scopes: ["operator.admin"],
+        },
+      );
+    } finally {
+      if (originalHome === undefined) {
+        delete process.env.OPENCLAW_HOME;
+      } else {
+        process.env.OPENCLAW_HOME = originalHome;
+      }
+    }
+
+    expect(process.env.OPENCLAW_HOME).toBe(originalHome);
+  });
+
+  it("wraps request failures with gateway logs", async () => {
+    gatewayRpcMock.callGatewayFromCli.mockRejectedValueOnce(new Error("gateway not connected"));
+    const client = await startQaGatewayRpcClient({
+      wsUrl: "ws://127.0.0.1:18789",
+      token: "qa-token",
+      logs: () => "OPENCLAW_GATEWAY_TOKEN=secret-token\nAuthorization: Bearer secret+/token=123456",
+    });
+
+    await expect(client.request("health")).rejects.toThrow(
+      "gateway not connected\nGateway logs:\nOPENCLAW_GATEWAY_TOKEN=<redacted>\nAuthorization: Bearer <redacted>",
+    );
+  });
+
+  it("rejects new requests after stop", async () => {
+    const client = await startQaGatewayRpcClient({
+      wsUrl: "ws://127.0.0.1:18789",
+      token: "qa-token",
+      logs: () => "url=http://127.0.0.1:18789/#token=abc123",
+    });
+
+    await client.stop();
+
+    await expect(client.request("health")).rejects.toThrow(
+      "gateway rpc client already stopped\nGateway logs:\nurl=http://127.0.0.1:18789/#token=<redacted>",
+    );
+  });
+
+  it("does not serialize requests across different gateway clients", async () => {
+    let resolveFirst: ((value: { ok: boolean }) => void) | null = null;
+    gatewayRpcMock.callGatewayFromCli
+      .mockImplementationOnce(
+        async () =>
+          await new Promise<{ ok: boolean }>((resolve) => {
+            resolveFirst = resolve;
+          }),
+      )
+      .mockResolvedValueOnce({ ok: true });
+
+    const firstClient = await startQaGatewayRpcClient({
+      wsUrl: "ws://127.0.0.1:18789",
+      token: "qa-token-a",
+      logs: () => "qa logs a",
+    });
+    const secondClient = await startQaGatewayRpcClient({
+      wsUrl: "ws://127.0.0.1:28789",
+      token: "qa-token-b",
+      logs: () => "qa logs b",
+    });
+
+    const firstRequest = firstClient.request("health");
+    await Promise.resolve();
+
+    await expect(secondClient.request("status")).resolves.toEqual({ ok: true });
+    expect(gatewayRpcMock.callGatewayFromCli).toHaveBeenNthCalledWith(
+      2,
+      "status",
+      {
+        url: "ws://127.0.0.1:28789",
+        token: "qa-token-b",
+        timeout: "20000",
+        expectFinal: undefined,
+        json: true,
+      },
+      {},
+      {
+        clientName: "gateway-client",
+        deviceIdentity: null,
+        expectFinal: undefined,
+        mode: "backend",
+        progress: false,
+        scopes: ["operator.admin"],
+      },
+    );
+
+    expectRequestResolver(resolveFirst)({ ok: true });
+    await expect(firstRequest).resolves.toEqual({ ok: true });
+  });
+
+  it("still serializes requests within the same gateway client", async () => {
+    let releaseFirst: (() => void) | null = null;
+    gatewayRpcMock.callGatewayFromCli
+      .mockImplementationOnce(
+        async () =>
+          await new Promise<{ ok: boolean }>((resolve) => {
+            releaseFirst = () => resolve({ ok: true });
+          }),
+      )
+      .mockResolvedValueOnce({ ok: true });
+
+    const client = await startQaGatewayRpcClient({
+      wsUrl: "ws://127.0.0.1:18789",
+      token: "qa-token",
+      logs: () => "qa logs",
+    });
+
+    const firstRequest = client.request("health");
+    await Promise.resolve();
+    const secondRequest = client.request("status");
+    await Promise.resolve();
+
+    expect(gatewayRpcMock.callGatewayFromCli).toHaveBeenCalledTimes(1);
+
+    expectReleaseCallback(releaseFirst)();
+
+    await expect(firstRequest).resolves.toEqual({ ok: true });
+    await expect(secondRequest).resolves.toEqual({ ok: true });
+    expect(gatewayRpcMock.callGatewayFromCli).toHaveBeenCalledTimes(2);
+  });
+
+  it("rejects queued requests that have not started before stop", async () => {
+    let releaseFirst: (() => void) | null = null;
+    gatewayRpcMock.callGatewayFromCli.mockImplementationOnce(
+      async () =>
+        await new Promise<{ ok: boolean }>((resolve) => {
+          releaseFirst = () => resolve({ ok: true });
+        }),
+    );
+
+    const client = await startQaGatewayRpcClient({
+      wsUrl: "ws://127.0.0.1:18789",
+      token: "qa-token",
+      logs: () => "qa logs",
+    });
+
+    const firstRequest = client.request("health");
+    await Promise.resolve();
+    const secondRequest = client.request("status");
+    await Promise.resolve();
+
+    await client.stop();
+    expectReleaseCallback(releaseFirst)();
+
+    await expect(firstRequest).resolves.toEqual({ ok: true });
+    await expect(secondRequest).rejects.toThrow(
+      "gateway rpc client already stopped\nGateway logs:\nqa logs",
+    );
+    expect(gatewayRpcMock.callGatewayFromCli).toHaveBeenCalledTimes(1);
+  });
+});