fix(desktop): learn a turn's executor from its stream and announce background chats

Builds on the background activity commit, against the final binding contract.

- Display only, deterministically. Sim marks a turn its desktop's executor runs
  on the stream that serves it: a response header on the send and on every
  reconnect, and a flag on the replay batch a reload attaches with. The chat
  view only shows that turn's desktop calls and never starts or reports them.
  This replaces reading the cached activity list, which a new turn's first call
  could beat.
- Needs input comes from the durable record: a call Sim asked the user about and
  they have not answered, or a running terminal handoff or browser takeover.
  An auto-allowed command no longer reads as needing input. Presence Sim cannot
  read is not reported as offline.
- Turn-complete notifications for chats in the background: a chat that finishes
  while the user is elsewhere is announced and opens on click; the chat on
  screen announces itself as before. "Notify only for chats in the background"
  (the existing default) now means exactly that, so a background chat is
  announced even while Sim is focused.
- The activity list refreshes when a turn starts or ends.

Author: waleedlatif1

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

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('electron', () => import('@/test/electron-mock'))
+
+import type { BrowserWindow } from 'electron'
+import { createDesktopSettingsService } from '@/main/desktop-settings'
+import { Notification } from '@/test/electron-mock'
+
+function service(window: { url: string; focused: boolean } | null) {
+  const config = new Map<string, unknown>()
+  return createDesktopSettingsService({
+    config: {
+      get: (key: string) => config.get(key),
+      set: (key: string, value: unknown) => config.set(key, value),
+      flush: () => true,
+    } as never,
+    getMainWindow: () =>
+      window
+        ? ({
+            isFocused: () => window.focused,
+            webContents: { getURL: () => window.url },
+          } as unknown as BrowserWindow)
+        : null,
+    openMainWindowAt: vi.fn(),
+    setAutoDownloadUpdates: vi.fn(),
+    setTrayEnabled: vi.fn(),
+    setBrowserEnabled: vi.fn(),
+    setTerminalEnabled: vi.fn(),
+    setBrowserTheme: vi.fn(),
+    setBrowserDefaultZoom: vi.fn(),
+    setTerminalDefaultZoom: vi.fn(),
+    getDefaultBrowserDownloadDirectory: () => '/tmp',
+    chooseBrowserDownloadDirectory: async () => null,
+  })
+}
+
+const BACKGROUND_CHAT = '/workspace/ws-1/chat/chat-b'
+
+describe('desktop notifications in the default "background only" mode', () => {
+  beforeEach(() => {
+    Notification.instances.length = 0
+  })
+
+  it('announces a chat in the background while the user works in another one', () => {
+    const shown = service({
+      url: 'https://sim.ai/workspace/ws-1/chat/chat-c',
+      focused: true,
+    }).notify({
+      title: 'Fix CI',
+      body: 'Sim finished responding.',
+      route: BACKGROUND_CHAT,
+    })
+
+    expect(shown).toBe(true)
+    expect(Notification.instances).toHaveLength(1)
+  })
+
+  it('stays quiet about the chat the focused window shows', () => {
+    const shown = service({ url: `https://sim.ai${BACKGROUND_CHAT}`, focused: true }).notify({
+      title: 'Fix CI',
+      body: 'Sim finished responding.',
+      route: BACKGROUND_CHAT,
+    })
+
+    expect(shown).toBe(false)
+    expect(Notification.instances).toHaveLength(0)
+  })
+
+  it('stays quiet about the app as a whole while it is focused', () => {
+    const shown = service({ url: 'https://sim.ai/workspace/ws-1/home', focused: true }).notify({
+      title: 'Update ready',
+      body: 'Restart to update.',
+    })
+
+    expect(shown).toBe(false)
+  })
+})

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

@@ -105,6 +105,21 @@ function readPreferences(
   }
 }
 
+/**
+ * Whether a focused window already shows what a notification is about. One without a route is
+ * about the app as a whole, which a focused window always shows; one about a chat is news only
+ * while that chat is in the background.
+ */
+function showsRoute(window: BrowserWindow, route: string | undefined): boolean {
+  if (!route) return true
+  try {
+    const shown = new URL(window.webContents.getURL()).pathname
+    return shown === new URL(route, 'https://sim.invalid').pathname
+  } catch {
+    return false
+  }
+}
+
 /**
  * Owns device preferences and their native side effects. Renderer code can
  * request a change, but only this main-process service touches login items,
@@ -203,7 +218,11 @@ export function createDesktopSettingsService(
         return false
       }
       const window = deps.getMainWindow()
-      if (preferences.notificationsOnlyWhenUnfocused && window?.isFocused()) {
+      if (
+        preferences.notificationsOnlyWhenUnfocused &&
+        window?.isFocused() &&
+        showsRoute(window, payload.route)
+      ) {
         return false
       }
 

apps/sim/app/api/copilot/chat/stream/desktop-executor.integration.ts

@@ -0,0 +1,134 @@
+/**
+ * A chat view learns from the stream it reads whether the desktop app's background executor runs
+ * the turn's desktop tools, so it only shows those calls. Exercised against real PostgreSQL and
+ * Redis through the production reconnect route, for the live tail and the replay batch a view
+ * attaches with after a reload.
+ */
+import { authMock, authMockFns } from '@sim/testing/mocks/auth.mock'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+
+const { redisUrl } = await vi.hoisted(async () => {
+  const { readTestRedisUrl } = await import('@sim/db/testing/test-infrastructure')
+  const url = readTestRedisUrl()
+  if (url) process.env.REDIS_URL = url
+  return { redisUrl: url }
+})
+
+vi.mock('@/lib/auth', () => authMock)
+
+import { db } from '@sim/db'
+import {
+  copilotChats,
+  copilotRuns,
+  desktopDevices,
+  permissions,
+  user,
+  workspace,
+} from '@sim/db/schema'
+import { generateId } from '@sim/utils/id'
+import { eq } from 'drizzle-orm'
+import { NextRequest } from 'next/server'
+import { closeRedisConnection } from '@/lib/core/config/redis'
+import { MOTHERSHIP_DESKTOP_EXECUTOR_HEADER } from '@/lib/mothership/constants'
+import { GET as streamGET } from '@/app/api/copilot/chat/stream/route'
+
+const userId = generateId()
+const workspaceId = generateId()
+const chatId = generateId()
+const deviceId = generateId()
+
+async function finishedRun(desktopDeviceId: string | null): Promise<string> {
+  const streamId = generateId()
+  await db.insert(copilotRuns).values({
+    id: generateId(),
+    executionId: generateId(),
+    chatId,
+    userId,
+    workspaceId,
+    streamId,
+    status: 'complete',
+    desktopDeviceId,
+  })
+  return streamId
+}
+
+function reconnect(streamId: string, batch: boolean) {
+  return streamGET(
+    new NextRequest(
+      `http://localhost:3000/api/copilot/chat/stream?streamId=${streamId}&after=0${batch ? '&batch=true' : ''}`
+    ),
+    { params: Promise.resolve({}) }
+  )
+}
+
+describe.runIf(Boolean(redisUrl))('desktop executor binding on a chat stream', () => {
+  beforeAll(async () => {
+    const now = new Date()
+    await db.insert(user).values({
+      id: userId,
+      name: 'Desktop stream fixture',
+      email: `${userId}@desktop-stream.test`,
+      emailVerified: true,
+      createdAt: now,
+      updatedAt: now,
+    })
+    await db.insert(workspace).values({
+      id: workspaceId,
+      name: 'Desktop stream fixture',
+      ownerId: userId,
+      billedAccountUserId: userId,
+    })
+    await db.insert(permissions).values({
+      id: generateId(),
+      userId,
+      entityType: 'workspace',
+      entityId: workspaceId,
+      permissionType: 'admin',
+    })
+    await db.insert(copilotChats).values({ id: chatId, userId, workspaceId, type: 'mothership' })
+    await db.insert(desktopDevices).values({
+      id: deviceId,
+      userId,
+      name: 'Studio Mac',
+      appVersion: '0.9.0',
+      platform: 'darwin-arm64',
+      capabilities: { executor: 1, browser: true, terminal: true, localFiles: true },
+    })
+    authMockFns.mockGetSession.mockResolvedValue({
+      user: { id: userId },
+      session: { id: generateId() },
+    })
+  })
+
+  afterAll(async () => {
+    await db.delete(copilotRuns).where(eq(copilotRuns.chatId, chatId))
+    await db.delete(copilotChats).where(eq(copilotChats.id, chatId))
+    await db.delete(desktopDevices).where(eq(desktopDevices.id, deviceId))
+    await db.delete(permissions).where(eq(permissions.userId, userId))
+    await db.delete(workspace).where(eq(workspace.id, workspaceId))
+    await db.delete(user).where(eq(user.id, userId))
+    await closeRedisConnection()
+  })
+
+  it('marks the live tail and the replay batch of a turn a desktop runs', async () => {
+    const streamId = await finishedRun(deviceId)
+
+    const tail = await reconnect(streamId, false)
+    await tail.text()
+    const batch = await (await reconnect(streamId, true)).json()
+
+    expect(tail.headers.get(MOTHERSHIP_DESKTOP_EXECUTOR_HEADER)).toBe('device')
+    expect(batch.desktopToolsOnDevice).toBe(true)
+  })
+
+  it('leaves a turn the chat view runs unmarked', async () => {
+    const streamId = await finishedRun(null)
+
+    const tail = await reconnect(streamId, false)
+    await tail.text()
+    const batch = await (await reconnect(streamId, true)).json()
+
+    expect(tail.headers.get(MOTHERSHIP_DESKTOP_EXECUTOR_HEADER)).toBeNull()
+    expect(batch.desktopToolsOnDevice).toBeUndefined()
+  })
+})

apps/sim/app/api/copilot/chat/stream/route.ts

@@ -13,7 +13,10 @@ import {
 } from '@/lib/api/server/routes'
 import { encodeSSEComment } from '@/lib/core/utils/sse'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { MOTHERSHIP_STREAM_REPLAY_HEADER } from '@/lib/mothership/constants'
+import {
+  MOTHERSHIP_DESKTOP_EXECUTOR_HEADER,
+  MOTHERSHIP_STREAM_REPLAY_HEADER,
+} from '@/lib/mothership/constants'
 import {
   MothershipStreamV1CompletionStatus,
   MothershipStreamV1EventType,
@@ -285,6 +288,7 @@ async function handleResumeRequestBody({
       previewSessions,
       status: run.status,
       ...(run.chatId ? { chatId: run.chatId } : {}),
+      ...(run.desktopDeviceId ? { desktopToolsOnDevice: true } : {}),
     })
   }
 
@@ -606,8 +610,10 @@ async function handleResumeRequestBody({
   }
 
   return new Response(stream, {
-    headers: replayBody
-      ? { ...SSE_RESPONSE_HEADERS, [MOTHERSHIP_STREAM_REPLAY_HEADER]: 'log' }
-      : SSE_RESPONSE_HEADERS,
+    headers: {
+      ...SSE_RESPONSE_HEADERS,
+      ...(replayBody ? { [MOTHERSHIP_STREAM_REPLAY_HEADER]: 'log' } : {}),
+      ...(run.desktopDeviceId ? { [MOTHERSHIP_DESKTOP_EXECUTOR_HEADER]: 'device' } : {}),
+    },
   })
 }

apps/sim/app/api/desktop/activity/route.ts

@@ -4,7 +4,7 @@ import {
   desktopExecutorErrorPolicy,
   desktopExecutorRateLimit,
 } from '@/lib/api/server/routes/desktop-executor'
-import { listDesktopActivity } from '@/lib/desktop/application/executor'
+import { listDesktopActivity } from '@/lib/desktop/application/activity'
 
 export const dynamic = 'force-dynamic'
 

apps/sim/app/workspace/[workspaceId]/home/hooks/stream-protocol.ts

@@ -25,6 +25,8 @@ export type StreamBatchResponse = {
   previewSessions?: FilePreviewSession[]
   status: string
   chatId?: string
+  /** The desktop app's background executor runs this turn's desktop tools. */
+  desktopToolsOnDevice?: true
 }
 
 const STREAM_SCHEMA_ENFORCEMENT_PREFIX = 'Client stream schema enforcement failed.'
@@ -108,6 +110,7 @@ export function parseStreamBatchResponse(value: unknown): StreamBatchResponse {
     ...(previewSessions ? { previewSessions } : {}),
     status: typeof value.status === 'string' ? value.status : 'unknown',
     ...(typeof value.chatId === 'string' && value.chatId ? { chatId: value.chatId } : {}),
+    ...(value.desktopToolsOnDevice === true ? { desktopToolsOnDevice: true as const } : {}),
   }
 }
 

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts

@@ -108,31 +108,47 @@ describe('tool events (dispatch → model + side effects)', () => {
     )
   })
 
-  it("only shows a desktop call when the chat's turn runs on a desktop in the background", () => {
+  it("only shows desktop calls when the desktop's background executor runs the turn", () => {
     const startClientBrowserTool = vi.fn()
-    const deps = makeStreamLoopDeps({ startClientBrowserTool, chatIdRef: ref('chat-1') })
-    vi.mocked(deps.queryClient.getQueryData).mockImplementation((key) =>
-      JSON.stringify(key) === JSON.stringify(['desktop-activity', 'list', 'ws-1'])
-        ? [{ chatId: 'chat-1', state: 'running', deviceName: 'MacBook' }]
-        : undefined
-    )
-    const ctx = createStreamLoopContext(deps)
-
-    dispatchStreamEvent(
-      ctx,
-      toolEnv({
-        phase: 'call',
-        executor: 'client',
-        mode: 'async',
-        toolCallId: 'click-1',
-        toolName: 'browser_click',
-        arguments: { ref: 'e1' },
-        status: 'executing',
+    const startClientTerminalTool = vi.fn()
+    const startClientLocalFilesystemTool = vi.fn()
+    const startClientWorkflowTool = vi.fn()
+    const ctx = createStreamLoopContext(
+      makeStreamLoopDeps({
+        startClientBrowserTool,
+        startClientTerminalTool,
+        startClientLocalFilesystemTool,
+        startClientWorkflowTool,
+        chatIdRef: ref('chat-1'),
+        options: { desktopToolsOnDevice: true },
       })
     )
+    const call = (toolCallId: string, toolName: string, args: Record<string, unknown>) =>
+      dispatchStreamEvent(
+        ctx,
+        toolEnv({
+          phase: 'call',
+          executor: 'client',
+          mode: 'async',
+          toolCallId,
+          toolName,
+          arguments: args,
+          status: 'executing',
+        })
+      )
+
+    call('click-1', 'browser_click', { ref: 'e1' })
+    call('run-1', 'terminal', { operation: 'run', args: { command: 'ls' } })
+    call('read-1', 'read_local_file', { path: '~/notes.txt' })
+    call('workflow-1', 'run_workflow', { workflowId: 'wf-1' })
 
     expect(toolNode(ctx, 'click-1').status).toBe('running')
     expect(startClientBrowserTool).not.toHaveBeenCalled()
+    expect(startClientTerminalTool).not.toHaveBeenCalled()
+    expect(startClientLocalFilesystemTool).not.toHaveBeenCalled()
+    expect(startClientWorkflowTool).toHaveBeenCalledWith('workflow-1', 'run_workflow', {
+      workflowId: 'wf-1',
+    })
   })
 
   it('runs a desktop call in the view when no desktop runs the chat in the background', () => {