harness-mix 0.1.0

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

@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  CdpClient,
+  getCdpBrowserVersion,
+  listCdpTargets,
+  type CdpFetch,
+  type CdpSocketFactory,
+} from "../src/index.js";
+
+interface SocketEvent {
+  data?: unknown;
+}
+
+type SocketListener = (event: SocketEvent) => void;
+
+class FakeSocket {
+  readonly requests: Array<{ id: number; method: string; sessionId?: string }> = [];
+  readonly #listeners = new Map<string, Set<SocketListener>>();
+
+  constructor() {
+    queueMicrotask(() => this.#emit("open", {}));
+  }
+
+  addEventListener(type: string, listener: SocketListener): void {
+    const listeners = this.#listeners.get(type) ?? new Set();
+    listeners.add(listener);
+    this.#listeners.set(type, listeners);
+  }
+
+  removeEventListener(type: string, listener: SocketListener): void {
+    this.#listeners.get(type)?.delete(listener);
+  }
+
+  send(data: string): void {
+    const request = JSON.parse(data) as { id: number; method: string; sessionId?: string };
+    this.requests.push(request);
+    const result =
+      request.method === "Runtime.evaluate"
+        ? { result: { type: "number", value: 42 } }
+        : { accepted: true };
+    queueMicrotask(() => {
+      if (request.method === "Target.setDiscoverTargets") {
+        this.#emit("message", {
+          data: JSON.stringify({
+            method: "Target.targetCreated",
+            params: { targetInfo: { targetId: "page-2" } },
+          }),
+        });
+      }
+      this.#emit("message", {
+        data: JSON.stringify({ id: request.id, result }),
+      });
+    });
+  }
+
+  close(): void {
+    this.#emit("close", {});
+  }
+
+  #emit(type: string, event: SocketEvent): void {
+    for (const listener of this.#listeners.get(type) ?? []) listener(event);
+  }
+}
+
+describe("CDP client", () => {
+  it("validates and returns loopback page targets", async () => {
+    const fetchImpl: CdpFetch = async (url) => ({
+      ok: true,
+      status: 200,
+      async json() {
+        expect(url).toBe("http://127.0.0.1:9222/json/list");
+        return [
+          {
+            id: "page-1",
+            type: "page",
+            title: "Codex",
+            url: "app://-/index.html",
+            webSocketDebuggerUrl: "ws://127.0.0.1:9222/devtools/page/page-1",
+          },
+        ];
+      },
+    });
+
+    await expect(listCdpTargets("http://127.0.0.1:9222", fetchImpl)).resolves.toEqual([
+      {
+        id: "page-1",
+        type: "page",
+        title: "Codex",
+        url: "app://-/index.html",
+        webSocketDebuggerUrl: "ws://127.0.0.1:9222/devtools/page/page-1",
+      },
+    ]);
+  });
+
+  it("validates browser-level discovery metadata", async () => {
+    const fetchImpl: CdpFetch = async (url) => ({
+      ok: true,
+      status: 200,
+      async json() {
+        expect(url).toBe("http://127.0.0.1:9222/json/version");
+        return {
+          Browser: "Chrome/150",
+          "Protocol-Version": "1.3",
+          webSocketDebuggerUrl: "ws://127.0.0.1:9222/devtools/browser/browser-1",
+        };
+      },
+    });
+
+    await expect(getCdpBrowserVersion("http://127.0.0.1:9222", fetchImpl)).resolves.toEqual({
+      browser: "Chrome/150",
+      protocolVersion: "1.3",
+      webSocketDebuggerUrl: "ws://127.0.0.1:9222/devtools/browser/browser-1",
+    });
+  });
+
+  it("rejects non-loopback discovery and target endpoints", async () => {
+    await expect(listCdpTargets("http://example.com:9222")).rejects.toThrow("loopback");
+    const fetchImpl: CdpFetch = async () => ({
+      ok: true,
+      status: 200,
+      async json() {
+        return [
+          {
+            id: "page-1",
+            type: "page",
+            title: "Codex",
+            url: "app://-/index.html",
+            webSocketDebuggerUrl: "ws://example.com/devtools/page/page-1",
+          },
+        ];
+      },
+    });
+    await expect(listCdpTargets("http://127.0.0.1:9222", fetchImpl)).rejects.toThrow("loopback");
+  });
+
+  it("correlates commands and unwraps Runtime.evaluate values", async () => {
+    const socket = new FakeSocket();
+    const socketFactory: CdpSocketFactory = () => socket;
+    const client = await CdpClient.connect("ws://127.0.0.1:9222/devtools/page/page-1", {
+      socketFactory,
+    });
+
+    await expect(client.command("Runtime.enable")).resolves.toEqual({ accepted: true });
+    await expect(client.evaluate<number>("6 * 7")).resolves.toBe(42);
+
+    const events: unknown[] = [];
+    client.on("Target.targetCreated", (params) => events.push(params));
+    await client.command("Target.setDiscoverTargets", { discover: true });
+    expect(events).toEqual([{ targetInfo: { targetId: "page-2" } }]);
+    await expect(client.sessionCommand("session-1", "Runtime.evaluate")).resolves.toEqual({
+      result: { type: "number", value: 42 },
+    });
+    expect(socket.requests.at(-1)?.sessionId).toBe("session-1");
+    client.close();
+  });
+});

package/src/native-ui/desktop-control/test/contract-audit.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+
+import { validateRendererContractAuditInspection } from "../src/index.js";
+
+const validInspection = {
+  schemaVersion: 1,
+  composer: {
+    composerCount: 1,
+    visibleComposerCount: 1,
+    activeComposerCount: 1,
+    modelCandidateCount: 1,
+    verifiedModelCandidateCount: 1,
+    permissionCandidateCount: 0,
+    verifiedPermissionCandidateCount: 0,
+    contextUsageCandidateCount: 0,
+    verifiedContextUsageCandidateCount: 0,
+    sendButtonCount: 1,
+    trailingActionOwnerCount: 1,
+  },
+  model: { draftCount: 1, conversationCount: 0, missingCount: 0, ambiguousCount: 0 },
+  settings: { headerCount: 1, visibleHeaderCount: 1, insertionPointCount: 1 },
+  sidebar: { rowCount: 0, titleOwnerCount: 0, resolvedThreadCount: 0, ambiguousThreadCount: 0 },
+  transcript: {
+    turnCount: 4,
+    itemNodeCount: 5,
+    identifiedItemCount: 11,
+    textBodyCount: 2,
+    textBodyOwnerCount: 2,
+  },
+  fork: { annotatedResponseCount: 0, candidateButtonCount: 0, verifiedButtonCount: 0 },
+  production: {
+    bindingPresent: false,
+    adapterState: "absent",
+    adapterReason: "absent",
+    titlePolicyState: "absent",
+    draftPrewarmPolicyState: "absent",
+  },
+};
+
+describe("Desktop contract audit inspection", () => {
+  it("accepts the bounded Renderer schema", () => {
+    expect(validateRendererContractAuditInspection(validInspection)).toEqual(validInspection);
+  });
+
+  it("rejects unknown fields and private values", () => {
+    expect(() =>
+      validateRendererContractAuditInspection({ ...validInspection, prompt: "private" }),
+    ).toThrow("unknown or missing fields");
+    expect(() =>
+      validateRendererContractAuditInspection({
+        ...validInspection,
+        production: { ...validInspection.production, source: "function source" },
+      }),
+    ).toThrow("unknown or missing fields");
+  });
+});

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

@@ -0,0 +1,98 @@
+import { createConnection, createServer } from "node:net";
+
+import { describe, expect, it, vi } from "vitest";
+
+import { startControllerAttachmentServer } from "../src/controller-attachment-server.js";
+
+const nonce = "0123456789abcdef0123456789abcdef";
+
+async function availablePort(): Promise<number> {
+  const server = createServer();
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  if (address === null || typeof address === "string") throw new Error("TCP address unavailable");
+  await new Promise<void>((resolve, reject) =>
+    server.close((error) => (error ? reject(error) : resolve())),
+  );
+  return address.port;
+}
+
+function request(port: number, line: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection({ host: "127.0.0.1", port });
+    let response = "";
+    socket.setEncoding("utf8");
+    socket.once("error", reject);
+    socket.on("data", (chunk: string) => {
+      response += chunk;
+    });
+    socket.once("end", () => resolve(response));
+    socket.once("connect", () => socket.write(line));
+  });
+}
+
+describe("Controller attachment server", () => {
+  it("accepts only the exact nonce and invokes the attachment callback", async () => {
+    const port = await availablePort();
+    const attach = vi.fn(async () => {});
+    const server = await startControllerAttachmentServer({
+      port,
+      nonce,
+      attach,
+    });
+    try {
+      await expect(request(port, `ATTACH ${nonce}\n`)).resolves.toBe("ready\n");
+      await expect(request(port, `ATTACH ${"0".repeat(32)}\n`)).resolves.toBe("rejected\n");
+      expect(attach).toHaveBeenCalledOnce();
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("rejects the retired compatibility update command", async () => {
+    const port = await availablePort();
+    const server = await startControllerAttachmentServer({
+      port,
+      nonce,
+      attach: async () => {},
+    });
+    try {
+      await expect(request(port, `COMPATIBILITY_UPDATE ${nonce}\n`)).resolves.toBe("rejected\n");
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("reports callback failure without exposing its error", async () => {
+    const port = await availablePort();
+    const server = await startControllerAttachmentServer({
+      port,
+      nonce,
+      attach: async () => {
+        throw new Error("private detail");
+      },
+    });
+    try {
+      await expect(request(port, `ATTACH ${nonce}\n`)).resolves.toBe("failed\n");
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("rejects the retired Desktop quit command", async () => {
+    const port = await availablePort();
+    const server = await startControllerAttachmentServer({
+      port,
+      nonce,
+      attach: async () => {},
+    });
+    try {
+      await expect(request(port, `SHUTDOWN ${nonce}\n`)).resolves.toBe("rejected\n");
+    } finally {
+      await server.close();
+    }
+  });
+});

package/src/native-ui/desktop-control/test/index.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { packageMetadata } from "../src/index.js";
+
+describe("desktop-control package", () => {
+  it("builds without implementing Desktop integration", () => {
+    expect(packageMetadata).toEqual({
+      name: "@codexhost/desktop-control",
+      contractVersion: 1,
+    });
+  });
+});

package/src/native-ui/desktop-control/test/main-process-title-policy.test.ts

@@ -0,0 +1,166 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  installMainProcessTitlePolicy,
+  markRendererTitlePolicyReady,
+  readMainProcessTitlePolicyCounters,
+} from "../src/main-process-title-policy.js";
+
+function commandSequence(responses: unknown[]) {
+  return {
+    command: vi.fn(async (...arguments_: [string, Record<string, unknown>?]) => {
+      void arguments_;
+      const response = responses.shift();
+      if (response === undefined) throw new Error("Unexpected CDP command");
+      return response;
+    }),
+  };
+}
+
+describe("main-process title policy", () => {
+  it("installs through the connect-app-host listener closure", async () => {
+    const inspector = commandSequence([
+      { result: { objectId: "listener" } },
+      {
+        result: [],
+        internalProperties: [{ name: "[[Scopes]]", value: { objectId: "scopes" } }],
+      },
+      { result: [{ name: "0", value: { objectId: "local-scope" } }] },
+      { result: [{ name: "f", value: { objectId: "get-context" } }] },
+      { result: { objectId: "install-promise" } },
+      {
+        result: {
+          value: {
+            state: "ready",
+            reason: "ready",
+            requiresRendererReload: true,
+          },
+        },
+      },
+    ]);
+
+    await expect(installMainProcessTitlePolicy(inspector, 17)).resolves.toEqual({
+      state: "ready",
+      reason: "ready",
+      requiresRendererReload: true,
+    });
+    expect(inspector.command.mock.calls.map(([method]) => method)).toEqual([
+      "Runtime.evaluate",
+      "Runtime.getProperties",
+      "Runtime.getProperties",
+      "Runtime.getProperties",
+      "Runtime.callFunctionOn",
+      "Runtime.awaitPromise",
+    ]);
+    expect(inspector.command.mock.calls.at(-2)?.[1]).toMatchObject({
+      objectId: "get-context",
+      arguments: [{ value: 17 }],
+    });
+    const functionDeclaration = inspector.command.mock.calls.at(-2)?.[1]?.functionDeclaration;
+    expect(functionDeclaration).toContain("webContents.fromId(rendererWebContentsId)");
+    expect(functionDeclaration).toContain("ownService(sampleService, selected)");
+    expect(functionDeclaration).not.toContain("querySelectorAll('*').length");
+    expect(functionDeclaration).not.toContain("constructor?.name");
+    expect(inspector.command.mock.calls.at(-1)?.[1]).toEqual({
+      promiseObjectId: "install-promise",
+      returnByValue: true,
+    });
+  });
+
+  it("fails closed when the required title service structure is unsupported", async () => {
+    const inspector = commandSequence([
+      { result: { objectId: "listener" } },
+      {
+        result: [],
+        internalProperties: [{ name: "[[Scopes]]", value: { objectId: "scopes" } }],
+      },
+      { result: [{ name: "0", value: { objectId: "local-scope" } }] },
+      { result: [{ name: "f", value: { objectId: "get-context" } }] },
+      { result: { objectId: "install-promise" } },
+      {
+        exceptionDetails: {
+          exception: { description: "ThreadMetadataGenerationService signature mismatch" },
+        },
+      },
+    ]);
+
+    await expect(installMainProcessTitlePolicy(inspector, 17)).rejects.toThrow(
+      "ThreadMetadataGenerationService signature mismatch",
+    );
+  });
+
+  it("fails closed when the listener scope is unavailable", async () => {
+    const inspector = commandSequence([
+      { result: { objectId: "listener" } },
+      { result: [], internalProperties: [] },
+    ]);
+
+    await expect(installMainProcessTitlePolicy(inspector, 17)).rejects.toThrow(
+      "connect-app-host listener scopes is unavailable",
+    );
+  });
+
+  it("marks only the selected owned Renderer as ready", async () => {
+    const evaluate = vi.fn(async (expression: string) => {
+      void expression;
+      return {
+        state: "ready",
+        reason: "owned-metadata-service",
+      };
+    });
+    const inspector = {
+      async evaluate<T>(expression: string): Promise<T> {
+        return (await evaluate(expression)) as T;
+      },
+    };
+
+    await expect(markRendererTitlePolicyReady(inspector, 17)).resolves.toEqual({
+      state: "ready",
+      reason: "owned-metadata-service",
+    });
+    expect(evaluate).toHaveBeenCalledWith(expect.stringContaining("webContents.fromId(17)"));
+    expect(evaluate).not.toHaveBeenCalledWith(expect.stringContaining("querySelectorAll"));
+  });
+
+  it("rejects invalid Renderer identities before inspection", async () => {
+    const inspector = commandSequence([]);
+    const evaluate = vi.fn(async (expression: string) => {
+      void expression;
+      return null;
+    });
+    const readinessInspector = {
+      async evaluate<T>(expression: string): Promise<T> {
+        return (await evaluate(expression)) as T;
+      },
+    };
+    await expect(installMainProcessTitlePolicy(inspector, 0)).rejects.toThrow("positive integer");
+    await expect(markRendererTitlePolicyReady(readinessInspector, -1)).rejects.toThrow(
+      "positive integer",
+    );
+    expect(inspector.command).not.toHaveBeenCalled();
+    expect(evaluate).not.toHaveBeenCalled();
+  });
+
+  it("reads only sanitized policy counters", async () => {
+    const evaluate = vi.fn();
+    const inspector = {
+      async evaluate<T>(expression: string): Promise<T> {
+        evaluate(expression);
+        return {
+          codexTitleCalls: 2,
+          piTitleSkips: 3,
+          externalTitleSkips: 4,
+          ambiguousTitleSkips: 1,
+        } as T;
+      },
+    };
+
+    await expect(readMainProcessTitlePolicyCounters(inspector)).resolves.toEqual({
+      codexTitleCalls: 2,
+      piTitleSkips: 3,
+      externalTitleSkips: 4,
+      ambiguousTitleSkips: 1,
+    });
+    expect(evaluate).toHaveBeenCalledOnce();
+  });
+});