harness-mix 0.1.0

package/src/native-ui/renderer-extension/test/settings/release-notes.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+
+import { createReleaseNotesElement } from "../../src/settings/release-notes.js";
+
+class FakeElement {
+  readonly children: unknown[] = [];
+  readonly attributes = new Map<string, string>();
+  className = "";
+  textContent = "";
+
+  constructor(
+    readonly tagName: string,
+    readonly ownerDocument: FakeDocument,
+  ) {}
+
+  append(...nodes: unknown[]): void {
+    this.children.push(...nodes);
+  }
+
+  setAttribute(name: string, value: string): void {
+    this.attributes.set(name, value);
+  }
+}
+
+class FakeDocument {
+  createElement(tagName: string): FakeElement {
+    return new FakeElement(tagName, this);
+  }
+}
+
+function descendants(root: FakeElement): FakeElement[] {
+  return [
+    root,
+    ...root.children.flatMap((child) => (child instanceof FakeElement ? descendants(child) : [])),
+  ];
+}
+
+function visibleText(root: FakeElement): string {
+  const parts: string[] = [];
+  const walk = (node: unknown): void => {
+    if (typeof node === "string") {
+      if (node) parts.push(node);
+      return;
+    }
+    if (!(node instanceof FakeElement)) return;
+    if (node.children.length === 0) {
+      if (node.textContent) parts.push(node.textContent);
+      return;
+    }
+    for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return parts.join(" ");
+}
+
+function render(markdown: string): FakeElement {
+  return createReleaseNotesElement(
+    new FakeDocument() as unknown as Document,
+    markdown,
+  ) as unknown as FakeElement;
+}
+
+describe("Release notes Markdown", () => {
+  it("renders the current GitHub Release subset as structured elements", () => {
+    const root = render(
+      [
+        "codexhost 是一个将 Pi 和 Claude Code 接入 Codex Desktop 的跨平台 Host。",
+        "",
+        "## 本次发布",
+        "",
+        "- 新增 Grok CLI adapter：支持在 Codex Desktop 中通过 Grok 执行任务。",
+        "- 集成 DeepSeek Harness：通过本地 Host 接入 DeepSeek。",
+        "",
+        "## 安装方式",
+        "",
+        "### npm",
+        "",
+        "```bash",
+        "npm install -g @codexhost/cli",
+        "codexhost",
+        "```",
+      ].join("\n"),
+    );
+
+    expect(root.className).toBe("settings-update-notes");
+    expect(root.children.map((child) => (child as FakeElement).tagName)).toEqual([
+      "p",
+      "h2",
+      "ul",
+      "h2",
+      "h3",
+      "pre",
+    ]);
+    expect(visibleText(root)).toContain("本次发布");
+    expect(visibleText(root)).not.toContain("##");
+    expect(visibleText(root)).not.toContain("- 新增");
+    expect(visibleText(root)).toContain("npm install -g @codexhost/cli");
+
+    const list = descendants(root).find((element) => element.tagName === "ul");
+    expect(list?.children).toHaveLength(2);
+    const code = descendants(root).find((element) => element.tagName === "code");
+    expect(code?.className).toBe("language-bash");
+    expect(code?.textContent).toBe("npm install -g @codexhost/cli\ncodexhost");
+  });
+
+  it("preserves authored line breaks within bilingual paragraphs", () => {
+    const root = render(
+      [
+        "Download the installer matching your OS and CPU architecture:",
+        "下载与你的操作系统和 CPU 架构对应的安装包：",
+      ].join("\n"),
+    );
+
+    const paragraph = descendants(root).find((element) => element.tagName === "p");
+    expect(paragraph?.children).toHaveLength(3);
+    expect((paragraph?.children[1] as FakeElement).tagName).toBe("br");
+  });
+
+  it("renders inline code, emphasis, links, and ordered lists", () => {
+    const root = render(
+      [
+        "Use `codexhost` and **restart** after install.",
+        "",
+        "1. Download the package",
+        "2. Open [Releases](https://github.com/BytePioneer-AI/codex-host/releases)",
+      ].join("\n"),
+    );
+
+    expect(root.children.map((child) => (child as FakeElement).tagName)).toEqual(["p", "ol"]);
+    const code = descendants(root).find((element) => element.tagName === "code");
+    expect(code?.textContent).toBe("codexhost");
+    const strong = descendants(root).find((element) => element.tagName === "strong");
+    expect(strong?.textContent).toBe("restart");
+    const link = descendants(root).find((element) => element.tagName === "a");
+    expect(link?.textContent).toBe("Releases");
+    expect(link?.attributes.get("href")).toBe(
+      "https://github.com/BytePioneer-AI/codex-host/releases",
+    );
+    expect(link?.attributes.get("target")).toBe("_blank");
+    expect(link?.attributes.get("rel")).toBe("noopener noreferrer");
+  });
+
+  it("renders release-note blockquotes and does not create unsafe links", () => {
+    const root = render(
+      [
+        "> **Note / 提示**: Linux x64/ARM64 users install via npm.",
+        ">",
+        "> See [the release](javascript:alert(1)).",
+        "---",
+      ].join("\n"),
+    );
+
+    expect(root.children.map((child) => (child as FakeElement).tagName)).toEqual([
+      "blockquote",
+      "hr",
+    ]);
+    const blockquote = descendants(root).find((element) => element.tagName === "blockquote");
+    expect(visibleText(blockquote as FakeElement)).toContain("Note / 提示");
+    expect(descendants(root).some((element) => element.tagName === "a")).toBe(false);
+    expect(visibleText(root)).toContain("the release");
+    expect(visibleText(root)).not.toContain("> ");
+  });
+});

package/src/native-ui/renderer-extension/test/settings/shell.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  DEFAULT_RENDERER_SETTINGS_PAGE_IDS,
+  createDefaultRendererSettingsPages,
+  createDefaultRendererSettingsRegistry,
+} from "../../src/settings/pages.js";
+import {
+  RENDERER_SETTINGS_COLOR_SCHEME,
+  isRendererSettingsDialogSupported,
+} from "../../src/settings/shell.js";
+
+describe("Renderer settings foundation", () => {
+  it("inherits the Codex theme instead of forcing a dark settings surface", () => {
+    expect(RENDERER_SETTINGS_COLOR_SCHEME).toBe("inherit");
+  });
+
+  it("publishes deterministic product sections with Connections as the default", () => {
+    const pages = createDefaultRendererSettingsPages();
+    const registry = createDefaultRendererSettingsRegistry();
+
+    expect(pages.map(({ id }) => id)).toEqual(DEFAULT_RENDERER_SETTINGS_PAGE_IDS);
+    expect(pages.map(({ label }) => label)).toEqual([
+      "Connections",
+      "Accounts",
+      "Session Import",
+      "Updates",
+      "About",
+    ]);
+    expect(pages.map(({ icon }) => icon)).toEqual([
+      "connections",
+      "accounts",
+      "session-import",
+      "updates",
+      "about",
+    ]);
+    expect(registry.defaultPageId).toBe("connections");
+    expect(Object.isFrozen(pages)).toBe(true);
+    expect(pages.every((page) => Object.isFrozen(page))).toBe(true);
+  });
+
+  it("enables the settings trigger only for a native modal dialog surface", () => {
+    expect(
+      isRendererSettingsDialogSupported({ showModal() {}, close() {} } as HTMLDialogElement),
+    ).toBe(true);
+    expect(
+      isRendererSettingsDialogSupported({
+        showModal: undefined,
+        close() {},
+      } as unknown as HTMLDialogElement),
+    ).toBe(false);
+    expect(
+      isRendererSettingsDialogSupported({
+        showModal() {},
+        close: undefined,
+      } as unknown as HTMLDialogElement),
+    ).toBe(false);
+  });
+
+  it("publishes only available settings pages", () => {
+    const pages = createDefaultRendererSettingsPages();
+
+    expect(pages.map(({ id }) => id)).toEqual([
+      "connections",
+      "accounts",
+      "session-import",
+      "updates",
+      "about",
+    ]);
+    expect(pages.find(({ id }) => id === "connections")?.mount.toString()).toContain(
+      "connectionRefresh",
+    );
+  });
+});

package/src/native-ui/renderer-extension/test/settings/trigger.test.ts

@@ -0,0 +1,270 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  type RendererSettingsBounds,
+  installRendererSettingsHeaderTrigger,
+  mountRendererSettingsTrigger,
+  selectRendererSettingsHeaderSlot,
+} from "../../src/settings/trigger.js";
+
+function bounds(left: number, top: number, width: number, height: number): RendererSettingsBounds {
+  return {
+    left,
+    right: left + width,
+    top,
+    bottom: top + height,
+    width,
+    height,
+  };
+}
+
+describe("Renderer settings header trigger", () => {
+  const header = bounds(240, 36, 942, 46);
+
+  it("selects the right-side group containing Open Location and the context menu", () => {
+    expect(
+      selectRendererSettingsHeaderSlot(header, [
+        { value: "open-location", bounds: bounds(1018, 45, 128, 28), visibleButtonCount: 1 },
+        { value: "actions", bounds: bounds(1018, 36, 164, 46), visibleButtonCount: 2 },
+        { value: "context-menu", bounds: bounds(1154, 45, 28, 28), visibleButtonCount: 1 },
+      ]),
+    ).toBe("actions");
+  });
+
+  it("selects the structural action group when a blank thread has no native actions", () => {
+    expect(
+      selectRendererSettingsHeaderSlot(header, [
+        {
+          value: "empty-actions",
+          bounds: bounds(1176, 59, 0, 0),
+          visibleButtonCount: 0,
+          structuralActionGroup: true,
+        },
+      ]),
+    ).toBe("empty-actions");
+  });
+
+  it("shows a dedicated update button and opens the Updates page directly", () => {
+    class FakeElement {
+      readonly attributes = new Map<string, string>();
+      readonly children: FakeElement[] = [];
+      readonly listeners = new Map<string, (event: { stopPropagation(): void }) => void>();
+      readonly classList = { add: vi.fn() };
+      readonly style: Record<string, string | ((name: string, value: string) => void)> = {};
+      disabled = false;
+      isConnected = true;
+      title = "";
+      type = "";
+
+      constructor() {
+        this.style.setProperty = (name: string, value: string) => {
+          this.style[name] = value;
+        };
+      }
+
+      addEventListener(name: string, listener: (event: { stopPropagation(): void }) => void): void {
+        this.listeners.set(name, listener);
+      }
+      append(...children: FakeElement[]): void {
+        this.children.push(...children);
+      }
+      appendChild(child: FakeElement): FakeElement {
+        this.children.push(child);
+        return child;
+      }
+      dispatch(name: string): void {
+        this.listeners.get(name)?.({ stopPropagation: vi.fn() });
+      }
+      hasAttribute(name: string): boolean {
+        return this.attributes.has(name);
+      }
+      remove(): void {
+        this.isConnected = false;
+      }
+      removeEventListener(name: string): void {
+        this.listeners.delete(name);
+      }
+      setAttribute(name: string, value: string): void {
+        this.attributes.set(name, value);
+      }
+      toggleAttribute(name: string, force: boolean): void {
+        if (force) this.attributes.set(name, "");
+        else this.attributes.delete(name);
+      }
+    }
+
+    const document = {
+      createElement: () => new FakeElement(),
+      createElementNS: () => new FakeElement(),
+    } as unknown as Document;
+    vi.stubGlobal("document", document);
+    const opened = vi.fn();
+    const control = mountRendererSettingsTrigger(
+      "test",
+      true,
+      (opener, pageId) => opened(opener, pageId),
+      document,
+    );
+
+    expect(control.updateButton.style.display).toBe("none");
+    control.setUpdateAvailable(true);
+    expect(control.updateButton.style.display).toBe("inline-flex");
+    expect(control.updateButton.style.background).toBe("#2563eb");
+    expect(control.updateButton.style.color).toBe("#ffffff");
+    expect(
+      (control.updateButton.children[1] as unknown as { textContent: string }).textContent,
+    ).toBe("Updates");
+    expect(control.root.hasAttribute("data-update-available")).toBe(true);
+    (control.updateButton as unknown as FakeElement).dispatch("click");
+    expect(opened).toHaveBeenCalledWith(control.updateButton, "updates");
+    control.setUpdateAvailable(false);
+    expect(control.updateButton.style.display).toBe("none");
+    control.dispose();
+    vi.unstubAllGlobals();
+  });
+
+  it("mounts directly before the application header end slot without Thread actions", () => {
+    class FakeElement {
+      readonly attributes = new Map<string, string>();
+      readonly children: FakeElement[] = [];
+      readonly listeners = new Map<string, (event: { stopPropagation(): void }) => void>();
+      readonly classList = { add: vi.fn() };
+      readonly style: Record<string, string | ((name: string, value: string) => void)> = {};
+      disabled = false;
+      isConnected = true;
+      parentElement: FakeElement | null = null;
+      title = "";
+      type = "";
+
+      constructor(readonly left = 0) {
+        this.style.setProperty = (name: string, value: string) => {
+          this.style[name] = value;
+        };
+      }
+
+      get firstChild(): FakeElement | null {
+        return this.children[0] ?? null;
+      }
+      get nextSibling(): FakeElement | null {
+        if (!this.parentElement) return null;
+        const index = this.parentElement.children.indexOf(this);
+        return this.parentElement.children[index + 1] ?? null;
+      }
+      addEventListener(name: string, listener: (event: { stopPropagation(): void }) => void): void {
+        this.listeners.set(name, listener);
+      }
+      append(...children: FakeElement[]): void {
+        for (const child of children) this.insertBefore(child, null);
+      }
+      appendChild(child: FakeElement): FakeElement {
+        return this.insertBefore(child, null);
+      }
+      getBoundingClientRect(): DOMRect {
+        return {
+          left: this.left,
+          right: this.left + 80,
+          top: 0,
+          bottom: 46,
+          width: 80,
+          height: 46,
+        } as DOMRect;
+      }
+      insertBefore(child: FakeElement, before: FakeElement | null): FakeElement {
+        child.remove();
+        child.parentElement = this;
+        child.isConnected = true;
+        const index = before ? this.children.indexOf(before) : -1;
+        if (index < 0) this.children.push(child);
+        else this.children.splice(index, 0, child);
+        return child;
+      }
+      querySelectorAll(selector: string): FakeElement[] {
+        return selector === ':scope > [data-test-id="header-shell-slot"]'
+          ? this.children.filter((child) => child.attributes.has("data-test-id"))
+          : [];
+      }
+      remove(): void {
+        if (this.parentElement) {
+          const index = this.parentElement.children.indexOf(this);
+          if (index >= 0) this.parentElement.children.splice(index, 1);
+        }
+        this.parentElement = null;
+        this.isConnected = false;
+      }
+      removeEventListener(name: string): void {
+        this.listeners.delete(name);
+      }
+      setAttribute(name: string, value: string): void {
+        this.attributes.set(name, value);
+      }
+      toggleAttribute(name: string, force: boolean): void {
+        if (force) this.attributes.set(name, "");
+        else this.attributes.delete(name);
+      }
+    }
+
+    const header = new FakeElement();
+    const startSlot = new FakeElement(0);
+    startSlot.setAttribute("data-test-id", "header-shell-slot");
+    const content = new FakeElement(240);
+    const endSlot = new FakeElement(1120);
+    endSlot.setAttribute("data-test-id", "header-shell-slot");
+    header.append(startSlot, content, endSlot);
+    let currentHeader = header;
+    const document = {
+      createElement: () => new FakeElement(),
+      createElementNS: () => new FakeElement(),
+      querySelector: (selector: string) =>
+        selector === 'header[data-pip-obstacle="app-shell-header"]' ? currentHeader : null,
+      querySelectorAll: () => [],
+    } as unknown as Document;
+    vi.stubGlobal("document", document);
+
+    try {
+      const control = installRendererSettingsHeaderTrigger({
+        available: true,
+        onOpen: vi.fn(),
+        ownerDocument: document,
+      });
+
+      expect(control.root).not.toBeNull();
+      expect(header.children).toEqual([startSlot, content, control.root, endSlot]);
+
+      const replacementHeader = new FakeElement();
+      const replacementStartSlot = new FakeElement(0);
+      replacementStartSlot.setAttribute("data-test-id", "header-shell-slot");
+      const replacementContent = new FakeElement(240);
+      const replacementEndSlot = new FakeElement(1120);
+      replacementEndSlot.setAttribute("data-test-id", "header-shell-slot");
+      replacementHeader.append(replacementStartSlot, replacementContent, replacementEndSlot);
+      currentHeader = replacementHeader;
+
+      expect(control.refresh()).toBe(true);
+      expect(header.children).toEqual([startSlot, content, endSlot]);
+      expect(replacementHeader.children).toEqual([
+        replacementStartSlot,
+        replacementContent,
+        control.root,
+        replacementEndSlot,
+      ]);
+      control.dispose();
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
+  it("fails closed without a visible or structural bounded action group", () => {
+    expect(
+      selectRendererSettingsHeaderSlot(header, [
+        { value: "open-location", bounds: bounds(1018, 45, 128, 28), visibleButtonCount: 1 },
+        { value: "hidden", bounds: bounds(1018, 36, 164, 46), visibleButtonCount: 0 },
+        {
+          value: "outside",
+          bounds: bounds(1184, 59, 0, 0),
+          visibleButtonCount: 0,
+          structuralActionGroup: true,
+        },
+      ]),
+    ).toBeNull();
+  });
+});

package/src/native-ui/renderer-extension/test/settings/update-request.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  RendererUpdateRequestTimeoutError,
+  runBoundedRendererUpdateRequest,
+} from "../../src/settings/update-request.js";
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("bounded renderer update requests", () => {
+  it("returns the operation result and clears its timeout", async () => {
+    vi.useFakeTimers();
+    const controller = new AbortController();
+
+    await expect(
+      runBoundedRendererUpdateRequest(async () => "ready", controller.signal, 10),
+    ).resolves.toBe("ready");
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("fails a request that never responds", async () => {
+    vi.useFakeTimers();
+    const controller = new AbortController();
+    const request = runBoundedRendererUpdateRequest(
+      () => new Promise<never>(() => {}),
+      controller.signal,
+      10,
+    );
+
+    const assertion = expect(request).rejects.toBeInstanceOf(RendererUpdateRequestTimeoutError);
+    await vi.advanceTimersByTimeAsync(10);
+    await assertion;
+  });
+
+  it("rejects when the settings page is disposed", async () => {
+    const controller = new AbortController();
+    const request = runBoundedRendererUpdateRequest(
+      () => new Promise<never>(() => {}),
+      controller.signal,
+      10_000,
+    );
+
+    controller.abort();
+    await expect(request).rejects.toThrow("aborted");
+  });
+});