Fix preview automation: surface not-editable error, decouple zoom from nav sync, fix clear-only type

Bug 1: NotEditable error not surfaced
- The desktop-side PreviewAutomationTargetNotEditableError was lost when
  crossing the Electron IPC boundary, causing agents/MCP to see a generic
  PreviewAutomationExecutionError instead of a structured not-editable
  response.
- Changed the automationType IPC handler to catch the error and return it
  as structured data ({ notEditable: true }) instead of throwing.
- Added a web-side PreviewAutomationTargetNotEditableError class with its
  own responseTag to the PreviewAutomationHostError union.
- Updated PreviewAutomationHosts to detect the structured result and throw
  the web-side error for proper serialization.

Bug 2: Zoom read blocks nav sync
- syncWebContentsState read getZoomFactor through the same failing attempt
  path as navigation fields. If zoom lookup threw, the whole sync aborted
  and listeners like did-stop-loading never updated navStatus.
- Made the zoom factor read non-fatal with Effect.orElseSucceed, falling
  back to the current tab's zoomFactor when the read fails.

Bug 3: Clear-only type fails incorrectly
- When clear:true with empty text, the in-page typing path used
  document.execCommand('delete') which often returns false on many inputs,
  incorrectly reporting PreviewAutomationTargetNotEditableError.
- Changed clear-only logic to directly set element.value or textContent
  to empty instead of relying on execCommand('delete').

Author: cursoragent

apps/desktop/src/ipc/methods/preview.ts

@@ -277,11 +277,17 @@ export const automationClick = DesktopIpc.makeIpcMethod({
 export const automationType = DesktopIpc.makeIpcMethod({
   channel: IpcChannels.PREVIEW_AUTOMATION_TYPE_CHANNEL,
   payload: DesktopPreviewAutomationTypeInputSchema,
-  result: Schema.Void,
-  handler: Effect.fn("desktop.ipc.preview.automationType")(function* ({ tabId, input }) {
-    const manager = yield* PreviewManager.PreviewManager;
-    yield* manager.automationType(tabId, input);
-  }),
+  result: Schema.NullOr(Schema.Struct({ notEditable: Schema.Literal(true) })),
+  handler: Effect.fn("desktop.ipc.preview.automationType")(
+    function* ({ tabId, input }) {
+      const manager = yield* PreviewManager.PreviewManager;
+      yield* manager.automationType(tabId, input);
+      return null;
+    },
+    Effect.catchTag("PreviewAutomationTargetNotEditableError", () =>
+      Effect.succeed({ notEditable: true as const }),
+    ),
+  ),
 });
 
 export const automationPress = DesktopIpc.makeIpcMethod({

apps/desktop/src/preview/Manager.ts

@@ -1109,7 +1109,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
       const zoomFactor = yield* attempt(
         { operation: "syncWebContentsState.getZoomFactor", tabId, webContentsId: wc.id },
         () => wc.getZoomFactor(),
-      );
+      ).pipe(Effect.orElseSucceed(() => undefined as number | undefined));
       const computedNavStatus = computeNavStatus(wc);
       const canGoBack = wc.navigationHistory.canGoBack();
       const canGoForward = wc.navigationHistory.canGoForward();
@@ -1129,7 +1129,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
           navStatus,
           canGoBack,
           canGoForward,
-          zoomFactor,
+          zoomFactor: zoomFactor ?? current.zoomFactor,
           updatedAt,
         };
         return [
@@ -2108,9 +2108,12 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
               }
             }
             const text = ${textJson};
-            const inserted = text.length > 0
-              ? document.execCommand("insertText", false, text)
-              : !clear || document.execCommand("delete", false);
+            let inserted = true;
+            if (text.length > 0) {
+              inserted = document.execCommand("insertText", false, text);
+            } else if (clear) {
+              if (textControl) { element.value = ""; } else { element.textContent = ""; }
+            }
             if (!inserted) return { notEditable: true };
             element.dispatchEvent(new Event("change", { bubbles: true }));
             return { ok: true };

apps/web/src/components/preview/PreviewAutomationHosts.tsx

@@ -47,6 +47,7 @@ import {
   PreviewAutomationOperationError,
   PreviewAutomationOverlayTimeoutError,
   PreviewAutomationRecordingNotActiveError,
+  PreviewAutomationTargetNotEditableError,
   PreviewAutomationTargetUnavailableError,
 } from "./previewAutomationErrors";
 import { createPreviewAutomationRequestConsumerAtom } from "./previewAutomationRequestConsumer";
@@ -429,10 +430,20 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId })
           }
           case "type": {
             const ready = await requireReadyTab();
-            return await ready.bridge.automation.type(
+            const typeResult = await ready.bridge.automation.type(
               ready.tabId,
               request.input as Parameters<typeof ready.bridge.automation.type>[1],
             );
+            if (typeResult && typeof typeResult === "object" && "notEditable" in typeResult) {
+              throw new PreviewAutomationTargetNotEditableError({
+                requestId: request.requestId,
+                operation: request.operation,
+                environmentId,
+                threadId: request.threadId,
+                tabId: ready.tabId,
+              });
+            }
+            return typeResult;
           }
           case "press": {
             const ready = await requireReadyTab();

apps/web/src/components/preview/previewAutomationErrors.ts

@@ -122,11 +122,31 @@ export class PreviewAutomationOperationError extends Schema.TaggedErrorClass<Pre
   }
 }
 
+export class PreviewAutomationTargetNotEditableError extends Schema.TaggedErrorClass<PreviewAutomationTargetNotEditableError>()(
+  "PreviewAutomationTargetNotEditableError",
+  {
+    requestId: TrimmedNonEmptyString,
+    operation: PreviewAutomationOperation,
+    environmentId: EnvironmentId,
+    threadId: ThreadId,
+    tabId: Schema.NullOr(PreviewTabId),
+  },
+) {
+  get responseTag() {
+    return "PreviewAutomationTargetNotEditableError" as const;
+  }
+
+  override get message(): string {
+    return `Preview automation ${this.operation} target is not editable for request ${this.requestId} on environment ${this.environmentId} thread ${this.threadId} (tab ${this.tabId ?? "unassigned"}).`;
+  }
+}
+
 export const PreviewAutomationHostError = Schema.Union([
   PreviewAutomationOverlayTimeoutError,
   PreviewAutomationNavigationTimeoutError,
   PreviewAutomationTargetUnavailableError,
   PreviewAutomationRecordingNotActiveError,
+  PreviewAutomationTargetNotEditableError,
   PreviewAutomationOperationError,
 ]);
 export type PreviewAutomationHostError = typeof PreviewAutomationHostError.Type;

packages/contracts/src/ipc.ts

@@ -987,7 +987,10 @@ export interface DesktopPreviewBridge {
     status: (tabId: string) => Promise<PreviewAutomationStatus>;
     snapshot: (tabId: string) => Promise<PreviewAutomationSnapshot>;
     click: (tabId: string, input: PreviewAutomationClickInput) => Promise<void>;
-    type: (tabId: string, input: PreviewAutomationTypeInput) => Promise<void>;
+    type: (
+      tabId: string,
+      input: PreviewAutomationTypeInput,
+    ) => Promise<void | { notEditable: true }>;
     press: (tabId: string, input: PreviewAutomationPressInput) => Promise<void>;
     scroll: (tabId: string, input: PreviewAutomationScrollInput) => Promise<void>;
     evaluate: (tabId: string, input: PreviewAutomationEvaluateInput) => Promise<unknown>;