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

scripts/e2e/lib/gateway-network/client.mjs

@@ -0,0 +1,152 @@
+// WebSocket client helpers for gateway network E2E scenarios.
+import { pathToFileURL } from "node:url";
+import { WebSocket } from "ws";
+import { sleep as delay } from "../../../lib/sleep.mjs";
+import { waitForWebSocketOpen } from "../websocket-open.mjs";
+import { readGatewayNetworkClientConnectTimeoutMs } from "./limits.mjs";
+import { onceFrame } from "./ws-frames.mjs";
+
+function remainingDeadlineMs(deadline) {
+  return Math.max(1, deadline - Date.now());
+}
+
+async function openSocket(url, timeoutMs = 10_000) {
+  const ws = new WebSocket(url);
+  await waitForWebSocketOpen(ws, timeoutMs, "ws open timeout");
+  return ws;
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function hasGatewayHealthSummaryPayload(response) {
+  if (!isRecord(response) || !isRecord(response.payload)) {
+    return false;
+  }
+  const { payload } = response;
+  return (
+    payload.ok === true &&
+    typeof payload.ts === "number" &&
+    typeof payload.durationMs === "number" &&
+    typeof payload.defaultAgentId === "string" &&
+    payload.defaultAgentId.trim() !== "" &&
+    Array.isArray(payload.agents) &&
+    isRecord(payload.channels) &&
+    Array.isArray(payload.channelOrder) &&
+    isRecord(payload.sessions)
+  );
+}
+
+export function responseError(method, response) {
+  const message = response.error?.message ?? "unknown";
+  return new Error(`${method} failed: ${message}`);
+}
+
+export function isRetryableStartupError(message) {
+  return (
+    message.includes("gateway starting") ||
+    message.includes("closed before frame") ||
+    message.includes("closed before open") ||
+    message.includes("ws open timeout") ||
+    message.includes("ECONNREFUSED") ||
+    message.includes("ECONNRESET") ||
+    message.includes("timeout")
+  );
+}
+
+async function readProtocolVersion() {
+  const protocol = await import("../../../../dist/gateway/protocol/index.js");
+  return protocol.PROTOCOL_VERSION;
+}
+
+export async function runGatewayNetworkClient(
+  { token, url, timeoutMs = readGatewayNetworkClientConnectTimeoutMs() },
+  deps = {},
+) {
+  const deadline = Date.now() + timeoutMs;
+  const delayImpl = deps.delay ?? delay;
+  const onceFrameImpl = deps.onceFrame ?? onceFrame;
+  const openSocketImpl = deps.openSocket ?? openSocket;
+  const protocolVersion = deps.protocolVersion ?? (await readProtocolVersion());
+  const stdout = deps.stdout ?? console.log;
+
+  let lastError;
+  while (Date.now() < deadline) {
+    let ws;
+    try {
+      ws = await openSocketImpl(url, remainingDeadlineMs(deadline));
+      ws.send(
+        JSON.stringify({
+          type: "req",
+          id: "c1",
+          method: "connect",
+          params: {
+            minProtocol: protocolVersion,
+            maxProtocol: protocolVersion,
+            client: {
+              id: "test",
+              displayName: "docker-net-e2e",
+              version: "dev",
+              platform: process.platform,
+              mode: "test",
+            },
+            caps: [],
+            auth: { token },
+          },
+        }),
+      );
+
+      const connectRes = await onceFrameImpl(
+        ws,
+        (frame) => frame?.type === "res" && frame?.id === "c1",
+        remainingDeadlineMs(deadline),
+      );
+      if (!connectRes.ok) {
+        lastError = responseError("connect", connectRes);
+        if (!isRetryableStartupError(lastError.message)) {
+          throw lastError;
+        }
+      } else {
+        ws.send(JSON.stringify({ type: "req", id: "h1", method: "health" }));
+        const healthRes = await onceFrameImpl(
+          ws,
+          (frame) => frame?.type === "res" && frame?.id === "h1",
+          remainingDeadlineMs(deadline),
+        );
+        if (healthRes.ok) {
+          if (!hasGatewayHealthSummaryPayload(healthRes)) {
+            throw new Error("health failed: missing health summary payload");
+          }
+          stdout("ok");
+          return;
+        }
+
+        throw responseError("health", healthRes);
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (!isRetryableStartupError(lastError.message)) {
+        throw lastError;
+      }
+    } finally {
+      ws?.close();
+    }
+
+    const retryDelayMs = Math.min(500, deadline - Date.now());
+    if (retryDelayMs > 0) {
+      await delayImpl(retryDelayMs);
+    }
+  }
+
+  throw lastError ?? new Error("connect failed: timeout");
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const url = process.env.GW_URL;
+  const token = process.env.GW_TOKEN;
+  if (!url || !token) {
+    throw new Error("missing GW_URL/GW_TOKEN");
+  }
+  await runGatewayNetworkClient({ token, url });
+}

scripts/e2e/lib/gateway-network/limits.mjs

@@ -0,0 +1,19 @@
+// Limits shared by gateway network E2E fixtures.
+function readPositiveIntEnv(name, fallback, env) {
+  const text = String(env[name] ?? fallback).trim();
+  if (!/^\d+$/u.test(text)) {
+    throw new Error(`invalid ${name}: ${text}`);
+  }
+  const value = Number(text);
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`invalid ${name}: ${text}`);
+  }
+  return value;
+}
+
+export function readGatewayNetworkClientConnectTimeoutMs(env = process.env) {
+  if (env.OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS != null) {
+    return readPositiveIntEnv("OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS", 80000, env);
+  }
+  return readPositiveIntEnv("OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS", 80000, env);
+}

scripts/e2e/lib/gateway-network/ws-frames.mjs

@@ -0,0 +1,67 @@
+// WebSocket frame helpers for gateway network E2E fixtures.
+function formatCloseValue(value) {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString();
+  }
+  return JSON.stringify(value) ?? "";
+}
+
+export function onceFrame(ws, filter, timeoutMs = 10_000) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const cleanup = () => {
+      clearTimeout(timer);
+      ws.off?.("message", onMessage);
+      ws.off?.("error", onError);
+      ws.off?.("close", onClose);
+    };
+    const settle = (fn, value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      fn(value);
+    };
+    const onMessage = (data) => {
+      let obj;
+      try {
+        obj = JSON.parse(String(data));
+        if (!filter(obj)) {
+          return;
+        }
+      } catch (error) {
+        settle(reject, error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      settle(resolve, obj);
+    };
+    const onError = (error) =>
+      settle(reject, error instanceof Error ? error : new Error(String(error)));
+    const onClose = (code, reason) => {
+      const closeDetails = [formatCloseValue(code), formatCloseValue(reason)]
+        .filter(Boolean)
+        .join(" ");
+      const suffix = closeDetails ? `: ${closeDetails}` : "";
+      settle(reject, new Error(`closed before frame${suffix}`));
+    };
+    const timer = setTimeout(() => {
+      settle(reject, new Error("timeout"));
+    }, timeoutMs);
+    timer.unref?.();
+
+    ws.on("message", onMessage);
+    ws.once("error", onError);
+    ws.once("close", onClose);
+  });
+}