fix(desktop): type the agent's next command only once the prompt is drawn

Git Bash drops input typed while it is still switching from a native
program back to its prompt, so a command run straight after a stopped one
vanished. bash now reports its prompt's end (OSC 633 B, drawn by readline
at the end of PS1), as PowerShell already did, and a run into a shell
that reports it waits for the prompt, at most 2 s. The bash init file
also sets PROMPT_COMMAND before its DEBUG trap, so that assignment is no
longer announced as a command at startup.

Author: waleedlatif1

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

@@ -1390,6 +1390,7 @@ export class TerminalService {
     if (!session.hasShellIntegration) {
       await this.awaitShellStartup(session, latch)
     }
+    await session.waitForPromptDrawn(latch.signal)
     if (session.isBusy) {
       throw new TerminalError(
         'BUSY',

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

@@ -184,6 +184,7 @@ vi.mock('@/main/terminal/session', async () => {
             if (signal === 'SIGINT' && state.interruptible) finishRun(130)
           }),
           waitForShellIntegration: async () => {},
+          waitForPromptDrawn: async () => {},
           /** Stands in for the user running `exit` or pressing Ctrl-D. */
           exit: () => {
             state.disposed = true

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

@@ -290,6 +290,68 @@ describe('TerminalSession command lifecycle', () => {
   })
 })
 
+describe('waiting for the prompt before typing a command', () => {
+  const marker = (body: string) => `\u001b]633;${body};test-nonce\u0007`
+
+  function promptSession(): TerminalSession {
+    return TerminalSession.create({
+      terminalId: 'terminal-prompt-drawn',
+      cwd: '/tmp',
+      cols: 80,
+      rows: 24,
+      callbacks: { onData: () => {}, onState: () => {}, onCommand: () => {}, onExit: () => {} },
+    })
+  }
+
+  async function settledAfter(promise: Promise<unknown>, ms: number): Promise<boolean> {
+    let settled = false
+    void promise.then(() => {
+      settled = true
+    })
+    await vi.advanceTimersByTimeAsync(ms)
+    return settled
+  }
+
+  it('waits, in a shell that reports it, until the next prompt is drawn', async () => {
+    vi.useFakeTimers()
+    const session = promptSession()
+    try {
+      ptyStub.dataHandler?.(`${marker('A')}$ ${marker('B')}`)
+      // The last command just finished: its prompt is not drawn yet.
+      ptyStub.dataHandler?.(`${marker('D;0')}${marker('A')}`)
+      const drawn = session.waitForPromptDrawn()
+
+      expect(await settledAfter(drawn, 500)).toBe(false)
+      ptyStub.dataHandler?.(`$ ${marker('B')}`)
+      expect(await settledAfter(drawn, 0)).toBe(true)
+    } finally {
+      session.dispose()
+    }
+  })
+
+  it('never waits on a shell that does not report its prompt', async () => {
+    vi.useFakeTimers()
+    const session = promptSession()
+    try {
+      ptyStub.dataHandler?.(`${marker('D;0')}${marker('A')}`)
+      expect(await settledAfter(session.waitForPromptDrawn(), 0)).toBe(true)
+    } finally {
+      session.dispose()
+    }
+  })
+
+  it('types anyway once a prompt that reports itself is slow to come', async () => {
+    vi.useFakeTimers()
+    const session = promptSession()
+    try {
+      ptyStub.dataHandler?.(`${marker('A')}$ ${marker('B')}${marker('A')}`)
+      expect(await settledAfter(session.waitForPromptDrawn(), 2_100)).toBe(true)
+    } finally {
+      session.dispose()
+    }
+  })
+})
+
 describe('TerminalSession on Windows', () => {
   const marker = (body: string) => `\u001b]633;${body};test-nonce\u0007`
 

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

@@ -246,6 +246,9 @@ const KEYSTROKE_GAP_MS = 150
  */
 const KEYSTROKE_SETTLE_MAX_MS = 1_000
 
+/** Cap on waiting for a shell's prompt to be drawn before typing into it anyway. */
+const PROMPT_DRAW_MAX_MS = 2_000
+
 interface PendingCommand {
   command: string
   toolCallId: string
@@ -374,8 +377,12 @@ export class TerminalSession {
   private pendingCommand: PendingCommand | null = null
   /** Command line reported by the shell but not yet bracketed by output-start. */
   private announcedCommand: string | null = null
-  /** Pending shell-readiness waits, rechecked whenever the shell's startup moves on. */
+  /** Pending readiness and prompt waits, rechecked whenever startup moves on or a prompt is drawn. */
   private readonly readinessWaiters = new Set<() => void>()
+  /** Whether the shell says when its prompt is drawn (`B`); bash and PowerShell do, zsh does not. */
+  private reportsPromptEnd = false
+  /** Whether the prompt is drawn and reading input, as far as the shell has said. */
+  private promptDrawn = false
 
   private constructor(
     options: TerminalSessionOptions,
@@ -600,6 +607,31 @@ export class TerminalSession {
     return now - this.startupBegunAt >= bounds.startingMs ? 'starting' : null
   }
 
+  /**
+   * Resolves once the prompt is drawn and reading input, for a shell that reports it; at once for
+   * one that does not. Git Bash drops what is typed while it is still switching from a native
+   * program back to its prompt, so a command typed straight after the last one finished can vanish.
+   * Also resolves after {@link PROMPT_DRAW_MAX_MS}, on exit, or when `signal` aborts.
+   */
+  waitForPromptDrawn(signal?: AbortSignal): Promise<void> {
+    return new Promise((resolve) => {
+      let timer: NodeJS.Timeout | null = null
+      const done = () => {
+        if (timer) clearTimeout(timer)
+        this.readinessWaiters.delete(check)
+        signal?.removeEventListener('abort', done)
+        resolve()
+      }
+      const check = () => {
+        if (this.promptDrawn || !this.reportsPromptEnd || this.disposed) done()
+      }
+      timer = setTimeout(done, PROMPT_DRAW_MAX_MS)
+      this.readinessWaiters.add(check)
+      signal?.addEventListener('abort', done)
+      check()
+    })
+  }
+
   private notifyReadinessWaiters(): void {
     for (const check of [...this.readinessWaiters]) check()
   }
@@ -901,7 +933,13 @@ export class TerminalSession {
           this.notifyReadinessWaiters()
         }
         break
+      case 'prompt-end':
+        this.reportsPromptEnd = true
+        this.promptDrawn = true
+        this.notifyReadinessWaiters()
+        break
       case 'prompt-start':
+        this.promptDrawn = false
         if (!this.shellIntegration) {
           this.shellIntegration = true
           this.emitState()
@@ -912,6 +950,7 @@ export class TerminalSession {
         this.announcedCommand = marker.command
         break
       case 'output-start': {
+        this.promptDrawn = false
         if (this.pendingCommand) {
           this.pendingCommand.capturing = true
           break

apps/desktop/src/main/terminal/shell-integration.ts

@@ -45,7 +45,8 @@ export function createNonce(): string {
 
 /**
  * Marker kinds we act on. `A` (prompt start) doubles as the "integration is
- * live" signal; `C`/`D` bracket a command's output; `E` reports the exact
+ * live" signal; `B` (prompt end) says the prompt is drawn and reading input;
+ * `C`/`D` bracket a command's output; `E` reports the exact
  * command line; `P` tracks the working directory across `cd`. `SimStartup` is
  * ours, not VS Code's: the shell sends it before running the user's startup
  * files, so a shell that is still starting can be told from one we never
@@ -54,6 +55,7 @@ export function createNonce(): string {
 export type ShellMarker =
   | { kind: 'startup' }
   | { kind: 'prompt-start' }
+  | { kind: 'prompt-end' }
   | { kind: 'command-line'; command: string }
   | { kind: 'output-start' }
   | { kind: 'output-end'; exitCode: number }
@@ -145,6 +147,8 @@ export class ShellIntegrationParser {
         return { kind: 'startup' }
       case 'A':
         return { kind: 'prompt-start' }
+      case 'B':
+        return { kind: 'prompt-end' }
       case 'C':
         return { kind: 'output-start' }
       case 'D': {
@@ -310,8 +314,17 @@ __sim_precmd() {
   return $st
 }
 
+# The prompt-end marker rides at the end of PS1, so it is drawn by readline itself, once the
+# prompt is up and reading. Appended after the user's PROMPT_COMMAND, which may rebuild PS1.
+__sim_prompt_end() {
+  local st=$? marker="\\[\\e]633;B;\${__sim_nonce}\\a\\]"
+  case "$PS1" in *"$marker") ;; *) PS1="$PS1$marker" ;; esac
+  return $st
+}
+
+# Set before the trap, so assigning it is not reported as a command.
+PROMPT_COMMAND="__sim_precmd\${PROMPT_COMMAND:+; $PROMPT_COMMAND}; __sim_prompt_end"
 trap '__sim_preexec' DEBUG
-PROMPT_COMMAND="__sim_precmd\${PROMPT_COMMAND:+; $PROMPT_COMMAND}"
 `
   )
   return rcPath