@vellumai/assistant 0.6.5 → 0.7.0

package/src/ipc/__tests__/ui-request-route.test.ts

@@ -1,31 +1,69 @@
 /**
  * Integration tests for the `ui_request` IPC route.
  *
- * Exercises the full IPC round-trip: CliIpcServer + cliIpcCall over
- * the Unix domain socket, with mock interactive UI resolvers to verify
- * submit / cancel / timeout, unknown-conversation, and non-interactive
- * failure scenarios.
+ * Exercises the full IPC round-trip: AssistantIpcServer + cliIpcCall over
+ * the Unix domain socket, with mock findConversation / showStandaloneSurface
+ * to verify submit / cancel / timeout, unknown-conversation, and
+ * non-interactive failure scenarios.
  */
 
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type {
-  InteractiveUiRequest,
-  InteractiveUiResult,
-} from "../../runtime/interactive-ui.js";
-import {
-  registerInteractiveUiResolver,
-  resetInteractiveUiResolverForTests,
-  resetSurfaceIdCounterForTests,
-} from "../../runtime/interactive-ui.js";
-import { cliIpcCall } from "../cli-client.js";
-import { CliIpcServer } from "../cli-server.js";
+import type { InteractiveUiResult } from "../../runtime/interactive-ui.js";
+
+// ---------------------------------------------------------------------------
+// Mock state — controls what requestInteractiveUi sees
+// ---------------------------------------------------------------------------
+
+/** When non-null, findConversation returns this object. */
+let mockConversation: Record<string, unknown> | null = {
+  conversationId: "conv-test-123",
+  hasNoClient: false,
+};
+
+/** The result showStandaloneSurface will resolve with. */
+let mockSurfaceResult: InteractiveUiResult = {
+  status: "submitted",
+  actionId: "confirm",
+  surfaceId: "mock-surface-1",
+};
+
+/** When non-null, showStandaloneSurface throws this error. */
+let mockSurfaceThrows: Error | null = null;
+
+// Re-export the real module and override only findConversation.
+const realStore = await import("../../daemon/conversation-store.js");
+mock.module("../../daemon/conversation-store.js", () => ({
+  ...realStore,
+  findConversation: (_conversationId: string) => mockConversation ?? undefined,
+}));
+
+// Re-export the real module and override only showStandaloneSurface.
+// The full module has many exports consumed transitively by the IPC server.
+const realSurfaces = await import("../../daemon/conversation-surfaces.js");
+mock.module("../../daemon/conversation-surfaces.js", () => ({
+  ...realSurfaces,
+  showStandaloneSurface: async (
+    _ctx: unknown,
+    _request: unknown,
+    _surfaceId: string,
+  ) => {
+    if (mockSurfaceThrows) throw mockSurfaceThrows;
+    return mockSurfaceResult;
+  },
+}));
+
+// Import after mocking so the mock bindings are picked up
+const { resetSurfaceIdCounterForTests } =
+  await import("../../runtime/interactive-ui.js");
+const { AssistantIpcServer } = await import("../assistant-server.js");
+const { cliIpcCall } = await import("../cli-client.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-let server: CliIpcServer | null = null;
+let server: InstanceType<typeof AssistantIpcServer> | null = null;
 
 function baseParams(
   overrides?: Partial<Record<string, unknown>>,
@@ -39,10 +77,16 @@ function baseParams(
 }
 
 beforeEach(async () => {
-  resetInteractiveUiResolverForTests();
   resetSurfaceIdCounterForTests();
-  server = new CliIpcServer();
-  server.start();
+  mockConversation = { conversationId: "conv-test-123", hasNoClient: false };
+  mockSurfaceResult = {
+    status: "submitted",
+    actionId: "confirm",
+    surfaceId: "mock-surface-1",
+  };
+  mockSurfaceThrows = null;
+  server = new AssistantIpcServer();
+  await server.start();
   // Allow the server socket to bind.
   await new Promise((resolve) => setTimeout(resolve, 50));
 });
@@ -50,7 +94,6 @@ beforeEach(async () => {
 afterEach(() => {
   server?.stop();
   server = null;
-  resetInteractiveUiResolverForTests();
   resetSurfaceIdCounterForTests();
 });
 
@@ -62,20 +105,20 @@ describe("ui_request IPC route", () => {
   // ── Submit ────────────────────────────────────────────────────────
 
   test("returns submitted result when user selects an action", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "submitted",
-        actionId: "confirm",
-        surfaceId: "mock-surface-1",
-      }),
-    );
+    mockSurfaceResult = {
+      status: "submitted",
+      actionId: "confirm",
+      surfaceId: "mock-surface-1",
+    };
 
     const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
-      ...baseParams(),
-      actions: [
-        { id: "confirm", label: "Yes", variant: "primary" },
-        { id: "deny", label: "No", variant: "secondary" },
-      ],
+      body: {
+        ...baseParams(),
+        actions: [
+          { id: "confirm", label: "Yes", variant: "primary" },
+          { id: "deny", label: "No", variant: "secondary" },
+        ],
+      },
     });
 
     expect(result.ok).toBe(true);
@@ -88,17 +131,14 @@ describe("ui_request IPC route", () => {
   // ── Cancel ────────────────────────────────────────────────────────
 
   test("returns cancelled result when user dismisses the surface", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "cancelled",
-        surfaceId: "mock-surface-2",
-      }),
-    );
-
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams(),
-    );
+    mockSurfaceResult = {
+      status: "cancelled",
+      surfaceId: "mock-surface-2",
+    };
+
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams(),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
@@ -108,36 +148,29 @@ describe("ui_request IPC route", () => {
   // ── Timeout ───────────────────────────────────────────────────────
 
   test("returns timed_out result when the surface times out", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "timed_out",
-        surfaceId: "mock-surface-3",
-      }),
-    );
-
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams({ timeoutMs: 1000 }),
-    );
+    mockSurfaceResult = {
+      status: "timed_out",
+      surfaceId: "mock-surface-3",
+    };
+
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams({ timeoutMs: 1000 }),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
     expect(result.result!.status).toBe("timed_out");
   });
 
-  // ── Unknown conversation (resolver throws) ────────────────────────
+  // ── showStandaloneSurface throws (resolver_error) ─────────────────
 
-  test("returns cancelled with resolver_error reason when resolver throws for unknown conversation", async () => {
-    registerInteractiveUiResolver(async (_req: InteractiveUiRequest) => {
-      throw new Error("Unknown conversation: conv-nonexistent");
-    });
+  test("returns cancelled with resolver_error reason when showStandaloneSurface throws", async () => {
+    mockSurfaceThrows = new Error("Surface rendering failed");
 
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams({ conversationId: "conv-nonexistent" }),
-    );
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams({ conversationId: "conv-nonexistent" }),
+    });
 
-    // requestInteractiveUi catches resolver errors and fails closed
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
     expect(result.result!.status).toBe("cancelled");
@@ -145,21 +178,19 @@ describe("ui_request IPC route", () => {
     expect(result.result!.surfaceId).toBeDefined();
   });
 
-  // ── Non-interactive failure (no resolver registered) ──────────────
+  // ── Conversation not in memory (fail-closed) ─────────────────────
 
-  test("returns cancelled with no_interactive_surface reason when no resolver is registered", async () => {
-    // No resolver registered — resetInteractiveUiResolverForTests()
-    // was called in beforeEach, so the module-level resolver is null.
+  test("returns cancelled with conversation_not_found when conversation is not in memory", async () => {
+    mockConversation = null;
 
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams(),
-    );
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams(),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
     expect(result.result!.status).toBe("cancelled");
-    expect(result.result!.cancellationReason).toBe("no_interactive_surface");
+    expect(result.result!.cancellationReason).toBe("conversation_not_found");
     expect(result.result!.surfaceId).toBeDefined();
   });
 
@@ -167,8 +198,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects missing conversationId", async () => {
     const result = await cliIpcCall("ui_request", {
-      surfaceType: "confirmation",
-      data: { message: "test" },
+      body: {
+        surfaceType: "confirmation",
+        data: { message: "test" },
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -177,9 +210,11 @@ describe("ui_request IPC route", () => {
 
   test("rejects empty conversationId", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "",
-      surfaceType: "confirmation",
-      data: { message: "test" },
+      body: {
+        conversationId: "",
+        surfaceType: "confirmation",
+        data: { message: "test" },
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -188,9 +223,11 @@ describe("ui_request IPC route", () => {
 
   test("rejects invalid surfaceType", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "conv-1",
-      surfaceType: "unsupported",
-      data: {},
+      body: {
+        conversationId: "conv-1",
+        surfaceType: "unsupported",
+        data: {},
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -199,8 +236,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects missing data field", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "conv-1",
-      surfaceType: "confirmation",
+      body: {
+        conversationId: "conv-1",
+        surfaceType: "confirmation",
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -209,10 +248,12 @@ describe("ui_request IPC route", () => {
 
   test("rejects non-positive timeoutMs", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "conv-1",
-      surfaceType: "confirmation",
-      data: {},
-      timeoutMs: 0,
+      body: {
+        conversationId: "conv-1",
+        surfaceType: "confirmation",
+        data: {},
+        timeoutMs: 0,
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -221,10 +262,12 @@ describe("ui_request IPC route", () => {
 
   test("rejects non-integer timeoutMs", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "conv-1",
-      surfaceType: "confirmation",
-      data: {},
-      timeoutMs: 1.5,
+      body: {
+        conversationId: "conv-1",
+        surfaceType: "confirmation",
+        data: {},
+        timeoutMs: 1.5,
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -233,10 +276,12 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with empty id", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "conv-1",
-      surfaceType: "confirmation",
-      data: {},
-      actions: [{ id: "", label: "OK" }],
+      body: {
+        conversationId: "conv-1",
+        surfaceType: "confirmation",
+        data: {},
+        actions: [{ id: "", label: "OK" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -245,10 +290,12 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with empty label", async () => {
     const result = await cliIpcCall("ui_request", {
-      conversationId: "conv-1",
-      surfaceType: "confirmation",
-      data: {},
-      actions: [{ id: "ok", label: "" }],
+      body: {
+        conversationId: "conv-1",
+        surfaceType: "confirmation",
+        data: {},
+        actions: [{ id: "ok", label: "" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -259,8 +306,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with reserved id 'selection_changed'", async () => {
     const result = await cliIpcCall("ui_request", {
-      ...baseParams(),
-      actions: [{ id: "selection_changed", label: "Select" }],
+      body: {
+        ...baseParams(),
+        actions: [{ id: "selection_changed", label: "Select" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -270,8 +319,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with reserved id 'content_changed'", async () => {
     const result = await cliIpcCall("ui_request", {
-      ...baseParams(),
-      actions: [{ id: "content_changed", label: "Change" }],
+      body: {
+        ...baseParams(),
+        actions: [{ id: "content_changed", label: "Change" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -281,8 +332,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with reserved id 'state_update'", async () => {
     const result = await cliIpcCall("ui_request", {
-      ...baseParams(),
-      actions: [{ id: "state_update", label: "Update" }],
+      body: {
+        ...baseParams(),
+        actions: [{ id: "state_update", label: "Update" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -292,8 +345,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with reserved id 'cancel'", async () => {
     const result = await cliIpcCall("ui_request", {
-      ...baseParams(),
-      actions: [{ id: "cancel", label: "Cancel" }],
+      body: {
+        ...baseParams(),
+        actions: [{ id: "cancel", label: "Cancel" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -303,8 +358,10 @@ describe("ui_request IPC route", () => {
 
   test("rejects action with reserved id 'dismiss'", async () => {
     const result = await cliIpcCall("ui_request", {
-      ...baseParams(),
-      actions: [{ id: "dismiss", label: "Dismiss" }],
+      body: {
+        ...baseParams(),
+        actions: [{ id: "dismiss", label: "Dismiss" }],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -314,11 +371,13 @@ describe("ui_request IPC route", () => {
 
   test("rejects when any action in the array uses a reserved id", async () => {
     const result = await cliIpcCall("ui_request", {
-      ...baseParams(),
-      actions: [
-        { id: "approve", label: "Approve" },
-        { id: "state_update", label: "Bad Action" },
-      ],
+      body: {
+        ...baseParams(),
+        actions: [
+          { id: "approve", label: "Approve" },
+          { id: "state_update", label: "Bad Action" },
+        ],
+      },
     });
 
     expect(result.ok).toBe(false);
@@ -329,19 +388,16 @@ describe("ui_request IPC route", () => {
   // ── Optional fields ───────────────────────────────────────────────
 
   test("accepts request with optional title", async () => {
-    registerInteractiveUiResolver(
-      async (req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "submitted",
-        actionId: "ok",
-        surfaceId: "mock-surface-title",
-        summary: req.title,
-      }),
-    );
-
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams({ title: "Confirm Action" }),
-    );
+    mockSurfaceResult = {
+      status: "submitted",
+      actionId: "ok",
+      surfaceId: "mock-surface-title",
+      summary: "Confirm Action",
+    };
+
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams({ title: "Confirm Action" }),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result!.status).toBe("submitted");
@@ -350,19 +406,16 @@ describe("ui_request IPC route", () => {
 
   // ── Cancellation reason round-trip ────────────────────────────────
 
-  test("round-trips user_dismissed cancellation reason from resolver", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "cancelled",
-        surfaceId: "mock-surface-dismissed",
-        cancellationReason: "user_dismissed",
-      }),
-    );
+  test("round-trips user_dismissed cancellation reason", async () => {
+    mockSurfaceResult = {
+      status: "cancelled",
+      surfaceId: "mock-surface-dismissed",
+      cancellationReason: "user_dismissed",
+    };
 
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams(),
-    );
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams(),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
@@ -370,19 +423,12 @@ describe("ui_request IPC route", () => {
     expect(result.result!.cancellationReason).toBe("user_dismissed");
   });
 
-  test("round-trips conversation_not_found cancellation reason from resolver", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "cancelled",
-        surfaceId: "mock-surface-not-found",
-        cancellationReason: "conversation_not_found",
-      }),
-    );
+  test("round-trips conversation_not_found cancellation reason", async () => {
+    mockConversation = null;
 
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams({ conversationId: "conv-missing" }),
-    );
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams({ conversationId: "conv-missing" }),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
@@ -391,18 +437,15 @@ describe("ui_request IPC route", () => {
   });
 
   test("submitted result does not carry cancellationReason through IPC", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "submitted",
-        actionId: "confirm",
-        surfaceId: "mock-surface-submitted",
-      }),
-    );
-
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams(),
-    );
+    mockSurfaceResult = {
+      status: "submitted",
+      actionId: "confirm",
+      surfaceId: "mock-surface-submitted",
+    };
+
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams(),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
@@ -410,56 +453,38 @@ describe("ui_request IPC route", () => {
     expect(result.result!.cancellationReason).toBeUndefined();
   });
 
-  // ── Persisted-but-not-loaded conversation (hydration path) ─────────
-
-  test("succeeds for a valid persisted-but-not-loaded conversation ID", async () => {
-    // Simulates the daemon resolver's Step B: the conversation was
-    // evicted from memory but still exists in persistent storage.
-    // The resolver hydrates it and delegates to the surface lifecycle.
-    const hydratedConversationId = "conv-persisted-not-loaded";
-    registerInteractiveUiResolver(
-      async (req: InteractiveUiRequest): Promise<InteractiveUiResult> => {
-        // Simulate successful hydration: the resolver found the
-        // conversation in storage and reconstituted it.
-        expect(req.conversationId).toBe(hydratedConversationId);
-        return {
-          status: "submitted",
-          actionId: "confirm",
-          surfaceId: `hydrated-surface-${req.conversationId}`,
-        };
-      },
-    );
+  // ── Conversation found — surface succeeds ─────────────────────────
+
+  test("succeeds when conversation is in memory", async () => {
+    mockConversation = {
+      conversationId: "conv-in-memory",
+      hasNoClient: false,
+    };
+    mockSurfaceResult = {
+      status: "submitted",
+      actionId: "confirm",
+      surfaceId: "hydrated-surface-conv-in-memory",
+    };
 
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams({ conversationId: hydratedConversationId }),
-    );
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams({ conversationId: "conv-in-memory" }),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
     expect(result.result!.status).toBe("submitted");
     expect(result.result!.actionId).toBe("confirm");
-    expect(result.result!.surfaceId).toContain(hydratedConversationId);
+    expect(result.result!.surfaceId).toContain("conv-in-memory");
   });
 
-  // ── Truly unknown conversation ID ─────────────────────────────────
-
-  test("returns cancelled with conversation_not_found for truly unknown conversation ID", async () => {
-    // Simulates the daemon resolver when the conversation does not
-    // exist in memory OR in persistent storage — the resolver returns
-    // conversation_not_found without throwing.
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "cancelled",
-        surfaceId: `ui-resolver-not-found`,
-        cancellationReason: "conversation_not_found",
-      }),
-    );
-
-    const result = await cliIpcCall<InteractiveUiResult>(
-      "ui_request",
-      baseParams({ conversationId: "conv-truly-unknown-xyz" }),
-    );
+  // ── Conversation not in memory ────────────────────────────────────
+
+  test("returns cancelled with conversation_not_found for unknown conversation ID", async () => {
+    mockConversation = null;
+
+    const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
+      body: baseParams({ conversationId: "conv-truly-unknown-xyz" }),
+    });
 
     expect(result.ok).toBe(true);
     expect(result.result).toBeDefined();
@@ -471,18 +496,18 @@ describe("ui_request IPC route", () => {
   // ── Optional fields (continued) ────────────────────────────────────
 
   test("accepts form surfaceType with submittedData", async () => {
-    registerInteractiveUiResolver(
-      async (_req: InteractiveUiRequest): Promise<InteractiveUiResult> => ({
-        status: "submitted",
-        submittedData: { name: "Alice", email: "alice@example.com" },
-        surfaceId: "mock-surface-form",
-      }),
-    );
+    mockSurfaceResult = {
+      status: "submitted",
+      submittedData: { name: "Alice", email: "alice@example.com" },
+      surfaceId: "mock-surface-form",
+    };
 
     const result = await cliIpcCall<InteractiveUiResult>("ui_request", {
-      conversationId: "conv-form",
-      surfaceType: "form",
-      data: { fields: [{ name: "name" }, { name: "email" }] },
+      body: {
+        conversationId: "conv-form",
+        surfaceType: "form",
+        data: { fields: [{ name: "name" }, { name: "email" }] },
+      },
     });
 
     expect(result.ok).toBe(true);