harness-mix 0.1.0

package/src/native-ui/renderer-extension/test/codex-locale-adapter.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { readCodexLocaleSettings, setCodexLocaleOverride } from "../src/codex-locale-adapter.js";
+
+interface FetchRequest {
+  type: "fetch";
+  requestId: string;
+  url: string;
+  body?: string;
+}
+
+function localeWindow(
+  responses: Readonly<Record<string, unknown>>,
+  languages: readonly string[] = ["en-US"],
+  sentRequests: FetchRequest[] = [],
+): Window {
+  const events = new EventTarget();
+  let requestOrdinal = 0;
+  const ownerWindow = {
+    addEventListener: events.addEventListener.bind(events),
+    removeEventListener: events.removeEventListener.bind(events),
+    clearTimeout: globalThis.clearTimeout,
+    setTimeout: globalThis.setTimeout,
+    crypto: {
+      randomUUID: () => `00000000-0000-4000-8000-${String(++requestOrdinal).padStart(12, "0")}`,
+    },
+    navigator: { language: languages[0] ?? "", languages },
+  } as unknown as Window & {
+    electronBridge: { sendMessageFromView(message: unknown): Promise<void> };
+  };
+  ownerWindow.electronBridge = {
+    async sendMessageFromView(message: unknown) {
+      const request = message as FetchRequest;
+      sentRequests.push(request);
+      const body = responses[request.url];
+      if (body === undefined) return;
+      queueMicrotask(() => {
+        events.dispatchEvent(
+          new MessageEvent("message", {
+            data: {
+              type: "fetch-response",
+              requestId: request.requestId,
+              responseType: "success",
+              status: 200,
+              bodyJsonString: JSON.stringify(body),
+            },
+          }),
+        );
+      });
+    },
+  };
+  return ownerWindow;
+}
+
+describe("Codex locale adapter", () => {
+  it("uses a validated explicit locale override before automatic locale inputs", async () => {
+    const result = await readCodexLocaleSettings({
+      ownerWindow: localeWindow({
+        "vscode://codex/get-setting": { value: "en-US" },
+        "vscode://codex/locale-info": { ideLocale: "zh-CN", systemLocale: "zh-CN" },
+      }),
+    });
+
+    expect(result).toEqual({
+      status: "ready",
+      mode: "explicit",
+      localeOverride: "en-US",
+      ideLocale: "zh-CN",
+      systemLocale: "zh-CN",
+      preferredLocale: "en-US",
+      source: "override",
+    });
+  });
+
+  it("uses Codex IDE locale when the setting is automatic", async () => {
+    const result = await readCodexLocaleSettings({
+      ownerWindow: localeWindow(
+        {
+          "vscode://codex/get-setting": { value: null },
+          "vscode://codex/locale-info": { ideLocale: "zh-cn", systemLocale: "en-US" },
+        },
+        ["en-US"],
+      ),
+    });
+
+    expect(result).toMatchObject({
+      status: "ready",
+      mode: "automatic",
+      localeOverride: null,
+      preferredLocale: "zh-CN",
+      source: "ide",
+    });
+  });
+
+  it("falls back without treating an unavailable setting as automatic", async () => {
+    const ownerWindow = localeWindow({}, ["zh-TW"]);
+    const result = await readCodexLocaleSettings({ ownerWindow, timeoutMs: 5 });
+
+    expect(result).toEqual({
+      status: "fallback",
+      mode: "unavailable",
+      localeOverride: undefined,
+      ideLocale: undefined,
+      systemLocale: undefined,
+      preferredLocale: "zh-TW",
+      source: "navigator",
+    });
+  });
+
+  it("writes only a bounded locale override through the fixed setting endpoint", async () => {
+    const sentRequests: FetchRequest[] = [];
+    const ownerWindow = localeWindow(
+      { "vscode://codex/set-setting": { success: true } },
+      ["en-US"],
+      sentRequests,
+    );
+
+    await setCodexLocaleOverride("zh-CN", { ownerWindow });
+    await setCodexLocaleOverride(null, { ownerWindow });
+
+    expect(sentRequests.map(({ url, body }) => ({ url, body }))).toEqual([
+      {
+        url: "vscode://codex/set-setting",
+        body: JSON.stringify({ key: "localeOverride", value: "zh-CN" }),
+      },
+      {
+        url: "vscode://codex/set-setting",
+        body: JSON.stringify({ key: "localeOverride", value: null }),
+      },
+    ]);
+    await expect(setCodexLocaleOverride("fr-FR" as "zh-CN", { ownerWindow })).rejects.toThrow(
+      "Unsupported Codex locale override",
+    );
+  });
+
+  it("aborts pending fixed requests and rejects invalid timeouts", async () => {
+    const controller = new AbortController();
+    const ownerWindow = localeWindow({});
+    const pending = readCodexLocaleSettings({
+      ownerWindow,
+      signal: controller.signal,
+      timeoutMs: 1_000,
+    });
+    controller.abort();
+
+    await expect(pending).rejects.toMatchObject({ name: "AbortError" });
+    await expect(readCodexLocaleSettings({ ownerWindow, timeoutMs: 0 })).rejects.toThrow(
+      "timeout must be positive",
+    );
+    vi.restoreAllMocks();
+  });
+});

package/src/native-ui/renderer-extension/test/contract-audit.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  inspectRendererComposerContract,
+  inspectRendererForkContract,
+  inspectRendererSettingsContract,
+  inspectRendererSidebarContract,
+} from "../src/index.js";
+
+function list<T>(values: T[]): NodeListOf<T & Node> {
+  return values as unknown as NodeListOf<T & Node>;
+}
+
+describe("Renderer contract audit inspectors", () => {
+  it("classifies a semantic Composer without reading content", () => {
+    const editor = {
+      hidden: false,
+      getAttribute: () => null,
+      getBoundingClientRect: () => ({ width: 100, height: 24 }),
+      ownerDocument: { defaultView: null },
+    } as unknown as HTMLElement;
+    const send = {
+      type: "submit",
+      parentElement: { children: [], parentElement: null },
+      hasAttribute: () => false,
+      getAttribute: () => null,
+      querySelectorAll: () => list([]),
+    } as unknown as HTMLButtonElement;
+    const composer = {
+      hidden: false,
+      getAttribute: () => null,
+      getBoundingClientRect: () => ({ width: 600, height: 120 }),
+      ownerDocument: { defaultView: null },
+      querySelectorAll: (selector: string) => {
+        if (selector.includes("textarea")) return list([editor]);
+        if (selector === "button") return list([send]);
+        return list([]);
+      },
+    } as unknown as Element;
+    const root = {
+      querySelectorAll: () => list([composer]),
+    } as unknown as ParentNode;
+
+    expect(inspectRendererComposerContract(root)).toMatchObject({
+      composerCount: 1,
+      visibleComposerCount: 1,
+      activeComposerCount: 1,
+      sendButtonCount: 1,
+    });
+  });
+
+  it("reports inactive Settings, Sidebar, and Fork surfaces with zero counts", () => {
+    const root = { querySelectorAll: () => list([]) } as unknown as Document;
+    expect(inspectRendererSettingsContract(root)).toEqual({
+      headerCount: 0,
+      visibleHeaderCount: 0,
+      insertionPointCount: 0,
+    });
+    expect(inspectRendererSidebarContract(root)).toEqual({
+      rowCount: 0,
+      titleOwnerCount: 0,
+      resolvedThreadCount: 0,
+      ambiguousThreadCount: 0,
+    });
+    expect(inspectRendererForkContract(root)).toEqual({
+      annotatedResponseCount: 0,
+      candidateButtonCount: 0,
+      verifiedButtonCount: 0,
+    });
+  });
+});

package/src/native-ui/renderer-extension/test/index.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { rendererBuildMetadata } from "../src/index.js";
+
+describe("renderer-extension package", () => {
+  it("declares a browser-only build target", () => {
+    expect(rendererBuildMetadata.target).toBe("browser");
+    expect(rendererBuildMetadata.contractVersion).toBe(1);
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-agent-icon.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+
+import { createRendererAgentIcon } from "../src/renderer-agent-icon.js";
+
+describe("Renderer Agent icons", () => {
+  it("renders OpenCode with the bundled official square mark", () => {
+    const image = {
+      src: "",
+      alt: "unset",
+      draggable: true,
+      style: {},
+    } as unknown as HTMLImageElement;
+    const ownerDocument = {
+      createElement(tagName: string) {
+        expect(tagName).toBe("img");
+        return image;
+      },
+    } as unknown as Document;
+
+    expect(createRendererAgentIcon("opencode", 16, ownerDocument)).toBe(image);
+    expect(image.src).toMatch(/opencode-agent\.png$/);
+    expect(image.alt).toBe("");
+    expect(image.draggable).toBe(false);
+    expect(image.style.width).toBe("16px");
+    expect(image.style.height).toBe("16px");
+  });
+
+  it("renders OMP with the bundled image asset", () => {
+    const image = {
+      src: "",
+      alt: "unset",
+      draggable: true,
+      style: {},
+    } as unknown as HTMLImageElement;
+    const ownerDocument = {
+      createElement(tagName: string) {
+        expect(tagName).toBe("img");
+        return image;
+      },
+    } as unknown as Document;
+
+    expect(createRendererAgentIcon("omp", 16, ownerDocument)).toBe(image);
+    expect(image.src).toMatch(/^data:image\/svg\+xml,/);
+    expect(image.alt).toBe("");
+    expect(image.draggable).toBe(false);
+    expect(image.style.width).toBe("16px");
+    expect(image.style.height).toBe("16px");
+    expect(image.style.borderRadius).toBe("22.37%");
+  });
+
+  it("renders Grok with the bundled image asset", () => {
+    const image = {
+      src: "",
+      alt: "unset",
+      draggable: true,
+      style: {},
+    } as unknown as HTMLImageElement;
+    const ownerDocument = {
+      createElement(tagName: string) {
+        expect(tagName).toBe("img");
+        return image;
+      },
+    } as unknown as Document;
+
+    expect(createRendererAgentIcon("grok", 16, ownerDocument)).toBe(image);
+    expect(image.src).toMatch(/grok-agent\.png$/);
+    expect(image.alt).toBe("");
+    expect(image.draggable).toBe(false);
+    expect(image.style.width).toBe("16px");
+    expect(image.style.height).toBe("16px");
+    expect(image.style.borderRadius).toBe("22.37%");
+  });
+
+  it.each(["antigravity", "kiro-cli"] as const)(
+    "renders %s with the bundled SVG asset",
+    (agent) => {
+      const image = {
+        src: "",
+        alt: "unset",
+        draggable: true,
+        style: {},
+      } as unknown as HTMLImageElement;
+      const ownerDocument = {
+        createElement(tagName: string) {
+          expect(tagName).toBe("img");
+          return image;
+        },
+      } as unknown as Document;
+
+      expect(createRendererAgentIcon(agent, 16, ownerDocument)).toBe(image);
+      expect(image.src).toMatch(/^data:image\/svg\+xml,/);
+      expect(image.alt).toBe("");
+      expect(image.draggable).toBe(false);
+      expect(image.style.width).toBe("16px");
+      expect(image.style.height).toBe("16px");
+    },
+  );
+});

package/src/native-ui/renderer-extension/test/renderer-agent-picker.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, it } from "vitest";
+
+import { isNativeModelControlCandidate } from "../src/renderer-composer-dom.js";
+import {
+  codexAccountDisplayName,
+  codexAccountPresentationSignature,
+} from "../src/renderer-codex-account-options.js";
+import {
+  rendererAgentMenuPlacement,
+  rendererAgentPickerTooltip,
+  rendererAgentPickerView,
+} from "../src/renderer-agent-picker.js";
+
+describe("Renderer Agent picker presentation", () => {
+  it("normalizes viewport coordinates against the Codex window zoom", () => {
+    expect(
+      rendererAgentMenuPlacement(
+        { right: 1_440, top: 1_312 },
+        { width: 1_920, height: 1_440 },
+        1.6,
+      ),
+    ).toEqual({ left: 676, bottom: 86 });
+  });
+
+  it("falls back to unscaled positioning when the Codex window zoom is unavailable", () => {
+    expect(
+      rendererAgentMenuPlacement(
+        { right: 900, top: 820 },
+        { width: 1_200, height: 900 },
+        Number.NaN,
+      ),
+    ).toEqual({ left: 676, bottom: 86 });
+  });
+
+  it("splits Codex Account email names from their muted domains", () => {
+    const account = {
+      accountId: "reviewer",
+      label: "Reviewer",
+      email: "reviewer@example.com",
+      codexHome: "/tmp/reviewer",
+      active: true,
+      isDefault: false,
+    };
+    expect(codexAccountDisplayName(account)).toEqual({
+      local: "reviewer",
+      domain: "example.com",
+      full: "reviewer@example.com",
+    });
+    expect(codexAccountDisplayName({ ...account, email: undefined })).toEqual({
+      local: "Reviewer",
+      domain: null,
+      full: "Reviewer",
+    });
+  });
+
+  it("refreshes Account presentation when live email metadata arrives", () => {
+    const account = {
+      accountId: "reviewer",
+      label: "Reviewer",
+      codexHome: "/tmp/reviewer",
+      active: true,
+      isDefault: false,
+    };
+    expect(codexAccountPresentationSignature([account])).not.toBe(
+      codexAccountPresentationSignature([{ ...account, email: "reviewer@example.com" }]),
+    );
+  });
+
+  it("includes the active Codex Account in the locked hover detail", () => {
+    expect(
+      rendererAgentPickerTooltip(
+        { agent: "codex", phase: "locked" },
+        {
+          accountId: "reviewer",
+          label: "Reviewer",
+          email: "reviewer@example.com",
+          codexHome: "/tmp/reviewer",
+          active: true,
+          isDefault: false,
+        },
+      ),
+    ).toBe("Agent: Codex · reviewer@example.com (locked)");
+    expect(rendererAgentPickerTooltip({ agent: "claude-code", phase: "locked" }, undefined)).toBe(
+      "Agent: Claude Code (locked)",
+    );
+  });
+
+  it("keeps a Codex draft switchable while disabling unavailable external Agents", () => {
+    expect(
+      rendererAgentPickerView({ agent: "codex", phase: "draft" }, "unsupported", false, [
+        "codex",
+        "pi",
+        "claude-code",
+        "grok",
+      ]),
+    ).toEqual({
+      label: "Codex",
+      triggerDisabled: false,
+      nativeModelHidden: false,
+      optionDisabled: { codex: false, pi: true, "claude-code": true, grok: true },
+      downloadVisible: { pi: false, "claude-code": false, grok: false },
+      errorVisible: { pi: false, "claude-code": false, grok: false },
+    });
+  });
+
+  it("keeps the Provider picker enabled when Codex has multiple Accounts", () => {
+    expect(
+      rendererAgentPickerView({ agent: "codex", phase: "draft" }, "ready", false, ["codex"], {}, 2),
+    ).toMatchObject({
+      label: "Codex",
+      triggerDisabled: false,
+      optionDisabled: { codex: false },
+    });
+  });
+
+  it("hides the native Model for an external Agent and locks submitted selection", () => {
+    expect(
+      rendererAgentPickerView({ agent: "pi", phase: "locked" }, "ready", false, ["codex", "pi"], {
+        pi: "ready",
+      }),
+    ).toEqual({
+      label: "Pi",
+      triggerDisabled: true,
+      nativeModelHidden: true,
+      optionDisabled: { codex: true, pi: true },
+      downloadVisible: { pi: false },
+      errorVisible: { pi: false },
+    });
+  });
+
+  it("hides the native Model and disables all choices while switching", () => {
+    expect(
+      rendererAgentPickerView({ agent: "codex", phase: "draft" }, "ready", true, ["codex", "pi"]),
+    ).toMatchObject({
+      triggerDisabled: true,
+      nativeModelHidden: true,
+      optionDisabled: { codex: true, pi: true },
+      downloadVisible: { pi: false },
+    });
+  });
+
+  it("disables an uninstalled external Agent and exposes its install action", () => {
+    expect(
+      rendererAgentPickerView({ agent: "codex", phase: "draft" }, "ready", false, ["codex", "pi"], {
+        pi: "notInstalled",
+      }),
+    ).toEqual({
+      label: "Codex",
+      triggerDisabled: false,
+      nativeModelHidden: false,
+      optionDisabled: { codex: false, pi: true },
+      downloadVisible: { pi: true },
+      errorVisible: { pi: false },
+    });
+  });
+
+  it("surfaces a distinct error action (not the install action) once a Harness fails", () => {
+    expect(
+      rendererAgentPickerView({ agent: "codex", phase: "draft" }, "ready", false, ["codex", "pi"], {
+        pi: "error",
+      }),
+    ).toEqual({
+      label: "Codex",
+      triggerDisabled: false,
+      nativeModelHidden: false,
+      optionDisabled: { codex: false, pi: true },
+      downloadVisible: { pi: false },
+      errorVisible: { pi: true },
+    });
+  });
+
+  it("does not treat a first-load check as a connection error", () => {
+    expect(
+      rendererAgentPickerView({ agent: "codex", phase: "draft" }, "ready", false, ["codex", "pi"], {
+        pi: "checking",
+      }),
+    ).toMatchObject({
+      optionDisabled: { codex: false, pi: true },
+      downloadVisible: { pi: false },
+      errorVisible: { pi: false },
+    });
+  });
+
+  it("recognizes only the native React Model menu as the Model candidate", () => {
+    const element = (
+      ownAttributes: readonly string[],
+      matches: boolean,
+      modelProps: boolean,
+      attributes: Readonly<Record<string, string>> = {},
+    ) => {
+      const candidate = {
+        getAttribute: (name: string) => attributes[name] ?? null,
+        hasAttribute: (name: string) => ownAttributes.includes(name) || name in attributes,
+        matches: () => matches,
+      } as unknown as Element;
+      Object.defineProperty(candidate, "__reactFiber$test", {
+        value: {
+          memoizedProps: modelProps
+            ? {
+                onSelectModel: () => undefined,
+                onSelectReasoningEffort: () => undefined,
+                reasoningEffort: "medium",
+                fallbackPowerSelection: {},
+              }
+            : {},
+        },
+      });
+      return candidate;
+    };
+
+    expect(isNativeModelControlCandidate(element([], true, true))).toBe(true);
+    expect(
+      isNativeModelControlCandidate(
+        element([], true, false, {
+          "data-codex-intelligence-trigger": "true",
+          "data-composer-navigation-target": "reasoning",
+        }),
+      ),
+    ).toBe(true);
+    expect(isNativeModelControlCandidate(element([], true, false))).toBe(false);
+    expect(isNativeModelControlCandidate(element([], false, true))).toBe(false);
+    expect(
+      isNativeModelControlCandidate(element(["data-codexhost-agent-control"], true, true)),
+    ).toBe(false);
+  });
+});