fix: improve thread resume dedupe

Author: Dimillian

package-lock.json

@@ -40,6 +40,7 @@
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2",
+    "@testing-library/react": "^16.3.2",
     "@types/prismjs": "^1.26.5",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
@@ -49,6 +50,7 @@
     "eslint": "^8.57.0",
     "eslint-plugin-react": "^7.36.1",
     "eslint-plugin-react-hooks": "^4.6.2",
+    "jsdom": "^27.0.1",
     "typescript": "~5.8.3",
     "vite": "^7.0.4",
     "vitest": "^3.2.4"

package.json

@@ -0,0 +1,167 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { AppServerEvent } from "../../../types";
+import { subscribeAppServerEvents } from "../../../services/events";
+import { useAppServerEvents } from "./useAppServerEvents";
+
+vi.mock("../../../services/events", () => ({
+  subscribeAppServerEvents: vi.fn(),
+}));
+
+type Handlers = Parameters<typeof useAppServerEvents>[0];
+
+function TestHarness({ handlers }: { handlers: Handlers }) {
+  useAppServerEvents(handlers);
+  return null;
+}
+
+let listener: ((event: AppServerEvent) => void) | null = null;
+const unlisten = vi.fn();
+
+beforeEach(() => {
+  listener = null;
+  unlisten.mockReset();
+  vi.mocked(subscribeAppServerEvents).mockImplementation(async (cb) => {
+    listener = cb;
+    return unlisten;
+  });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+async function mount(handlers: Handlers) {
+  const container = document.createElement("div");
+  const root = createRoot(container);
+  await act(async () => {
+    root.render(<TestHarness handlers={handlers} />);
+  });
+  return { root };
+}
+
+describe("useAppServerEvents", () => {
+  it("routes app-server events to handlers", async () => {
+    const handlers: Handlers = {
+      onAppServerEvent: vi.fn(),
+      onWorkspaceConnected: vi.fn(),
+      onAgentMessageDelta: vi.fn(),
+      onApprovalRequest: vi.fn(),
+      onItemCompleted: vi.fn(),
+      onAgentMessageCompleted: vi.fn(),
+    };
+    const { root } = await mount(handlers);
+
+    expect(listener).toBeTypeOf("function");
+
+    act(() => {
+      listener?.({ workspace_id: "ws-1", message: { method: "codex/connected" } });
+    });
+    expect(handlers.onWorkspaceConnected).toHaveBeenCalledWith("ws-1");
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/agentMessage/delta",
+          params: { threadId: "thread-1", itemId: "item-1", delta: "Hello" },
+        },
+      });
+    });
+    expect(handlers.onAgentMessageDelta).toHaveBeenCalledWith({
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      itemId: "item-1",
+      delta: "Hello",
+    });
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "workspace/requestApproval",
+          id: 7,
+          params: { mode: "full" },
+        },
+      });
+    });
+    expect(handlers.onApprovalRequest).toHaveBeenCalledWith({
+      workspace_id: "ws-1",
+      request_id: 7,
+      method: "workspace/requestApproval",
+      params: { mode: "full" },
+    });
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/completed",
+          params: {
+            threadId: "thread-1",
+            item: { type: "agentMessage", id: "item-2", text: "Done" },
+          },
+        },
+      });
+    });
+    expect(handlers.onItemCompleted).toHaveBeenCalledWith("ws-1", "thread-1", {
+      type: "agentMessage",
+      id: "item-2",
+      text: "Done",
+    });
+    expect(handlers.onAgentMessageCompleted).toHaveBeenCalledWith({
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      itemId: "item-2",
+      text: "Done",
+    });
+
+    await act(async () => {
+      root.unmount();
+    });
+    expect(unlisten).toHaveBeenCalledTimes(1);
+  });
+
+  it("ignores delta events missing required fields", async () => {
+    const handlers: Handlers = {
+      onAgentMessageDelta: vi.fn(),
+    };
+    const { root } = await mount(handlers);
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/agentMessage/delta",
+          params: { threadId: "", itemId: "item-1", delta: "Hello" },
+        },
+      });
+    });
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/agentMessage/delta",
+          params: { threadId: "thread-1", itemId: "", delta: "Hello" },
+        },
+      });
+    });
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/agentMessage/delta",
+          params: { threadId: "thread-1", itemId: "item-1", delta: "" },
+        },
+      });
+    });
+
+    expect(handlers.onAgentMessageDelta).not.toHaveBeenCalled();
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});