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/codex-media-path/client.mjs

@@ -0,0 +1,178 @@
+// Client helpers for Codex media-path E2E fixtures.
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { PROTOCOL_VERSION } from "../../../../dist/gateway/protocol/index.js";
+import { renderBitmapTextPngBase64 } from "../../../../test/helpers/live-image-probe.ts";
+import { createGatewayWsClient } from "../../../lib/gateway-ws-client.ts";
+import { resolveGatewaySuccessPayload } from "../gateway-frame-payload.mjs";
+import { createJsonlRequestTailer } from "./jsonl-request-tail.mjs";
+import { readPositiveIntEnv, readTcpPortEnv } from "./limits.mjs";
+
+const portText = process.env.PORT;
+const token = process.env.OPENCLAW_GATEWAY_TOKEN;
+const appServerLog =
+  process.env.OPENCLAW_CODEX_MEDIA_PATH_APP_SERVER_LOG ??
+  "/tmp/openclaw-codex-media-path-app-server.jsonl";
+const timeoutSeconds = readPositiveIntEnv("OPENCLAW_CODEX_MEDIA_PATH_TIMEOUT_SECONDS", 180);
+const logTailMaxBytes = readPositiveIntEnv(
+  "OPENCLAW_CODEX_MEDIA_PATH_LOG_TAIL_MAX_BYTES",
+  2 * 1024 * 1024,
+);
+
+if (!portText || !token) {
+  throw new Error("missing PORT/OPENCLAW_GATEWAY_TOKEN");
+}
+const port = readTcpPortEnv("PORT", portText);
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function sha256Base64(data) {
+  return createHash("sha256").update(Buffer.from(data, "base64")).digest("hex");
+}
+
+const loggedRequests = createJsonlRequestTailer(appServerLog, {
+  maxReadBytes: logTailMaxBytes,
+});
+
+async function waitFor(label, predicate, timeoutMs) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const value = await predicate();
+    if (value !== undefined) {
+      return value;
+    }
+    await delay(50);
+  }
+  throw new Error(`timeout waiting for ${label}`);
+}
+
+async function connectGateway() {
+  const gatewayClient = createGatewayWsClient({
+    handshakeTimeoutMs: 45_000,
+    openTimeoutMs: 45_000,
+    openTimeoutMessage: "gateway ws open timeout",
+    url: `ws://127.0.0.1:${port}`,
+  });
+  await gatewayClient.waitOpen();
+
+  async function request(method, params, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 60_000;
+    const response = await gatewayClient.request(method, params ?? {}, timeoutMs);
+    if (response.ok) {
+      return resolveGatewaySuccessPayload(response);
+    }
+    throw new Error(
+      response.error && typeof response.error === "object" && "message" in response.error
+        ? String(response.error.message)
+        : "gateway request failed",
+    );
+  }
+
+  await request(
+    "connect",
+    {
+      minProtocol: PROTOCOL_VERSION,
+      maxProtocol: PROTOCOL_VERSION,
+      client: {
+        id: "gateway-client",
+        displayName: "docker-codex-media-path",
+        version: "1.0.0",
+        platform: process.platform,
+        mode: "backend",
+      },
+      role: "operator",
+      scopes: ["operator.read", "operator.write", "operator.admin"],
+      caps: [],
+      auth: { token },
+    },
+    { timeoutMs: 60_000 },
+  );
+  await request("sessions.subscribe", {}, { timeoutMs: 60_000 });
+
+  return {
+    request,
+    async close() {
+      gatewayClient.close();
+    },
+  };
+}
+
+const gateway = await connectGateway();
+
+function randomBitmapTextToken(length = 6) {
+  const alphabet = "24567ACEF";
+  return [...randomBytes(length)].map((byte) => alphabet[byte % alphabet.length]).join("");
+}
+
+try {
+  const expectedToken = randomBitmapTextToken();
+  const imageBase64 = renderBitmapTextPngBase64(expectedToken);
+  const expectedHash = sha256Base64(imageBase64);
+  const runId = `codex-media-path-${randomUUID()}`;
+  const started = Date.now();
+
+  const response = await gateway.request(
+    "chat.send",
+    {
+      sessionKey: "agent:main:codex-media-path-e2e",
+      idempotencyKey: runId,
+      message: "Read the code printed in the attached image. Reply only the code.",
+      attachments: [
+        {
+          mimeType: "image/png",
+          fileName: "codex-media-path-probe.png",
+          content: imageBase64,
+        },
+      ],
+      originatingChannel: "codex-media-path-e2e",
+      originatingTo: "codex-media-path-e2e",
+      originatingAccountId: "codex-media-path-e2e",
+    },
+    { timeoutMs: timeoutSeconds * 1000 },
+  );
+  assert(response?.status === "started", `chat.send did not start: ${JSON.stringify(response)}`);
+
+  const turnRequest = await waitFor(
+    "Codex turn/start image input",
+    () =>
+      loggedRequests.read().find((request) => {
+        if (request.method !== "turn/start") {
+          return undefined;
+        }
+        const imageInput = request.params?.input?.find?.(
+          (entry) => entry?.type === "image" && typeof entry.url === "string",
+        );
+        return imageInput ? request : undefined;
+      }),
+    timeoutSeconds * 1000,
+  );
+
+  const imageInput = turnRequest.params.input.find((entry) => entry?.type === "image");
+  const imageUrl = imageInput.url;
+  assert(
+    imageUrl.startsWith("data:image/png;base64,"),
+    `turn/start image input is not an inline PNG: ${JSON.stringify(imageInput)}`,
+  );
+  const actualBase64 = imageUrl.slice("data:image/png;base64,".length);
+  const actualHash = sha256Base64(actualBase64);
+  assert(
+    actualHash === expectedHash,
+    `forwarded PNG hash mismatch: expected ${expectedHash}, got ${actualHash}`,
+  );
+
+  await delay(50);
+  console.log(
+    JSON.stringify({
+      ok: true,
+      elapsedMs: Date.now() - started,
+      expectedToken,
+      imageSha256: actualHash,
+    }),
+  );
+} finally {
+  await gateway.close();
+}

scripts/e2e/lib/codex-media-path/fake-codex-app-server.mjs

@@ -0,0 +1,104 @@
+// Fake Codex app server used by media-path E2E scenarios.
+import fs from "node:fs";
+import readline from "node:readline";
+
+const requestLog =
+  process.env.OPENCLAW_CODEX_MEDIA_PATH_APP_SERVER_LOG ??
+  "/tmp/openclaw-codex-media-path-app-server.jsonl";
+let turnCount = 0;
+
+function appendRequest(request) {
+  try {
+    fs.appendFileSync(requestLog, `${JSON.stringify(request)}\n`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`fake Codex app-server request log write failed: ${message}\n`);
+    if (request?.id != null) {
+      sendError(request.id, `fake Codex app-server request log write failed: ${message}`);
+    }
+    return false;
+  }
+}
+
+function send(id, result) {
+  process.stdout.write(`${JSON.stringify({ id, result })}\n`);
+}
+
+function sendError(id, message) {
+  process.stdout.write(`${JSON.stringify({ error: { message }, id })}\n`);
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+  if (!line.trim()) {
+    return;
+  }
+  const request = JSON.parse(line);
+  if (!appendRequest(request)) {
+    return;
+  }
+  const { id, method, params } = request;
+  if (method === "initialize") {
+    send(id, {
+      protocolVersion: "2",
+      serverInfo: { name: "openclaw-codex-media-path-e2e", version: "0.125.0" },
+      userAgent: "openclaw-codex-media-path-e2e/0.125.0 (Docker; test)",
+    });
+    return;
+  }
+  if (method === "thread/start") {
+    const now = Date.now();
+    send(id, {
+      thread: {
+        id: "thread-codex-media-path-e2e",
+        sessionId: "session-codex-media-path-e2e",
+        forkedFromId: null,
+        preview: "",
+        ephemeral: false,
+        modelProvider: "openai",
+        createdAt: now,
+        updatedAt: now,
+        cwd: params?.cwd ?? process.cwd(),
+        status: { type: "idle" },
+        path: null,
+        cliVersion: "0.125.0",
+        source: "unknown",
+        agentNickname: null,
+        agentRole: null,
+        gitInfo: null,
+        name: null,
+        turns: [],
+      },
+      model: params?.model ?? "gpt-5.5",
+      modelProvider: "openai",
+      serviceTier: null,
+      cwd: params?.cwd ?? process.cwd(),
+      instructionSources: [],
+      approvalPolicy: params?.approvalPolicy ?? "never",
+      approvalsReviewer: params?.approvalsReviewer ?? "user",
+      sandbox: { type: "dangerFullAccess" },
+      permissionProfile: null,
+      reasoningEffort: null,
+    });
+    return;
+  }
+  if (method === "turn/start") {
+    turnCount += 1;
+    send(id, {
+      turn: {
+        id: `turn-codex-media-path-e2e-${turnCount}`,
+        status: "completed",
+        items: [
+          {
+            type: "agentMessage",
+            id: `msg-codex-media-path-e2e-${turnCount}`,
+            text: "CODEX_MEDIA_PATH_E2E_OK",
+          },
+        ],
+      },
+    });
+    return;
+  }
+  send(id, {});
+});

scripts/e2e/lib/codex-media-path/jsonl-request-tail.mjs

@@ -0,0 +1,43 @@
+// Tails JSONL request logs for Codex media-path E2E assertions.
+import {
+  createIncrementalLineReader,
+  resolvePositiveInteger,
+} from "../incremental-line-reader.mjs";
+
+const DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
+const DEFAULT_HISTORY_LIMIT = 1024;
+
+export function createJsonlRequestTailer(filePath, options = {}) {
+  const maxReadBytes = resolvePositiveInteger(options.maxReadBytes, DEFAULT_MAX_READ_BYTES);
+  const historyLimit = resolvePositiveInteger(options.historyLimit, DEFAULT_HISTORY_LIMIT);
+  const reader = createIncrementalLineReader(filePath, { maxReadBytes });
+  let requests = [];
+
+  function parseLine(line) {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`invalid app-server JSONL at ${filePath}: ${message}`, { cause: error });
+    }
+  }
+
+  return {
+    read() {
+      const { lines, reset } = reader.readLines();
+      if (reset) {
+        requests = [];
+      }
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        requests.push(parseLine(line));
+      }
+      if (requests.length > historyLimit) {
+        requests = requests.slice(-historyLimit);
+      }
+      return requests;
+    },
+  };
+}

scripts/e2e/lib/codex-media-path/limits.mjs

@@ -0,0 +1,21 @@
+// Limits shared by Codex media-path E2E fixtures.
+export function readPositiveIntEnv(name, fallback, env = process.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 readTcpPortEnv(name, fallback, env = process.env) {
+  const value = readPositiveIntEnv(name, fallback, env);
+  if (value > 65_535) {
+    const text = String(env[name] ?? fallback).trim();
+    throw new Error(`invalid ${name}: ${text}`);
+  }
+  return value;
+}

scripts/e2e/lib/codex-media-path/scenario.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+source scripts/lib/openclaw-e2e-instance.sh
+openclaw_e2e_eval_test_state_from_b64 "${OPENCLAW_TEST_STATE_SCRIPT_B64:?missing OPENCLAW_TEST_STATE_SCRIPT_B64}"
+export OPENCLAW_SKIP_CHANNELS=1
+export OPENCLAW_SKIP_GMAIL_WATCHER=1
+export OPENCLAW_SKIP_CRON=1
+export OPENCLAW_SKIP_CANVAS_HOST=1
+export OPENCLAW_SKIP_BROWSER_CONTROL_SERVER=1
+export OPENCLAW_SKIP_ACPX_RUNTIME=1
+export OPENCLAW_SKIP_ACPX_RUNTIME_PROBE=1
+export OPENCLAW_AGENT_HARNESS_FALLBACK=none
+export OPENCLAW_CODEX_MEDIA_PATH_APP_SERVER_LOG="/tmp/openclaw-codex-media-path-app-server.jsonl"
+
+PORT="${PORT:?missing PORT}"
+TOKEN="${OPENCLAW_GATEWAY_TOKEN:?missing OPENCLAW_GATEWAY_TOKEN}"
+PLUGIN_SPEC="${OPENCLAW_CODEX_MEDIA_PATH_PLUGIN_SPEC:?missing OPENCLAW_CODEX_MEDIA_PATH_PLUGIN_SPEC}"
+GATEWAY_LOG="/tmp/openclaw-codex-media-path-gateway.log"
+CLIENT_LOG="/tmp/openclaw-codex-media-path-client.log"
+PLUGIN_INSTALL_LOG="/tmp/openclaw-codex-media-path-plugin-install.log"
+PLUGIN_INSPECT_LOG="/tmp/openclaw-codex-media-path-plugin-inspect.json"
+gateway_pid=""
+
+cleanup() {
+  openclaw_e2e_stop_process "$gateway_pid"
+}
+trap cleanup EXIT
+
+dump_debug_logs() {
+  local status="$1"
+  echo "Codex media-path Docker E2E failed with exit code $status" >&2
+  openclaw_e2e_dump_logs "$PLUGIN_INSTALL_LOG" "$PLUGIN_INSPECT_LOG" "$GATEWAY_LOG" "$CLIENT_LOG" "$OPENCLAW_CODEX_MEDIA_PATH_APP_SERVER_LOG"
+}
+trap 'status=$?; dump_debug_logs "$status"; exit "$status"' ERR
+
+entry="$(openclaw_e2e_resolve_entrypoint)"
+mkdir -p "$OPENCLAW_STATE_DIR" "$OPENCLAW_TEST_WORKSPACE_DIR"
+rm -f "$OPENCLAW_CODEX_MEDIA_PATH_APP_SERVER_LOG"
+
+openclaw_e2e_enable_openclaw_cli_timeout
+
+echo "Installing Codex plugin: $PLUGIN_SPEC"
+openclaw plugins install "$PLUGIN_SPEC" --force >"$PLUGIN_INSTALL_LOG" 2>&1
+openclaw plugins inspect codex --runtime --json >"$PLUGIN_INSPECT_LOG"
+
+node scripts/e2e/lib/codex-media-path/write-config.mjs
+
+gateway_pid="$(openclaw_e2e_start_gateway "$entry" "$PORT" "$GATEWAY_LOG")"
+openclaw_e2e_wait_gateway_ready "$gateway_pid" "$GATEWAY_LOG" 480 "$PORT"
+
+PORT="$PORT" OPENCLAW_GATEWAY_TOKEN="$TOKEN" \
+  tsx scripts/e2e/lib/codex-media-path/client.mjs >"$CLIENT_LOG" 2>&1
+
+openclaw_e2e_print_log "$CLIENT_LOG"
+echo "Codex media-path Docker E2E passed"

scripts/e2e/lib/codex-media-path/write-config.mjs

@@ -0,0 +1,79 @@
+// Writes config fixtures for Codex media-path E2E scenarios.
+import fs from "node:fs";
+import path from "node:path";
+import { readPositiveIntEnv, readTcpPortEnv } from "./limits.mjs";
+
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`missing ${name}`);
+  }
+  return value;
+}
+
+const configPath = requireEnv("OPENCLAW_CONFIG_PATH");
+const stateDir = requireEnv("OPENCLAW_STATE_DIR");
+const workspaceDir = requireEnv("OPENCLAW_TEST_WORKSPACE_DIR");
+const token = requireEnv("OPENCLAW_GATEWAY_TOKEN");
+const timeoutSeconds = readPositiveIntEnv("OPENCLAW_CODEX_MEDIA_PATH_TIMEOUT_SECONDS", 180);
+const gatewayPort = readTcpPortEnv("PORT", 18790);
+
+const config = {
+  gateway: {
+    port: gatewayPort,
+    bind: "loopback",
+    auth: { mode: "token", token },
+    controlUi: { enabled: false },
+  },
+  plugins: {
+    enabled: true,
+    allow: ["codex"],
+    entries: {
+      codex: {
+        enabled: true,
+        config: {
+          appServer: {
+            mode: "yolo",
+            command: "node",
+            args: ["scripts/e2e/lib/codex-media-path/fake-codex-app-server.mjs"],
+            requestTimeoutMs: timeoutSeconds * 1000,
+            turnCompletionIdleTimeoutMs: timeoutSeconds * 1000,
+          },
+        },
+      },
+    },
+  },
+  agents: {
+    defaults: {
+      model: { primary: "codex/gpt-5.5", fallbacks: [] },
+      models: {
+        "codex/gpt-5.5": {
+          agentRuntime: { id: "codex" },
+        },
+      },
+      workspace: workspaceDir,
+      skipBootstrap: true,
+      timeoutSeconds,
+      sandbox: { mode: "off" },
+    },
+    list: [
+      {
+        id: "main",
+        default: true,
+        model: { primary: "codex/gpt-5.5", fallbacks: [] },
+        models: {
+          "codex/gpt-5.5": {
+            agentRuntime: { id: "codex" },
+          },
+        },
+        workspace: workspaceDir,
+      },
+    ],
+  },
+  skills: { allowBundled: [] },
+};
+
+fs.mkdirSync(path.dirname(configPath), { recursive: true });
+fs.mkdirSync(workspaceDir, { recursive: true });
+fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+fs.mkdirSync(path.join(stateDir, "logs"), { recursive: true });