fix(desktop): stop agent tmux runs from the moment they start, and when Terminal is switched off

- A tmux run is tracked as soon as its window exists, not once its wait
  ends. Sign-out now reaches a command the chat view started that is still
  inside its wait window. Reaping skips runs whose call is still reading
  their files.
- Switching Terminal off stops the agent's commands before the shells go,
  as sign-out does.
- The runner's deadline is built on the shared interruptible sleep.
- A hostname longer than Sim's 128-character limit is shortened, so
  registration does not fail on it.

Author: waleedlatif1

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

@@ -36,6 +36,7 @@ import {
   type TerminalToolResponse,
 } from '@sim/terminal-protocol'
 import { getErrorMessage } from '@sim/utils/errors'
+import { interruptibleSleep } from '@sim/utils/helpers'
 import { isRecordLike } from '@sim/utils/object'
 import type { DesktopToolRunner } from '@/main/desktop-executor/executor'
 import type { ClaimedDesktopCall } from '@/main/desktop-executor/protocol'
@@ -101,14 +102,15 @@ async function withDeadline<T>(
   onTimeout: () => T
 ): Promise<T> {
   if (timeoutMs === null) return work
-  let timer: ReturnType<typeof setTimeout> | undefined
-  const timeout = new Promise<T>((resolve) => {
-    timer = setTimeout(() => resolve(onTimeout()), timeoutMs)
-  })
+  // Aborted once the race settles, which cancels the sleep; a cancelled sleep never times out.
+  const settled = new AbortController()
+  const timeout = interruptibleSleep(timeoutMs, settled.signal).then(() =>
+    settled.signal.aborted ? new Promise<T>(() => {}) : onTimeout()
+  )
   try {
     return await Promise.race([work, timeout])
   } finally {
-    clearTimeout(timer)
+    settled.abort()
   }
 }
 

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

@@ -7,7 +7,7 @@ import { describe, expect, it, vi } from 'vitest'
 
 vi.mock('electron', () => import('@/test/electron-mock'))
 
-import { createDesktopExecutorService } from '@/main/desktop-executor/service'
+import { createDesktopExecutorService, deviceName } from '@/main/desktop-executor/service'
 
 /** Sim's device routes, with registration answers held until the test releases them. */
 function fakeSim(protocolVersion = 1) {
@@ -84,3 +84,10 @@ describe('desktop executor registration', () => {
     expect(desktopExecutor.getDevice()).toBeNull()
   })
 })
+
+describe('device name', () => {
+  it('fits a long hostname within what Sim accepts at registration', () => {
+    expect(deviceName(`${'studio-'.repeat(40)}.local`).length).toBeLessThanOrEqual(128)
+    expect(deviceName('Studio-Mac.local')).toBe('Studio-Mac')
+  })
+})

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

@@ -13,6 +13,7 @@ import { generateId } from '@sim/utils/id'
 import { isRecordLike } from '@sim/utils/object'
 import { randomFloat } from '@sim/utils/random'
 import { backoffWithJitter } from '@sim/utils/retry'
+import { truncate } from '@sim/utils/string'
 import type { Session } from 'electron'
 import { app, net, powerMonitor } from 'electron'
 import { readFileWithinLimit, writeJsonFileAtomically } from '@/main/atomic-json-file'
@@ -75,12 +76,13 @@ async function readInstallId(filePath: string): Promise<string | null> {
   }
 }
 
-function deviceName(): string {
-  return (
-    hostname()
-      .replace(/\.local$/, '')
-      .trim() || 'Sim desktop'
-  )
+/** Sim refuses a longer device name at registration. */
+const DEVICE_NAME_MAX_CHARS = 128
+
+/** The machine's name as the user knows it, within what Sim accepts. */
+export function deviceName(host = hostname()): string {
+  const name = host.replace(/\.local$/, '').trim() || 'Sim desktop'
+  return truncate(name, DEVICE_NAME_MAX_CHARS - 3)
 }
 
 export function createDesktopExecutorService(

apps/desktop/src/main/index.ts

@@ -537,7 +537,8 @@ function main(): void {
       desktopExecutor.refreshRegistration()
     },
     setTerminalEnabled: (enabled) => {
-      if (!enabled) terminal.dispose()
+      // Agent commands are stopped by their process groups first; a tmux run outlives its shell.
+      if (!enabled) void terminal.stopAgentCommands().then(() => terminal.dispose())
       desktopExecutor.refreshRegistration()
     },
     setBrowserTheme: setAgentBrowserTheme,

apps/desktop/src/main/terminal/index.ts

@@ -246,6 +246,8 @@ export class TerminalService {
    * Held here so the terminal's own lifecycle can reclaim them.
    */
   private readonly pendingRuns = new Map<string, TmuxRunHandle[]>()
+  /** Runs a `run` call is still waiting on; their files are read when the wait ends. */
+  private readonly awaitedRuns = new Set<TmuxRunHandle>()
   /** How to stop each tool call still in flight, so Stop interrupts exactly what it started. */
   private readonly toolStops = new Map<string, () => Promise<void>>()
 
@@ -479,13 +481,19 @@ export class TerminalService {
     if (!pending) return
     const stillRunning: TmuxRunHandle[] = []
     for (const handle of pending) {
-      if (isRunComplete(handle)) handle.dispose()
+      if (isRunComplete(handle) && !this.awaitedRuns.has(handle)) handle.dispose()
       else stillRunning.push(handle)
     }
     if (stillRunning.length === 0) this.pendingRuns.delete(terminalId)
     else this.pendingRuns.set(terminalId, stillRunning)
   }
 
+  private untrackRun(terminalId: string, handle: TmuxRunHandle): void {
+    const remaining = (this.pendingRuns.get(terminalId) ?? []).filter((entry) => entry !== handle)
+    if (remaining.length === 0) this.pendingRuns.delete(terminalId)
+    else this.pendingRuns.set(terminalId, remaining)
+  }
+
   /**
    * Releases every tracked run for a terminal, finished or not. The terminal is
    * going away, so nothing will ever read these files again.
@@ -1251,6 +1259,11 @@ export class TerminalService {
     this.reapFinishedRuns(terminal.terminalId)
     const handle = await startRun(session, command, terminal.currentCwd, terminal.env)
     if ('error' in handle) throw new TerminalError('SPAWN_FAILED', handle.error)
+    // Tracked from the moment its window exists, so sign-out can stop it even mid-wait.
+    const pending = this.pendingRuns.get(terminal.terminalId)
+    if (pending) pending.push(handle)
+    else this.pendingRuns.set(terminal.terminalId, [handle])
+    this.awaitedRuns.add(handle)
 
     const waitMs = resolveRunWaitMs(args.waitSeconds)
     // Inside tmux a stop arrives as Ctrl-C in the run's own window; closing that window hangs up
@@ -1269,17 +1282,14 @@ export class TerminalService {
     const outcome = await Promise.race([
       awaitRun(handle, waitMs),
       stopped.then(() => ({ ...pollRun(handle), done: true })),
-    ])
+    ]).finally(() => this.awaitedRuns.delete(handle))
     if (outcome.done) {
       await closeRunWindow(handle, terminal.env)
+      this.untrackRun(terminal.terminalId, handle)
       handle.dispose()
-    } else {
-      // Still going, and nothing polls the status file again — `read` captures
-      // the pane instead.
-      const pending = this.pendingRuns.get(terminal.terminalId)
-      if (pending) pending.push(handle)
-      else this.pendingRuns.set(terminal.terminalId, [handle])
     }
+    // Still going, it stays tracked, and nothing polls the status file again: `read` captures
+    // the pane instead.
 
     const { text, truncated } = elideOutput(outcome.output)
     return {

apps/desktop/src/main/terminal/service.test.ts

@@ -1,6 +1,55 @@
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import { describe, expect, it, vi } from 'vitest'
 import { TerminalService } from '@/main/terminal'
 
+/**
+ * A tmux attachment the service sees only when a test turns it on: run windows get real status
+ * files, and Ctrl-C in a run's window ends its command the way tmux would.
+ */
+const tmuxFake = vi.hoisted(() => ({
+  on: false,
+  keys: [] as Array<{ target: string; key: string }>,
+  closed: [] as string[],
+  statusPaths: new Map<string, string>(),
+}))
+
+vi.mock('@/main/terminal/tmux', async () => {
+  const actual =
+    await vi.importActual<typeof import('@/main/terminal/tmux')>('@/main/terminal/tmux')
+  let nextWindow = 1
+  return {
+    ...actual,
+    isTmuxUnavailable: () => (tmuxFake.on ? false : actual.isTmuxUnavailable()),
+    resolveAttachment: async (pid: number, env: NodeJS.ProcessEnv) =>
+      tmuxFake.on
+        ? { session: 'agent', clientTty: '/dev/ttys001' }
+        : actual.resolveAttachment(pid, env),
+    startRun: async (...args: Parameters<typeof actual.startRun>) => {
+      if (!tmuxFake.on) return actual.startRun(...args)
+      const dir = mkdtempSync(join(tmpdir(), 'sim-tmux-fake-'))
+      const window = `@${nextWindow++}`
+      const statusPath = join(dir, 'status')
+      writeFileSync(join(dir, 'out'), '')
+      tmuxFake.statusPaths.set(window, statusPath)
+      return { window, outPath: join(dir, 'out'), statusPath, dispose: () => {} }
+    },
+    sendKey: async (target: string, key: string, env: NodeJS.ProcessEnv) => {
+      if (!tmuxFake.on) return actual.sendKey(target, key, env)
+      tmuxFake.keys.push({ target, key })
+      const statusPath = tmuxFake.statusPaths.get(target)
+      if (key === 'C-c' && statusPath) writeFileSync(statusPath, '130')
+      return { ok: true, stdout: '', stderr: '' }
+    },
+    closeRunWindow: async (...args: Parameters<typeof actual.closeRunWindow>) => {
+      const [handle] = args
+      if (!tmuxFake.on) return actual.closeRunWindow(...args)
+      tmuxFake.closed.push(handle.window)
+    },
+  }
+})
+
 /** Stub sessions by terminal id, populated by the mock below. */
 const { stubSessions } = vi.hoisted(() => ({
   stubSessions: new Map<
@@ -500,3 +549,28 @@ describe('stopping a tool call', () => {
     await running
   })
 })
+
+describe('agent commands in tmux', () => {
+  it('stops a tmux run at sign-out while its call still waits on it', async () => {
+    tmuxFake.on = true
+    try {
+      const terminal = new TerminalService({ loadCwd: () => '/tmp' })
+      terminal.start({ cols: 80, rows: 24 })
+      const running = terminal.executeTool('call-tmux', 'run', {
+        command: 'sleep 600',
+        waitSeconds: 60,
+      })
+      await vi.waitFor(() => expect(tmuxFake.statusPaths.size).toBe(1))
+
+      await terminal.stopAgentCommands()
+
+      expect(tmuxFake.keys).toEqual([{ target: '@1', key: 'C-c' }])
+      await expect(running).resolves.toMatchObject({
+        ok: true,
+        result: { status: 'completed', exitCode: 130 },
+      })
+    } finally {
+      tmuxFake.on = false
+    }
+  })
+})