harness-mix 0.1.0

package/src/native-ui/renderer-extension/test/renderer-unsupported-methods.test.ts

@@ -0,0 +1,167 @@
+import {
+  harnessIdSchema,
+  hostThreadIdSchema,
+  harnessModelRefSchema,
+  type HarnessInspection,
+} from "@codexhost/shared-contracts";
+import { describe, expect, it, vi } from "vitest";
+import {
+  createRendererModelClient,
+  CODEX_ACCOUNT_LIST_METHOD,
+  HARNESS_INSPECT_METHOD,
+  THREAD_INSPECT_METHOD,
+} from "../src/renderer-model-client.js";
+
+const unsupported = (method: string) =>
+  Object.assign(new Error(`Invalid request: unknown variant \`${method}\``), { code: -32600 });
+const threadId = hostThreadIdSchema.parse("native-thread");
+const missingHarness = {
+  status: "notInstalled",
+  error: { code: "notInstalled", message: "not installed", retryable: false },
+};
+const usage = { threadId, usage: null };
+const readyHarness: HarnessInspection = {
+  status: "ready",
+  catalog: {
+    models: [
+      {
+        ref: harnessModelRefSchema.parse({ id: "synthetic" }),
+        label: "Native model",
+        supportedThinkingOptionIds: [],
+      },
+    ],
+    defaultModel: harnessModelRefSchema.parse({ id: "synthetic" }),
+    thinkingOptions: [],
+  },
+  capabilities: {
+    configuration: {
+      selectModel: true,
+      selectThinkingOption: true,
+      selectPermissionMode: false,
+      permissionModeScope: "live",
+    },
+    history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: false },
+  },
+};
+
+function clientFor(sendRequest: (method: string, params: unknown) => Promise<unknown>) {
+  const client = createRendererModelClient([{ sendRequest }]);
+  if (!client) throw new Error("Synthetic client unavailable");
+  return client;
+}
+
+describe("unsupported methods on one Host connection", () => {
+  it("does not send a known unsupported method again, even with different Harness params", async () => {
+    const sendRequest = vi.fn(async (method: string) => {
+      throw unsupported(method);
+    });
+    const client = clientFor(sendRequest);
+    for (const harnessId of ["pi", "claude-code", "pi"]) {
+      await expect(
+        client.inspectHarness({ harnessId: harnessIdSchema.parse(harnessId), refresh: true }),
+      ).rejects.toThrow();
+    }
+    expect(sendRequest).toHaveBeenCalledTimes(1);
+  });
+
+  it("an unsupported Account API does not suppress Harness discovery, usage, or another Host", async () => {
+    const sendRequest = vi.fn(async (method: string) => {
+      if (method === CODEX_ACCOUNT_LIST_METHOD) throw unsupported(method);
+      if (method === HARNESS_INSPECT_METHOD) return readyHarness;
+      return usage;
+    });
+    const client = clientFor(sendRequest);
+    for (let i = 0; i < 3; i++) await expect(client.listCodexAccounts()).rejects.toThrow();
+    for (const harnessId of ["pi", "claude-code"]) {
+      await expect(
+        client.inspectHarness({ harnessId: harnessIdSchema.parse(harnessId) }),
+      ).resolves.toEqual(readyHarness);
+    }
+    await expect(client.inspectThreadUsage({ threadId })).resolves.toEqual(usage);
+    const otherHost = clientFor(async () => ({ accounts: [] }));
+    await expect(otherHost.listCodexAccounts()).resolves.toEqual({ accounts: [] });
+    expect(sendRequest.mock.calls.filter(([m]) => m === CODEX_ACCOUNT_LIST_METHOD)).toHaveLength(1);
+    expect(sendRequest.mock.calls.filter(([m]) => m === HARNESS_INSPECT_METHOD)).toHaveLength(2);
+  });
+
+  it("a missing Harness does not disable discovery of other installed Harnesses", async () => {
+    const sendRequest = vi
+      .fn()
+      .mockResolvedValueOnce(missingHarness)
+      .mockResolvedValue(readyHarness);
+    const client = clientFor(sendRequest);
+    await expect(
+      client.inspectHarness({ harnessId: harnessIdSchema.parse("grok") }),
+    ).resolves.toEqual(missingHarness);
+    for (const harnessId of ["pi", "claude-code"]) {
+      await expect(
+        client.inspectHarness({ harnessId: harnessIdSchema.parse(harnessId) }),
+      ).resolves.toEqual(readyHarness);
+    }
+    expect(sendRequest).toHaveBeenCalledTimes(3);
+  });
+
+  it("keeps supported requests concurrent and does not cache their results", async () => {
+    let release: (() => void) | undefined;
+    const pending = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const sendRequest = vi.fn(async () => {
+      await pending;
+      return readyHarness;
+    });
+    const client = clientFor(sendRequest);
+    const requests = ["pi", "claude-code"].map((id) =>
+      client.inspectHarness({ harnessId: harnessIdSchema.parse(id) }),
+    );
+    expect(sendRequest).toHaveBeenCalledTimes(2);
+    release?.();
+    await Promise.all(requests);
+    await client.inspectHarness({ harnessId: harnessIdSchema.parse("pi"), refresh: true });
+    expect(sendRequest).toHaveBeenCalledTimes(3);
+  });
+
+  it.each([
+    new Error("Method not found"),
+    Object.assign(new Error("timeout"), { code: -32000 }),
+    Object.assign(new Error("unauthorized"), { code: -32001 }),
+    Object.assign(new Error("Invalid request: unknown variant `some-param`"), { code: -32600 }),
+  ])("retains recovery after a transient, auth, or parameter error: %s", async (error) => {
+    const sendRequest = vi
+      .fn()
+      .mockRejectedValueOnce(error)
+      .mockResolvedValueOnce({ accounts: [] });
+    const client = clientFor(sendRequest);
+    await expect(client.listCodexAccounts()).rejects.toBe(error);
+    await expect(client.listCodexAccounts()).resolves.toEqual({ accounts: [] });
+    expect(sendRequest).toHaveBeenCalledTimes(2);
+  });
+
+  it("a replacement connection rechecks methods that were unsupported", async () => {
+    const sendRequest = vi
+      .fn()
+      .mockRejectedValueOnce(unsupported(CODEX_ACCOUNT_LIST_METHOD))
+      .mockResolvedValueOnce({ accounts: [] });
+    await expect(clientFor(sendRequest).listCodexAccounts()).rejects.toThrow();
+    await expect(clientFor(sendRequest).listCodexAccounts()).resolves.toEqual({ accounts: [] });
+  });
+
+  it("skips repeat unsupported inspections but still verifies every native Thread", async () => {
+    const sendRequest = vi.fn(async (method: string) => {
+      if (method === THREAD_INSPECT_METHOD) throw unsupported(method);
+      return { thread: { id: threadId, modelProvider: "custom", cliVersion: "0.151.0" } };
+    });
+    const client = clientFor(sendRequest);
+    for (let i = 0; i < 3; i++)
+      await expect(client.inspectThread({ threadId })).resolves.toEqual({
+        owner: "codex",
+        locked: true,
+      });
+    expect(sendRequest.mock.calls.map(([m]) => m)).toEqual([
+      THREAD_INSPECT_METHOD,
+      "thread/read",
+      "thread/read",
+      "thread/read",
+    ]);
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-usage-control.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  formatRendererContextSummary,
+  formatRendererCredits,
+  formatRendererPlanReset,
+  formatRendererPlanWindow,
+  formatRendererTokenCount,
+  formatRendererTokenRate,
+  rendererUsageHasDisplayData,
+  rendererUsageMessages,
+} from "../src/renderer-usage-control.js";
+
+describe("Renderer Usage localization", () => {
+  it("shows credit-only and context-only data without dollar conversion", () => {
+    expect(rendererUsageHasDisplayData({ totalCredits: 0.05 })).toBe(true);
+    expect(rendererUsageHasDisplayData({ contextUsagePercent: 9.5 })).toBe(true);
+    expect(formatRendererCredits(0.058778444510779446)).toBe("0.059 credits");
+    expect(formatRendererCredits(0.00001)).toBe("<0.001 credits");
+    expect(formatRendererCredits(0)).toBe("0 credits");
+    expect(rendererUsageMessages("zh-CN").recordedCredits).toBe("已记录消耗");
+  });
+  it("uses Chinese copy only for the Chinese settings locale", () => {
+    expect(rendererUsageMessages("zh-CN")).toMatchObject({
+      usage: "用量",
+      context: "上下文",
+      latestCacheHit: "最近缓存命中率",
+      inputOutput: "输入 / 输出",
+      sessionCostEstimate: "会话费用估算",
+    });
+    expect(formatRendererTokenRate(42.5, "zh-CN")).toBe("42.5 Token/秒");
+    expect(rendererUsageMessages("en")).toMatchObject({
+      usage: "Usage",
+      context: "Context",
+      latestCacheHit: "Latest cache hit",
+      inputOutput: "Input / output",
+      sessionCostEstimate: "Session cost estimate",
+    });
+    expect(formatRendererTokenRate(42.5, "en")).toBe("42.5 tok/s");
+  });
+});
+
+describe("Renderer Usage token-count formatting", () => {
+  it("switches units at the exact k, M, and B thresholds", () => {
+    expect(formatRendererTokenCount(999)).toBe("999");
+    expect(formatRendererTokenCount(1_000)).toBe("1k");
+    expect(formatRendererTokenCount(999_999)).toBe("1000k");
+    expect(formatRendererTokenCount(1_000_000)).toBe("1M");
+    expect(formatRendererTokenCount(162_108_400)).toBe("162.1M");
+    expect(formatRendererTokenCount(999_999_999)).toBe("1000M");
+    expect(formatRendererTokenCount(1_000_000_000)).toBe("1B");
+    expect(formatRendererTokenCount(-1_250_000_000)).toBe("-1.3B");
+  });
+});
+
+describe("Renderer Usage context-summary formatting", () => {
+  it("shows the used percentage and the context window", () => {
+    expect(formatRendererContextSummary(15_000, 934_500)).toBe("1.6% / 934.5k");
+  });
+});
+
+describe("Renderer Usage plan-window formatting", () => {
+  it("formats a used percent with no reset", () => {
+    expect(formatRendererPlanWindow(45)).toBe("45%");
+  });
+
+  it("formats a used percent with a localized reset time", () => {
+    const formatted = formatRendererPlanWindow(45, 1_756_130_400);
+    expect(formatted.startsWith("45%")).toBe(true);
+    expect(formatted).toContain("·");
+  });
+
+  it("formats an invalid reset timestamp as an empty string", () => {
+    expect(formatRendererPlanReset(Number.NaN)).toBe("");
+  });
+});
+
+describe("Renderer Usage Claude plan windows", () => {
+  it("does not show Usage for a plan-only snapshot", () => {
+    expect(rendererUsageHasDisplayData({ planFiveHourUsedPercent: 45 })).toBe(false);
+    expect(rendererUsageHasDisplayData({ planSevenDayUsedPercent: 12 })).toBe(false);
+  });
+});
+
+describe("Renderer Usage native Codex snapshots", () => {
+  it("keeps token-only native snapshots eligible for the left Usage popover", () => {
+    expect(
+      rendererUsageHasDisplayData({
+        totalTokens: 12_345,
+        inputTokens: 10_000,
+        outputTokens: 2_345,
+      }),
+    ).toBe(true);
+    expect(rendererUsageHasDisplayData(null)).toBe(false);
+  });
+});

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

@@ -0,0 +1,208 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../src/settings/icons.js", () => ({
+  createRendererSettingsIcon: () => "icon",
+}));
+
+import {
+  renderAccountResetCredits,
+  renderAccountUsage,
+  resetCreditDetailLine,
+} from "../../src/settings/accounts-usage.js";
+import { rendererSettingsMessages } from "../../src/settings/localization.js";
+
+class FakeElement {
+  readonly children: unknown[] = [];
+  readonly attributes = new Map<string, string>();
+  readonly style: Record<string, string> = {};
+  readonly listeners = new Map<string, () => void>();
+  className = "";
+  textContent = "";
+  title = "";
+  type = "";
+  disabled = false;
+  constructor(readonly tagName: string) {}
+  addEventListener(name: string, listener: () => void): void {
+    this.listeners.set(name, listener);
+  }
+  append(...children: unknown[]): void {
+    this.children.push(...children);
+  }
+  setAttribute(name: string, value: string): void {
+    this.attributes.set(name, value);
+  }
+}
+
+const document = {
+  createElement: (tagName: string) => new FakeElement(tagName),
+} as unknown as Document;
+const messages = rendererSettingsMessages("zh-CN");
+function descendants(root: FakeElement): FakeElement[] {
+  return [
+    root,
+    ...root.children.flatMap((child) => (child instanceof FakeElement ? descendants(child) : [])),
+  ];
+}
+function elements(root: HTMLElement): FakeElement[] {
+  return descendants(root as unknown as FakeElement);
+}
+function text(root: HTMLElement): string {
+  return elements(root)
+    .map((el) => el.textContent)
+    .join(" ");
+}
+const credits = {
+  usedPercent: 91,
+  periodType: "five_hour" as const,
+  resetsAt: "2026-09-10T03:12:00.000Z",
+};
+
+function usage(snapshot = credits, display: "used" | "remaining" = "used") {
+  const result = renderAccountUsage(
+    document,
+    { status: "ready", credits: snapshot },
+    messages,
+    display,
+    vi.fn(),
+  );
+  if (!result) throw new Error("Expected limits");
+  return result;
+}
+
+describe("Account limit windows", () => {
+  it("does not synthesize a 5h window for weekly-only accounts", () => {
+    const result = renderAccountUsage(
+      document,
+      { status: "ready", credits: { usedPercent: 9, periodType: "seven_day" } },
+      messages,
+      "used",
+      vi.fn(),
+    );
+    if (!result) throw new Error("Expected limits");
+    expect(text(result)).toContain("7 天");
+    expect(text(result)).not.toContain("5 小时");
+    expect(text(result)).not.toContain("未返回");
+    expect(elements(result).filter((el) => el.attributes.get("role") === "meter")).toHaveLength(1);
+  });
+
+  it("preserves primary and product windows without summing or deduplicating them", () => {
+    const result = renderAccountUsage(
+      document,
+      {
+        status: "ready",
+        credits: {
+          ...credits,
+          productUsage: [
+            { product: "7-day window", usagePercent: 0 },
+            { product: "GPT-5.3-Codex-Spark", usagePercent: 25 },
+          ],
+        },
+      },
+      messages,
+      "used",
+      vi.fn(),
+    );
+    if (!result) throw new Error("Expected limits");
+    expect(
+      elements(result)
+        .filter((el) => el.attributes.get("role") === "meter")
+        .map((el) => el.attributes.get("aria-valuenow")),
+    ).toEqual(["91", "0", "25"]);
+    expect(text(result)).toContain("7 天");
+    expect(text(result)).toContain("GPT-5.3-Codex-Spark");
+    expect(
+      elements(result).filter((el) => el.className === "settings-account-usage__sub"),
+    ).toHaveLength(1);
+  });
+
+  it("places the display label beside the percent and keeps warnings based on used usage", () => {
+    const result = usage(credits, "remaining");
+    expect(text(result)).toContain("剩余 9%");
+    const meter = elements(result).find((el) => el.attributes.get("role") === "meter");
+    expect(meter?.attributes.get("aria-valuenow")).toBe("9");
+    expect(meter?.attributes.get("aria-label")).toBe("5 小时 · 剩余");
+    expect(meter?.className).toContain("--hot");
+    expect((meter?.children[0] as FakeElement).style.width).toBe("9%");
+  });
+
+  it.each([0, 100])("renders the %i percent boundary in either display mode", (usedPercent) => {
+    for (const display of ["used", "remaining"] as const) {
+      const result = usage({ ...credits, usedPercent }, display);
+      expect(
+        elements(result)
+          .find((el) => el.attributes.get("role") === "meter")
+          ?.attributes.get("aria-valuenow"),
+      ).toBe(String(display === "used" ? usedPercent : 100 - usedPercent));
+    }
+  });
+
+  it("keeps unavailable, loading, empty, and failed states distinct from zero usage", () => {
+    expect(renderAccountUsage(document, undefined, messages, "used", vi.fn())).toBeNull();
+    for (const status of ["loading", "empty", "error"] as const) {
+      const retry = vi.fn();
+      const result = renderAccountUsage(document, { status }, messages, "used", retry);
+      if (!result) throw new Error("Expected state");
+      expect(elements(result).some((el) => el.attributes.get("role") === "meter")).toBe(false);
+      if (status === "error") {
+        elements(result)
+          .find((el) => el.tagName === "button")
+          ?.listeners.get("click")?.();
+        expect(retry).toHaveBeenCalledOnce();
+      } else expect(elements(result).some((el) => el.tagName === "button")).toBe(false);
+      if (status === "loading")
+        expect((result as unknown as FakeElement).attributes.get("aria-busy")).toBe("true");
+    }
+  });
+});
+
+describe("Account reset-card details", () => {
+  it("formats each available card's expiry", () => {
+    const now = new Date(2026, 8, 10, 12, 0, 0);
+    const expires = new Date(2026, 8, 10, 16, 12, 0);
+    const line = resetCreditDetailLine(1, expires.toISOString(), messages, now);
+    expect(line.startsWith("第 1 张 · ")).toBe(true);
+    expect(line).toContain("今天");
+    expect(line.endsWith("到期")).toBe(true);
+  });
+
+  it("does not invent a zero card count when no reset snapshot is provided", () => {
+    expect(
+      renderAccountResetCredits(document, credits, messages, {
+        usingReset: false,
+        resetDisabled: false,
+      }),
+    ).toBeNull();
+  });
+
+  it("shows a count and reset action even without per-card expiry data", () => {
+    const onUseReset = vi.fn();
+    const result = renderAccountResetCredits(
+      document,
+      { ...credits, resetCredits: { availableCount: 2 } },
+      messages,
+      { usingReset: false, resetDisabled: false, onUseReset },
+    );
+    if (!result) throw new Error("Expected reset details");
+    expect(text(result.summary)).toContain("2 张");
+    expect(elements(result.details).some((el) => el.tagName === "ul")).toBe(false);
+    elements(result.details)
+      .find((el) => el.tagName === "button")
+      ?.listeners.get("click")?.();
+    expect(onUseReset).toHaveBeenCalledOnce();
+  });
+
+  it("renders every expiry and disables consumption while another reset is pending", () => {
+    const expiresAt = ["2026-09-10T16:12:00.000Z", "2026-09-18T08:00:00.000Z"];
+    const result = renderAccountResetCredits(
+      document,
+      { ...credits, resetCredits: { availableCount: 2, nextExpiresAt: expiresAt[0], expiresAt } },
+      messages,
+      { usingReset: false, resetDisabled: true, onUseReset: vi.fn() },
+    );
+    if (!result) throw new Error("Expected reset details");
+    expect(elements(result.details).filter((el) => el.tagName === "li")).toHaveLength(2);
+    expect(text(result.details)).toContain("第 1 张");
+    expect(text(result.details)).toContain("第 2 张");
+    expect(elements(result.details).find((el) => el.tagName === "button")?.disabled).toBe(true);
+  });
+});

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

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  RendererSettingsNavigationState,
+  RendererSettingsPageScope,
+  createRendererSettingsPageRegistry,
+  type RendererSettingsPageDefinition,
+} from "../../src/settings/core.js";
+
+function page(
+  id: string,
+  label = id,
+  icon: RendererSettingsPageDefinition["icon"] = "connections",
+): RendererSettingsPageDefinition {
+  return { id, label, icon, mount: () => undefined };
+}
+
+function deferred<T>(): {
+  promise: Promise<T>;
+  resolve(value: T): void;
+  reject(error: unknown): void;
+} {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+describe("Renderer settings page registry", () => {
+  it("normalizes labels, freezes deterministic pages, and navigates from the default", () => {
+    const registry = createRendererSettingsPageRegistry([
+      page("connections", "  Connections  "),
+      page("model-pool", "Model Pool", "model-pool"),
+    ]);
+    const navigation = new RendererSettingsNavigationState(registry);
+
+    expect(registry.pages.map(({ id, label }) => ({ id, label }))).toEqual([
+      { id: "connections", label: "Connections" },
+      { id: "model-pool", label: "Model Pool" },
+    ]);
+    expect(Object.isFrozen(registry.pages)).toBe(true);
+    expect(Object.isFrozen(registry.pages[0])).toBe(true);
+    expect(navigation.activePageId).toBe("connections");
+    expect(navigation.select("model-pool")).toBe(true);
+    expect(navigation.select("model-pool")).toBe(false);
+    expect(navigation.reset()).toBe(true);
+  });
+
+  it.each([
+    { pages: [] as RendererSettingsPageDefinition[], error: "cannot be empty" },
+    { pages: [page("Overview")], error: "Invalid settings page ID" },
+    { pages: [page("bad id")], error: "Invalid settings page ID" },
+    { pages: [page("connections", " ")], error: "Invalid settings page label" },
+    { pages: [page("connections"), page("connections")], error: "Duplicate settings page ID" },
+  ])("rejects an invalid registry: $error", ({ pages, error }) => {
+    expect(() => createRendererSettingsPageRegistry(pages)).toThrow(error);
+  });
+
+  it("rejects a missing default and unknown navigation", () => {
+    const registry = createRendererSettingsPageRegistry(
+      [page("routes", "Routes", "routes")],
+      "routes",
+    );
+    const navigation = new RendererSettingsNavigationState(registry);
+    expect(() => createRendererSettingsPageRegistry([page("routes")], "connections")).toThrow(
+      "Default settings page is not registered",
+    );
+    expect(() => navigation.select("connections")).toThrow("Unknown settings page");
+  });
+});
+
+describe("Renderer settings page async scope", () => {
+  it("applies only the latest request result and aborts the older request", async () => {
+    const first = deferred<string>();
+    const second = deferred<string>();
+    const success = vi.fn();
+    const failure = vi.fn();
+    const signals: AbortSignal[] = [];
+    const scope = new RendererSettingsPageScope();
+
+    const firstRun = scope.runLatest(
+      (signal) => {
+        signals.push(signal);
+        return first.promise;
+      },
+      { success, failure },
+    );
+    const secondRun = scope.runLatest(
+      (signal) => {
+        signals.push(signal);
+        return second.promise;
+      },
+      { success, failure },
+    );
+    expect(signals[0]?.aborted).toBe(true);
+    expect(signals[1]?.aborted).toBe(false);
+
+    first.resolve("stale");
+    second.resolve("current");
+    await Promise.all([firstRun, secondRun]);
+    expect(success).toHaveBeenCalledTimes(1);
+    expect(success).toHaveBeenCalledWith("current");
+    expect(failure).not.toHaveBeenCalled();
+  });
+
+  it("reports only a current failure", async () => {
+    const failure = vi.fn();
+    const scope = new RendererSettingsPageScope();
+    await scope.runLatest(() => Promise.reject(new Error("unavailable")), {
+      success: vi.fn(),
+      failure,
+    });
+    expect(failure).toHaveBeenCalledTimes(1);
+    expect(failure.mock.calls[0]?.[0]).toBeInstanceOf(Error);
+  });
+
+  it("aborts and ignores a late result after disposal", async () => {
+    const pending = deferred<string>();
+    const success = vi.fn();
+    const failure = vi.fn();
+    const scope = new RendererSettingsPageScope();
+    let operationSignal: AbortSignal | undefined;
+    const run = scope.runLatest(
+      (signal) => {
+        operationSignal = signal;
+        return pending.promise;
+      },
+      { success, failure },
+    );
+
+    scope.dispose();
+    expect(scope.signal.aborted).toBe(true);
+    expect(operationSignal?.aborted).toBe(true);
+    pending.resolve("late");
+    await run;
+    expect(success).not.toHaveBeenCalled();
+    expect(failure).not.toHaveBeenCalled();
+    await expect(
+      scope.runLatest(() => Promise.resolve("no"), { success, failure }),
+    ).rejects.toThrow("Settings page scope is disposed");
+  });
+});