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

test/scripts/bench-gateway-child-test-support.ts

@@ -0,0 +1,351 @@
+// Gateway benchmark child test support simulates child process behavior for script tests.
+import type { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { expect, it, vi } from "vitest";
+import { resolveWindowsTaskkillPath } from "../../scripts/lib/windows-taskkill.mjs";
+
+function expectedTaskkillPath(): string {
+  return resolveWindowsTaskkillPath();
+}
+
+type StopChildResult = {
+  exitedBeforeTeardown: boolean;
+  exitCode: number | null;
+  signal: string | null;
+};
+
+type StopChild<TChild> = (
+  child: TChild,
+  options?: {
+    killGraceMs?: number;
+    platform?: NodeJS.Platform;
+    runTaskkill?: typeof spawnSync;
+    teardownGraceMs?: number;
+  },
+) => Promise<StopChildResult>;
+
+export function registerStopChildBehaviorTests<TChild>(params: {
+  stopChild: StopChild<TChild>;
+  queuedExitCode: number;
+}) {
+  it("classifies queued child exits before sending teardown signals", async () => {
+    const child = new EventEmitter() as EventEmitter & {
+      exitCode: number | null;
+      kill: ReturnType<typeof vi.fn>;
+      signalCode: NodeJS.Signals | null;
+    };
+    child.exitCode = null;
+    child.signalCode = null;
+    child.kill = vi.fn(() => true);
+
+    const stopped = params.stopChild(child as unknown as TChild);
+    queueMicrotask(() => {
+      child.exitCode = params.queuedExitCode;
+      child.emit("exit", params.queuedExitCode, null);
+    });
+
+    await expect(stopped).resolves.toEqual({
+      exitedBeforeTeardown: true,
+      exitCode: params.queuedExitCode,
+      signal: null,
+    });
+    expect(child.kill).not.toHaveBeenCalled();
+  });
+
+  it("classifies failed teardown signaling as a pre-teardown child exit", async () => {
+    const child = new EventEmitter() as EventEmitter & {
+      exitCode: number | null;
+      kill: ReturnType<typeof vi.fn>;
+      signalCode: NodeJS.Signals | null;
+    };
+    child.exitCode = null;
+    child.signalCode = null;
+    child.kill = vi.fn(() => {
+      setImmediate(() => {
+        child.exitCode = 8;
+        child.emit("exit", 8, null);
+      });
+      return false;
+    });
+
+    await expect(params.stopChild(child as unknown as TChild)).resolves.toEqual({
+      exitedBeforeTeardown: true,
+      exitCode: 8,
+      signal: null,
+    });
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+  });
+
+  it("bounds teardown when the child ignores termination signals", async () => {
+    const child = new EventEmitter() as EventEmitter & {
+      exitCode: number | null;
+      kill: ReturnType<typeof vi.fn>;
+      signalCode: NodeJS.Signals | null;
+      stderr: { destroy: ReturnType<typeof vi.fn> };
+      stdin: { destroy: ReturnType<typeof vi.fn> };
+      stdout: { destroy: ReturnType<typeof vi.fn> };
+      unref: ReturnType<typeof vi.fn>;
+    };
+    child.exitCode = null;
+    child.signalCode = null;
+    child.kill = vi.fn(() => true);
+    child.stderr = { destroy: vi.fn() };
+    child.stdin = { destroy: vi.fn() };
+    child.stdout = { destroy: vi.fn() };
+    child.unref = vi.fn();
+
+    await expect(
+      params.stopChild(child as unknown as TChild, {
+        killGraceMs: 1,
+        teardownGraceMs: 1,
+      }),
+    ).resolves.toEqual({
+      exitedBeforeTeardown: false,
+      exitCode: null,
+      signal: "SIGKILL",
+    });
+    expect(child.kill).toHaveBeenNthCalledWith(1, "SIGTERM");
+    expect(child.kill).toHaveBeenNthCalledWith(2, "SIGKILL");
+    expect(child.stdin.destroy).toHaveBeenCalledOnce();
+    expect(child.stdout.destroy).toHaveBeenCalledOnce();
+    expect(child.stderr.destroy).toHaveBeenCalledOnce();
+    expect(child.unref).toHaveBeenCalledOnce();
+  });
+
+  it("signals Windows child process trees with taskkill", async () => {
+    const child = new EventEmitter() as EventEmitter & {
+      exitCode: number | null;
+      kill: ReturnType<typeof vi.fn>;
+      pid: number;
+      signalCode: NodeJS.Signals | null;
+      stderr: { destroy: ReturnType<typeof vi.fn> };
+      stdin: { destroy: ReturnType<typeof vi.fn> };
+      stdout: { destroy: ReturnType<typeof vi.fn> };
+      unref: ReturnType<typeof vi.fn>;
+    };
+    child.exitCode = null;
+    child.kill = vi.fn(() => true);
+    child.pid = 4450;
+    child.signalCode = null;
+    child.stderr = { destroy: vi.fn() };
+    child.stdin = { destroy: vi.fn() };
+    child.stdout = { destroy: vi.fn() };
+    child.unref = vi.fn();
+    const runTaskkill = vi.fn(() => ({ error: undefined, status: 0 }));
+
+    await expect(
+      params.stopChild(child as unknown as TChild, {
+        killGraceMs: 1,
+        platform: "win32",
+        runTaskkill,
+        teardownGraceMs: 1,
+      }),
+    ).resolves.toEqual({
+      exitedBeforeTeardown: false,
+      exitCode: null,
+      signal: "SIGKILL",
+    });
+    expect(runTaskkill).toHaveBeenNthCalledWith(1, expectedTaskkillPath(), ["/PID", "4450", "/T"], {
+      stdio: "ignore",
+    });
+    expect(runTaskkill).toHaveBeenNthCalledWith(
+      2,
+      expectedTaskkillPath(),
+      ["/PID", "4450", "/T", "/F"],
+      {
+        stdio: "ignore",
+      },
+    );
+    expect(child.kill).not.toHaveBeenCalled();
+    expect(child.stdin.destroy).toHaveBeenCalledOnce();
+    expect(child.stdout.destroy).toHaveBeenCalledOnce();
+    expect(child.stderr.destroy).toHaveBeenCalledOnce();
+    expect(child.unref).toHaveBeenCalledOnce();
+  });
+
+  it("force-kills Windows child process trees when graceful taskkill fails", async () => {
+    const child = new EventEmitter() as EventEmitter & {
+      exitCode: number | null;
+      kill: ReturnType<typeof vi.fn>;
+      pid: number;
+      signalCode: NodeJS.Signals | null;
+      stderr: { destroy: ReturnType<typeof vi.fn> };
+      stdin: { destroy: ReturnType<typeof vi.fn> };
+      stdout: { destroy: ReturnType<typeof vi.fn> };
+      unref: ReturnType<typeof vi.fn>;
+    };
+    child.exitCode = null;
+    child.kill = vi.fn(() => true);
+    child.pid = 4450;
+    child.signalCode = null;
+    child.stderr = { destroy: vi.fn() };
+    child.stdin = { destroy: vi.fn() };
+    child.stdout = { destroy: vi.fn() };
+    child.unref = vi.fn();
+    const runTaskkill = vi
+      .fn()
+      .mockReturnValueOnce({ error: undefined, status: 1 })
+      .mockReturnValueOnce({ error: undefined, status: 0 })
+      .mockReturnValueOnce({ error: undefined, status: 0 });
+
+    await expect(
+      params.stopChild(child as unknown as TChild, {
+        killGraceMs: 1,
+        platform: "win32",
+        runTaskkill,
+        teardownGraceMs: 1,
+      }),
+    ).resolves.toEqual({
+      exitedBeforeTeardown: false,
+      exitCode: null,
+      signal: "SIGKILL",
+    });
+    expect(runTaskkill).toHaveBeenNthCalledWith(1, expectedTaskkillPath(), ["/PID", "4450", "/T"], {
+      stdio: "ignore",
+    });
+    expect(runTaskkill).toHaveBeenNthCalledWith(
+      2,
+      expectedTaskkillPath(),
+      ["/PID", "4450", "/T", "/F"],
+      {
+        stdio: "ignore",
+      },
+    );
+    expect(runTaskkill).toHaveBeenNthCalledWith(
+      3,
+      expectedTaskkillPath(),
+      ["/PID", "4450", "/T", "/F"],
+      {
+        stdio: "ignore",
+      },
+    );
+    expect(child.kill).not.toHaveBeenCalled();
+  });
+
+  it.skipIf(process.platform === "win32")(
+    "preserves pre-teardown wrapper exits while cleaning the process group",
+    async () => {
+      const child = new EventEmitter() as EventEmitter & {
+        exitCode: number | null;
+        kill: ReturnType<typeof vi.fn>;
+        pid: number;
+        signalCode: NodeJS.Signals | null;
+        stderr: { destroy: ReturnType<typeof vi.fn> };
+        stdin: { destroy: ReturnType<typeof vi.fn> };
+        stdout: { destroy: ReturnType<typeof vi.fn> };
+        unref: ReturnType<typeof vi.fn>;
+      };
+      child.exitCode = null;
+      child.kill = vi.fn(() => true);
+      child.pid = 4444;
+      child.signalCode = null;
+      child.stderr = { destroy: vi.fn() };
+      child.stdin = { destroy: vi.fn() };
+      child.stdout = { destroy: vi.fn() };
+      child.unref = vi.fn();
+
+      let processGroupAlive = true;
+      const processKill = vi.spyOn(process, "kill").mockImplementation((pid, signal) => {
+        expect(pid).toBe(-child.pid);
+        if (signal === "SIGKILL") {
+          processGroupAlive = false;
+          return true;
+        }
+        if (signal === 0 && !processGroupAlive) {
+          throw Object.assign(new Error("gone"), { code: "ESRCH" });
+        }
+        return true;
+      });
+      try {
+        const stopped = params.stopChild(child as unknown as TChild, {
+          killGraceMs: 50,
+          teardownGraceMs: 1,
+        });
+        queueMicrotask(() => {
+          child.exitCode = 0;
+          child.emit("exit", 0, null);
+        });
+        await expect(stopped).resolves.toEqual({
+          exitedBeforeTeardown: true,
+          exitCode: 0,
+          signal: null,
+        });
+        expect(processKill).toHaveBeenCalledWith(-child.pid, "SIGTERM");
+        expect(processKill).toHaveBeenCalledWith(-child.pid, "SIGKILL");
+        expect(child.kill).not.toHaveBeenCalled();
+        expect(child.stdin.destroy).not.toHaveBeenCalled();
+        expect(child.stdout.destroy).not.toHaveBeenCalled();
+        expect(child.stderr.destroy).not.toHaveBeenCalled();
+        expect(child.unref).not.toHaveBeenCalled();
+      } finally {
+        processKill.mockRestore();
+      }
+    },
+  );
+
+  it.skipIf(process.platform === "win32")(
+    "waits for the process group after a teardown-triggered wrapper exit",
+    async () => {
+      const child = new EventEmitter() as EventEmitter & {
+        exitCode: number | null;
+        kill: ReturnType<typeof vi.fn>;
+        pid: number;
+        signalCode: NodeJS.Signals | null;
+        stderr: { destroy: ReturnType<typeof vi.fn> };
+        stdin: { destroy: ReturnType<typeof vi.fn> };
+        stdout: { destroy: ReturnType<typeof vi.fn> };
+        unref: ReturnType<typeof vi.fn>;
+      };
+      child.exitCode = null;
+      child.kill = vi.fn(() => true);
+      child.pid = 4445;
+      child.signalCode = null;
+      child.stderr = { destroy: vi.fn() };
+      child.stdin = { destroy: vi.fn() };
+      child.stdout = { destroy: vi.fn() };
+      child.unref = vi.fn();
+
+      let emittedExit = false;
+      let processGroupAlive = true;
+      const processKill = vi.spyOn(process, "kill").mockImplementation((pid, signal) => {
+        expect(pid).toBe(-child.pid);
+        if (signal === "SIGTERM" && !emittedExit) {
+          emittedExit = true;
+          queueMicrotask(() => {
+            child.exitCode = 0;
+            child.emit("exit", 0, null);
+          });
+        }
+        if (signal === "SIGKILL") {
+          processGroupAlive = false;
+          return true;
+        }
+        if (signal === 0 && !processGroupAlive) {
+          throw Object.assign(new Error("gone"), { code: "ESRCH" });
+        }
+        return true;
+      });
+      try {
+        await expect(
+          params.stopChild(child as unknown as TChild, {
+            killGraceMs: 50,
+            teardownGraceMs: 1,
+          }),
+        ).resolves.toEqual({
+          exitedBeforeTeardown: false,
+          exitCode: 0,
+          signal: null,
+        });
+        expect(processKill).toHaveBeenCalledWith(-child.pid, "SIGTERM");
+        expect(processKill).toHaveBeenCalledWith(-child.pid, "SIGKILL");
+        expect(child.kill).not.toHaveBeenCalled();
+        expect(child.stdin.destroy).not.toHaveBeenCalled();
+        expect(child.stdout.destroy).not.toHaveBeenCalled();
+        expect(child.stderr.destroy).not.toHaveBeenCalled();
+        expect(child.unref).not.toHaveBeenCalled();
+      } finally {
+        processKill.mockRestore();
+      }
+    },
+  );
+}