fix(desktop): settle Stop without the device, survive Redis errors, and only run offered calls

Stop on a call the background executor held never settled the turn's tool
executions unless the device acknowledged: the executor's claim marked a Sim
execution as started, and Stop does not settle that execution. A device that
was asleep, offline or signed out left abortRun unsettled and the next turn's
workbench pending. The executor's claim now takes only its owner token and
lease; no Sim handler runs for it, so Sim-execution quiescence ignores it, as
it already ignores the chat view's desktop claims.

An overdue unclaimed call now settles from its row when presence cannot be
read, and never fails early as offline on a failed read; each call in the
cron's sweep settles in its own try/catch; presence writes are best effort, so
a Redis error no longer fails a pull or a renewal.

The executor takes only a call Sim offered it, within its pickup window, and
the inbox lists unclaimed calls only while offered or waiting for the user. A
call Sim never got to offer gets an implicit deadline one pickup window after
it could first run, so the cron still settles it.

A revoked install id stays revoked on re-registration, a claim racing the
device binding answers "no longer waiting", Stop rings the device only after
its chat is validated, the two device lookups are one, and the desktop inbox
E2E runs in the http-e2e CI job against its own app with Redis.

Author: waleedlatif1

.github/workflows/test-build.yml

@@ -123,7 +123,8 @@ jobs:
   http-e2e:
     name: End-to-end over real HTTP
     runs-on: ${{ (vars.CI_PROVIDER == '' || vars.CI_PROVIDER == 'blacksmith') && 'blacksmith-8vcpu-ubuntu-2404' || 'ubuntu-latest' }}
-    timeout-minutes: 20
+    # Four suites, each starting its own dev app, run in sequence.
+    timeout-minutes: 30
     services:
       postgres:
         image: pgvector/pgvector:pg17
@@ -138,6 +139,16 @@ jobs:
           --health-interval 5s
           --health-timeout 5s
           --health-retries 10
+      # Only the desktop executor's app is given REDIS_URL: its doorbell and presence live there.
+      redis:
+        image: redis:7-alpine
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
     env:
       DATABASE_URL: postgresql://postgres:postgres@127.0.0.1:5432/sim_test
       BETTER_AUTH_SECRET: http-e2e-ci-secret-at-least-32-characters
@@ -298,6 +309,54 @@ jobs:
           STOP_AFTER_E2E_REPORT_PATH="$report_dir/stop-after-http-report.json" \
             bun run test:workflow-stop-after:e2e
 
+      # The desktop background executor's protocol: device registration, the SSE doorbell over
+      # Redis pub/sub, presence, leased claims, Stop and isolation, against its own app with Redis.
+      - name: Verify the desktop background executor's inbox over real HTTP
+        working-directory: apps/sim
+        env:
+          NEXT_PUBLIC_APP_URL: http://127.0.0.1:3019
+          BETTER_AUTH_URL: http://127.0.0.1:3019
+          REDIS_URL: redis://127.0.0.1:6379
+          NEXT_PUBLIC_FORCE_HOSTED: 'false'
+          MSHIP_DESKTOP_BACKGROUND_EXECUTOR: 'true'
+          COPILOT_TOOL_PERMISSIONS_ENABLED: 'true'
+          INTERNAL_API_SECRET: desktop-inbox-http-ci-local-secret-at-least-32-characters
+          DB_TX_TRIPWIRE: throw
+          DISABLE_TELEMETRY: 'true'
+          NEXT_TELEMETRY_DISABLED: '1'
+          READY_TIMEOUT_SECONDS: 300
+        run: |
+          report_dir="$RUNNER_TEMP/e2e"
+          server_log="$report_dir/desktop-inbox-next.log"
+          mkdir -p "$report_dir"
+          node ../../node_modules/next/dist/bin/next dev --hostname 127.0.0.1 --port 3019 > "$server_log" 2>&1 &
+          server_pid=$!
+          finish() {
+            kill "$server_pid" 2>/dev/null || true
+            wait "$server_pid" 2>/dev/null || true
+            awk '/^ (GET|POST|PUT|PATCH|DELETE|HEAD) \/api\// { print }' "$server_log" > "$report_dir/desktop-inbox-http-status.log"
+          }
+          trap finish EXIT
+          fail_startup() {
+            echo "::error::$1"
+            tail -n 200 "$server_log"
+            exit 1
+          }
+          started=$SECONDS
+          until curl --fail --silent --max-time 10 http://127.0.0.1:3019/api/health > /dev/null; do
+            kill -0 "$server_pid" 2>/dev/null || fail_startup 'Local desktop executor app exited during startup.'
+            [ $((SECONDS - started)) -lt "$READY_TIMEOUT_SECONDS" ] ||
+              fail_startup "Local desktop executor app did not become ready within $READY_TIMEOUT_SECONDS seconds."
+            sleep 2
+          done
+          echo "Local desktop executor app ready after $((SECONDS - started))s"
+          DESKTOP_INBOX_E2E_BASE_URL="$NEXT_PUBLIC_APP_URL" \
+          DESKTOP_INBOX_E2E_DATABASE_URL="$DATABASE_URL" \
+          DESKTOP_INBOX_E2E_REDIS_URL="$REDIS_URL" \
+          DESKTOP_INBOX_E2E_AUTH_SECRET="$BETTER_AUTH_SECRET" \
+          DESKTOP_INBOX_E2E_REPORT_PATH="$report_dir/desktop-inbox-http-report.json" \
+            bun run test:desktop-inbox:e2e
+
       - name: Upload end-to-end reports and server logs
         if: failure()
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4

apps/sim/lib/desktop/application/executor.integration.ts

@@ -153,14 +153,15 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
   }
 
   /**
-   * A desktop call the run persisted before forwarding its frame. `awaitingApproval` marks it held
-   * for the user's decision, as pre-persist does for a gated call.
+   * A desktop call the run persisted before forwarding its frame and offered to the device, as the
+   * run's wait does. `awaitingApproval` instead holds it for the user's decision, as pre-persist
+   * does for a gated call; `unoffered` leaves it as a run that died before offering it would.
    */
   async function pendingCall(
     runId: string,
     toolName = 'browser_click',
     args: Record<string, unknown> = { ref: 'e1' },
-    options: { awaitingApproval?: boolean } = {}
+    options: { awaitingApproval?: boolean; unoffered?: boolean } = {}
   ) {
     const toolCallId = generateId()
     await db.insert(copilotAsyncToolCalls).values({
@@ -169,6 +170,9 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
       toolName,
       args,
       ...(options.awaitingApproval ? { permissionRequestedAt: new Date() } : {}),
+      ...(options.awaitingApproval || options.unoffered
+        ? {}
+        : { pickupDeadlineAt: sql`now() + interval '1 minute'` }),
     })
     return toolCallId
   }
@@ -283,6 +287,28 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
       expect(stored).toEqual({ userId: owner.userId, sessionId: owner.sessionId })
     })
 
+    it('keeps a revoked install id revoked when the device registers it again', async () => {
+      const desktop = await signedInDesktop()
+      await db
+        .update(desktopDevices)
+        .set({ revokedAt: new Date() })
+        .where(eq(desktopDevices.id, desktop.deviceId))
+
+      await expect(
+        registerDesktopDevice.execute({
+          principal: desktop.principal,
+          input: {
+            deviceId: desktop.deviceId,
+            name: 'Fixture Mac',
+            appVersion: '0.9.1',
+            platform: 'darwin-arm64',
+            capabilities: CAPABILITIES,
+          },
+        })
+      ).rejects.toThrow('was revoked')
+      await expect(inbox(desktop)).rejects.toBeInstanceOf(DesktopDeviceUnrecognizedError)
+    })
+
     it('rebinds the device to its newest session and locks out the older one', async () => {
       const desktop = await signedInDesktop()
       const sessionId = generateId()
@@ -345,7 +371,8 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
       expect(stored.status).toBe('running')
       expect(stored.claimedBy).toBe('desktop-browser')
       expect(stored.executionOwnerToken).toBe(granted?.executionToken)
-      expect(stored.executionStartedAt).not.toBeNull()
+      /** The device runs it, not a Sim handler, so no Sim execution is marked as started. */
+      expect(stored.executionStartedAt).toBeNull()
       expect(stored.executionLeaseExpiresAt?.getTime()).toBeGreaterThan(Date.now() + 50_000)
     })
 
@@ -412,13 +439,30 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
           executor: { deviceId, ownerToken: generateId() },
         })
 
-      await expect(executorClaim(sameUserOtherMac.deviceId)).rejects.toThrow(
-        'Tool execution ownership is unavailable'
-      )
+      await expect(executorClaim(sameUserOtherMac.deviceId)).resolves.toEqual({
+        outcome: 'existing',
+      })
       expect((await row(toolCallId)).status).toBe('pending')
       await expect(executorClaim(desktop.deviceId)).resolves.toEqual({ outcome: 'claimed' })
     })
 
+    it('never hands over a call Sim did not offer, nor list it', async () => {
+      const desktop = await signedInDesktop()
+      const run = await boundRun(desktop)
+      const toolCallId = await pendingCall(
+        run.runId,
+        'browser_click',
+        { ref: 'e1' },
+        { unoffered: true }
+      )
+
+      expect((await inbox(desktop)).items).toEqual([])
+      await expect(claim(desktop.principal, desktop.deviceId, toolCallId)).rejects.toThrow(
+        'no longer waiting'
+      )
+      expect((await row(toolCallId)).status).toBe('pending')
+    })
+
     it('ignores runs that were never bound to a device', async () => {
       const desktop = await signedInDesktop()
       const unbound = await boundRun({ userId: desktop.userId, deviceId: null })
@@ -456,9 +500,14 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
         message: expect.stringContaining('not approved'),
       })
 
+      /** The user allows it, and the run's wait offers it to the device. */
       await db
         .update(copilotAsyncToolCalls)
-        .set({ permissionDecision: 'allow', permissionDecidedAt: new Date() })
+        .set({
+          permissionDecision: 'allow',
+          permissionDecidedAt: new Date(),
+          pickupDeadlineAt: sql`now() + interval '1 minute'`,
+        })
         .where(eq(copilotAsyncToolCalls.toolCallId, toolCallId))
       expect((await inbox(desktop)).items).toMatchObject([{ kind: 'call', toolCallId }])
       await expect(claim(desktop.principal, desktop.deviceId, toolCallId)).resolves.toMatchObject({
@@ -748,6 +797,28 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
   })
 
   describe('presence and the inbox', () => {
+    it('still serves pulls and renewals when presence cannot be written', async () => {
+      const desktop = await signedInDesktop()
+      const run = await boundRun(desktop)
+      const toolCallId = await pendingCall(run.runId)
+      const redis = getRedisClient()
+      if (!redis) throw new Error('Redis is required')
+      const writes = vi.spyOn(redis, 'set').mockRejectedValue(new Error('Redis unavailable'))
+      try {
+        expect((await inbox(desktop)).items).toMatchObject([{ kind: 'call', toolCallId }])
+        const { executionToken } = await claim(desktop.principal, desktop.deviceId, toolCallId)
+        await expect(
+          renewDesktopToolLease.execute({
+            principal: desktop.principal,
+            input: { deviceId: desktop.deviceId, toolCallId, executionToken },
+          })
+        ).resolves.toEqual({ renewed: true })
+        expect(writes).toHaveBeenCalled()
+      } finally {
+        writes.mockRestore()
+      }
+    })
+
     it('lists pending calls in persistence order even when their doorbell was never heard', async () => {
       const desktop = await signedInDesktop()
       const run = await boundRun(desktop)

apps/sim/lib/desktop/application/executor.ts

@@ -26,7 +26,6 @@ import { classifyDesktopInbox, type DesktopInboxEntry } from '@/lib/desktop/exec
 import { markDesktopPresent } from '@/lib/desktop/executor/presence'
 import {
   acknowledgeDesktopCallResult,
-  getBindableDesktopDevice,
   getBoundDesktopCall,
   getBoundDesktopDevice,
   listDesktopInboxRows,
@@ -79,11 +78,10 @@ export async function resolveTurnDesktopDevice(
   deviceId: string
 ): Promise<string | null> {
   if (!(await isDesktopBackgroundExecutorEnabled(principal.userId))) return null
-  const device = await getBindableDesktopDevice({
-    deviceId,
-    userId: principal.userId,
-    sessionId: principal.sessionId,
-  })
+  const device = await getBoundDesktopDevice(
+    { deviceId, userId: principal.userId, sessionId: principal.sessionId },
+    { executor: true }
+  )
   if (!device) {
     logger.warn('Turn not bound: its desktop is not registered to this session', {
       userId: principal.userId,
@@ -133,7 +131,7 @@ export const registerDesktopDevice = defineAuthorizedCredentialUserUseCase({
       if (!registered)
         throw new OrchestrationError(
           'conflict',
-          'This device ID belongs to another account. Generate a new device ID and register again.'
+          'This device ID belongs to another account or was revoked. Generate a new device ID and register again.'
         )
       logger.info('Desktop device registered', {
         userId: principal.userId,