harness-mix 0.1.0

package/src/native-ui/desktop-control/test/production-controller.test.ts

@@ -0,0 +1,389 @@
+import path from "node:path";
+
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  parseDesktopControllerArguments,
+  runDesktopController,
+  serializeDesktopControllerReadiness,
+  type DesktopControllerDependencies,
+} from "../src/production-controller.js";
+import type { RendererCdpControlSession } from "../src/renderer-cdp-control-session.js";
+
+const attachmentNonce = "0123456789abcdef0123456789abcdef";
+
+function controllerOptions() {
+  return {
+    rendererCdpEndpoint: "http://127.0.0.1:43123",
+    rendererPath: "/renderer.js",
+    defaultAgent: "pi" as const,
+    attachmentPort: 43124,
+    attachmentNonce,
+  };
+}
+
+function attachmentServer() {
+  return { close: vi.fn(async () => {}) };
+}
+
+function controllerSnapshot(): RendererCdpControlSession["snapshot"] {
+  return {} as RendererCdpControlSession["snapshot"];
+}
+
+describe("production Desktop Controller", () => {
+  it("accepts only a loopback Renderer CDP endpoint, absolute Renderer path, and strict attachment fields", () => {
+    const rendererPath = path.resolve("fixtures/renderer-extension.js");
+    expect(
+      parseDesktopControllerArguments([
+        "--renderer-cdp-endpoint",
+        "http://127.0.0.1:43123",
+        "--renderer",
+        rendererPath,
+        "--default-agent",
+        "pi",
+        "--attachment-port",
+        "43124",
+        "--attachment-nonce",
+        attachmentNonce,
+      ]),
+    ).toEqual({
+      rendererCdpEndpoint: "http://127.0.0.1:43123",
+      rendererPath,
+      defaultAgent: "pi",
+      attachmentPort: 43124,
+      attachmentNonce,
+    });
+    expect(() =>
+      parseDesktopControllerArguments([
+        "--renderer-cdp-endpoint",
+        "http://example.com:43123",
+        "--renderer",
+        "/renderer.js",
+      ]),
+    ).toThrow("loopback HTTP origin");
+    expect(() =>
+      parseDesktopControllerArguments([
+        "--renderer-cdp-endpoint",
+        "http://127.0.0.1:43123",
+        "--renderer",
+        "renderer.js",
+      ]),
+    ).toThrow("absolute path");
+    expect(() =>
+      parseDesktopControllerArguments([
+        "--renderer-cdp-endpoint",
+        "http://127.0.0.1:43123",
+        "--renderer",
+        rendererPath,
+        "--default-agent",
+        "pi",
+        "--attachment-port",
+        "43124",
+        "--attachment-nonce",
+        "bad",
+      ]),
+    ).toThrow("32 lowercase hexadecimal");
+  });
+
+  it("serializes only strict and bounded readiness results", () => {
+    expect(
+      serializeDesktopControllerReadiness({
+        schemaVersion: 2,
+        state: "compatible",
+        issues: [],
+      }),
+    ).toBe('{"schemaVersion":2,"state":"compatible","issues":[]}');
+    expect(() =>
+      serializeDesktopControllerReadiness({
+        schemaVersion: 2,
+        state: "incompatible",
+        issues: [],
+      } as never),
+    ).toThrow("readiness is invalid");
+  });
+
+  it("signals compatible readiness, serves attachment, and monitors recovery", async () => {
+    const abort = new AbortController();
+    const snapshot = controllerSnapshot();
+    const ensureInstalled = vi.fn(async () => {
+      abort.abort();
+      return snapshot;
+    });
+    const activateDesktop = vi.fn(async () => 1);
+    const close = vi.fn();
+    const session: RendererCdpControlSession = {
+      snapshot,
+      ensureInstalled,
+      activateDesktop,
+      executeRenderer: vi.fn(),
+      close,
+    };
+    const ready = vi.fn();
+    const install = vi.fn(async () => session);
+    const server = attachmentServer();
+    let attach: (() => Promise<void>) | undefined;
+    const startAttachmentServer = vi.fn(async (options) => {
+      attach = options.attach;
+      return server;
+    });
+    const dependencies: DesktopControllerDependencies = {
+      readRenderer: vi.fn(async () => "production renderer"),
+      install,
+      startAttachmentServer,
+      ready,
+      sleep: vi.fn(async () => {}),
+      monitorIntervalMs: 1,
+    };
+
+    await runDesktopController(controllerOptions(), abort.signal, dependencies);
+
+    expect(install).toHaveBeenCalledWith({
+      rendererCdpEndpoint: "http://127.0.0.1:43123",
+      rendererSource:
+        'globalThis.__zod_globalConfig ??= {}; globalThis.__zod_globalConfig.jitless = true;\nObject.defineProperty(window, "__codexhostProductionConfigV1", { configurable: true, value: { defaultAgent: "pi" } });\nproduction renderer',
+      enabledAgents: [
+        "codex",
+        "pi",
+        "claude-code",
+        "deepseek-harness",
+        "omp",
+        "opencode",
+        "grok",
+        "openclaw",
+        "hermes",
+        "antigravity",
+        "qoder",
+        "workbuddy",
+        "zcode",
+        "trae",
+      ],
+      timeoutMs: 90_000,
+    });
+    expect(startAttachmentServer).toHaveBeenCalledWith({
+      port: 43124,
+      nonce: attachmentNonce,
+      attach: expect.any(Function),
+    });
+    expect(ready).toHaveBeenCalledWith({
+      schemaVersion: 2,
+      state: "compatible",
+      issues: [],
+    });
+    expect(ensureInstalled).toHaveBeenCalledOnce();
+    expect(server.close).toHaveBeenCalledOnce();
+    expect(close).toHaveBeenCalledOnce();
+    expect(attach).toEqual(expect.any(Function));
+  });
+
+  it("retries a transient Renderer evaluation failure during cold startup", async () => {
+    const abort = new AbortController();
+    abort.abort();
+    const close = vi.fn();
+    const session: RendererCdpControlSession = {
+      snapshot: controllerSnapshot(),
+      ensureInstalled: vi.fn(),
+      activateDesktop: vi.fn(async () => 1),
+
+      executeRenderer: vi.fn(),
+      close,
+    };
+    const install = vi
+      .fn<DesktopControllerDependencies["install"]>()
+      .mockRejectedValueOnce(
+        new Error("Renderer installation failed", {
+          cause: new Error("Execution context was destroyed during Renderer reload"),
+        }),
+      )
+      .mockRejectedValueOnce(new Error("Promise was collected"))
+      .mockResolvedValueOnce(session);
+    const ready = vi.fn();
+    const sleep = vi.fn(async () => {});
+
+    await runDesktopController(controllerOptions(), abort.signal, {
+      readRenderer: vi.fn(async () => "production renderer"),
+      install,
+      startAttachmentServer: vi.fn(async () => attachmentServer()),
+      ready,
+      sleep,
+      monitorIntervalMs: 1,
+    });
+
+    expect(install).toHaveBeenCalledTimes(3);
+    expect(sleep).toHaveBeenCalledTimes(2);
+    expect(sleep).toHaveBeenCalledWith(250);
+    expect(ready).toHaveBeenCalledWith({ schemaVersion: 2, state: "compatible", issues: [] });
+    expect(close).toHaveBeenCalledOnce();
+  });
+
+  it("recovers an unclassified inspection failure after managed readiness", async () => {
+    const abort = new AbortController();
+    const close = vi.fn();
+    const session: RendererCdpControlSession = {
+      snapshot: controllerSnapshot(),
+      ensureInstalled: vi.fn(),
+      activateDesktop: vi.fn(async () => 1),
+
+      executeRenderer: vi.fn(),
+      close,
+    };
+    const install = vi
+      .fn<DesktopControllerDependencies["install"]>()
+      .mockRejectedValueOnce(new Error("Inspector target is not ready"))
+      .mockResolvedValueOnce(session);
+    const ready = vi.fn();
+    let currentTime = 0;
+    const sleep = vi.fn(async (milliseconds: number) => {
+      if (milliseconds === 1) currentTime += 30_000;
+      if (install.mock.calls.length >= 2) abort.abort();
+    });
+
+    await runDesktopController(controllerOptions(), abort.signal, {
+      readRenderer: vi.fn(async () => "production renderer"),
+      install,
+      startAttachmentServer: vi.fn(async () => attachmentServer()),
+      ready,
+      sleep,
+      now: () => currentTime,
+      monitorIntervalMs: 1,
+    });
+
+    expect(install).toHaveBeenCalledTimes(2);
+    expect(sleep).toHaveBeenCalledWith(1);
+    expect(ready).toHaveBeenCalledWith({ schemaVersion: 2, state: "compatible", issues: [] });
+    expect(close).toHaveBeenCalledOnce();
+  });
+
+  it("suppresses a structural installation failure and starts attachment", async () => {
+    const abort = new AbortController();
+    abort.abort();
+    const ready = vi.fn();
+    const startAttachmentServer = vi.fn(async () => attachmentServer());
+    const install = vi.fn(async () => {
+      throw new Error("Production Renderer Adapter is unsupported: signature-mismatch");
+    });
+
+    await runDesktopController(controllerOptions(), abort.signal, {
+      readRenderer: vi.fn(async () => "production renderer"),
+      install,
+      startAttachmentServer,
+      ready,
+      sleep: vi.fn(async () => {}),
+      monitorIntervalMs: 1,
+    });
+
+    expect(install).toHaveBeenCalledOnce();
+    expect(ready).toHaveBeenCalledWith({ schemaVersion: 2, state: "compatible", issues: [] });
+    expect(JSON.stringify(ready.mock.calls)).not.toContain("signature-mismatch");
+    expect(startAttachmentServer).toHaveBeenCalledOnce();
+  });
+
+  it("suppresses an unclassified inspection failure without leaking its error", async () => {
+    const abort = new AbortController();
+    abort.abort();
+    const ready = vi.fn();
+    const startAttachmentServer = vi.fn(async () => attachmentServer());
+    await runDesktopController(controllerOptions(), abort.signal, {
+      readRenderer: vi.fn(async () => {
+        throw new Error("/private/user/path and request details");
+      }),
+      install: vi.fn(),
+      startAttachmentServer,
+      ready,
+      sleep: vi.fn(async () => {}),
+      monitorIntervalMs: 1,
+    });
+
+    expect(ready).toHaveBeenCalledWith({ schemaVersion: 2, state: "compatible", issues: [] });
+    expect(JSON.stringify(ready.mock.calls)).not.toContain("private/user");
+    expect(startAttachmentServer).toHaveBeenCalledOnce();
+  });
+
+  it("installs on demand when attachment arrives during recovery", async () => {
+    const abort = new AbortController();
+    const activateDesktop = vi.fn(async () => 1);
+    const close = vi.fn();
+    const session: RendererCdpControlSession = {
+      snapshot: controllerSnapshot(),
+      ensureInstalled: vi.fn(),
+      activateDesktop,
+
+      executeRenderer: vi.fn(),
+      close,
+    };
+    const install = vi
+      .fn<DesktopControllerDependencies["install"]>()
+      .mockRejectedValueOnce(new Error("Composer is not ready"))
+      .mockResolvedValueOnce(session);
+    let attach: (() => Promise<void>) | undefined;
+    const startAttachmentServer = vi.fn(async (options) => {
+      attach = options.attach;
+      return attachmentServer();
+    });
+    const sleep = vi.fn(async () => {
+      await attach?.();
+      abort.abort();
+    });
+
+    await runDesktopController(controllerOptions(), abort.signal, {
+      readRenderer: vi.fn(async () => "production renderer"),
+      install,
+      startAttachmentServer,
+      ready: vi.fn(),
+      sleep,
+      monitorIntervalMs: 1,
+    });
+
+    expect(install).toHaveBeenCalledTimes(2);
+    expect(activateDesktop).toHaveBeenCalledOnce();
+    expect(close).toHaveBeenCalledOnce();
+  });
+
+  it("replaces a ready Session after Renderer recovery fails", async () => {
+    const abort = new AbortController();
+    const firstClose = vi.fn();
+    const secondClose = vi.fn();
+    const first: RendererCdpControlSession = {
+      snapshot: controllerSnapshot(),
+      ensureInstalled: vi.fn(async () => {
+        throw new Error("Renderer binding disappeared");
+      }),
+      activateDesktop: vi.fn(async () => 1),
+
+      executeRenderer: vi.fn(),
+      close: firstClose,
+    };
+    const second: RendererCdpControlSession = {
+      snapshot: controllerSnapshot(),
+      ensureInstalled: vi.fn(),
+      activateDesktop: vi.fn(async () => 1),
+
+      executeRenderer: vi.fn(),
+      close: secondClose,
+    };
+    const install = vi
+      .fn<DesktopControllerDependencies["install"]>()
+      .mockResolvedValueOnce(first)
+      .mockResolvedValueOnce(second);
+    let monitorCycles = 0;
+    let currentTime = 0;
+    const sleep = vi.fn(async () => {
+      monitorCycles += 1;
+      currentTime += 30_000;
+      if (monitorCycles === 3) abort.abort();
+    });
+
+    await runDesktopController(controllerOptions(), abort.signal, {
+      readRenderer: vi.fn(async () => "production renderer"),
+      install,
+      startAttachmentServer: vi.fn(async () => attachmentServer()),
+      ready: vi.fn(),
+      sleep,
+      now: () => currentTime,
+      monitorIntervalMs: 1,
+    });
+
+    expect(install).toHaveBeenCalledTimes(2);
+    expect(firstClose).toHaveBeenCalledOnce();
+    expect(secondClose).toHaveBeenCalledOnce();
+  });
+});

package/src/native-ui/desktop-control/test/renderer-cdp-control-session.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  createRendererCdpControlSession,
+  selectPrimaryRendererTarget,
+} from "../src/renderer-cdp-control-session.js";
+import type { CdpTarget } from "../src/cdp-client.js";
+
+function target(id: string, url = "app://-/index.html"): CdpTarget {
+  return {
+    id,
+    type: "page",
+    title: "Codex",
+    url,
+    webSocketDebuggerUrl: `ws://127.0.0.1:43123/devtools/page/${id}`,
+  };
+}
+
+function readyBinding() {
+  return {
+    version: 2,
+    enabledAgents: ["codex", "pi"],
+    adapter: { state: "ready", reason: "ready" },
+  };
+}
+
+function rendererClient(binding = readyBinding()) {
+  const commands: Array<{ method: string; params?: Record<string, unknown> }> = [];
+  const evaluateSpy = vi.fn(async (expression: string) => {
+    void expression;
+    return binding as unknown;
+  });
+  return {
+    commands,
+    evaluateSpy,
+    command: vi.fn(async (method: string, params?: Record<string, unknown>) => {
+      commands.push({ method, ...(params ? { params } : {}) });
+      if (method === "Runtime.evaluate") return { result: { type: "undefined" } };
+      return {};
+    }),
+    async evaluate<T>(expression: string): Promise<T> {
+      return (await evaluateSpy(expression)) as T;
+    },
+    close: vi.fn(),
+  };
+}
+
+describe("Renderer CDP Control Session", () => {
+  it("selects only the exact primary app surface and preserves an owned target", () => {
+    const first = target("page-1");
+    const owned = target("page-2");
+    expect(
+      selectPrimaryRendererTarget([
+        target("overlay", "app://-/avatar-overlay.html"),
+        { ...target("worker"), type: "worker" },
+        first,
+        target("query", "app://-/index.html?window=second"),
+        owned,
+      ]),
+    ).toBe(first);
+    expect(selectPrimaryRendererTarget([first, owned], "page-2")).toBe(owned);
+    expect(
+      selectPrimaryRendererTarget([target("overlay", "app://-/avatar-overlay.html")]),
+    ).toBeNull();
+  });
+
+  it("registers future-document injection before evaluating the current document", async () => {
+    const client = rendererClient();
+    const source = "globalThis.__codexhostInstalled = true";
+    const session = await createRendererCdpControlSession({
+      rendererCdpEndpoint: "http://127.0.0.1:43123",
+      rendererSource: source,
+      pollIntervalMs: 1,
+      timeoutMs: 100,
+      operations: {
+        listTargets: vi.fn(async () => [target("page-1")]),
+        connect: vi.fn(async () => client),
+        installDraftPrewarmPolicy: vi.fn(async () => ({
+          state: "ready" as const,
+          reason: "owned-request-bridge" as const,
+        })),
+      },
+    });
+
+    expect(client.commands).toEqual([
+      { method: "Runtime.enable" },
+      { method: "Page.enable" },
+      { method: "Page.addScriptToEvaluateOnNewDocument", params: { source } },
+      {
+        method: "Runtime.evaluate",
+        params: { expression: source, awaitPromise: true },
+      },
+    ]);
+    expect(session.snapshot.binding).toEqual(readyBinding());
+    session.close();
+  });
+
+  it("activates the owned page target", async () => {
+    const client = rendererClient();
+    const session = await createRendererCdpControlSession({
+      rendererCdpEndpoint: "http://127.0.0.1:43123",
+      rendererSource: "production renderer",
+      pollIntervalMs: 1,
+      timeoutMs: 100,
+      operations: {
+        listTargets: vi.fn(async () => [target("page-1")]),
+        connect: vi.fn(async () => client),
+        installDraftPrewarmPolicy: vi.fn(async () => ({
+          state: "ready" as const,
+          reason: "owned-request-bridge" as const,
+        })),
+      },
+    });
+
+    await expect(session.activateDesktop()).resolves.toBe(1);
+    expect(client.command).toHaveBeenLastCalledWith("Page.bringToFront");
+    session.close();
+  });
+
+  it("fails closed when the injected Adapter is unsupported", async () => {
+    const client = rendererClient({
+      version: 2,
+      enabledAgents: ["codex", "pi"],
+      adapter: { state: "unsupported", reason: "signature-mismatch" },
+    } as never);
+    await expect(
+      createRendererCdpControlSession({
+        rendererCdpEndpoint: "http://127.0.0.1:43123",
+        rendererSource: "production renderer",
+        pollIntervalMs: 1,
+        timeoutMs: 100,
+        operations: {
+          listTargets: vi.fn(async () => [target("page-1")]),
+          connect: vi.fn(async () => client),
+          installDraftPrewarmPolicy: vi.fn(async () => ({
+            state: "ready" as const,
+            reason: "owned-request-bridge" as const,
+          })),
+        },
+      }),
+    ).rejects.toThrow("Production Renderer Adapter is unsupported: signature-mismatch");
+    expect(client.close).toHaveBeenCalledOnce();
+  });
+
+  it("reconnects and installs a replacement primary target", async () => {
+    const first = rendererClient();
+    const replacement = rendererClient();
+    let inventory = [target("page-1")];
+    const connect = vi.fn().mockResolvedValueOnce(first).mockResolvedValueOnce(replacement);
+    const session = await createRendererCdpControlSession({
+      rendererCdpEndpoint: "http://127.0.0.1:43123",
+      rendererSource: "production renderer",
+      pollIntervalMs: 1,
+      timeoutMs: 100,
+      operations: {
+        listTargets: vi.fn(async () => inventory),
+        connect,
+        installDraftPrewarmPolicy: vi.fn(async () => ({
+          state: "ready" as const,
+          reason: "owned-request-bridge" as const,
+        })),
+      },
+    });
+
+    inventory = [target("page-2")];
+    await expect(session.ensureInstalled()).resolves.toMatchObject({
+      target: { id: "page-2" },
+    });
+    expect(first.close).toHaveBeenCalledOnce();
+    expect(connect).toHaveBeenCalledTimes(2);
+    await session.executeRenderer("42");
+    expect(replacement.evaluateSpy).toHaveBeenLastCalledWith("42");
+    session.close();
+    expect(replacement.close).toHaveBeenCalledOnce();
+  });
+
+  it("does not replace the installed snapshot when replacement installation fails", async () => {
+    const first = rendererClient();
+    const replacement = rendererClient();
+    let inventory = [target("page-1")];
+    let installs = 0;
+    const session = await createRendererCdpControlSession({
+      rendererCdpEndpoint: "http://127.0.0.1:43123",
+      rendererSource: "production renderer",
+      pollIntervalMs: 1,
+      timeoutMs: 100,
+      operations: {
+        listTargets: vi.fn(async () => inventory),
+        connect: vi.fn().mockResolvedValueOnce(first).mockResolvedValueOnce(replacement),
+        installDraftPrewarmPolicy: vi.fn(async () => {
+          installs += 1;
+          if (installs > 1) throw new Error("request manager unavailable");
+          return { state: "ready" as const, reason: "owned-request-bridge" as const };
+        }),
+      },
+    });
+
+    inventory = [target("page-2")];
+    await expect(session.ensureInstalled()).rejects.toThrow("request manager unavailable");
+    expect(session.snapshot.target.id).toBe("page-1");
+    expect(first.close).not.toHaveBeenCalled();
+    expect(replacement.close).toHaveBeenCalledOnce();
+    session.close();
+  });
+});