harness-mix 0.1.0

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

@@ -0,0 +1,363 @@
+import {
+  hostThreadIdSchema,
+  hostTurnIdSchema,
+  type ThreadInspection,
+} from "@codexhost/shared-contracts";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  installRendererForkControl,
+  openRendererThread,
+  rendererForkTargetFromButton,
+  type RendererForkDom,
+  type RendererForkTarget,
+} from "../src/renderer-fork-control.js";
+import type { RendererModelClient } from "../src/renderer-model-client.js";
+
+class FakeForkDom implements RendererForkDom {
+  listener: ((target: RendererForkTarget) => boolean) | null = null;
+  readonly openThread = vi.fn(async () => undefined);
+  readonly replay = vi.fn();
+
+  listen(onFork: (target: RendererForkTarget) => boolean): () => void {
+    this.listener = onFork;
+    return () => {
+      this.listener = null;
+    };
+  }
+
+  emit(target: RendererForkTarget): boolean {
+    return this.listener?.(target) ?? false;
+  }
+}
+
+function clientWith(inspection: ThreadInspection): RendererModelClient {
+  return {
+    forkThread: vi.fn(async () => ({ threadId: hostThreadIdSchema.parse("derived-thread") })),
+    inspectHarness: vi.fn(),
+    inspectThread: vi.fn(async () => inspection),
+    inspectHarnessCommands: vi.fn(),
+    inspectThreadCommands: vi.fn(),
+    executeThreadCommand: vi.fn(),
+    inspectThreadUsage: vi.fn(),
+    listThreadOwnership: vi.fn(),
+    selectThreadModel: vi.fn(),
+    selectThreadThinking: vi.fn(),
+    selectThreadPermissionMode: vi.fn(),
+    checkUpdate: vi.fn(),
+    startUpdate: vi.fn(),
+    readUpdateStatus: vi.fn(),
+    listCodexAccounts: vi.fn(),
+    refreshCodexAccounts: vi.fn(),
+    createCodexAccount: vi.fn(),
+    deleteCodexAccount: vi.fn(),
+    activateCodexAccount: vi.fn(),
+    startCodexAccountLogin: vi.fn(),
+    cancelCodexAccountLogin: vi.fn(),
+    subscribeCodexAccountLogin: vi.fn(),
+  };
+}
+
+function target(isProjectlessConversation = true): RendererForkTarget {
+  return {
+    control: {},
+    isProjectlessConversation,
+    threadId: hostThreadIdSchema.parse("source-thread"),
+    turnId: hostTurnIdSchema.parse("source-turn"),
+  };
+}
+
+async function settle(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function forkButton(
+  input: {
+    domThreadId?: string;
+    fiberThreadId?: string;
+    domTurnId?: string;
+    fiberTurnId?: string;
+    forkSignature?: boolean;
+    isProjectlessConversation?: boolean;
+    projectlessSignature?: boolean;
+  } = {},
+): HTMLButtonElement {
+  const domThreadId = input.domThreadId ?? "source-thread";
+  const fiberThreadId = input.fiberThreadId ?? domThreadId;
+  const domTurnId = input.domTurnId ?? "source-turn";
+  const fiberTurnId = input.fiberTurnId ?? domTurnId;
+  const annotation = {
+    getAttribute: (name: string) =>
+      name === "data-response-annotation-conversation" ? domThreadId : null,
+  };
+  const turn = {
+    getAttribute: (name: string) => (name === "data-content-search-turn-key" ? domTurnId : null),
+  };
+  const button = {
+    closest(selector: string) {
+      if (selector === "[data-response-annotation-conversation]") return annotation;
+      if (selector === "[data-content-search-turn-key]") return turn;
+      return null;
+    },
+  } as unknown as HTMLButtonElement;
+  const fiber = {
+    memoizedProps:
+      input.forkSignature === false ? { onClick: vi.fn() } : { "aria-busy": undefined },
+    return: {
+      memoizedProps: {
+        conversationId: fiberThreadId,
+        turnId: fiberTurnId,
+        hostId: "local",
+        onFork: vi.fn(),
+        ...(input.projectlessSignature === false
+          ? {}
+          : { isProjectlessConversation: input.isProjectlessConversation ?? false }),
+      },
+      return: null,
+    },
+  };
+  Object.defineProperty(button, "__reactFiber$test", { value: fiber });
+  return button;
+}
+
+function sidebarRow(threadId: string, hostId: string) {
+  const attributes = {
+    "data-app-action-sidebar-thread-row": "row-marker",
+    "data-app-action-sidebar-thread-id": `${hostId}:${threadId}`,
+    "data-app-action-sidebar-thread-host-id": hostId,
+  } as const;
+  const row = {
+    click: vi.fn(),
+    getAttribute: (name: string) => attributes[name as keyof typeof attributes] ?? null,
+  } as unknown as HTMLElement;
+  Object.defineProperty(row, "__reactFiber$test", {
+    value: {
+      memoizedProps: {
+        conversationId: threadId,
+        dataAttributes: attributes,
+      },
+      return: null,
+    },
+  });
+  return row;
+}
+
+describe("Renderer external Thread Fork control", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it("opens only the Host-qualified standard sidebar row", async () => {
+    const local = sidebarRow("same-thread", "local");
+    const remote = sidebarRow("same-thread", "remote-1");
+    vi.stubGlobal("document", {
+      querySelectorAll: () => [local, remote],
+      documentElement: {},
+    });
+
+    await openRendererThread(hostThreadIdSchema.parse("same-thread"), { hostId: "remote-1" });
+
+    expect(local.click).not.toHaveBeenCalled();
+    expect(remote.click).toHaveBeenCalledOnce();
+  });
+
+  it("keeps the generic Fork opener compatible with a Remote Host row", async () => {
+    const remote = sidebarRow("remote-thread", "remote-1");
+    vi.stubGlobal("document", {
+      querySelectorAll: () => [remote],
+      documentElement: {},
+    });
+
+    await openRendererThread(hostThreadIdSchema.parse("remote-thread"));
+
+    expect(remote.click).toHaveBeenCalledOnce();
+  });
+
+  it("opens a delayed Host-qualified row and releases its observer", async () => {
+    const local = sidebarRow("delayed-thread", "local");
+    let rows: HTMLElement[] = [];
+    const callbacks: MutationCallback[] = [];
+    const disconnect = vi.fn();
+    class FakeMutationObserver {
+      constructor(callback: MutationCallback) {
+        callbacks.push(callback);
+      }
+      observe = vi.fn();
+      disconnect = disconnect;
+    }
+    vi.stubGlobal("document", {
+      querySelectorAll: () => rows,
+      documentElement: {},
+    });
+    vi.stubGlobal("window", {
+      setTimeout: globalThis.setTimeout,
+      clearTimeout: globalThis.clearTimeout,
+    });
+    vi.stubGlobal("MutationObserver", FakeMutationObserver);
+    const opening = openRendererThread(hostThreadIdSchema.parse("delayed-thread"), {
+      hostId: "local",
+      timeoutMs: 60_000,
+    });
+
+    rows = [local];
+    const notify = callbacks[0];
+    if (!notify) throw new Error("Sidebar observer was not installed");
+    notify([], {} as MutationObserver);
+    await opening;
+
+    expect(local.click).toHaveBeenCalledOnce();
+    expect(disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("aborts a pending sidebar wait and releases its observer", async () => {
+    const disconnect = vi.fn();
+    class FakeMutationObserver {
+      observe = vi.fn();
+      disconnect = disconnect;
+    }
+    vi.stubGlobal("document", { querySelectorAll: () => [], documentElement: {} });
+    vi.stubGlobal("window", {
+      setTimeout: globalThis.setTimeout,
+      clearTimeout: globalThis.clearTimeout,
+    });
+    vi.stubGlobal("MutationObserver", FakeMutationObserver);
+    const abort = new AbortController();
+    const opening = openRendererThread(hostThreadIdSchema.parse("pending-thread"), {
+      hostId: "remote-1",
+      signal: abort.signal,
+      timeoutMs: 60_000,
+    });
+
+    abort.abort();
+
+    await expect(opening).rejects.toMatchObject({ name: "AbortError" });
+    expect(disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("times out a missing sidebar row and releases its observer", async () => {
+    vi.useFakeTimers();
+    const disconnect = vi.fn();
+    class FakeMutationObserver {
+      observe = vi.fn();
+      disconnect = disconnect;
+    }
+    vi.stubGlobal("document", { querySelectorAll: () => [], documentElement: {} });
+    vi.stubGlobal("window", {
+      setTimeout: globalThis.setTimeout,
+      clearTimeout: globalThis.clearTimeout,
+    });
+    vi.stubGlobal("MutationObserver", FakeMutationObserver);
+    const opening = openRendererThread(hostThreadIdSchema.parse("missing-thread"), {
+      hostId: "local",
+      timeoutMs: 5,
+    });
+    const rejection = expect(opening).rejects.toThrow("Thread did not appear in the sidebar");
+
+    await vi.advanceTimersByTimeAsync(5);
+
+    await rejection;
+    expect(disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("resolves a Fork button only when DOM and Fiber identities agree", () => {
+    expect(rendererForkTargetFromButton(forkButton())).toMatchObject({
+      isProjectlessConversation: false,
+      threadId: "source-thread",
+      turnId: "source-turn",
+    });
+    expect(
+      rendererForkTargetFromButton(forkButton({ fiberThreadId: "different-thread" })),
+    ).toBeNull();
+    expect(rendererForkTargetFromButton(forkButton({ fiberTurnId: "different-turn" }))).toBeNull();
+    expect(rendererForkTargetFromButton(forkButton({ forkSignature: false }))).toBeNull();
+    expect(rendererForkTargetFromButton(forkButton({ projectlessSignature: false }))).toBeNull();
+  });
+
+  it("intercepts a projectless external Fork and opens the derived Thread", async () => {
+    const dom = new FakeForkDom();
+    const client = clientWith({
+      owner: "external",
+      harnessId: "pi",
+      transportModelId: "codexhost/pi-native",
+      history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: false },
+      locked: true,
+    });
+    const control = installRendererForkControl({ getClient: () => client, dom });
+
+    expect(dom.emit(target())).toBe(true);
+    await settle();
+
+    expect(client.forkThread).toHaveBeenCalledWith({
+      threadId: "source-thread",
+      lastTurnId: "source-turn",
+    });
+    expect(dom.openThread).toHaveBeenCalledWith("derived-thread");
+    expect(dom.replay).not.toHaveBeenCalled();
+    control.dispose();
+  });
+
+  it("replays the native destination flow for a project external Thread", async () => {
+    const dom = new FakeForkDom();
+    const client = clientWith({
+      owner: "external",
+      harnessId: "pi",
+      transportModelId: "codexhost/pi-native",
+      history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: false },
+      locked: true,
+    });
+    const source = target(false);
+    const control = installRendererForkControl({ getClient: () => client, dom });
+
+    expect(dom.emit(source)).toBe(true);
+    await settle();
+
+    expect(dom.replay).toHaveBeenCalledWith(source);
+    expect(client.forkThread).not.toHaveBeenCalled();
+    control.dispose();
+  });
+
+  it("replays the native destination flow for a project Thread without cross-cwd capability", async () => {
+    const dom = new FakeForkDom();
+    const client = clientWith({
+      owner: "external",
+      harnessId: "claude-code",
+      transportModelId: "codexhost/claude-code-native",
+      history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: false },
+      locked: true,
+    });
+    const source = target(false);
+    const control = installRendererForkControl({ getClient: () => client, dom });
+
+    expect(dom.emit(source)).toBe(true);
+    await settle();
+
+    expect(dom.replay).toHaveBeenCalledWith(source);
+    expect(client.forkThread).not.toHaveBeenCalled();
+    expect(dom.openThread).not.toHaveBeenCalled();
+    control.dispose();
+  });
+
+  it("replays the native action for a Codex-owned Thread", async () => {
+    const dom = new FakeForkDom();
+    const client = clientWith({ owner: "codex", locked: true });
+    const source = target();
+    const control = installRendererForkControl({ getClient: () => client, dom });
+
+    expect(dom.emit(source)).toBe(true);
+    await settle();
+
+    expect(dom.replay).toHaveBeenCalledWith(source);
+    expect(client.forkThread).not.toHaveBeenCalled();
+    control.dispose();
+  });
+
+  it("leaves the native action untouched when the fixed request client is unavailable", () => {
+    const dom = new FakeForkDom();
+    const control = installRendererForkControl({ getClient: () => null, dom });
+
+    expect(dom.emit(target())).toBe(false);
+    control.dispose();
+    expect(dom.listener).toBeNull();
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-harness-command-claim.test.ts

@@ -0,0 +1,167 @@
+import {
+  harnessCommandDescriptorSchema,
+  type HarnessCommandDescriptor,
+} from "@codexhost/shared-contracts";
+import { describe, expect, it, vi } from "vitest";
+
+import { routeRendererHarnessCommandSelection } from "../src/renderer-harness-command-claim.js";
+
+const textCommand = {
+  id: "dsh.goal",
+  invocation: "/dsh-goal",
+  label: "Goal",
+  argumentMode: "text",
+} as HarnessCommandDescriptor;
+
+const noneCommand = {
+  id: "dsh.compact",
+  invocation: "/compact",
+  label: "Compact",
+  argumentMode: "none",
+} as HarnessCommandDescriptor;
+
+class FakeInputEvent {
+  constructor(
+    readonly type: string,
+    readonly init: Record<string, unknown>,
+  ) {}
+}
+
+class FakeTextarea {
+  #value = "keep this draft";
+  selectionStart: number | null = 5;
+  selectionEnd: number | null = 9;
+  readonly events: FakeInputEvent[] = [];
+  readonly focus = vi.fn();
+  readonly setSelectionRange = vi.fn();
+  readonly ownerDocument = {
+    defaultView: {
+      HTMLTextAreaElement: FakeTextarea,
+      InputEvent: FakeInputEvent,
+    },
+  };
+
+  get value(): string {
+    return this.#value;
+  }
+
+  set value(value: string) {
+    this.#value = value;
+  }
+
+  dispatchEvent(event: FakeInputEvent): boolean {
+    this.events.push(event);
+    return true;
+  }
+}
+
+describe("Renderer Harness command Composer claims", () => {
+  it("prefixes a textarea draft and leaves execution to the normal submit path", () => {
+    const editor = new FakeTextarea();
+    const execute = vi.fn();
+
+    expect(
+      routeRendererHarnessCommandSelection(editor as unknown as HTMLElement, textCommand, execute),
+    ).toBe(true);
+    expect(editor.value).toBe("/dsh-goal keep this draft");
+    expect(editor.events).toHaveLength(1);
+    expect(editor.events[0]).toMatchObject({
+      type: "input",
+      init: { bubbles: true, data: "/dsh-goal ", inputType: "insertText" },
+    });
+    expect(editor.setSelectionRange).toHaveBeenCalledWith(15, 19);
+    expect(editor.focus).toHaveBeenCalledWith({ preventScroll: true });
+    expect(execute).not.toHaveBeenCalled();
+  });
+
+  it("uses Chromium insertText for a Lexical contenteditable without replacing its draft", () => {
+    const range = {
+      selectNodeContents: vi.fn(),
+      collapse: vi.fn(),
+    };
+    const selection = {
+      removeAllRanges: vi.fn(),
+      addRange: vi.fn(),
+    };
+    const editor = {
+      textContent: "existing rich draft",
+      getAttribute: (name: string) => (name === "contenteditable" ? "true" : null),
+      focus: vi.fn(),
+    };
+    const execCommand = vi.fn((_command: string, _showUi: boolean, prefix: string) => {
+      editor.textContent = prefix + editor.textContent;
+      return true;
+    });
+    Object.assign(editor, {
+      ownerDocument: {
+        defaultView: { HTMLTextAreaElement: FakeTextarea },
+        createRange: () => range,
+        execCommand,
+        getSelection: () => selection,
+      },
+    });
+    const execute = vi.fn();
+
+    expect(
+      routeRendererHarnessCommandSelection(editor as unknown as HTMLElement, textCommand, execute),
+    ).toBe(true);
+    expect(range.selectNodeContents).toHaveBeenCalledWith(editor);
+    expect(range.collapse).toHaveBeenCalledWith(true);
+    expect(execCommand).toHaveBeenCalledWith("insertText", false, "/dsh-goal ");
+    expect(editor.textContent).toBe("/dsh-goal existing rich draft");
+    expect(execute).not.toHaveBeenCalled();
+  });
+
+  it("fails closed when contenteditable insertion is unavailable", () => {
+    const editor = {
+      textContent: "keep this draft",
+      getAttribute: () => "true",
+      focus: vi.fn(),
+      ownerDocument: {
+        defaultView: { HTMLTextAreaElement: FakeTextarea },
+        createRange: () => ({ selectNodeContents: vi.fn(), collapse: vi.fn() }),
+        execCommand: vi.fn(() => false),
+        getSelection: () => ({ removeAllRanges: vi.fn(), addRange: vi.fn() }),
+      },
+    };
+    const execute = vi.fn();
+
+    expect(
+      routeRendererHarnessCommandSelection(editor as unknown as HTMLElement, textCommand, execute),
+    ).toBe(false);
+    expect(editor.textContent).toBe("keep this draft");
+    expect(execute).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["claude.compact", "text"],
+    ["pi.compact", "text"],
+    ["omp.compact", "text"],
+    ["grok.compact", "text"],
+    ["opencode.compact", "none"],
+    ["dsh.compact", "none"],
+  ] as const)("executes %s directly without changing the draft", (id, argumentMode) => {
+    const editor = new FakeTextarea();
+    const execute = vi.fn();
+    const command = harnessCommandDescriptorSchema.parse({ ...noneCommand, id, argumentMode });
+
+    expect(
+      routeRendererHarnessCommandSelection(editor as unknown as HTMLElement, command, execute),
+    ).toBe(true);
+    expect(execute).toHaveBeenCalledOnce();
+    expect(editor.value).toBe("keep this draft");
+    expect(editor.events).toHaveLength(0);
+    expect(editor.focus).not.toHaveBeenCalled();
+
+    execute.mockClear();
+    expect(routeRendererHarnessCommandSelection(null, command, execute)).toBe(true);
+    expect(execute).toHaveBeenCalledOnce();
+  });
+
+  it("keeps argument-free commands on detached execution", () => {
+    const execute = vi.fn();
+
+    expect(routeRendererHarnessCommandSelection(null, noneCommand, execute)).toBe(true);
+    expect(execute).toHaveBeenCalledOnce();
+  });
+});

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

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+
+import type { HarnessCommandDescriptor } from "@codexhost/shared-contracts";
+
+import {
+  rendererHarnessCommandPresentation,
+  rendererHarnessMessages,
+} from "../src/renderer-harness-localization.js";
+
+const compactCommand = {
+  id: "pi.compact",
+  invocation: "/compact",
+  label: "Compact context",
+  description: "Compact the current conversation context",
+  argumentMode: "text",
+} as HarnessCommandDescriptor;
+
+const customCommand = {
+  id: "custom.explain",
+  invocation: "/explain",
+  label: "Explain",
+  description: "Explain the current change",
+  argumentMode: "none",
+} as HarnessCommandDescriptor;
+
+describe("Renderer Harness command localization", () => {
+  it("uses Chinese chrome and compact copy for the Chinese settings locale", () => {
+    expect(rendererHarnessMessages("zh-CN")).toMatchObject({
+      commands: "命令",
+      harnessCommands: "Harness 命令",
+      textArgument: "文本",
+    });
+    expect(rendererHarnessCommandPresentation(compactCommand, "zh-CN")).toEqual({
+      label: "压缩上下文",
+      description: "压缩当前对话上下文",
+    });
+  });
+
+  it("keeps current English and unknown command copy outside Chinese", () => {
+    expect(rendererHarnessMessages("en")).toMatchObject({
+      commands: "Commands",
+      harnessCommands: "Harness commands",
+      textArgument: "Text",
+    });
+    expect(rendererHarnessCommandPresentation(compactCommand, "en")).toEqual({
+      label: "Compact context",
+      description: "Compact the current conversation context",
+    });
+    expect(rendererHarnessCommandPresentation(customCommand, "zh-CN")).toEqual({
+      label: "Explain",
+      description: "Explain the current change",
+    });
+  });
+});