[codex] structure desktop preview failures

apps/desktop/src/preview/Manager.test.ts

@@ -7,17 +7,18 @@ import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import { TestClock } from "effect/testing";
-import { beforeEach, describe, expect, vi } from "vite-plus/test";
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
 
 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
 import * as BrowserSession from "./BrowserSession.ts";
 import * as PreviewManager from "./Manager.ts";
 
 const { createFromPath, fromId, mkdir, showItemInFolder, webviewSend, writeFile, writeImage } =
   vi.hoisted(() => ({
-    createFromPath: vi.fn(() => ({ isEmpty: () => false })),
+    createFromPath: vi.fn((): { readonly isEmpty: () => boolean } => ({ isEmpty: () => false })),
     fromId: vi.fn(() => null),
     mkdir: vi.fn((_path: string) => undefined),
     showItemInFolder: vi.fn(),
@@ -79,6 +80,7 @@ const layer = PreviewManager.layer.pipe(
   Layer.provideMerge(fileSystemLayer),
   Layer.provideMerge(Path.layer),
 );
+const encodePreviewManagerError = Schema.encodeSync(PreviewManager.PreviewManagerError);
 
 const withManager = <A>(
   use: (
@@ -237,6 +239,20 @@ describe("PreviewManager", () => {
         expect(artifact.path).toMatch(
           /\/browser-artifacts\/browser-screenshot-example-com-[^.]+\.png$/,
         );
+
+        const captureCause = new Error("capture failed");
+        capturePage.mockRejectedValueOnce(captureCause);
+        const exit = yield* Effect.exit(manager.captureScreenshot("tab_1"));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isSuccess(exit)) return;
+        const error = Option.getOrThrow(Cause.findErrorOption(exit.cause));
+        expect(error).toMatchObject({
+          _tag: "PreviewOperationError",
+          operation: "captureScreenshot.capturePage",
+          tabId: "tab_1",
+          webContentsId: 42,
+          cause: captureCause,
+        });
       }),
     ),
   );
@@ -302,9 +318,12 @@ describe("PreviewManager", () => {
         expect(Exit.isFailure(exit)).toBe(true);
         if (Exit.isSuccess(exit)) return;
         const error = Option.getOrThrow(Cause.findErrorOption(exit.cause));
-        expect(error.cause).toMatchObject({
-          message: "Preview artifact path is outside the configured artifact directory.",
+        expect(error).toMatchObject({
+          _tag: "PreviewArtifactPathOutsideDirectoryError",
+          artifactPath: "/tmp/t3/dev/settings.json",
+          artifactDirectory: "/tmp/t3/dev/browser-artifacts",
         });
+        expect("cause" in error).toBe(false);
       }),
     ),
   );
@@ -324,8 +343,20 @@ describe("PreviewManager", () => {
         expect(Exit.isFailure(exit)).toBe(true);
         if (Exit.isSuccess(exit)) return;
         const error = Option.getOrThrow(Cause.findErrorOption(exit.cause));
-        expect(error.cause).toMatchObject({
-          message: "Preview artifact path is outside the configured artifact directory.",
+        expect(error).toMatchObject({
+          _tag: "PreviewArtifactPathOutsideDirectoryError",
+          artifactPath: "/tmp/t3/dev/settings.json",
+          artifactDirectory: "/tmp/t3/dev/browser-artifacts",
+        });
+        expect("cause" in error).toBe(false);
+
+        createFromPath.mockReturnValueOnce({ isEmpty: () => true });
+        const invalidImageExit = yield* Effect.exit(manager.copyArtifactToClipboard(artifactPath));
+        expect(Exit.isFailure(invalidImageExit)).toBe(true);
+        if (Exit.isSuccess(invalidImageExit)) return;
+        expect(Option.getOrThrow(Cause.findErrorOption(invalidImageExit.cause))).toMatchObject({
+          _tag: "PreviewArtifactImageLoadError",
+          artifactPath,
         });
       }),
     ),
@@ -466,10 +497,174 @@ describe("PreviewManager", () => {
         expect(Exit.isFailure(exit)).toBe(true);
         if (Exit.isSuccess(exit)) return;
         const error = Option.getOrThrow(Cause.findErrorOption(exit.cause));
-        expect(error.cause).toMatchObject({
-          name: "PreviewAutomationControlInterruptedError",
+        expect(error).toMatchObject({
+          _tag: "PreviewAutomationControlInterruptedError",
+          operation: "click",
+          tabId: "tab_1",
+          webContentsId: 42,
         });
+        expect(error).toBeInstanceOf(Error);
+        if (error instanceof Error) {
+          expect(error.name).toBe("PreviewAutomationControlInterruptedError");
+        }
+        expect("cause" in error).toBe(false);
       }),
     ),
   );
+
+  effectIt.effect("derives evaluation detail kind and length from the same non-empty source", () =>
+    withManager((manager) =>
+      Effect.gen(function* () {
+        const text = "ReferenceError: fallbackDetail is not defined";
+        const exceptionDetails = {
+          text,
+          exception: { description: "" },
+        };
+        const sendCommand = vi.fn(async (method: string) =>
+          method === "Runtime.evaluate" ? { exceptionDetails } : undefined,
+        );
+        fromId.mockReturnValue({
+          id: 42,
+          isDestroyed: () => false,
+          getType: () => "webview",
+          getURL: () => "https://example.com",
+          getTitle: () => "Example",
+          isLoading: () => false,
+          isDevToolsOpened: () => false,
+          getZoomFactor: () => 1,
+          setZoomFactor: vi.fn(),
+          on: vi.fn(),
+          off: vi.fn(),
+          ipc: { on: vi.fn(), off: vi.fn() },
+          send: webviewSend,
+          navigationHistory: { canGoBack: () => false, canGoForward: () => false },
+          setWindowOpenHandler: vi.fn(),
+          debugger: {
+            isAttached: () => false,
+            attach: vi.fn(),
+            sendCommand,
+            on: vi.fn(),
+            off: vi.fn(),
+          },
+        } as never);
+
+        yield* manager.createTab("tab_1");
+        yield* manager.registerWebview("tab_1", 42);
+        const exit = yield* Effect.exit(
+          manager.automationEvaluate("tab_1", { expression: "fallbackDetail" }),
+        );
+
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isSuccess(exit)) return;
+        const error = Option.getOrThrow(Cause.findErrorOption(exit.cause));
+        expect(error).toMatchObject({
+          _tag: "PreviewAutomationEvaluationError",
+          detailKind: "exception-text",
+          detailLength: text.length,
+          cause: exceptionDetails,
+        });
+      }),
+    ),
+  );
+});
+
+describe("PreviewOperationError", () => {
+  it("keeps timeline detail separate from its structured message", () => {
+    const cause = new Error("CDP command failed with an invalid node id");
+    const error = new PreviewManager.PreviewOperationError({
+      operation: "click.DOM.resolveNode",
+      tabId: "tab_1",
+      webContentsId: 42,
+      cause,
+    });
+
+    expect(error.message).not.toContain(cause.message);
+    expect(PreviewManager.PreviewOperationError.toTimelineMessage(error)).toBe(cause.message);
+  });
+});
+
+describe("Preview automation diagnostics", () => {
+  it("keeps browser exception detail out of structural diagnostics", () => {
+    const secret = "unrelated-browser-payload-secret";
+    const detail = "ReferenceError: missingValue is not defined";
+    const cause = {
+      text: "Uncaught Error",
+      exception: { description: detail },
+      unsafePayload: secret,
+    };
+    const error = new PreviewManager.PreviewAutomationEvaluationError({
+      tabId: "tab_1",
+      detailKind: "exception-description",
+      detailLength: detail.length,
+      cause,
+    });
+
+    const encoded = encodePreviewManagerError(error);
+    const { cause: encodedCause, ...encodedDiagnostics } = encoded as typeof encoded & {
+      readonly cause?: unknown;
+    };
+
+    expect(error.cause).toBe(cause);
+    expect(encodedCause).toStrictEqual(cause);
+    expect(error.message).toBe("Preview JavaScript evaluation failed in tab tab_1");
+    expect(error.message).not.toContain(secret);
+    expect(JSON.stringify(encodedDiagnostics)).not.toContain(secret);
+    expect("detail" in error).toBe(false);
+    expect(PreviewManager.PreviewAutomationEvaluationError.toTimelineMessage(error)).toBe(detail);
+    expect(PreviewManager.PreviewAutomationEvaluationError.toTimelineMessage(error)).not.toContain(
+      secret,
+    );
+  });
+
+  it("retains bounded selector diagnostics without exposing selector or reason text", () => {
+    const selector = "role=button[name='selector-secret']";
+    const reason = "Unexpected token near reason-secret";
+    const cause = { invalidSelector: true as const, message: reason };
+    const error = new PreviewManager.PreviewAutomationInvalidSelectorError({
+      operation: "click",
+      tabId: "tab_1",
+      selectorKind: "locator",
+      selectorLength: selector.length,
+      reasonLength: reason.length,
+      cause,
+    });
+
+    const encoded = encodePreviewManagerError(error);
+    const { cause: encodedCause, ...encodedDiagnostics } = encoded as typeof encoded & {
+      readonly cause?: unknown;
+    };
+
+    expect(error.cause).toBe(cause);
+    expect(encodedCause).toStrictEqual(cause);
+    expect(error).toMatchObject({
+      selectorKind: "locator",
+      selectorLength: selector.length,
+      reasonLength: reason.length,
+    });
+    expect(error.detail).toEqual({
+      selectorKind: "locator",
+      selectorLength: selector.length,
+    });
+    expect(error.message).not.toContain("secret");
+    expect(JSON.stringify(encodedDiagnostics)).not.toContain("secret");
+    expect("selector" in error).toBe(false);
+    expect("reason" in error).toBe(false);
+    expect(PreviewManager.PreviewAutomationInvalidSelectorError.toTimelineMessage(error)).toBe(
+      reason,
+    );
+  });
+
+  it("does not retain a missing target locator", () => {
+    const selector = "[data-token='target-secret']";
+    const error = new PreviewManager.PreviewAutomationTargetNotFoundError({
+      operation: "scroll",
+      tabId: "tab_1",
+      selectorKind: "selector",
+      selectorLength: selector.length,
+    });
+
+    expect(error.message).not.toContain(selector);
+    expect(JSON.stringify(error)).not.toContain(selector);
+    expect("locator" in error).toBe(false);
+  });
 });