@harness-mix/cli 0.1.3

package/src/native-ui/renderer-extension/src/assets.d.ts

@@ -0,0 +1,26 @@
+declare module "*.png" {
+  const dataUrl: string;
+  export default dataUrl;
+}
+
+declare module "*.svg" {
+  const dataUrl: string;
+  export default dataUrl;
+}
+
+declare module "*.css" {
+  const cssText: string;
+  export default cssText;
+}
+
+declare module "lucide/dist/esm/createElement.mjs" {
+  import type { IconNode, SVGProps } from "lucide";
+  const createElement: (iconNode: IconNode, customAttributes?: SVGProps) => SVGElement;
+  export default createElement;
+}
+
+declare module "lucide/dist/esm/icons/*.mjs" {
+  import type { IconNode } from "lucide";
+  const iconNode: IconNode;
+  export default iconNode;
+}

package/src/native-ui/renderer-extension/src/audit-entry.ts

@@ -0,0 +1,5 @@
+import { inspectRendererContracts } from "./contract-audit.js";
+
+window.__codexhostContractAuditV1 = Object.freeze({
+  inspect: () => inspectRendererContracts(window),
+});

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

@@ -0,0 +1,321 @@
+const GET_LOCALE_OVERRIDE_URL = "vscode://codex/get-setting";
+const GET_LOCALE_INFO_URL = "vscode://codex/locale-info";
+const SET_LOCALE_OVERRIDE_URL = "vscode://codex/set-setting";
+const DEFAULT_LOCALE_REQUEST_TIMEOUT_MS = 750;
+
+interface ElectronLocaleBridge {
+  sendMessageFromView(message: unknown): unknown;
+}
+
+interface ElectronLocaleWindow extends Window {
+  electronBridge?: ElectronLocaleBridge;
+}
+
+interface LocaleOverrideResponse {
+  value: string | null;
+}
+
+interface LocaleInfoResponse {
+  ideLocale: string | undefined;
+  systemLocale: string | undefined;
+}
+
+interface SetLocaleOverrideResponse {
+  success: true;
+}
+
+type FixedLocaleRequest =
+  | {
+      kind: "locale-override";
+      url: typeof GET_LOCALE_OVERRIDE_URL;
+      body: string;
+    }
+  | {
+      kind: "locale-info";
+      url: typeof GET_LOCALE_INFO_URL;
+      body?: undefined;
+    }
+  | {
+      kind: "set-locale-override";
+      url: typeof SET_LOCALE_OVERRIDE_URL;
+      body: string;
+    };
+
+export type CodexLocaleOverride = "en-US" | "zh-CN" | null;
+export type CodexLocaleReadStatus = "ready" | "fallback";
+export type CodexLocaleMode = "explicit" | "automatic" | "unavailable";
+export type CodexLocaleSource = "override" | "ide" | "system" | "navigator" | "default";
+
+export interface CodexLocaleSettings {
+  readonly status: CodexLocaleReadStatus;
+  readonly mode: CodexLocaleMode;
+  readonly localeOverride: string | null | undefined;
+  readonly ideLocale: string | undefined;
+  readonly systemLocale: string | undefined;
+  readonly preferredLocale: string;
+  readonly source: CodexLocaleSource;
+}
+
+export interface CodexLocaleRequestOptions {
+  ownerWindow?: Window;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+
+export type ReadCodexLocaleSettingsOptions = CodexLocaleRequestOptions;
+export type SetCodexLocaleOverrideOptions = CodexLocaleRequestOptions;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function canonicalLocale(value: unknown): string | undefined {
+  if (typeof value !== "string" || value.trim().length === 0) return undefined;
+  try {
+    return Intl.getCanonicalLocales(value.trim())[0];
+  } catch {
+    return undefined;
+  }
+}
+
+function firstNavigatorLocale(ownerWindow: Window): string | undefined {
+  for (const candidate of ownerWindow.navigator.languages) {
+    const locale = canonicalLocale(candidate);
+    if (locale) return locale;
+  }
+  return canonicalLocale(ownerWindow.navigator.language);
+}
+
+function abortError(): DOMException {
+  return new DOMException("The operation was aborted", "AbortError");
+}
+
+function parseLocaleOverride(value: unknown): LocaleOverrideResponse {
+  if (!isRecord(value) || !("value" in value)) {
+    throw new Error("Codex locale override response is malformed");
+  }
+  if (value.value === null) return { value: null };
+  const locale = canonicalLocale(value.value);
+  if (!locale) throw new Error("Codex locale override is invalid");
+  return { value: locale };
+}
+
+function optionalLocale(value: unknown, field: string): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  const locale = canonicalLocale(value);
+  if (!locale) throw new Error(`Codex ${field} is invalid`);
+  return locale;
+}
+
+function parseLocaleInfo(value: unknown): LocaleInfoResponse {
+  if (!isRecord(value)) throw new Error("Codex locale info response is malformed");
+  return {
+    ideLocale: optionalLocale(value.ideLocale, "IDE locale"),
+    systemLocale: optionalLocale(value.systemLocale, "system locale"),
+  };
+}
+
+function parseSetLocaleOverride(value: unknown): SetLocaleOverrideResponse {
+  if (!isRecord(value) || value.success !== true) {
+    throw new Error("Codex locale update response is malformed");
+  }
+  return { success: true };
+}
+
+function sendFixedLocaleRequest(
+  request: FixedLocaleRequest,
+  ownerWindow: Window,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<unknown> {
+  const bridge = (ownerWindow as ElectronLocaleWindow).electronBridge;
+  if (typeof bridge?.sendMessageFromView !== "function") {
+    return Promise.reject(new Error("Codex locale bridge is unavailable"));
+  }
+  if (signal?.aborted) return Promise.reject(abortError());
+
+  const requestId = ownerWindow.crypto.randomUUID();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = (): void => {
+      ownerWindow.clearTimeout(timer);
+      ownerWindow.removeEventListener("message", onMessage);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const settle = (operation: () => void): void => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      operation();
+    };
+    const onAbort = (): void => settle(() => reject(abortError()));
+    const onMessage = (event: MessageEvent): void => {
+      const message = event.data;
+      if (!isRecord(message) || message.type !== "fetch-response") return;
+      if (message.requestId !== requestId) return;
+      if (
+        message.responseType !== "success" ||
+        typeof message.status !== "number" ||
+        message.status < 200 ||
+        message.status >= 300 ||
+        typeof message.bodyJsonString !== "string"
+      ) {
+        settle(() => reject(new Error("Codex locale request failed")));
+        return;
+      }
+      try {
+        const body: unknown = JSON.parse(message.bodyJsonString);
+        settle(() => resolve(body));
+      } catch {
+        settle(() => reject(new Error("Codex locale response is not valid JSON")));
+      }
+    };
+    const timer = ownerWindow.setTimeout(
+      () => settle(() => reject(new Error("Codex locale request timed out"))),
+      timeoutMs,
+    );
+
+    ownerWindow.addEventListener("message", onMessage);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const message = {
+      type: "fetch",
+      requestId,
+      method: "POST",
+      url: request.url,
+      ...(request.body === undefined ? {} : { body: request.body }),
+      reportUploadProgress: false,
+    };
+    try {
+      Promise.resolve(bridge.sendMessageFromView(message)).catch((error: unknown) => {
+        settle(() => reject(error));
+      });
+    } catch (error) {
+      settle(() => reject(error));
+    }
+  });
+}
+
+async function readLocaleOverride(
+  ownerWindow: Window,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<LocaleOverrideResponse> {
+  const response = await sendFixedLocaleRequest(
+    {
+      kind: "locale-override",
+      url: GET_LOCALE_OVERRIDE_URL,
+      body: JSON.stringify({ key: "localeOverride" }),
+    },
+    ownerWindow,
+    signal,
+    timeoutMs,
+  );
+  return parseLocaleOverride(response);
+}
+
+async function readLocaleInfo(
+  ownerWindow: Window,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<LocaleInfoResponse> {
+  const response = await sendFixedLocaleRequest(
+    { kind: "locale-info", url: GET_LOCALE_INFO_URL },
+    ownerWindow,
+    signal,
+    timeoutMs,
+  );
+  return parseLocaleInfo(response);
+}
+
+export async function setCodexLocaleOverride(
+  localeOverride: CodexLocaleOverride,
+  options: SetCodexLocaleOverrideOptions = {},
+): Promise<void> {
+  if (localeOverride !== null && localeOverride !== "en-US" && localeOverride !== "zh-CN") {
+    throw new Error("Unsupported Codex locale override");
+  }
+  const ownerWindow = options.ownerWindow ?? window;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCALE_REQUEST_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Codex locale request timeout must be positive");
+  }
+  const response = await sendFixedLocaleRequest(
+    {
+      kind: "set-locale-override",
+      url: SET_LOCALE_OVERRIDE_URL,
+      body: JSON.stringify({ key: "localeOverride", value: localeOverride }),
+    },
+    ownerWindow,
+    options.signal,
+    timeoutMs,
+  );
+  parseSetLocaleOverride(response);
+}
+
+export async function readCodexLocaleSettings(
+  options: ReadCodexLocaleSettingsOptions = {},
+): Promise<CodexLocaleSettings> {
+  const ownerWindow = options.ownerWindow ?? window;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCALE_REQUEST_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Codex locale request timeout must be positive");
+  }
+  if (options.signal?.aborted) throw abortError();
+
+  const [overrideResult, localeInfoResult] = await Promise.allSettled([
+    readLocaleOverride(ownerWindow, options.signal, timeoutMs),
+    readLocaleInfo(ownerWindow, options.signal, timeoutMs),
+  ]);
+  if (options.signal?.aborted) throw abortError();
+
+  const navigatorLocale = firstNavigatorLocale(ownerWindow);
+  const overrideKnown = overrideResult.status === "fulfilled";
+  const localeOverride = overrideKnown ? overrideResult.value.value : undefined;
+  const localeInfo: LocaleInfoResponse =
+    localeInfoResult.status === "fulfilled"
+      ? localeInfoResult.value
+      : { ideLocale: undefined, systemLocale: undefined };
+
+  if (typeof localeOverride === "string") {
+    return Object.freeze({
+      status: "ready",
+      mode: "explicit",
+      localeOverride,
+      ideLocale: localeInfo.ideLocale,
+      systemLocale: localeInfo.systemLocale,
+      preferredLocale: localeOverride,
+      source: "override",
+    });
+  }
+
+  if (overrideKnown) {
+    const preferredLocale =
+      localeInfo.ideLocale ?? localeInfo.systemLocale ?? navigatorLocale ?? "en-US";
+    const source: CodexLocaleSource = localeInfo.ideLocale
+      ? "ide"
+      : localeInfo.systemLocale
+        ? "system"
+        : navigatorLocale
+          ? "navigator"
+          : "default";
+    return Object.freeze({
+      status: "ready",
+      mode: "automatic",
+      localeOverride: null,
+      ideLocale: localeInfo.ideLocale,
+      systemLocale: localeInfo.systemLocale,
+      preferredLocale,
+      source,
+    });
+  }
+
+  return Object.freeze({
+    status: "fallback",
+    mode: "unavailable",
+    localeOverride: undefined,
+    ideLocale: localeInfo.ideLocale,
+    systemLocale: localeInfo.systemLocale,
+    preferredLocale: navigatorLocale ?? "en-US",
+    source: navigatorLocale ? "navigator" : "default",
+  });
+}

package/src/native-ui/renderer-extension/src/collaboration-icon.ts

@@ -0,0 +1,13 @@
+import { projectIcon } from './harness-mix-icons.js';
+
+export function collaborationIcon(id: string, name: string, size = 22): HTMLElement {
+  const aliases: Record<string, string> = { 'claude-code': 'claude', 'deepseek-harness': 'dsh', 'codex-harness': 'codex' };
+  const key = id.toLowerCase();
+  const icon = projectIcon('harnesses', aliases[key] ?? key, size, document);
+  if (icon) return icon;
+  const fallback = document.createElement('span');
+  fallback.textContent = name.slice(0, 1).toUpperCase();
+  fallback.setAttribute('aria-hidden', 'true');
+  fallback.style.cssText = `display:inline-grid;place-items:center;width:${size}px;height:${size}px;flex:none;border-radius:6px;background:#8882;font-size:12px`;
+  return fallback;
+}

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

@@ -0,0 +1,102 @@
+import {
+  CODEX_COMPOSER_SELECTOR,
+  inspectRendererComposerContract,
+  type RendererComposerContractInspection,
+} from "./renderer-composer-dom.js";
+import {
+  inspectRendererForkContract,
+  type RendererForkContractInspection,
+} from "./renderer-fork-control.js";
+import {
+  inspectRendererSidebarContract,
+  type RendererSidebarContractInspection,
+} from "./renderer-sidebar-agent-icons.js";
+import {
+  inspectRendererTranscriptContract,
+  type RendererTranscriptContractInspection,
+} from "./renderer-transcript-dom.js";
+import {
+  inspectRendererSettingsContract,
+  type RendererSettingsContractInspection,
+} from "./settings/trigger.js";
+import {
+  inspectComposerModelContract,
+  type RendererComposerModelContractState,
+} from "./versioned-renderer-adapter.js";
+
+export const RENDERER_CONTRACT_AUDIT_SCHEMA_VERSION = 1 as const;
+
+export interface RendererContractAuditApi {
+  inspect(): RendererContractAuditInspection;
+}
+
+export interface RendererContractAuditInspection {
+  schemaVersion: typeof RENDERER_CONTRACT_AUDIT_SCHEMA_VERSION;
+  composer: RendererComposerContractInspection;
+  model: {
+    draftCount: number;
+    conversationCount: number;
+    missingCount: number;
+    ambiguousCount: number;
+  };
+  settings: RendererSettingsContractInspection;
+  sidebar: RendererSidebarContractInspection;
+  transcript: RendererTranscriptContractInspection;
+  fork: RendererForkContractInspection;
+  production: {
+    bindingPresent: boolean;
+    adapterState: "installing" | "ready" | "unsupported" | "absent";
+    adapterReason: string;
+    titlePolicyState: "ready" | "absent" | "unknown";
+    draftPrewarmPolicyState: "ready" | "absent" | "unknown";
+  };
+}
+
+declare global {
+  interface Window {
+    __codexhostContractAuditV1?: RendererContractAuditApi;
+  }
+}
+
+function modelCounts(states: readonly RendererComposerModelContractState[]): {
+  draftCount: number;
+  conversationCount: number;
+  missingCount: number;
+  ambiguousCount: number;
+} {
+  return {
+    draftCount: states.filter((state) => state === "draft").length,
+    conversationCount: states.filter((state) => state === "conversation").length,
+    missingCount: states.filter((state) => state === "missing").length,
+    ambiguousCount: states.filter((state) => state === "ambiguous").length,
+  };
+}
+
+export function inspectRendererContracts(
+  ownerWindow: Window = window,
+): RendererContractAuditInspection {
+  const composers = [...ownerWindow.document.querySelectorAll<Element>(CODEX_COMPOSER_SELECTOR)];
+  const binding = ownerWindow.__codexhostRendererBindingProbeV1;
+  const status = binding?.status();
+  const adapterState = status?.adapter.state ?? "absent";
+  const titlePolicy = ownerWindow.__codexhostMainProcessTitlePolicyV1;
+  const draftPolicy = ownerWindow.__codexhostDraftPrewarmPolicyV1;
+  return {
+    schemaVersion: RENDERER_CONTRACT_AUDIT_SCHEMA_VERSION,
+    composer: inspectRendererComposerContract(ownerWindow.document),
+    model: modelCounts(composers.map(inspectComposerModelContract)),
+    settings: inspectRendererSettingsContract(ownerWindow.document),
+    sidebar: inspectRendererSidebarContract(ownerWindow.document),
+    transcript: inspectRendererTranscriptContract(ownerWindow.document),
+    fork: inspectRendererForkContract(ownerWindow.document),
+    production: {
+      bindingPresent: binding !== undefined,
+      adapterState,
+      adapterReason: status?.adapter.state ?? "absent",
+      titlePolicyState:
+        titlePolicy === undefined ? "absent" : titlePolicy.state === "ready" ? "ready" : "unknown",
+      draftPrewarmPolicyState:
+        draftPolicy === undefined ? "absent" : draftPolicy.state === "ready" ? "ready" : "unknown",
+    },
+  };
+}

package/src/native-ui/renderer-extension/src/harness-mix-icons.ts

@@ -0,0 +1,31 @@
+// Project-owned assets compiled by scripts/build-native.cjs.
+function isMonochromeSvg(svg: string): boolean {
+  const fills = Array.from(svg.matchAll(/\bfill\s*=\s*["']([^"']+)["']/gi), match => match[1]?.trim().toLowerCase() ?? '');
+  return fills.includes('currentcolor') && fills.every(fill => fill === 'currentcolor' || fill === 'none');
+}
+
+export function projectIcon(kind: 'harnesses' | 'models', id: string, size: number, doc: Document): HTMLImageElement | null {
+  const globals = globalThis as any;
+  const svg = globals.__HARNESS_MIX_ICONS__?.[kind]?.[id === 'codex-harness' ? 'codex' : id]?.svg;
+  if (!svg) return null;
+  const image = doc.createElement('img');
+  image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+  // An SVG loaded as an image cannot inherit the surrounding text color.
+  // Mask monochrome marks so they remain visible when the desktop theme changes.
+  // Keep multi-color brand marks as images so explicit fills (for example
+  // Qoder's green path) are not flattened to the current text color.
+  if (isMonochromeSvg(svg)) {
+    const mask = `url("${image.src}")`;
+    image.src = 'data:image/svg+xml,%3Csvg xmlns="http://www.w3.org/2000/svg" width="24" height="24"/%3E';
+    Object.assign(image.style, { backgroundColor: 'currentColor', maskImage: mask, maskSize: 'contain', maskRepeat: 'no-repeat', maskPosition: 'center' });
+  }
+  image.alt = '';
+  image.draggable = false;
+  image.dataset.harnessMixIcon = `${kind}/${id}`;
+  Object.assign(image.style, { width: `${size}px`, height: `${size}px`, flex: 'none', objectFit: 'contain' });
+  return image;
+}
+export function projectModelIcon(label: string, doc: Document): HTMLImageElement {
+  const family = ((globalThis as any).__HARNESS_MIX_MODEL_FAMILIES__ ?? []).find((f: any) => new RegExp(f.pattern, 'i').test(label));
+  return projectIcon('models', family?.id ?? 'astra', 18, doc)!;
+}

package/src/native-ui/renderer-extension/src/harness-mix-settings.ts

@@ -0,0 +1,88 @@
+import {
+  rendererSettingsMessages,
+  resolveRendererSettingsLocale,
+  type RendererSettingsLocale,
+} from './settings/localization.js';
+import {
+  createConnectionsSettingsPage,
+} from './settings/connections-page.js';
+import {
+  createAccountsSettingsPage,
+} from './settings/accounts-page.js';
+import {
+  aboutPage,
+  updatesPage,
+} from './settings/pages.js';
+import { installRendererSettingsShell, type RendererSettingsShell } from './settings/shell.js';
+import {
+  installRendererSettingsHeaderTrigger,
+  type RendererSettingsHeaderTriggerControl,
+} from './settings/trigger.js';
+import type {
+  RendererSettingsLifecycleOptions,
+  RendererSettingsLifecycleControl,
+} from './renderer-settings-lifecycle.js';
+
+export function installRendererSettingsLifecycle(
+  ownerWindow: Window,
+  options: RendererSettingsLifecycleOptions = {},
+): RendererSettingsLifecycleControl {
+  let locale: RendererSettingsLocale = resolveRendererSettingsLocale(ownerWindow.navigator.languages);
+  let shell: RendererSettingsShell | null = null;
+  let trigger: RendererSettingsHeaderTriggerControl | null = null;
+  let disposed = false;
+
+  const mount = () => {
+    const messages = rendererSettingsMessages(locale);
+    const pages = [
+      createConnectionsSettingsPage(messages, options.getConnectionDiagnostics ?? (() => null)),
+      createAccountsSettingsPage(messages, options.getAccountClient ?? (() => null)),
+      updatesPage(messages, options.getUpdateClient ?? (() => null)),
+      aboutPage(messages),
+    ];
+    const nextShell = installRendererSettingsShell(pages, messages, ownerWindow.document);
+    const nextTrigger = installRendererSettingsHeaderTrigger({
+      available: nextShell.supported,
+      messages,
+      ownerDocument: ownerWindow.document,
+      onOpen(opener, pageId) {
+        if (disposed) return;
+        const currentOpener = opener?.isConnected
+          ? opener
+          : (nextTrigger.root?.querySelector<HTMLButtonElement>('button') ?? undefined);
+        nextShell.openSettings(currentOpener, pageId ?? 'connections');
+      },
+    });
+    shell = nextShell;
+    trigger = nextTrigger;
+  };
+
+  const onKeyDown = (event: KeyboardEvent) => {
+    if ((event.ctrlKey || event.metaKey) && event.key === ',') {
+      event.preventDefault();
+      shell?.openSettings(undefined, 'connections');
+    }
+  };
+
+  mount();
+  ownerWindow.addEventListener('keydown', onKeyDown);
+
+  return {
+    get locale() {
+      return locale;
+    },
+    refresh() {
+      if (disposed) return false;
+      return trigger?.refresh() ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      ownerWindow.removeEventListener('keydown', onKeyDown);
+      trigger?.dispose();
+      shell?.dispose();
+      trigger = null;
+      shell = null;
+    },
+  };
+}