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/fixtures/common.mjs

@@ -0,0 +1,25 @@
+// Common file/assertion helpers for E2E fixture writers.
+import fs from "node:fs";
+import path from "node:path";
+
+export const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+export const readJson = (file) => JSON.parse(fs.readFileSync(file, "utf8"));
+
+export const write = (file, contents) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, contents);
+};
+export const writeJson = (file, value) => write(file, json(value));
+
+export const requireArg = (value, name) => {
+  if (!value) {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+};
+
+export const assert = (condition, message) => {
+  if (!condition) {
+    throw new Error(message);
+  }
+};

scripts/e2e/lib/fixtures/config.mjs

@@ -0,0 +1,122 @@
+// Config fixture writer commands for E2E scenarios.
+import path from "node:path";
+import { readPositiveIntEnv, readTcpPortEnv } from "../env-limits.mjs";
+import { requireArg, writeJson } from "./common.mjs";
+
+function writeConfig(kind) {
+  const configPath = requireArg(process.env.OPENCLAW_CONFIG_PATH, "OPENCLAW_CONFIG_PATH");
+  const port = readTcpPortEnv("PORT", 18789);
+  const config =
+    kind === "config-reload"
+      ? {
+          gateway: {
+            port,
+            auth: {
+              mode: "token",
+              token: { source: "env", provider: "default", id: "GATEWAY_AUTH_TOKEN_REF" },
+            },
+            channelHealthCheckMinutes: 1,
+            controlUi: { enabled: false },
+            reload: { mode: "hybrid", debounceMs: 0 },
+          },
+        }
+      : kind === "browser-cdp"
+        ? {
+            gateway: {
+              port,
+              auth: {
+                mode: "token",
+                token: requireArg(process.env.OPENCLAW_GATEWAY_TOKEN, "OPENCLAW_GATEWAY_TOKEN"),
+              },
+              controlUi: { enabled: false },
+            },
+            browser: {
+              enabled: true,
+              defaultProfile: "docker-cdp",
+              ssrfPolicy: { allowedHostnames: ["127.0.0.1"] },
+              profiles: {
+                "docker-cdp": {
+                  cdpUrl: `http://127.0.0.1:${readTcpPortEnv("CDP_PORT", 19222)}`,
+                  color: "#FF4500",
+                },
+              },
+            },
+          }
+        : null;
+  writeJson(configPath, requireArg(config, "known config kind"));
+}
+
+function writeOpenAiWebSearchMinimalConfig() {
+  writeJson(path.join(process.env.OPENCLAW_STATE_DIR, "openclaw.json"), {
+    agents: {
+      defaults: {
+        model: { primary: "openai/gpt-5" },
+        models: {
+          "openai/gpt-5": {
+            params: { transport: "sse", openaiWsWarmup: false },
+          },
+        },
+      },
+    },
+    models: {
+      providers: {
+        openai: {
+          api: "openai-responses",
+          baseUrl: "http://api.openai.com/v1",
+          apiKey: { source: "env", provider: "default", id: "OPENAI_API_KEY" },
+          request: { allowPrivateNetwork: true },
+          models: [
+            {
+              id: "gpt-5",
+              name: "gpt-5",
+              api: "openai-responses",
+              reasoning: true,
+              input: ["text"],
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              contextWindow: 128000,
+              contextTokens: 96000,
+              maxTokens: 4096,
+            },
+          ],
+        },
+      },
+    },
+    tools: { web: { search: { enabled: true, maxResults: 3 } } },
+    plugins: { enabled: true, allow: ["openai"], entries: { openai: { enabled: true } } },
+    gateway: { auth: { mode: "token", token: process.env.OPENCLAW_GATEWAY_TOKEN } },
+  });
+}
+
+function writeOpenWebUiConfig([openaiApiKey]) {
+  const batchPath = requireArg(
+    process.env.OPENCLAW_CONFIG_BATCH_PATH,
+    "OPENCLAW_CONFIG_BATCH_PATH",
+  );
+  writeJson(batchPath, [
+    { path: "models.providers.openai.apiKey", value: requireArg(openaiApiKey, "OpenAI API key") },
+    {
+      path: "models.providers.openai.baseUrl",
+      value: (process.env.OPENAI_BASE_URL || "https://api.openai.com/v1").trim(),
+    },
+    { path: "models.providers.openai.models", value: [] },
+    {
+      path: "models.providers.openai.timeoutSeconds",
+      value: readPositiveIntEnv("OPENCLAW_OPENWEBUI_PROVIDER_TIMEOUT_SECONDS", 900),
+    },
+    { path: "models.providers.openai.agentRuntime", value: { id: "openclaw" } },
+    { path: "gateway.controlUi.enabled", value: false },
+    { path: "gateway.mode", value: "local" },
+    { path: "gateway.bind", value: "lan" },
+    { path: "gateway.auth.mode", value: "token" },
+    { path: "gateway.auth.token", value: process.env.OPENCLAW_GATEWAY_TOKEN },
+    { path: "gateway.http.endpoints.chatCompletions.enabled", value: true },
+    { path: "agents.defaults.model.primary", value: process.env.OPENCLAW_OPENWEBUI_MODEL },
+  ]);
+}
+
+export const configCommands = {
+  "config-reload": () => writeConfig("config-reload"),
+  "browser-cdp": () => writeConfig("browser-cdp"),
+  "openai-web-search-minimal-config": writeOpenAiWebSearchMinimalConfig,
+  "openwebui-config": writeOpenWebUiConfig,
+};

scripts/e2e/lib/fixtures/mock-openai-config.mjs

@@ -0,0 +1,100 @@
+// Mock OpenAI model config helpers for E2E fixture generation.
+function formatMockPortValue(value) {
+  return value === undefined ? "<missing>" : JSON.stringify(String(value));
+}
+
+export function parseMockOpenAiPort(value, label = "mock OpenAI port") {
+  const text = String(value ?? "").trim();
+  if (!/^[1-9]\d*$/u.test(text)) {
+    throw new Error(
+      `${label} must be a TCP port from 1 to 65535. Got: ${formatMockPortValue(value)}`,
+    );
+  }
+  const port = Number(text);
+  if (!Number.isSafeInteger(port) || port > 65535) {
+    throw new Error(
+      `${label} must be a TCP port from 1 to 65535. Got: ${formatMockPortValue(value)}`,
+    );
+  }
+  return port;
+}
+
+export function applyMockOpenAiModelConfig(cfg, params) {
+  const mockPort = parseMockOpenAiPort(params.mockPort);
+  const modelRef = params.modelRef ?? "openai/gpt-5.5";
+  const modelId = modelRef.split("/").at(-1) ?? "gpt-5.5";
+  const cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  cfg.models = {
+    ...cfg.models,
+    mode: "merge",
+    providers: {
+      ...cfg.models?.providers,
+      openai: {
+        ...cfg.models?.providers?.openai,
+        baseUrl: `http://127.0.0.1:${mockPort}/v1`,
+        apiKey: { source: "env", provider: "default", id: "OPENAI_API_KEY" },
+        api: "openai-responses",
+        agentRuntime: { id: "openclaw" },
+        request: { ...cfg.models?.providers?.openai?.request, allowPrivateNetwork: true },
+        models: [
+          {
+            id: modelId,
+            name: modelId,
+            api: "openai-responses",
+            agentRuntime: { id: "openclaw" },
+            reasoning: false,
+            input: ["text", "image"],
+            cost,
+            contextWindow: 128000,
+            contextTokens: 96000,
+            maxTokens: 4096,
+          },
+        ],
+      },
+    },
+  };
+  cfg.agents = {
+    ...cfg.agents,
+    defaults: {
+      ...cfg.agents?.defaults,
+      model: { primary: modelRef },
+      ...(params.includeImageDefaults
+        ? {
+            imageModel: { primary: modelRef, timeoutMs: 30_000 },
+            imageGenerationModel: { primary: "openai/gpt-image-1", timeoutMs: 30_000 },
+          }
+        : {}),
+      models: {
+        ...cfg.agents?.defaults?.models,
+        [modelRef]: {
+          agentRuntime: { id: "openclaw" },
+          params: { transport: "sse", openaiWsWarmup: false },
+        },
+      },
+    },
+    ...(Array.isArray(cfg.agents?.list)
+      ? {
+          list: cfg.agents.list.map((agent) => ({
+            ...agent,
+            model: { ...agent.model, primary: modelRef },
+            models: {
+              ...agent.models,
+              [modelRef]: {
+                ...agent.models?.[modelRef],
+                agentRuntime: { id: "openclaw" },
+                params: {
+                  ...agent.models?.[modelRef]?.params,
+                  transport: "sse",
+                  openaiWsWarmup: false,
+                },
+              },
+            },
+          })),
+        }
+      : {}),
+  };
+  cfg.plugins = {
+    ...cfg.plugins,
+    enabled: true,
+  };
+}

scripts/e2e/lib/fixtures/plugins.mjs

@@ -0,0 +1,173 @@
+// Plugin fixture writer commands for E2E scenarios.
+import path from "node:path";
+import { requireArg, write, writeJson } from "./common.mjs";
+
+function writePluginManifest(file, id, extra = {}) {
+  writeJson(file, { id, ...extra, configSchema: { type: "object", properties: {} } });
+}
+
+function writeFakeIsNumberPackage(dir) {
+  writeJson(path.join(dir, "package.json"), {
+    name: "is-number",
+    version: "7.0.0",
+    main: "index.js",
+  });
+  write(path.join(dir, "index.js"), "module.exports = (value) => typeof value === 'number';\n");
+}
+
+function writePluginDemo([dir]) {
+  write(
+    path.join(requireArg(dir, "dir"), "index.js"),
+    'module.exports = { id: "demo-plugin", name: "Demo Plugin", description: "Docker E2E demo plugin", register(api) { api.registerTool(() => null, { name: "demo_tool" }); api.registerGatewayMethod("demo.ping", async () => ({ ok: true })); api.registerCli(() => {}, { commands: ["demo"] }); api.registerService({ id: "demo-service", start: () => {} }); }, };\n',
+  );
+  writePluginManifest(path.join(dir, "openclaw.plugin.json"), "demo-plugin", {
+    contracts: { tools: ["demo_tool"] },
+  });
+}
+
+function writePlugin([dir, id, version, method, name]) {
+  for (const [value, label] of [
+    [dir, "dir"],
+    [id, "id"],
+    [version, "version"],
+    [method, "method"],
+    [name, "name"],
+  ]) {
+    requireArg(value, label);
+  }
+  writeJson(path.join(dir, "package.json"), {
+    name: `@openclaw/${id}`,
+    version,
+    openclaw: { extensions: ["./index.js"] },
+  });
+  write(
+    path.join(dir, "index.js"),
+    `module.exports = { id: ${JSON.stringify(id)}, name: ${JSON.stringify(name)}, register(api) { api.registerGatewayMethod(${JSON.stringify(method)}, async () => ({ ok: true })); }, };\n`,
+  );
+  writePluginManifest(path.join(dir, "openclaw.plugin.json"), id);
+}
+
+function writePluginWithVendoredDependency([dir, id, version, method, name]) {
+  writePlugin([dir, id, version, method, name]);
+  const packageJsonPath = path.join(dir, "package.json");
+  writeJson(packageJsonPath, {
+    name: `@openclaw/${id}`,
+    version,
+    dependencies: { "is-number": "7.0.0" },
+    openclaw: { extensions: ["./index.js"] },
+  });
+  write(
+    path.join(dir, "index.js"),
+    `const isNumber = require("is-number");\nmodule.exports = { id: ${JSON.stringify(id)}, name: ${JSON.stringify(name)}, register(api) { api.registerGatewayMethod(${JSON.stringify(method)}, async () => ({ ok: isNumber(42) })); }, };\n`,
+  );
+  writeFakeIsNumberPackage(path.join(dir, "node_modules", "is-number"));
+}
+
+function writePluginWithCli([dir, id, version, method, name, cliRoot, cliOutput]) {
+  for (const [value, label] of [
+    [dir, "dir"],
+    [id, "id"],
+    [version, "version"],
+    [method, "method"],
+    [name, "name"],
+    [cliRoot, "cliRoot"],
+    [cliOutput, "cliOutput"],
+  ]) {
+    requireArg(value, label);
+  }
+  writeJson(path.join(dir, "package.json"), {
+    name: `@openclaw/${id}`,
+    version,
+    dependencies: { "is-number": "file:./deps/is-number" },
+    openclaw: { extensions: ["./index.js"] },
+  });
+  writeFakeIsNumberPackage(path.join(dir, "deps", "is-number"));
+  write(
+    path.join(dir, "index.js"),
+    `const isNumber = require("is-number");\nmodule.exports = { id: ${JSON.stringify(id)}, name: ${JSON.stringify(name)}, register(api) { api.registerGatewayMethod(${JSON.stringify(method)}, async () => ({ ok: isNumber(42) })); api.registerCli(({ program }) => { const root = program.command(${JSON.stringify(cliRoot)}).description(${JSON.stringify(`${name} fixture command`)}); root.command("ping").description("Print fixture ping output").action(() => { console.log(${JSON.stringify(cliOutput)}); }); }, { descriptors: [{ name: ${JSON.stringify(cliRoot)}, description: ${JSON.stringify(`${name} fixture command`)}, hasSubcommands: true }] }); }, };\n`,
+  );
+  writePluginManifest(path.join(dir, "openclaw.plugin.json"), id);
+}
+
+function writePluginWithCliRegistryDependency([
+  dir,
+  id,
+  version,
+  method,
+  name,
+  cliRoot,
+  cliOutput,
+]) {
+  for (const [value, label] of [
+    [dir, "dir"],
+    [id, "id"],
+    [version, "version"],
+    [method, "method"],
+    [name, "name"],
+    [cliRoot, "cliRoot"],
+    [cliOutput, "cliOutput"],
+  ]) {
+    requireArg(value, label);
+  }
+  writeJson(path.join(dir, "package.json"), {
+    name: `@openclaw/${id}`,
+    version,
+    dependencies: { "is-number": "7.0.0" },
+    openclaw: { extensions: ["./index.js"] },
+  });
+  write(
+    path.join(dir, "index.js"),
+    `const isNumber = require("is-number");\nmodule.exports = { id: ${JSON.stringify(id)}, name: ${JSON.stringify(name)}, register(api) { api.registerGatewayMethod(${JSON.stringify(method)}, async () => ({ ok: isNumber(42) })); api.registerCli(({ program }) => { const root = program.command(${JSON.stringify(cliRoot)}).description(${JSON.stringify(`${name} fixture command`)}); root.command("ping").description("Print fixture ping output").action(() => { console.log(${JSON.stringify(cliOutput)}); }); }, { descriptors: [{ name: ${JSON.stringify(cliRoot)}, description: ${JSON.stringify(`${name} fixture command`)}, hasSubcommands: true }] }); }, };\n`,
+  );
+  writePluginManifest(path.join(dir, "openclaw.plugin.json"), id);
+}
+
+function writeClaudeBundle(args) {
+  const root = requireArg(args[0], "root");
+  writeJson(path.join(root, ".claude-plugin", "plugin.json"), { name: "claude-bundle-e2e" });
+  write(
+    path.join(root, "commands", "office-hours.md"),
+    "---\ndescription: Help with architecture and rollout planning\n---\nAct as an engineering advisor.\n\nFocus on:\n$ARGUMENTS\n",
+  );
+}
+
+function writePluginMarketplace(args) {
+  const root = requireArg(args[0], "root");
+  writeJson(path.join(root, ".claude-plugin", "marketplace.json"), {
+    name: "Fixture Marketplace",
+    version: "1.0.0",
+    plugins: [
+      {
+        name: "marketplace-shortcut",
+        version: "0.0.1",
+        description: "Shortcut install fixture",
+        source: "./plugins/marketplace-shortcut",
+      },
+      {
+        name: "marketplace-direct",
+        version: "0.0.1",
+        description: "Explicit marketplace fixture",
+        source: { type: "path", path: "./plugins/marketplace-direct" },
+      },
+    ],
+  });
+  writeJson(path.join(process.env.HOME, ".claude", "plugins", "known_marketplaces.json"), {
+    "claude-fixtures": {
+      installLocation: root,
+      source: { type: "github", repo: "openclaw/fixture-marketplace" },
+    },
+  });
+}
+
+export const pluginCommands = {
+  "plugin-demo": writePluginDemo,
+  plugin: writePlugin,
+  "plugin-vendored-dep": writePluginWithVendoredDependency,
+  "plugin-cli": writePluginWithCli,
+  "plugin-cli-registry-dep": writePluginWithCliRegistryDependency,
+  "fake-is-number-package": ([dir]) => writeFakeIsNumberPackage(requireArg(dir, "dir")),
+  "plugin-manifest": ([file, id]) =>
+    writePluginManifest(requireArg(file, "file"), requireArg(id, "id")),
+  "claude-bundle": writeClaudeBundle,
+  marketplace: writePluginMarketplace,
+};

scripts/e2e/lib/fixtures/workspace.mjs

@@ -0,0 +1,103 @@
+// Workspace fixture writer commands for E2E scenarios.
+import fs from "node:fs";
+import path from "node:path";
+import { readTextFileTail } from "../text-file-utils.mjs";
+import { assert, readJson, requireArg, write, writeJson } from "./common.mjs";
+
+const AGENTS_DELETE_OUTPUT_MAX_BYTES = readPositiveIntEnv(
+  "OPENCLAW_FIXTURE_AGENTS_DELETE_OUTPUT_MAX_BYTES",
+  1024 * 1024,
+);
+const ERROR_DETAIL_TAIL_BYTES = 16 * 1024;
+
+function readPositiveIntEnv(name, fallback) {
+  const text = String(process.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;
+}
+
+function writeOpenWebUiWorkspace() {
+  const workspace =
+    process.env.OPENCLAW_WORKSPACE_DIR || path.join(process.env.HOME, ".openclaw", "workspace");
+  write(
+    path.join(workspace, "IDENTITY.md"),
+    "# Identity\n\n- Name: OpenClaw\n- Purpose: Open WebUI Docker compatibility smoke test assistant.\n",
+  );
+  writeJson(path.join(workspace, ".openclaw", "workspace-state.json"), {
+    version: 1,
+    setupCompletedAt: "2026-01-01T00:00:00.000Z",
+  });
+  fs.rmSync(path.join(workspace, "BOOTSTRAP.md"), { force: true });
+}
+
+function writeAgentsDeleteConfig() {
+  const stateDir = requireArg(process.env.OPENCLAW_STATE_DIR, "OPENCLAW_STATE_DIR");
+  const sharedWorkspace = requireArg(process.env.SHARED_WORKSPACE, "SHARED_WORKSPACE");
+  const gatewayToken = process.env.OPENCLAW_GATEWAY_TOKEN?.trim();
+  fs.mkdirSync(sharedWorkspace, { recursive: true });
+  writeJson(path.join(stateDir, "openclaw.json"), {
+    agents: {
+      list: [
+        { id: "main", workspace: sharedWorkspace },
+        { id: "ops", workspace: sharedWorkspace },
+      ],
+    },
+    ...(gatewayToken ? { gateway: { auth: { mode: "token", token: gatewayToken } } } : {}),
+  });
+}
+
+function assertAgentsDeleteResult([outputPath]) {
+  const resolvedOutputPath = requireArg(outputPath, "outputPath");
+  const outputStat = fs.statSync(resolvedOutputPath);
+  if (outputStat.isFile() && outputStat.size > AGENTS_DELETE_OUTPUT_MAX_BYTES) {
+    throw new Error(
+      `agents delete --json output exceeded ${AGENTS_DELETE_OUTPUT_MAX_BYTES} bytes:\nstdout tail=${readTextFileTail(
+        resolvedOutputPath,
+        ERROR_DETAIL_TAIL_BYTES,
+      )}`,
+    );
+  }
+  let parsed;
+  try {
+    parsed = readJson(resolvedOutputPath);
+  } catch (error) {
+    console.error("agents delete --json did not emit valid JSON:");
+    console.error(readTextFileTail(resolvedOutputPath, ERROR_DETAIL_TAIL_BYTES).trim());
+    const message = error instanceof Error ? error.message.split("\n").at(0) : String(error);
+    throw new Error(`agents delete --json parse failed: ${message}`, { cause: error });
+  }
+  for (const [actual, expected, label] of [
+    [parsed.agentId, "ops", "agentId"],
+    [parsed.workspace, process.env.SHARED_WORKSPACE, "workspace"],
+    [parsed.workspaceRetained, true, "workspaceRetained"],
+    [parsed.workspaceRetainedReason, "shared", "workspaceRetainedReason"],
+  ]) {
+    assert(actual === expected, `${label} mismatch: ${JSON.stringify(actual)}`);
+  }
+  assert(
+    Array.isArray(parsed.workspaceSharedWith) && parsed.workspaceSharedWith.includes("main"),
+    "missing shared-with main marker",
+  );
+  assert(fs.existsSync(process.env.SHARED_WORKSPACE), "shared workspace was removed");
+  const remaining =
+    readJson(path.join(process.env.OPENCLAW_STATE_DIR, "openclaw.json"))?.agents?.list ?? [];
+  assert(Array.isArray(remaining), "agents list missing after delete");
+  assert(!remaining.some((entry) => entry?.id === "ops"), "deleted agent remained in config");
+  assert(
+    remaining.some((entry) => entry?.id === "main"),
+    "main agent missing after delete",
+  );
+  console.log("agents delete shared workspace smoke ok");
+}
+
+export const workspaceCommands = {
+  "openwebui-workspace": writeOpenWebUiWorkspace,
+  "agents-delete-config": writeAgentsDeleteConfig,
+  "agents-delete-assert": assertAgentsDeleteResult,
+};