fix(desktop): hold refused results until the device registers again, and stay awake through recovery

- A result Sim refuses because it no longer recognizes the device is parked
  rather than retried every 30 s. The journal keeps it, and it is sent once
  the device registers again. The service is told once.
- A dormant device's 15-minute registration recheck is no longer pushed out
  by every refused request.
- A 408 is retried like any other timeout.
- Results a previous app run left behind keep the executor busy until Sim
  has them, so the machine does not sleep with them undelivered.
- A Sim that answers registration with another protocol version gets no new
  turns bound to this device.
- Selecting an already granted folder again while a read runs keeps the
  read's answer. Only a revoked or different grant discards it.

Author: waleedlatif1

apps/desktop/src/main/desktop-executor/client.ts

@@ -38,9 +38,9 @@ export class DeviceRequestError extends Error {
     return this.status === 401
   }
 
-  /** Worth retrying unchanged: no answer, a server fault, or a rate limit. */
+  /** Worth retrying unchanged: no answer, a timeout, a server fault, or a rate limit. */
   get transient(): boolean {
-    return this.status === 0 || this.status === 429 || this.status >= 500
+    return this.status === 0 || this.status === 408 || this.status === 429 || this.status >= 500
   }
 }
 

apps/desktop/src/main/desktop-executor/executor.test.ts

@@ -152,16 +152,18 @@ function setup(options: { leaseRenewMs?: number; maxHeldCalls?: number } = {}) {
   const journal = new MemoryJournal()
   const runner = new FakeRunner()
   const onUnregistered = vi.fn()
+  const busy: boolean[] = []
   const executor = new DesktopExecutor({
     client: sim.client,
     journal,
     runner,
     leaseRenewMs: options.leaseRenewMs ?? 60_000,
     retryBaseMs: 5,
     onUnregistered,
+    onBusyChange: (value) => busy.push(value),
     ...(options.maxHeldCalls ? { maxHeldCalls: options.maxHeldCalls } : {}),
   })
-  return { sim, journal, runner, executor, onUnregistered }
+  return { sim, journal, runner, executor, onUnregistered, busy }
 }
 
 describe('claiming', () => {
@@ -431,6 +433,79 @@ describe('restarting', () => {
   })
 })
 
+describe('delivery', () => {
+  it('retries a result whose request timed out', async () => {
+    const { sim, journal, executor } = setup()
+    sim.completeErrors = [new DeviceRequestError(408, 'request timeout')]
+    await journal.put({
+      toolCallId: 'r-1',
+      state: 'result',
+      executionToken: 't-1',
+      completion: DONE,
+    })
+
+    await executor.recover()
+
+    await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
+  })
+
+  it('holds a result Sim refuses as unregistered until the device registers again', async () => {
+    const { sim, journal, executor, onUnregistered } = setup()
+    sim.completeErrors = [new DeviceRequestError(401, 'unregistered')]
+    await journal.put({
+      toolCallId: 'r-1',
+      state: 'result',
+      executionToken: 't-1',
+      completion: DONE,
+    })
+
+    await executor.recover()
+    await vi.waitFor(() => expect(onUnregistered).toHaveBeenCalledTimes(1))
+    await sleep(40)
+
+    expect(onUnregistered).toHaveBeenCalledTimes(1)
+    expect(sim.completions).toHaveLength(0)
+    expect(journal.entries.get('r-1')?.state).toBe('result')
+
+    executor.resumeParked()
+
+    await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
+    await vi.waitFor(() => expect(journal.entries.size).toBe(0))
+  })
+})
+
+describe('keeping the machine awake', () => {
+  it('is busy from the claim until Sim has the result', async () => {
+    const { sim, runner, executor, busy } = setup()
+    sim.inbox = [callItem('call-1', 'chat-a')]
+    await executor.reconcile()
+    await vi.waitFor(() => expect(runner.started).toEqual(['call-1']))
+    expect(busy).toEqual([true])
+
+    runner.finish('call-1')
+
+    await vi.waitFor(() => expect(busy).toEqual([true, false]))
+    expect(sim.completions).toHaveLength(1)
+  })
+
+  it('stays busy while a result a previous run left is still on its way to Sim', async () => {
+    const { sim, journal, executor, busy } = setup()
+    sim.completeErrors = [new DeviceRequestError(503, 'deploying')]
+    await journal.put({
+      toolCallId: 'result-1',
+      state: 'result',
+      executionToken: 't-result',
+      completion: DONE,
+    })
+
+    await executor.recover()
+    expect(busy).toEqual([true])
+
+    await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
+    await vi.waitFor(() => expect(busy).toEqual([true, false]))
+  })
+})
+
 describe('registration', () => {
   it('asks to register again when Sim no longer recognizes the device', async () => {
     const { sim, executor, onUnregistered } = setup()

apps/desktop/src/main/desktop-executor/executor.ts

@@ -86,6 +86,13 @@ export class DesktopExecutor {
   private paused = false
   private disposed = false
   private busy = false
+  /** Results a previous app run left, still on their way to Sim. */
+  private recoveredInFlight = 0
+  /** Results Sim refused because it no longer recognized this device; sent once it registers again. */
+  private readonly parked = new Map<
+    string,
+    { executionToken: string; completion: DesktopToolCompletion }
+  >()
 
   constructor(private readonly options: DesktopExecutorOptions) {}
 
@@ -131,7 +138,22 @@ export class DesktopExecutor {
         toolCallId: entry.toolCallId,
         state: entry.state,
       })
-      void this.deliver(entry.toolCallId, entry.executionToken, completion)
+      // Held awake like a running call: the result exists only on this machine until Sim has it.
+      this.recoveredInFlight += 1
+      this.updateBusy()
+      void this.deliver(entry.toolCallId, entry.executionToken, completion).finally(() => {
+        this.recoveredInFlight -= 1
+        this.updateBusy()
+      })
+    }
+  }
+
+  /** After registering again: sends the results parked while Sim did not recognize the device. */
+  resumeParked(): void {
+    const parked = [...this.parked]
+    this.parked.clear()
+    for (const [toolCallId, { executionToken, completion }] of parked) {
+      void this.deliver(toolCallId, executionToken, completion)
     }
   }
 
@@ -329,15 +351,21 @@ export class DesktopExecutor {
         break
       } catch (error) {
         if (!(error instanceof DeviceRequestError)) throw error
-        if (error.unregistered) this.options.onUnregistered()
-        else if (error.status === 413 && pending.data !== undefined) {
+        if (error.unregistered) {
+          // Retrying cannot help until the device registers again; the journal keeps the result.
+          this.parked.set(toolCallId, { executionToken, completion: pending })
+          this.options.onUnregistered()
+          return
+        }
+        if (error.status === 413 && pending.data !== undefined) {
           pending = {
             status: pending.status,
             message: RESULT_TOO_LARGE,
             data: { error: RESULT_TOO_LARGE, resultOmitted: true },
           }
           continue
-        } else if (!error.transient) {
+        }
+        if (!error.transient) {
           logger.warn('Sim refused a desktop call result; dropping it', {
             toolCallId,
             status: error.status,
@@ -413,7 +441,7 @@ export class DesktopExecutor {
   }
 
   private updateBusy(): void {
-    const busy = this.held.size > 0
+    const busy = this.held.size > 0 || this.recoveredInFlight > 0
     if (busy === this.busy) return
     this.busy = busy
     this.options.onBusyChange?.(busy)

apps/desktop/src/main/desktop-executor/service.test.ts

@@ -10,7 +10,7 @@ vi.mock('electron', () => import('@/test/electron-mock'))
 import { createDesktopExecutorService } from '@/main/desktop-executor/service'
 
 /** Sim's device routes, with registration answers held until the test releases them. */
-function fakeSim() {
+function fakeSim(protocolVersion = 1) {
   const requests: string[] = []
   const registrations: Array<(enabled: boolean) => void> = []
   const fetch = vi.fn(async (url: string, init: RequestInit): Promise<Response> => {
@@ -20,7 +20,7 @@ function fakeSim() {
       const enabled = await new Promise<boolean>((resolve) => registrations.push(resolve))
       return Response.json({
         enabled,
-        protocolVersion: 1,
+        protocolVersion,
         leaseMs: 60_000,
         leaseRenewMs: 20_000,
         reconcileMs: 10_000,
@@ -34,8 +34,8 @@ function fakeSim() {
   return { fetch, requests, registrations }
 }
 
-async function service() {
-  const sim = fakeSim()
+async function service(protocolVersion = 1) {
+  const sim = fakeSim(protocolVersion)
   const desktopExecutor = createDesktopExecutorService({
     userDataPath: await mkdtemp(join(tmpdir(), 'sim-executor-service-')),
     origin: () => 'https://sim.test',
@@ -72,4 +72,15 @@ describe('desktop executor registration', () => {
     expect(sim.requests).not.toContain('GET /api/desktop/inbox')
     expect(sim.requests).not.toContain('GET /api/desktop/inbox/stream')
   })
+
+  it('offers no binding to a Sim that speaks another protocol version', async () => {
+    const { sim, desktopExecutor } = await service(2)
+    desktopExecutor.start()
+    await vi.waitFor(() => expect(sim.registrations).toHaveLength(1))
+
+    sim.registrations[0]?.(true)
+    await vi.waitFor(() => expect(sim.requests).toContain('GET /api/desktop/inbox'))
+
+    expect(desktopExecutor.getDevice()).toBeNull()
+  })
 })

apps/desktop/src/main/desktop-executor/service.ts

@@ -150,7 +150,8 @@ export function createDesktopExecutorService(
       return
     }
     stopLoops()
-    scheduleRegistration(DORMANT_RECHECK_MS)
+    // Every refused request lands here; re-arming each time would push the recheck out forever.
+    if (!registrationTimer) scheduleRegistration(DORMANT_RECHECK_MS)
   }
 
   function stopLoops(): void {
@@ -186,6 +187,8 @@ export function createDesktopExecutorService(
       await executor.recover()
       // Signed out while recovering: sign-out already disposed this executor.
       if (registrationGeneration !== generation || !executor) return
+    } else {
+      executor.resumeParked()
     }
     if (!doorbell) {
       doorbell = new InboxDoorbell({
@@ -224,9 +227,11 @@ export function createDesktopExecutorService(
       })
       if (registrationGeneration !== generation || id !== deviceId) return
       registrationAttempt = 0
-      device = nextTiming.enabled
-        ? { deviceId: id, protocolVersion: DESKTOP_EXECUTOR_PROTOCOL_VERSION }
-        : null
+      // A Sim that speaks another protocol version gets no new turns bound to this device.
+      device =
+        nextTiming.enabled && nextTiming.protocolVersion === DESKTOP_EXECUTOR_PROTOCOL_VERSION
+          ? { deviceId: id, protocolVersion: DESKTOP_EXECUTOR_PROTOCOL_VERSION }
+          : null
       logger.info('Desktop executor registered', { enabled: nextTiming.enabled })
       // Off for this user: a turn already bound to this device still finishes here, so the
       // executor keeps serving the inbox; no new turn binds while `device` is null.

apps/desktop/src/main/local-filesystem.test.ts

@@ -247,6 +247,16 @@ describe('LocalFilesystemService', () => {
     await expect(searching).resolves.toMatchObject({ ok: false, code: 'MOUNT_NOT_FOUND' })
   })
 
+  it('keeps a read whose folder the user selected again while it ran', async () => {
+    const granted = await mount(service)
+
+    const reading = service.handle({ operation: 'read', uri: `${granted.uri}README.md` })
+    const again = await mount(service)
+
+    expect(again.uri).toBe(granted.uri)
+    await expect(reading).resolves.toMatchObject({ ok: true })
+  })
+
   it('rejects unknown mounts and symlinks that escape the selected directory', async () => {
     const granted = await mount(service)
     const outside = await mkdtemp(join(tmpdir(), 'sim-localfs-outside-'))

apps/desktop/src/main/local-filesystem.ts

@@ -493,7 +493,7 @@ export class LocalFilesystemService {
           this.activeRequests.delete(requestId)
         }
       }
-      if (grant && this.mounts.get(grant.id) !== grant) throw mountNotFound()
+      if (grant && this.mounts.get(grant.id)?.rootPath !== grant.rootPath) throw mountNotFound()
       return { ok: true, data }
     } catch (error) {
       const safe = safeError(error)

apps/sim/lib/mothership/tools/client/local-filesystem.test.ts

@@ -1,6 +1,7 @@
 /**
  * @vitest-environment jsdom
  */
+import { sleep } from '@sim/utils/helpers'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const { mockReportCompletion } = vi.hoisted(() => ({
@@ -260,12 +261,12 @@ describe('executeLocalFilesystemTool', () => {
     await vi.waitFor(() =>
       expect(localFilesystem).toHaveBeenCalledWith(expect.objectContaining({ operation: 'read' }))
     )
-    await new Promise((resolve) => setTimeout(resolve, 10))
+    await sleep(10)
     expect(resolved).toBe(false)
 
     finishRead({ ok: true, data: { content: 'hello', totalLines: 1 } })
     await vi.waitFor(() => expect(mockReportCompletion).toHaveBeenCalled())
-    await new Promise((resolve) => setTimeout(resolve, 10))
+    await sleep(10)
     expect(resolved).toBe(false)
 
     finishReport()