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/parallels/host-server.ts

@@ -0,0 +1,202 @@
+// Host Server script supports OpenClaw repository automation.
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { createServer } from "node:http";
+import { createConnection } from "node:net";
+import path from "node:path";
+import { sleep as delay } from "../../lib/sleep.mjs";
+import { die, run, say, sh, warn } from "./host-command.ts";
+import type { HostServer } from "./types.ts";
+
+const HOST_SERVER_STDERR_LIMIT_BYTES = 64 * 1024;
+const HOST_SERVER_STDERR_DRAIN_MS = 5_000;
+
+export function resolveHostIp(explicit = ""): string {
+  if (explicit) {
+    return explicit;
+  }
+  const output = sh("ifconfig | awk '/inet 10\\.211\\./ { print $2; exit }'", {
+    quiet: true,
+  }).stdout.trim();
+  if (!output) {
+    die("failed to detect Parallels host IP; pass --host-ip");
+  }
+  return output;
+}
+
+export function allocateHostPort(): number {
+  return Number(
+    run(
+      "python3",
+      [
+        "-c",
+        "import socket; s=socket.socket(); s.bind(('0.0.0.0', 0)); print(s.getsockname()[1]); s.close()",
+      ],
+      { quiet: true },
+    ).stdout.trim(),
+  );
+}
+
+export async function isHostPortFree(port: number): Promise<boolean> {
+  return await new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => resolve(false));
+    server.listen(port, "0.0.0.0", () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+export async function resolveHostPort(
+  port: number,
+  explicit: boolean,
+  defaultPort: number,
+): Promise<number> {
+  if (await isHostPortFree(port)) {
+    return port;
+  }
+  if (explicit) {
+    die(`host port ${port} already in use`);
+  }
+  const allocated = allocateHostPort();
+  warn(`host port ${defaultPort} busy; using ${allocated}`);
+  return allocated;
+}
+
+export async function startHostServer(input: {
+  dir: string;
+  hostIp: string;
+  port: number;
+  artifactPath: string;
+  label: string;
+}): Promise<HostServer> {
+  const actualPort = input.port || allocateHostPort();
+  const child = spawn(
+    "python3",
+    ["-m", "http.server", String(actualPort), "--bind", "0.0.0.0", "--directory", input.dir],
+    {
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+  await waitForHostServer(child, actualPort);
+  say(`Serve ${input.label} on ${input.hostIp}:${actualPort}`);
+  return {
+    hostIp: input.hostIp,
+    port: actualPort,
+    stop: async () => {
+      await stopHostServerChild(child);
+    },
+    urlFor: (filePath) =>
+      `http://${input.hostIp}:${actualPort}/${encodeURIComponent(path.basename(filePath))}`,
+  };
+}
+
+async function stopHostServerChild(
+  child: ChildProcessWithoutNullStreams,
+  terminateTimeoutMs = 2_000,
+  killTimeoutMs = 1_500,
+): Promise<boolean> {
+  if (hasHostServerChildExited(child)) {
+    return true;
+  }
+  child.kill("SIGTERM");
+  if (await waitForChildExit(child, terminateTimeoutMs)) {
+    return true;
+  }
+  child.kill("SIGKILL");
+  return await waitForChildExit(child, killTimeoutMs);
+}
+
+async function waitForChildExit(
+  child: ChildProcessWithoutNullStreams,
+  timeoutMs: number,
+): Promise<boolean> {
+  if (hasHostServerChildExited(child)) {
+    return true;
+  }
+  return await new Promise<boolean>((resolve) => {
+    let settled = false;
+    const onExit = () => settle(true);
+    const timeout = setTimeout(() => settle(hasHostServerChildExited(child)), timeoutMs);
+    timeout.unref();
+    function settle(exited: boolean): void {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      child.off("exit", onExit);
+      resolve(exited);
+    }
+    child.once("exit", onExit);
+  });
+}
+
+function hasHostServerChildExited(child: ChildProcessWithoutNullStreams): boolean {
+  return child.exitCode != null || child.signalCode != null;
+}
+
+async function waitForHostServer(
+  child: ChildProcessWithoutNullStreams,
+  port: number,
+): Promise<void> {
+  let stderr = "";
+  child.stderr.on("data", (chunk: Buffer) => {
+    stderr = appendBoundedOutput(stderr, chunk, HOST_SERVER_STDERR_LIMIT_BYTES);
+  });
+  let childClosed = false;
+  const childClose = new Promise<void>((resolve) => {
+    child.once("close", () => {
+      childClosed = true;
+      resolve();
+    });
+  });
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < 10_000) {
+    if (hasHostServerChildExited(child)) {
+      if (!childClosed) {
+        await Promise.race([childClose, delay(HOST_SERVER_STDERR_DRAIN_MS)]);
+      }
+      die(`host artifact server exited early: ${stderr.trim() || formatHostServerExit(child)}`);
+    }
+    if (await canConnect(port)) {
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 100);
+    });
+  }
+  child.kill("SIGTERM");
+  die(`host artifact server did not start on port ${port}: ${stderr.trim()}`);
+}
+
+function appendBoundedOutput(previous: string, chunk: Buffer, limitBytes: number): string {
+  const combined = Buffer.concat([Buffer.from(previous, "utf8"), chunk]);
+  if (combined.byteLength <= limitBytes) {
+    return combined.toString("utf8");
+  }
+  return combined.subarray(combined.byteLength - limitBytes).toString("utf8");
+}
+
+function formatHostServerExit(child: ChildProcessWithoutNullStreams): string {
+  return child.signalCode ? `signal ${child.signalCode}` : `exit ${child.exitCode ?? "unknown"}`;
+}
+
+async function canConnect(port: number): Promise<boolean> {
+  return await new Promise((resolve) => {
+    const socket = createConnection({ host: "127.0.0.1", port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => resolve(false));
+    socket.setTimeout(250, () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+
+export const testing = {
+  appendBoundedOutput,
+  stopHostServerChild,
+};