feat(preview): draw the agent cursor on tabs the desktop renders

The server sends each agent pointer for a desktop-rendered tab over the
browser channel, and the desktop feeds it to the same cursor overlay and
recording cursor its own tabs use.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/desktop/src/preview/DesktopBrowserHost.ts

@@ -65,11 +65,24 @@ export class DesktopBrowserHost extends Context.Service<
     readonly detach: (key: DesktopBrowserTabKey) => void;
     /** Re-announces attached tabs to a backend that just started. */
     readonly announceAll: Effect.Effect<void>;
+    /** The agent's cursor positions for attached tabs, keyed by their server tab. */
+    readonly pointers: Stream.Stream<{
+      readonly key: DesktopBrowserTabKey;
+      readonly phase: "move" | "click";
+      readonly x: number;
+      readonly y: number;
+    }>;
   }
 >()("@t3tools/desktop/preview/DesktopBrowserHost") {}
 
 export const make = Effect.gen(function* () {
   const outbox = yield* PubSub.unbounded<DesktopBrowserEventType>();
+  const pointers = yield* PubSub.sliding<{
+    readonly key: DesktopBrowserTabKey;
+    readonly phase: "move" | "click";
+    readonly x: number;
+    readonly y: number;
+  }>(16);
   const runFork = Effect.runForkWith(yield* Effect.context<never>());
   const tabs = new Map<string, AttachedTab>();
   const emit = (event: DesktopBrowserEventType) => runFork(PubSub.publish(outbox, event));
@@ -126,6 +139,11 @@ export const make = Effect.gen(function* () {
       if (Option.isNone(command)) return;
       const tab = tabs.get(keyOf(command.value));
       if (!tab) return;
+      if (command.value.type === "pointer") {
+        const { threadId, tabId, phase, x, y } = command.value;
+        runFork(PubSub.publish(pointers, { key: { threadId, tabId }, phase, x, y }));
+        return;
+      }
       if (command.value.type === "release") {
         // A new server connection starts with a fresh relay and fresh sessions.
         tab.relay = null;
@@ -135,6 +153,7 @@ export const make = Effect.gen(function* () {
     });
 
   return DesktopBrowserHost.of({
+    pointers: Stream.fromPubSub(pointers),
     events: Stream.fromPubSub(outbox).pipe(
       Stream.map((event) => lineEncoder.encode(`${encodeEvent(event)}\n`)),
     ),

apps/desktop/src/preview/Manager.ts

@@ -49,6 +49,7 @@ import * as Path from "effect/Path";
 import * as Ref from "effect/Ref";
 import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
+import * as Stream from "effect/Stream";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
@@ -67,6 +68,7 @@ import {
   RECORDING_CURSOR_CHANNEL,
   RECORDING_INPUT_CHANNEL,
   RECORDING_CONTROLLER_CHANNEL,
+  RECORDING_POINTER_CHANNEL,
   START_PICK_CHANNEL,
 } from "./GuestProtocol.ts";
 import { isPreviewAnnotationPayload } from "./PickedElementPayload.ts";
@@ -2287,6 +2289,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
         return;
       }
       if (afterAttach.serverTab) {
+        yield* listenForAgentPointers;
         browserHost.attach(afterAttach.serverTab, { webContents: wc, debugger: control.debugger });
       }
       if (afterAttach.colorScheme !== "system") {
@@ -3173,6 +3176,58 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
     );
   });
 
+  let pointerSequence = 0;
+  /**
+   * The server reports where an agent action is about to land on a tab it
+   * drives here. The live cursor and desktop recordings draw it like any agent.
+   */
+  const emitAgentPointer = Effect.fn("PreviewManager.emitAgentPointer")(function* (pointer: {
+    readonly key: { readonly threadId: string; readonly tabId: string };
+    readonly phase: "move" | "click";
+    readonly x: number;
+    readonly y: number;
+  }) {
+    const tab = [...(yield* SynchronizedRef.get(tabsRef)).values()].find(
+      (candidate) =>
+        candidate.serverTab?.threadId === pointer.key.threadId &&
+        candidate.serverTab.tabId === pointer.key.tabId,
+    );
+    if (!tab) return;
+    const event: DesktopPreviewPointerEvent = {
+      tabId: tab.tabId,
+      phase: pointer.phase,
+      x: pointer.x,
+      y: pointer.y,
+      sequence: ++pointerSequence,
+      createdAt: yield* currentIso,
+    };
+    const recording = (yield* SynchronizedRef.get(frameCaptureSessionsRef)).get(tab.tabId);
+    const webContentsId = tab.webContentsId;
+    if (recording?.consumers.has("recording") && webContentsId != null) {
+      yield* attempt({ operation: "recording.pointer", tabId: tab.tabId }, () => {
+        const contents = webContents.fromId(webContentsId);
+        if (contents && !contents.isDestroyed()) contents.send(RECORDING_POINTER_CHANNEL, event);
+      }).pipe(Effect.ignore);
+    }
+    const listeners = yield* Ref.get(pointerEventListenersRef);
+    yield* Effect.forEach(
+      listeners,
+      (listener) => deliverEvent("pointer-event", tab.tabId, () => listener(event)),
+      { discard: true },
+    );
+  });
+  // Listening starts with the first tab of the desktop's own server.
+  let pointersStarted = false;
+  const listenForAgentPointers = Effect.suspend(() => {
+    if (pointersStarted) return Effect.void;
+    pointersStarted = true;
+    return browserHost.pointers.pipe(
+      Stream.runForEach(emitAgentPointer),
+      Effect.forkIn(parentScope),
+      Effect.asVoid,
+    );
+  });
+
   const subscribe = <A>(
     ref: Ref.Ref<ReadonlySet<A>>,
     listener: A,

apps/server/src/preview/DesktopBrowserChannel.ts

@@ -60,6 +60,11 @@ export class DesktopBrowserChannel extends Context.Service<
      * releases the tab on the desktop and stops the endpoint.
      */
     readonly endpoint: (key: DesktopTabKey) => Effect.Effect<string, never, Scope.Scope>;
+    /** Draws the agent's cursor over a tab the desktop renders. */
+    readonly pointer: (
+      key: DesktopTabKey,
+      pointer: { readonly phase: "move" | "click"; readonly x: number; readonly y: number },
+    ) => Effect.Effect<void>;
   }
 >()("t3/preview/DesktopBrowserChannel") {}
 
@@ -80,6 +85,7 @@ export const make = Effect.gen(function* () {
       detached: Stream.empty,
       isAttached: () => Effect.succeed(false),
       endpoint: () => Effect.die("No desktop app is attached to this server."),
+      pointer: () => Effect.void,
     });
   }
 
@@ -207,6 +213,7 @@ export const make = Effect.gen(function* () {
     ),
     isAttached: (key) => Effect.sync(() => attachedTabs.has(keyOf(key))),
     endpoint,
+    pointer: (key, pointer) => command({ type: "pointer", ...key, ...pointer }),
   });
 });
 
@@ -221,5 +228,6 @@ export const layerNone = Layer.succeed(
     detached: Stream.empty,
     isAttached: () => Effect.succeed(false),
     endpoint: () => Effect.die("No desktop app is attached to this server."),
+    pointer: () => Effect.void,
   }),
 );

apps/server/src/preview/ServerBrowser.test.ts

@@ -202,6 +202,7 @@ const dependencies = Layer.mergeAll(
       Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () =>
         Effect.sync(() => releasedDesktopTabs.push(key.tabId)),
       ),
+    pointer: () => Effect.void,
   }),
 ).pipe(
   Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "t3-server-browser-" })),

apps/server/src/preview/ServerBrowser.ts

@@ -1274,11 +1274,19 @@ const make = Effect.gen(function* () {
     (tab: ServerTab): ServerBrowserPage.PointerReporter =>
     async ({ x, y }, phase) => {
       const encoder = tab.recording?.encoder;
-      if (tab.viewers.size === 0 && !encoder) return;
+      // A desktop-rendered tab is always on screen in the desktop app.
+      if (tab.viewers.size === 0 && !encoder && !tab.desktop) return;
       const show = (next: "move" | "click") => {
         const sequence = ++pointerSequence;
         for (const viewer of tab.viewers)
           viewer.push({ _tag: "pointer", phase: next, x, y, sequence });
+        if (tab.desktop)
+          runFork(
+            desktopChannel.pointer(
+              { threadId: tab.threadId, tabId: tab.tabId },
+              { phase: next, x, y },
+            ),
+          );
         void encoder
           ?.evaluate(
             ([px, py, click]) =>

packages/contracts/src/desktopBrowser.ts

@@ -34,5 +34,13 @@ export const DesktopBrowserCommand = Schema.Union([
   Schema.Struct({ type: Schema.Literal("cdp"), ...TabKey, message: Schema.String }),
   /** The server stopped driving this tab, so the relay can drop its sessions. */
   Schema.Struct({ type: Schema.Literal("release"), ...TabKey }),
+  /** Where an agent action is about to land, so the desktop draws its cursor there. */
+  Schema.Struct({
+    type: Schema.Literal("pointer"),
+    ...TabKey,
+    phase: Schema.Literals(["move", "click"]),
+    x: Schema.Finite,
+    y: Schema.Finite,
+  }),
 ]);
 export type DesktopBrowserCommand = typeof DesktopBrowserCommand.Type;