test(desktop): assert outcomes instead of mock calls, and drive Stop through abortRun

The desktop tests asserted that mocks were or were not called. They now assert what the caller sees: the 409, the sweep's settled count, and the device's own doorbell, which Stop now rings through the real abortRun against a stand-in worker.

Author: waleedlatif1

apps/sim/app/api/copilot/confirm/route.test.ts

@@ -149,8 +149,6 @@ describe('Copilot Confirm API Route', () => {
     )
 
     expect(response.status).toBe(409)
-    expect(completePendingAsyncToolCall).not.toHaveBeenCalled()
-    expect(completeAsyncToolCall).not.toHaveBeenCalled()
   })
 
   it('atomically detaches a live background confirmation', async () => {

apps/sim/app/api/desktop/tool/authorize/route.test.ts

@@ -90,7 +90,6 @@ describe('desktop tool authorization', () => {
 
     const response = await POST(request('bound-click'))
     expect(response.status).toBe(409)
-    expect(claimDesktopToolCall).not.toHaveBeenCalled()
   })
 
   it('rejects retired browser tools retained only for history', async () => {

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

@@ -813,7 +813,6 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
             input: { deviceId: desktop.deviceId, toolCallId, executionToken },
           })
         ).resolves.toEqual({ renewed: true })
-        expect(writes).toHaveBeenCalled()
       } finally {
         writes.mockRestore()
       }

apps/sim/lib/desktop/executor/bound-turn.integration.ts

@@ -8,17 +8,29 @@
 import { authMock, authMockFns } from '@sim/testing/mocks/auth.mock'
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { redisUrl, inheritedEnv } = await vi.hoisted(async () => {
+const { redisUrl, inheritedEnv, worker } = await vi.hoisted(async () => {
   const { readTestRedisUrl } = await import('@sim/db/testing/test-infrastructure')
+  const { createServer } = await import('node:http')
+  /** Stands in for the agent worker, which Stop also tells to end the stream. */
+  const server = createServer(async (request, response) => {
+    for await (const _chunk of request) {
+    }
+    response.writeHead(200, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ settled: true }))
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const { port } = server.address() as { port: number }
   const url = readTestRedisUrl()
   const inheritedEnv = {
     REDIS_URL: process.env.REDIS_URL,
     COPILOT_TOOL_PERMISSIONS_ENABLED: process.env.COPILOT_TOOL_PERMISSIONS_ENABLED,
+    SIM_AGENT_API_URL: process.env.SIM_AGENT_API_URL,
   }
-  /** The real Redis module, the confirmation channel and the permission flag read these at import. */
+  /** The real Redis module, the confirmation channel, the permission flag and worker URL read these at import. */
   if (url) process.env.REDIS_URL = url
   process.env.COPILOT_TOOL_PERMISSIONS_ENABLED = 'true'
-  return { redisUrl: url, inheritedEnv }
+  process.env.SIM_AGENT_API_URL = `http://127.0.0.1:${port}`
+  return { redisUrl: url, inheritedEnv, worker: { server } }
 })
 
 vi.mock('@/lib/auth', () => authMock)
@@ -31,6 +43,7 @@ import {
   copilotChats,
   copilotRuns,
   desktopDevices,
+  permissions,
   session,
   user,
   workspace,
@@ -59,9 +72,9 @@ import {
   areStreamToolExecutionsSettled,
   claimToolExecution,
   prepareWorkbenchAccess,
-  requestRunStop,
   revokeExpiredSimToolExecutions,
 } from '@/lib/mothership/async-runs/repository'
+import { abortRun } from '@/lib/mothership/request/application/controls'
 import { prePersistClientExecutableToolCall, sseHandlers } from '@/lib/mothership/request/handlers'
 import { waitForClientToolCompletion } from '@/lib/mothership/request/tools/client'
 import { TraceCollector } from '@/lib/mothership/request/trace'
@@ -125,6 +138,7 @@ afterAll(async () => {
     channels[name] = undefined
   }
   await closeRedisConnection()
+  await new Promise<void>((resolve) => worker.server.close(() => resolve()))
   for (const [key, value] of Object.entries(inheritedEnv)) {
     if (value === undefined) delete process.env[key]
     else process.env[key] = value
@@ -328,6 +342,13 @@ describe.runIf(Boolean(redisUrl))("a turn bound to a desktop's background execut
       ownerId: userId,
       billedAccountUserId: userId,
     })
+    await db.insert(permissions).values({
+      id: generateId(),
+      userId,
+      entityType: 'workspace',
+      entityId: workspaceId,
+      permissionType: 'admin',
+    })
     authMockFns.mockGetSession.mockResolvedValue({
       user: { id: userId, email: `${userId}@bound-turn.test`, name: 'Bound turn' },
       session: { id: generateId(), userId },
@@ -541,7 +562,7 @@ describe.runIf(Boolean(redisUrl))("a turn bound to a desktop's background execut
   )
 
   it(
-    'ends a running call on Stop, and the device learns its token was revoked',
+    'ends a running call on Stop without the device, and tells the device to cancel it',
     async () => {
       const desktop = await signedInDesktop()
       const run = await boundRun(desktop)
@@ -553,8 +574,16 @@ describe.runIf(Boolean(redisUrl))("a turn bound to a desktop's background execut
       })
       await offered(toolCallId)
       const { executionToken } = await desktop.claim(toolCallId)
-      await requestRunStop({ userId, workspaceId, streamId: run.streamId })
+      await abortRun.execute({
+        principal: { kind: 'session', userId, sessionId: generateId() },
+        input: { streamId: run.streamId, chatId: run.chatId, workspaceId },
+      })
       await answer
+      /** Stop rings the device to cancel what it runs; it never acknowledges here. */
+      await until(
+        async () => [...desktop.rings],
+        (rings) => rings.includes('cancel')
+      )
 
       expect(resultOf(context, toolCallId)).toMatchObject({
         success: false,
@@ -611,7 +640,6 @@ describe.runIf(Boolean(redisUrl))("a turn bound to a desktop's background execut
 
         await lapse(toolCallId, 'pickup')
         await answer
-        expect(reads).toHaveBeenCalled()
         expect(resultOf(context, toolCallId)).toMatchObject({
           success: false,
           output: { notStarted: true, reason: 'not_responding' },

apps/sim/lib/mothership/request/application/controls-boundary.test.ts

@@ -13,9 +13,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const hoisted = vi.hoisted(() => ({
   signal: vi.fn(),
-  ring: vi.fn(),
 }))
-vi.mock('@/lib/desktop/executor/doorbell', () => ({ ringDesktopInbox: hoisted.ring }))
 vi.mock('@/lib/mothership/async-runs/repository', () => mothershipAsyncRunsMock)
 vi.mock('@/lib/mothership/request/session/explicit-abort', () => ({
   requestExplicitStreamAbort: hoisted.signal,
@@ -45,7 +43,6 @@ beforeEach(() => {
     .mockResolvedValue({ hideCopilot: true, disableWorkspaceCreation: true })
   mocks.stop.mockReset().mockResolvedValue(null)
   mocks.signal.mockReset().mockResolvedValue({ settled: true })
-  mocks.ring.mockReset()
   mocks.latest.mockResolvedValue({
     chatId: 'chat',
     workspaceId: null,
@@ -91,42 +88,6 @@ describe('abort authorization before service signaling', () => {
       timeoutMs: 6000,
     })
     expect(mocks.permissions).not.toHaveBeenCalled()
-    expect(mocks.ring).not.toHaveBeenCalled()
-  })
-
-  it('tells the desktop a stopped run is bound to that it must cancel what it runs', async () => {
-    queueTableRows(schemaMock.copilotChats, [ownedChat])
-    queueTableRows(schemaMock.copilotChats, [ownedChat])
-    queueTableRows(schemaMock.member, [{ role: 'member' }])
-    mocks.stop.mockResolvedValue({
-      chatId: 'chat',
-      workspaceId: null,
-      organizationId: 'organization',
-      desktopDeviceId: 'device-1',
-    })
-
-    await abortRun.execute({ principal, input })
-
-    expect(mocks.ring).toHaveBeenCalledWith('device-1', 'cancel')
-  })
-
-  it('rings no desktop for a stopped run that turns out to belong to another chat', async () => {
-    queueTableRows(schemaMock.copilotChats, [ownedChat])
-    queueTableRows(schemaMock.copilotChats, [ownedChat])
-    queueTableRows(schemaMock.member, [{ role: 'member' }])
-    mocks.stop.mockResolvedValue({
-      chatId: 'newer-chat',
-      workspaceId: null,
-      organizationId: 'organization',
-      desktopDeviceId: 'device-1',
-    })
-
-    await expect(abortRun.execute({ principal, input })).rejects.toMatchObject({
-      code: 'forbidden',
-    })
-
-    expect(mocks.ring).not.toHaveBeenCalled()
-    expect(mocks.signal).not.toHaveBeenCalled()
   })
 
   it('rejects a removed member before persisting or forwarding Stop', async () => {

apps/sim/lib/mothership/request/tools/desktop-wait.test.ts

@@ -1,3 +1,4 @@
+import { encryptionMock } from '@sim/testing/mocks/encryption.mock'
 import {
   mothershipAsyncRunsMock,
   mothershipAsyncRunsMockFns,
@@ -17,6 +18,7 @@ const desktopRepository = vi.hoisted(() => ({
 vi.mock('@/lib/mothership/async-runs/repository', () => mothershipAsyncRunsMock)
 vi.mock('@/lib/mothership/request/tools/client', () => mothershipClientToolWaiterMock)
 vi.mock('@/lib/desktop/executor/repository', () => desktopRepository)
+vi.mock('@/lib/core/security/encryption', () => encryptionMock)
 
 import {
   settleAbandonedDesktopToolCalls,
@@ -74,14 +76,22 @@ describe('waitForDesktopToolCall', () => {
 
 describe('settleAbandonedDesktopToolCalls', () => {
   it('keeps sweeping past a call it could not settle', async () => {
-    desktopRepository.listOverdueDesktopToolCalls.mockResolvedValueOnce(['a', 'b', 'c'])
+    desktopRepository.listOverdueDesktopToolCalls.mockResolvedValueOnce(['lost', 'overdue'])
     desktopRepository.getDesktopToolCallDeadlines
       .mockRejectedValueOnce(new Error('connection reset'))
-      .mockResolvedValueOnce(null)
-      .mockRejectedValueOnce(new Error('connection reset'))
-
-    await expect(settleAbandonedDesktopToolCalls(0)).resolves.toBe(0)
+      .mockResolvedValueOnce({
+        toolCallId: 'overdue',
+        runId: 'run-1',
+        userId: 'user-1',
+        deviceId: 'device-1',
+        status: 'pending',
+        ownerToken: null,
+        result: null,
+        pickupOverdue: true,
+        leaseLapsed: false,
+      })
+    completePendingAsyncToolCall.mockImplementationOnce(async (input) => ({ ...input }))
 
-    expect(desktopRepository.getDesktopToolCallDeadlines.mock.calls).toEqual([['a'], ['b'], ['c']])
+    await expect(settleAbandonedDesktopToolCalls(0)).resolves.toBe(1)
   })
 })