fix(desktop): reclaim tmux run temp directories that outlive their wait window

`startRun` makes a temp directory per run holding the tee target and the status
file, and only its handle can remove it. `runInTmux` disposed the handle on the
`outcome.done` branch only — on the still-running path the handle was a local
that went out of scope, and nothing polls that run again (`read` captures the
pane instead). With a 30s default wait, every longer command leaked its
`/tmp/sim-tmux-run-*` directory for the life of the process while `tee` kept
appending the full output to it.

Handles for still-running commands are now held per terminal and reclaimed by
the terminal's own lifecycle: `retire`/`dispose` release them all, and a new run
on the same terminal first reaps any whose status file has since appeared. No
reaper timer — the new-run path is already doing run bookkeeping. Live runs are
left alone, since their tee is still writing there.

Not a security issue: the directories are 0700 in the per-user tmpdir and tmux
reaps the window itself. It is unbounded disk and inode growth.

Author: waleedlatif1

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

@@ -40,6 +40,7 @@ import {
   awaitRun,
   capturePane,
   closeRunWindow,
+  isRunComplete,
   isTmuxUnavailable,
   killPane,
   listPanes,
@@ -49,6 +50,7 @@ import {
   startRun,
   TMUX_KEY_NAMES,
   type TmuxAttachment,
+  type TmuxRunHandle,
 } from '@/main/terminal/tmux'
 
 const logger = createLogger('DesktopTerminal')
@@ -176,6 +178,14 @@ export class TerminalService {
   private readonly handoffs = new Map<string, boolean>()
   /** Recently resolved tmux attachments, by terminal id, to avoid re-spawning. */
   private readonly tmuxCache = new Map<string, { at: number; attachment: TmuxAttachment | null }>()
+  /**
+   * Run handles for commands that outlived their wait window, keyed by
+   * terminal. `startRun` makes a temp directory per run and only its handle can
+   * remove it, so a handle dropped on the still-running path leaks that
+   * directory for the life of the process while `tee` keeps appending to it.
+   * Held here so the terminal's own lifecycle can reclaim them.
+   */
+  private readonly pendingRuns = new Map<string, TmuxRunHandle[]>()
 
   constructor(private readonly options: TerminalServiceOptions = {}) {}
 
@@ -294,6 +304,37 @@ export class TerminalService {
     return this.retire(terminalId)
   }
 
+  /**
+   * Removes the temp directories of tracked runs that have since finished.
+   *
+   * Called when a new run starts on the same terminal, which is the one moment
+   * the service is already doing run bookkeeping — a dedicated reaper timer
+   * would be a subsystem to own for something this cheap. A run still going is
+   * left alone: its `tee` is still appending to that directory.
+   */
+  private reapFinishedRuns(terminalId: string): void {
+    const pending = this.pendingRuns.get(terminalId)
+    if (!pending) return
+    const stillRunning = pending.filter((handle) => {
+      if (!isRunComplete(handle)) return true
+      handle.dispose()
+      return false
+    })
+    if (stillRunning.length === 0) this.pendingRuns.delete(terminalId)
+    else this.pendingRuns.set(terminalId, stillRunning)
+  }
+
+  /**
+   * Releases every tracked run for a terminal, finished or not. The terminal is
+   * going away, so nothing will ever read these files again.
+   */
+  private releasePendingRuns(terminalId: string): void {
+    const pending = this.pendingRuns.get(terminalId)
+    if (!pending) return
+    for (const handle of pending) handle.dispose()
+    this.pendingRuns.delete(terminalId)
+  }
+
   /**
    * Drops a terminal and decides what replaces it. Closing and exiting share
    * this so the two cannot drift into different answers for "what happens to
@@ -310,6 +351,7 @@ export class TerminalService {
     session.dispose()
     this.sessions.delete(terminalId)
     this.tmuxCache.delete(terminalId)
+    this.releasePendingRuns(terminalId)
 
     if (this.sessions.size === 0) {
       this.spawn(this.resolveCwd(closedCwd), cols, rows)
@@ -459,6 +501,7 @@ export class TerminalService {
     }
     this.sessions.clear()
     this.tmuxCache.clear()
+    for (const terminalId of [...this.pendingRuns.keys()]) this.releasePendingRuns(terminalId)
     this.activeId = null
     // A stale claim here is what let Cmd-W close a shell that no longer exists.
     this.setPanelFocused(false)
@@ -784,6 +827,7 @@ export class TerminalService {
     if (!command) throw new TerminalError('INVALID_REQUEST', 'run needs a `command`.')
 
     const started = Date.now()
+    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)
 
@@ -792,6 +836,12 @@ export class TerminalService {
     if (outcome.done) {
       await closeRunWindow(handle, terminal.env)
       handle.dispose()
+    } else {
+      // Still going, and nothing polls the status file again — `read` captures
+      // the pane instead. Without this the handle would go out of scope here.
+      const pending = this.pendingRuns.get(terminal.terminalId)
+      if (pending) pending.push(handle)
+      else this.pendingRuns.set(terminal.terminalId, [handle])
     }
 
     const { text, truncated } = elideOutput(outcome.output)

apps/desktop/src/main/terminal/pending-runs.test.ts

@@ -0,0 +1,132 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { tmuxStub } = vi.hoisted(() => ({
+  tmuxStub: {
+    /** Handles handed out by `startRun`, newest last, with their dispose spies. */
+    handles: [] as Array<{ window: string; dispose: ReturnType<typeof vi.fn> }>,
+    /** Whether a run's status file is considered present yet. */
+    complete: new Set<string>(),
+    /** What `awaitRun` reports — the leak is on the `done: false` path. */
+    done: false,
+  },
+}))
+
+vi.mock('@/main/terminal/tmux', () => ({
+  TMUX_KEY_NAMES: {},
+  activePane: vi.fn(async () => 'sess:0.0'),
+  awaitRun: vi.fn(async () => ({
+    done: tmuxStub.done,
+    output: 'out',
+    exitCode: tmuxStub.done ? 0 : null,
+  })),
+  capturePane: vi.fn(async () => ({ ok: true, stdout: '', stderr: '' })),
+  closeRunWindow: vi.fn(async () => undefined),
+  isRunComplete: vi.fn((handle: { window: string }) => tmuxStub.complete.has(handle.window)),
+  isTmuxUnavailable: vi.fn(() => false),
+  killPane: vi.fn(async () => ({ ok: true, stdout: '', stderr: '' })),
+  listPanes: vi.fn(async () => []),
+  resolveAttachment: vi.fn(async () => ({ session: 'sess' })),
+  sendKey: vi.fn(async () => ({ ok: true, stdout: '', stderr: '' })),
+  sendText: vi.fn(async () => ({ ok: true, stdout: '', stderr: '' })),
+  startRun: vi.fn(async () => {
+    const handle = {
+      window: `sess:${tmuxStub.handles.length}`,
+      outPath: '/tmp/fake/out',
+      statusPath: '/tmp/fake/status',
+      dispose: vi.fn(),
+    }
+    tmuxStub.handles.push(handle)
+    return handle
+  }),
+}))
+
+vi.mock('@/main/terminal/session', () => ({
+  elide: (text: string) => ({ text, truncated: false }),
+  TerminalSession: {
+    create: ({ terminalId, cwd }: { terminalId: string; cwd: string }) => ({
+      terminalId,
+      cols: 80,
+      rows: 24,
+      pid: 1234,
+      env: {},
+      shell: 'zsh',
+      alive: true,
+      currentCwd: cwd,
+      foreground: null,
+      isBusy: false,
+      hasShellIntegration: true,
+      dispose: vi.fn(),
+      write: vi.fn(),
+      resize: vi.fn(),
+      setBusy: vi.fn(),
+      refreshCwd: async () => {},
+      takeReplaySnapshot: () => '',
+      tabState: (active: boolean) => ({
+        terminalId,
+        title: 'zsh',
+        cwd,
+        running: null,
+        interactive: false,
+        active,
+      }),
+    }),
+  },
+}))
+
+import { TerminalService } from '@/main/terminal'
+
+/**
+ * A run whose command outlives the wait window leaves a temp directory behind
+ * that only its handle can remove, and nothing polls that run again — `read`
+ * captures the tmux pane instead. These cover who eventually disposes it.
+ */
+describe('pending tmux runs', () => {
+  let service: TerminalService
+
+  beforeEach(() => {
+    tmuxStub.handles.length = 0
+    tmuxStub.complete.clear()
+    tmuxStub.done = false
+    service = new TerminalService({ loadCwd: () => '/tmp', saveCwd: () => {} })
+  })
+
+  it('reclaims a still-running run when the terminal is closed', async () => {
+    await service.executeTool('call-1', 'run', { command: 'sleep 600' })
+
+    const [handle] = tmuxStub.handles
+    expect(handle.dispose).not.toHaveBeenCalled()
+
+    service.dispose()
+
+    expect(handle.dispose).toHaveBeenCalledTimes(1)
+  })
+
+  it('reaps a finished run when the next run starts, and leaves live ones alone', async () => {
+    await service.executeTool('call-1', 'run', { command: 'sleep 600' })
+    const [first] = tmuxStub.handles
+
+    await service.executeTool('call-2', 'run', { command: 'sleep 600' })
+    expect(first.dispose).not.toHaveBeenCalled()
+
+    tmuxStub.complete.add(first.window)
+    await service.executeTool('call-3', 'run', { command: 'sleep 600' })
+
+    expect(first.dispose).toHaveBeenCalledTimes(1)
+    expect(tmuxStub.handles[1].dispose).not.toHaveBeenCalled()
+
+    service.dispose()
+  })
+
+  it('disposes a run inline when it finishes inside the wait window', async () => {
+    tmuxStub.done = true
+    await service.executeTool('call-1', 'run', { command: 'true' })
+
+    expect(tmuxStub.handles[0].dispose).toHaveBeenCalledTimes(1)
+
+    service.dispose()
+    expect(tmuxStub.handles[0].dispose).toHaveBeenCalledTimes(1)
+  })
+})

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

@@ -381,7 +381,7 @@ export function pollRun(handle: TmuxRunHandle): TmuxRunOutcome {
  * second, quadratic in output size. Liveness only needs the status file, which
  * is a few bytes; the output is read once, when the run is settled.
  */
-function isRunComplete(handle: TmuxRunHandle): boolean {
+export function isRunComplete(handle: TmuxRunHandle): boolean {
   return readIfPresent(handle.statusPath) !== null
 }