fix(desktop): close a finished untracked run's pane only when its start command proves it is the run's

Author: waleedlatif1

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

@@ -100,7 +100,7 @@ describe('run status files', () => {
 interface FakeTmuxState {
   nextWindow: number
   nextPane: number
-  panes: Record<string, { window: string; options: Record<string, string> }>
+  panes: Record<string, { window: string; options: Record<string, string>; command?: string }>
   /** Every command that reached a pane: `send-keys %1 C-c`, `kill-pane %1`. */
   log: string[]
   /** Commands the fake fails, with the error tmux would print. */
@@ -132,7 +132,7 @@ switch (args[0]) {
   case 'new-window': {
     const window = '@' + state.nextWindow++
     const pane = '%' + state.nextPane++
-    state.panes[pane] = { window, options: {} }
+    state.panes[pane] = { window, options: {}, command: args[args.length - 1] }
     save()
     // Runs the pane's command for real, the way tmux would, when a test asks for it.
     if (process.env.FAKE_TMUX_EXEC) {
@@ -154,7 +154,13 @@ switch (args[0]) {
     // Like tmux 3.x, a pane that is gone answers with an empty line rather than an error.
     const pane = state.panes[target()]
     const name = args[args.length - 1].slice(2, -1)
-    const value = !pane ? '' : name === 'pane_id' ? target() : (pane.options[name] ?? '')
+    const value = !pane
+      ? ''
+      : name === 'pane_id'
+        ? target()
+        : name === 'pane_start_command'
+          ? (pane.command ?? '')
+          : (pane.options[name] ?? '')
     process.stdout.write(value + '\\n')
     break
   }
@@ -316,6 +322,25 @@ describe('stopping a tmux run touches only its own pane', () => {
     expect(Object.keys(tmux.read().panes)).toEqual([])
   })
 
+  it("never closes a pane that took a finished untracked run's id after tmux restarted", async () => {
+    const tmux = fakeTmux()
+    dirs.push(tmux.dir)
+    tmux.write({ ...tmux.read(), fail: { 'set-option': 'invalid option: @sim-run-id' } })
+    const run = await startRun('agent', 'make build', null, tmux.env)
+    if ('error' in run) throw new Error(run.error)
+    writeFileSync(run.statusPath, '0')
+    tmux.restart()
+    // The user's own shell gets the ids the run's pane had.
+    const state = tmux.read()
+    state.panes[run.pane] = { window: run.window, options: {}, command: 'zsh' }
+    tmux.write(state)
+
+    await closeRunPane(run, tmux.env)
+
+    expect(tmux.read().log).toEqual([])
+    expect(Object.keys(tmux.read().panes)).toEqual([run.pane])
+  })
+
   it('lets a tagged run start only once its pane is tagged', async () => {
     const tmux = fakeTmux()
     const run = await started(tmux)

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

@@ -19,7 +19,7 @@
 import { spawn } from 'node:child_process'
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { createLogger } from '@sim/logger'
 import type { TerminalPaneState } from '@sim/terminal-protocol'
 import { getErrorMessage } from '@sim/utils/errors'
@@ -538,15 +538,32 @@ export async function killPane(target: string, env: NodeJS.ProcessEnv): Promise<
   return runTmux(['kill-pane', '-t', target], env)
 }
 
+/**
+ * Whether the pane under an untracked run's id was started with that run's own script, whose path
+ * is unique to the run. Every tmux reports a pane's start command, so this holds where tags do not.
+ */
+async function startedByRun(handle: TmuxRunHandle, env: NodeJS.ProcessEnv): Promise<boolean> {
+  const script = join(dirname(handle.statusPath), 'run.sh')
+  const shown = await runTmux(
+    ['display-message', '-p', '-t', handle.pane, '#{pane_start_command}'],
+    env
+  )
+  return shown.ok && shown.stdout.includes(script)
+}
+
 /**
  * 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. 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.
+ * pane is closed only once the run has written its exit status, and only if the pane was started
+ * by the run's own script: a restarted tmux may have handed the id to one of the user's panes.
  */
 export async function closeRunPane(handle: TmuxRunHandle, env: NodeJS.ProcessEnv): Promise<void> {
   const state = await runPaneState(handle, env)
-  const finishedUntracked = handle.runId === null && state === 'unknown' && isRunComplete(handle)
+  const finishedUntracked =
+    handle.runId === null &&
+    state === 'unknown' &&
+    isRunComplete(handle) &&
+    (await startedByRun(handle, env))
   if (state !== 'ours' && !finishedUntracked) return
   const killed = await runTmux(['kill-pane', '-t', handle.pane], env)
   if (!killed.ok) {