fix(desktop): run untracked only on tmux without pane options, and reap and close finished untracked panes

- Only tmux before 3.0, which refuses `set-option -p` as an unknown flag or
  invalid option, runs a command untracked. A tmux that can tag panes but did
  not (it timed out, or failed otherwise) gets the run refused, as before, so
  no command starts that Stop and sign-out could never end.
- tmux 3.x answers `display-message` for a pane that is gone with an empty line
  rather than an error, so an untracked run's pane is gone unless tmux echoes
  its id back.
- A finished untracked run's pane is closed, and a run that finishes after its
  call returned has its pane closed when it is reaped, so dead panes kept by
  `remain-on-exit` do not pile up.

Author: waleedlatif1

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

@@ -494,7 +494,10 @@ export class TerminalService {
     }
     for (const handle of this.pendingRuns.get(terminalId) ?? []) {
       if (this.awaitedRuns.has(handle)) continue
-      if (isRunComplete(handle) || (await runPaneState(handle, env)) === 'gone') {
+      const complete = isRunComplete(handle)
+      if (complete || (await runPaneState(handle, env)) === 'gone') {
+        // A pane kept open after its command ended (`remain-on-exit`) closes with its run.
+        if (complete) await closeRunPane(handle, env)
         this.untrackRun(terminalId, handle)
         handle.dispose()
       }

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

@@ -18,6 +18,8 @@ const tmuxFake = vi.hoisted(() => ({
   gone: new Set<string>(),
   /** Runs start untracked, as on a tmux too old to tag their panes. */
   untracked: false,
+  /** Run panes tmux still shows, kept open after their command ends (`remain-on-exit`). */
+  open: new Set<string>(),
   statusPaths: new Map<string, string>(),
 }))
 
@@ -39,6 +41,7 @@ vi.mock('@/main/terminal/tmux', async () => {
       const statusPath = join(dir, 'status')
       writeFileSync(join(dir, 'out'), 'partial output')
       tmuxFake.statusPaths.set(pane, statusPath)
+      tmuxFake.open.add(pane)
       return {
         window: `@${pane.slice(1)}`,
         pane,
@@ -62,6 +65,7 @@ vi.mock('@/main/terminal/tmux', async () => {
     },
     closeRunPane: async (...args: Parameters<typeof actual.closeRunPane>) => {
       if (!tmuxFake.on) return actual.closeRunPane(...args)
+      tmuxFake.open.delete(args[0].pane)
     },
   }
 })
@@ -619,6 +623,27 @@ describe('agent commands in tmux', () => {
     }
   })
 
+  it("closes a run's pane when a later run reaps it after it finished", async () => {
+    tmuxFake.on = true
+    tmuxFake.statusPaths.clear()
+    tmuxFake.open.clear()
+    try {
+      const terminal = new TerminalService({ loadCwd: () => '/tmp' })
+      terminal.start({ cols: 80, rows: 24 })
+      await terminal.executeTool('call-long', 'run', { command: 'make build', waitSeconds: 1 })
+      const [[pane = '', statusPath = ''] = []] = [...tmuxFake.statusPaths]
+      // It finishes after its call returned, and its dead pane stays open.
+      writeFileSync(statusPath, '0')
+      expect(tmuxFake.open.has(pane)).toBe(true)
+
+      await terminal.executeTool('call-next', 'run', { command: 'ls', waitSeconds: 1 })
+
+      expect(tmuxFake.open.has(pane)).toBe(false)
+    } finally {
+      tmuxFake.on = false
+    }
+  })
+
   it("keeps a run's output readable for its call when the terminal goes away mid-wait", async () => {
     tmuxFake.on = true
     tmuxFake.statusPaths.clear()

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

@@ -5,6 +5,7 @@ import { sleep } from '@sim/utils/helpers'
 import { afterEach, describe, expect, it } from 'vitest'
 import {
   awaitRun,
+  closeRunPane,
   isDescendantOf,
   parseFormatLines,
   pollRun,
@@ -167,10 +168,11 @@ switch (args[0]) {
     break
   }
   case 'display-message': {
+    // Like tmux 3.x, a pane that is gone answers with an empty line rather than an error.
     const pane = state.panes[target()]
-    if (!pane) fail("can't find pane")
     const name = args[args.length - 1].slice(2, -1)
-    process.stdout.write((pane.options[name] ?? '') + '\\n')
+    const value = !pane ? '' : name === 'pane_id' ? target() : (pane.options[name] ?? '')
+    process.stdout.write(value + '\\n')
     break
   }
   case 'list-clients': {
@@ -307,28 +309,62 @@ describe('stopping a tmux run touches only its own pane', () => {
     expect(tmux.read().log).toEqual([])
   })
 
-  it('starts a run it could not tag, untracked, and never stops it by a pane id', async () => {
+  it.each(['invalid option: @sim-run-id', 'unknown flag -p'])(
+    'starts a run untracked on a tmux without pane options (%s), and never stops it by a pane id',
+    async (refusal) => {
+      const tmux = fakeTmux()
+      dirs.push(tmux.dir)
+      // tmux before 3.0 has no pane options.
+      tmux.write({ ...tmux.read(), fail: { 'set-option': refusal } })
+
+      const run = await startRun('agent', 'sleep 600', null, tmux.env)
+      if ('error' in run) throw new Error(run.error)
+
+      expect(run.runId).toBeNull()
+      expect(existsSync(join(run.statusPath, '..', 'go'))).toBe(true)
+      expect(await runPaneState(run, tmux.env)).toBe('unknown')
+      await stopRun(run, tmux.env, 0)
+      // No pane is touched by an id that a restarted server might have handed to the user.
+      expect(tmux.read().log).toEqual([])
+      expect(Object.keys(tmux.read().panes)).toEqual([run.pane])
+
+      // Once its pane is gone, it can be let go.
+      const state = tmux.read()
+      delete state.panes[run.pane]
+      tmux.write(state)
+      expect(await runPaneState(run, tmux.env)).toBe('gone')
+    }
+  )
+
+  it.each(['tmux did not respond', 'server exited unexpectedly'])(
+    'refuses a run that a tmux able to tag panes did not tag (%s)',
+    async (failure) => {
+      const tmux = fakeTmux()
+      dirs.push(tmux.dir)
+      tmux.write({ ...tmux.read(), fail: { 'set-option': failure } })
+
+      const result = await startRun('agent', 'sleep 600', null, tmux.env)
+
+      // Untagged on a tmux that tags, nothing could stop it later, so it never starts.
+      expect(result).toMatchObject({ error: expect.stringContaining('was not run') })
+      expect(tmux.read().log).toEqual([])
+    }
+  )
+
+  it("closes a finished untracked run's pane, and only once it has finished", async () => {
     const tmux = fakeTmux()
     dirs.push(tmux.dir)
-    // tmux before 3.0 has no pane options.
     tmux.write({ ...tmux.read(), fail: { 'set-option': 'invalid option: @sim-run-id' } })
-
-    const run = await startRun('agent', 'sleep 600', null, tmux.env)
+    const run = await startRun('agent', 'make build', null, tmux.env)
     if ('error' in run) throw new Error(run.error)
 
-    expect(run.runId).toBeNull()
-    expect(existsSync(join(run.statusPath, '..', 'go'))).toBe(true)
-    expect(await runPaneState(run, tmux.env)).toBe('unknown')
-    await stopRun(run, tmux.env, 0)
-    // No pane is touched by an id that a restarted server might have handed to the user.
-    expect(tmux.read().log).toEqual([])
+    await closeRunPane(run, tmux.env)
     expect(Object.keys(tmux.read().panes)).toEqual([run.pane])
 
-    // Once its pane is gone, it can be let go.
-    const state = tmux.read()
-    delete state.panes[run.pane]
-    tmux.write(state)
-    expect(await runPaneState(run, tmux.env)).toBe('gone')
+    // Its command ended; with `remain-on-exit` its dead pane would otherwise stay open.
+    writeFileSync(run.statusPath, '0')
+    await closeRunPane(run, tmux.env)
+    expect(Object.keys(tmux.read().panes)).toEqual([])
   })
 
   it('lets a tagged run start only once its pane is tagged', async () => {

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

@@ -330,6 +330,9 @@ const RUN_GATE_POLLS = Math.ceil((2 * TMUX_TIMEOUT_MS + 5_000) / 50)
 /** The tmux user option that marks a pane as one run's own. */
 const RUN_ID_OPTION = '@sim-run-id'
 
+/** How tmux before 3.0, which has no pane options, refuses `set-option -p`. */
+const NO_PANE_OPTIONS = /unknown flag|invalid option/i
+
 /**
  * Starts a command in a dedicated tmux window.
  *
@@ -414,10 +417,18 @@ export async function startRun(
   const [window = '', pane = ''] = created.stdout.trim().split(' ')
   const tag = generateId()
   // An untagged pane is never treated as the run's: without the tag a stop could not tell it from
-  // a pane the user opened later under the same id, so the run is left untracked.
+  // a pane the user opened later under the same id.
   const tagged = await runTmux(['set-option', '-p', '-t', pane, RUN_ID_OPTION, tag], env)
+  if (!tagged.ok && !NO_PANE_OPTIONS.test(tagged.stderr)) {
+    // A tmux that can tag panes but did not (it timed out, or failed otherwise) gets no command
+    // that nothing could stop: without the go file the wrapper exits by itself.
+    dispose()
+    return {
+      error: `tmux could not mark the command's pane (${tagged.stderr.trim() || 'no detail'}), so the command was not run.`,
+    }
+  }
   if (!tagged.ok) {
-    logger.warn('tmux could not tag a run pane; the run goes ahead untracked', {
+    logger.warn('This tmux cannot tag a run pane; the run goes ahead untracked', {
       error: tagged.stderr.trim(),
     })
   }
@@ -447,7 +458,10 @@ export async function runPaneState(
   // An untracked run's pane can still be found missing, with a format every tmux knows.
   const format = handle.runId === null ? '#{pane_id}' : `#{${RUN_ID_OPTION}}`
   const shown = await runTmux(['display-message', '-p', '-t', handle.pane, format], env)
-  if (shown.ok && handle.runId === null) return 'unknown'
+  // tmux 3.x answers for a missing pane with an empty line rather than an error.
+  if (shown.ok && handle.runId === null) {
+    return shown.stdout.trim() === handle.pane ? 'unknown' : 'gone'
+  }
   if (shown.ok) return shown.stdout.trim() === handle.runId ? 'ours' : 'gone'
   return /can't find|no server running/i.test(shown.stderr) ? 'gone' : 'unknown'
 }
@@ -531,10 +545,14 @@ export async function killPane(target: string, env: NodeJS.ProcessEnv): Promise<
 
 /**
  * Closes the pane opened by {@link startRun}, and with it the window once that pane is the last
- * one in it. Only the run's own pane, and only while it is still the run's.
+ * one in it. Only the run's own pane, and only while it is still the run's. An untracked run's
+ * pane is closed only once the run has written its exit status: its command has just ended in
+ * that pane, so the id is still the one the run opened.
  */
 export async function closeRunPane(handle: TmuxRunHandle, env: NodeJS.ProcessEnv): Promise<void> {
-  if ((await runPaneState(handle, env)) !== 'ours') return
+  const state = await runPaneState(handle, env)
+  const finishedUntracked = handle.runId === null && state === 'unknown' && isRunComplete(handle)
+  if (state !== 'ours' && !finishedUntracked) return
   const killed = await runTmux(['kill-pane', '-t', handle.pane], env)
   if (!killed.ok) {
     logger.warn('Could not close the tmux run pane', { error: killed.stderr.trim() })