@harness-mix/cli 0.1.3

package/src/native-ui/renderer-extension/test/renderer-external-steering.test.ts

@@ -0,0 +1,279 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { installRendererExternalSteering } from "../src/renderer-external-steering.js";
+
+function fixture(owner: "external" | "codex" = "external") {
+  const events: string[] = [];
+  const requestOptions: Record<string, unknown> = { timeoutMs: 30_000 };
+  let queued: Array<{ id: string; pausedReason?: string }> = [];
+  const originalTurn = {
+    turnId: "old",
+    status: "inProgress",
+    input: "original",
+    steeringItems: [],
+  };
+  const turns = [originalTurn];
+  const rpc = vi.fn(
+    async (method: unknown, params: unknown, options?: unknown): Promise<unknown> => {
+      void options;
+      if (method === "codexhost/thread/ownership/list") {
+        return {
+          threads: [
+            { threadId: "thread", owner, ...(owner === "external" ? { harnessId: "pi" } : {}) },
+          ],
+        };
+      }
+      if (method === "turn/steer") {
+        events.push("cancel old");
+        originalTurn.status = "interrupted";
+        queued = queued.map((message) => ({
+          ...message,
+          pausedReason: message.pausedReason ?? "Interrupted before the steer was accepted.",
+        }));
+        events.push("old completed");
+        return { turnId: "replacement" };
+      }
+      return { method, params };
+    },
+  );
+  const manager = {
+    sendRequest: rpc,
+    steerTurn: vi
+      .fn<(...args: unknown[]) => Promise<{ turnId: string }>>()
+      .mockResolvedValue({ turnId: "official" }),
+    getStreamRole: vi.fn(() => ({ role: "owner" })),
+    getTurnCoordinator: () => ({
+      loadMessages: async () => undefined,
+      readMessages: () => queued,
+      mutate: (_threadId: string, update: (messages: typeof queued) => typeof queued) => {
+        queued = update(queued);
+      },
+      options: {
+        submissionHost: {
+          getActiveTurnId: () =>
+            turns.at(-1)?.status === "inProgress" ? turns.at(-1)?.turnId : null,
+          hasPendingTurnStart: () => false,
+        },
+      },
+    }),
+    startTurn: vi.fn(async (...args: unknown[]) => {
+      const operation = args[1] as {
+        request: { input: Array<{ text: string }>; clientUserMessageId: string };
+        context: unknown;
+      };
+      const placeholder = {
+        turnId: "",
+        status: "inProgress",
+        input: operation.request.input[0]?.text ?? "",
+        steeringItems: [],
+      };
+      turns.push(placeholder);
+      events.push("new input displayed");
+      if (typeof args[2] === "function") await args[2]();
+      const response = (await manager.sendRequest(
+        "turn/start",
+        operation.request,
+        requestOptions,
+      )) as { turn: { id: string } };
+      placeholder.turnId = response.turn.id;
+      events.push("new identity accepted");
+      return response;
+    }),
+  };
+  const originalSteer = manager.steerTurn;
+  const dispose = installRendererExternalSteering(manager);
+  if (!dispose) throw new Error("Synthetic Renderer steering binding was not installed");
+  const args: unknown[] = [
+    "thread",
+    [{ type: "text", text: "new input", text_elements: [] }],
+    { id: "message", cwd: "/project", context: { commentAttachments: [] } },
+    null,
+    [],
+    "message",
+    null,
+    null,
+    vi.fn(),
+  ];
+  return {
+    manager,
+    rpc,
+    args,
+    events,
+    turns,
+    originalSteer,
+    dispose,
+    requestOptions,
+    queue: {
+      read: () => queued,
+      set: (messages: typeof queued) => {
+        queued = messages;
+      },
+    },
+  };
+}
+
+describe("external direction changes use normal Desktop start presentation", () => {
+  it("creates a new input placeholder, replaces through steer RPC, and never creates an old steering Item", async () => {
+    const f = fixture();
+    // Normal start operations carry their thread identity, as Desktop's start preparation does.
+    await expect(f.manager.steerTurn(...f.args)).resolves.toEqual({ turnId: "replacement" });
+    expect(f.originalSteer).not.toHaveBeenCalled();
+    expect(f.events).toEqual([
+      "new input displayed",
+      "cancel old",
+      "old completed",
+      "new identity accepted",
+    ]);
+    expect(f.turns).toEqual([
+      { turnId: "old", status: "interrupted", input: "original", steeringItems: [] },
+      { turnId: "replacement", status: "inProgress", input: "new input", steeringItems: [] },
+    ]);
+    expect(f.rpc).toHaveBeenLastCalledWith(
+      "turn/steer",
+      expect.objectContaining({
+        threadId: "thread",
+        expectedTurnId: "old",
+        clientUserMessageId: "message",
+        input: f.args[1],
+      }),
+      { timeoutMs: 30_000 },
+    );
+    expect(f.args[8]).toHaveBeenCalledOnce();
+    f.dispose();
+  });
+
+  it("passes official steering and unrelated requests through unchanged", async () => {
+    const f = fixture("codex");
+    await expect(f.manager.steerTurn(...f.args)).resolves.toEqual({ turnId: "official" });
+    expect(f.originalSteer).toHaveBeenCalledWith(...f.args);
+    expect(f.manager.startTurn).not.toHaveBeenCalled();
+    await f.manager.sendRequest(
+      "turn/start",
+      { threadId: "other", clientUserMessageId: "message" },
+      { custom: true },
+    );
+    expect(f.rpc).toHaveBeenLastCalledWith(
+      "turn/start",
+      { threadId: "other", clientUserMessageId: "message" },
+      { custom: true },
+    );
+    f.dispose();
+    expect(f.manager.steerTurn).toBe(f.originalSteer);
+    expect(f.manager.sendRequest).toBe(f.rpc);
+  });
+
+  it.each([
+    { input: [] },
+    { input: [{ type: "text", text: " " }] },
+    { input: [{ type: "image", url: "image" }] },
+    {
+      input: [
+        { type: "text", text: "new input" },
+        { type: "localImage", path: "" },
+      ],
+    },
+  ])("rejects unsupported input before cancel or creating a placeholder: %j", async ({ input }) => {
+    const f = fixture();
+    f.args[1] = input;
+    await expect(f.manager.steerTurn(...f.args)).rejects.toThrow("text input");
+    expect(f.manager.startTurn).not.toHaveBeenCalled();
+    expect(f.events).toEqual([]);
+    f.dispose();
+  });
+
+  it("coalesces duplicate messages and rejects competing replacements", async () => {
+    const f = fixture();
+    const waiting = Promise.withResolvers<undefined>();
+    f.args[8] = () => waiting.promise;
+    const first = f.manager.steerTurn(...f.args);
+    await vi.waitFor(() => expect(f.manager.startTurn).toHaveBeenCalledOnce());
+    const duplicate = f.manager.steerTurn(...f.args);
+    const competing = [...f.args];
+    competing[5] = "different-message";
+    await expect(f.manager.steerTurn(...competing)).rejects.toThrow("already changing direction");
+    waiting.resolve(undefined);
+    await expect(first).resolves.toEqual({ turnId: "replacement" });
+    await expect(duplicate).resolves.toEqual({ turnId: "replacement" });
+    expect(f.manager.startTurn).toHaveBeenCalledOnce();
+    expect(f.events.filter((event) => event === "cancel old")).toHaveLength(1);
+    f.dispose();
+  });
+
+  it("retains Desktop outcome-unknown delivery tracking until the replacement is confirmed", async () => {
+    const f = fixture();
+    const response = Promise.withResolvers<unknown>();
+    const unknown = vi.fn();
+    f.requestOptions.onOutcomeUnknown = unknown;
+    const original = f.rpc.getMockImplementation();
+    f.rpc.mockImplementation(async (method, params, options) => {
+      if (method !== "turn/steer") return original?.(method, params, options);
+      expect(options).toBe(f.requestOptions);
+      (options as { onOutcomeUnknown(delivery: unknown): void }).onOutcomeUnknown({
+        requestId: "rpc",
+        method,
+        stage: "outcome-unknown",
+      });
+      return response.promise;
+    });
+    const result = f.manager.steerTurn(...f.args);
+    await vi.waitFor(() => expect(unknown).toHaveBeenCalledOnce());
+    expect(f.events).toEqual(["new input displayed"]);
+    const duplicate = f.manager.steerTurn(...f.args);
+    response.resolve({ turnId: "replacement" });
+    await expect(result).resolves.toEqual({ turnId: "replacement" });
+    await expect(duplicate).resolves.toEqual({ turnId: "replacement" });
+    expect(f.manager.startTurn).toHaveBeenCalledOnce();
+    f.dispose();
+  });
+
+  it("does not fall back to an ordinary start if disposed before dispatch", async () => {
+    const f = fixture();
+    const waiting = Promise.withResolvers<undefined>();
+    f.args[8] = () => waiting.promise;
+    const result = f.manager.steerTurn(...f.args);
+    await vi.waitFor(() => expect(f.manager.startTurn).toHaveBeenCalledOnce());
+    f.dispose();
+    waiting.resolve(undefined);
+    await expect(result).rejects.toThrow("disposed");
+    expect(f.rpc.mock.calls.map(([method]) => method)).toEqual(["codexhost/thread/ownership/list"]);
+  });
+
+  it("resumes automatically paused queue messages without unpausing older paused entries", async () => {
+    const f = fixture();
+    const pausedReason = "Interrupted before the steer was accepted.";
+    f.queue.set([{ id: "queued" }, { id: "previously-paused", pausedReason }]);
+    f.args[8] = () => f.queue.set([...f.queue.read(), { id: "queued-during-replacement" }]);
+    await f.manager.steerTurn(...f.args);
+    expect(f.queue.read()).toEqual([
+      { id: "queued" },
+      { id: "previously-paused", pausedReason },
+      { id: "queued-during-replacement" },
+    ]);
+    f.dispose();
+  });
+
+  it("lets a follower delegate the original steer to its owning window", async () => {
+    const f = fixture();
+    f.manager.getStreamRole.mockReturnValue({ role: "follower" });
+    await expect(f.manager.steerTurn(...f.args)).resolves.toEqual({ turnId: "official" });
+    expect(f.originalSteer).toHaveBeenCalledWith(...f.args);
+    expect(f.rpc).not.toHaveBeenCalled();
+    expect(f.manager.startTurn).not.toHaveBeenCalled();
+    f.dispose();
+  });
+
+  it("does not swallow an ownership failure or retry a failed replacement", async () => {
+    const f = fixture();
+    f.rpc.mockRejectedValueOnce(new Error("ownership unavailable"));
+    await expect(f.manager.steerTurn(...f.args)).rejects.toThrow("ownership unavailable");
+    expect(f.originalSteer).not.toHaveBeenCalled();
+    f.rpc.mockImplementation(async (method) => {
+      if (method === "codexhost/thread/ownership/list")
+        return { threads: [{ threadId: "thread", owner: "external", harnessId: "pi" }] };
+      throw new Error("cancel failed");
+    });
+    await expect(f.manager.steerTurn(...f.args)).rejects.toThrow("cancel failed");
+    expect(f.manager.startTurn).toHaveBeenCalledOnce();
+    f.dispose();
+  });
+});

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();
+  });
+});