fix(desktop): replace exited terminal sessions

Author: Sg312

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

@@ -155,6 +155,8 @@ export class TerminalService {
   /** Insertion-ordered, which is also the tab order the user sees. */
   private readonly sessions = new Map<string, TerminalSession>()
   private activeId: string | null = null
+  /** True while tearing every shell down, so an exit does not respawn one. */
+  private disposing = false
   private nextId = 1
   private sink: TerminalSink | null = null
   private lastEmittedTabs: string | null = null
@@ -273,14 +275,26 @@ export class TerminalService {
    * every count — the same shape as closing a browser's last tab, which
    * leaves you a tab rather than an empty window.
    *
-   * A shell that exits on its own is different and still closes the panel:
-   * that is the user saying they are done, not asking for a clean one.
+   * A shell that ends by itself — `exit`, or Ctrl-D — goes the same way. It
+   * leaves behind a session that can no longer do anything, so it has to be
+   * reaped either way; treating it as a close means the last one is replaced
+   * rather than leaving a dead tab that cannot be typed into.
    */
   closeTerminal(terminalId: string): TerminalTabsState {
-    const session = this.sessions.get(terminalId)
-    if (!session) {
+    if (!this.sessions.has(terminalId)) {
       throw new TerminalError('NO_SUCH_TERMINAL', unknownTerminal(terminalId))
     }
+    return this.retire(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
+   * the last one".
+   */
+  private retire(terminalId: string): TerminalTabsState {
+    const session = this.sessions.get(terminalId)
+    if (!session) return this.getTabs()
     const closedCwd = session.currentCwd
     const cols = session.cols
     const rows = session.rows
@@ -362,11 +376,13 @@ export class TerminalService {
   }
 
   dispose(): void {
+    this.disposing = true
     this.stopCwdWatch()
     for (const session of this.sessions.values()) session.dispose()
     this.sessions.clear()
     this.tmuxCache.clear()
     this.activeId = null
+    this.disposing = false
   }
 
   async executeTool(
@@ -756,6 +772,12 @@ export class TerminalService {
             this.emitTabs()
           },
           onCommand: (event) => this.sink?.command(event),
+          onExit: (id) => {
+            // Not during shutdown: every shell is ending then, and replacing
+            // the last one would spawn a shell as the app is closing.
+            if (this.disposing) return
+            this.retire(id)
+          },
         },
       })
       this.sessions.set(terminalId, session)

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

@@ -3,7 +3,7 @@ import { TerminalService } from '@/main/terminal'
 
 /** Stub sessions by terminal id, populated by the mock below. */
 const { stubSessions } = vi.hoisted(() => ({
-  stubSessions: new Map<string, { setBusy(busy: boolean): void }>(),
+  stubSessions: new Map<string, { setBusy(busy: boolean): void; exit(): void }>(),
 }))
 
 /**
@@ -19,12 +19,26 @@ vi.mock('@/main/terminal/session', async () => {
   return {
     ...actual,
     TerminalSession: {
-      create: ({ terminalId, cwd, cols, rows }: Record<string, never> & { terminalId: string }) => {
+      create: ({
+        terminalId,
+        cwd,
+        cols,
+        rows,
+        callbacks,
+      }: Record<string, never> & {
+        terminalId: string
+        callbacks: { onExit(terminalId: string): void }
+      }) => {
         const state = { cwd, disposed: false, busy: false }
         const stub = {
           setBusy: (busy: boolean) => {
             state.busy = busy
           },
+          /** Stands in for the user running `exit` or pressing Ctrl-D. */
+          exit: () => {
+            state.disposed = true
+            callbacks.onExit(terminalId)
+          },
           terminalId,
           cols,
           rows,
@@ -237,3 +251,33 @@ describe('closing', () => {
     expect(terminal.getTabs().tabs).toHaveLength(1)
   })
 })
+
+describe('a shell that ends by itself', () => {
+  it('replaces the only terminal instead of leaving a dead tab', () => {
+    const terminal = service()
+    const { activeTerminalId } = terminal.start({ cols: 80, rows: 24 })
+    const original = activeTerminalId as string
+
+    stubSessions.get(original)?.exit()
+
+    // The panel's whole content is the terminal, so an exited last shell used
+    // to sit there unusable — nothing to type into and no way to get it back.
+    const after = terminal.getTabs()
+    expect(after.tabs).toHaveLength(1)
+    expect(after.activeTerminalId).not.toBe(original)
+    expect(after.tabs[0]?.terminalId).toBe(after.activeTerminalId)
+  })
+
+  it('removes one of several and activates a neighbour', () => {
+    const terminal = service()
+    terminal.start({ cols: 80, rows: 24 })
+    const second = terminal.openTerminal().activeTerminalId as string
+
+    stubSessions.get(second)?.exit()
+
+    const after = terminal.getTabs()
+    expect(after.tabs.map((tab) => tab.terminalId)).not.toContain(second)
+    expect(after.tabs).toHaveLength(1)
+    expect(after.activeTerminalId).toBe(after.tabs[0]?.terminalId)
+  })
+})

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

@@ -268,6 +268,12 @@ export interface TerminalSessionCallbacks {
   onData(terminalId: string, data: string): void
   onState(): void
   onCommand(event: TerminalCommandEvent): void
+  /**
+   * The shell ended by itself — the user ran `exit`, or pressed Ctrl-D at an
+   * empty prompt. Distinct from the service disposing the session, which is
+   * already-known and never reaches here.
+   */
+  onExit(terminalId: string): void
 }
 
 export interface TerminalSessionOptions {
@@ -978,6 +984,7 @@ export class TerminalSession {
     this.finishCommand(null)
     this.cleanupIntegrationDir()
     this.emitState()
+    this.callbacks.onExit(this.terminalId)
   }
 
   private emitState(): void {