Merge pull request #200 from supabitapp/sbertix/script-exit

Keep terminal alive after blocking script completes

Author: sbertix

supacode/Clients/Terminal/TerminalClient.swift

@@ -10,6 +10,7 @@ struct TerminalClient {
     case createTabWithInput(Worktree, input: String, runSetupScriptIfNew: Bool)
     case ensureInitialTab(Worktree, runSetupScriptIfNew: Bool, focusing: Bool)
     case stopRunScript(Worktree)
+    case selectTab(Worktree, tabId: TerminalTabID)
     case runBlockingScript(Worktree, kind: BlockingScriptKind, script: String)
     case closeFocusedTab(Worktree)
     case closeFocusedSurface(Worktree)
@@ -31,7 +32,8 @@ struct TerminalClient {
     case tabClosed(worktreeID: Worktree.ID)
     case focusChanged(worktreeID: Worktree.ID, surfaceID: UUID)
     case taskStatusChanged(worktreeID: Worktree.ID, status: WorktreeTaskStatus)
-    case blockingScriptCompleted(worktreeID: Worktree.ID, kind: BlockingScriptKind, exitCode: Int?)
+    case blockingScriptCompleted(
+      worktreeID: Worktree.ID, kind: BlockingScriptKind, exitCode: Int?, tabId: TerminalTabID?)
     case commandPaletteToggleRequested(worktreeID: Worktree.ID)
     case setupScriptConsumed(worktreeID: Worktree.ID)
   }

supacode/Features/App/Reducer/AppFeature.swift

@@ -228,6 +228,12 @@ struct AppFeature {
           await terminalClient.send(.runBlockingScript(worktree, kind: kind, script: script))
         }
 
+      case .repositories(.delegate(.selectTerminalTab(let worktreeID, let tabId))):
+        guard let worktree = state.repositories.worktree(for: worktreeID) else { return .none }
+        return .run { _ in
+          await terminalClient.send(.selectTab(worktree, tabId: tabId))
+        }
+
       case .settings(.setSelection(let selection)):
         let resolvedSelection = selection ?? .general
         switch resolvedSelection {
@@ -675,14 +681,14 @@ struct AppFeature {
       case .terminalEvent(.setupScriptConsumed(let worktreeID)):
         return .send(.repositories(.consumeSetupScript(worktreeID)))
 
-      case .terminalEvent(.blockingScriptCompleted(let worktreeID, let kind, let exitCode)):
+      case .terminalEvent(.blockingScriptCompleted(let worktreeID, let kind, let exitCode, let tabId)):
         switch kind {
         case .run:
-          return .send(.repositories(.runScriptCompleted(worktreeID: worktreeID, exitCode: exitCode)))
+          return .send(.repositories(.runScriptCompleted(worktreeID: worktreeID, exitCode: exitCode, tabId: tabId)))
         case .archive:
-          return .send(.repositories(.archiveScriptCompleted(worktreeID: worktreeID, exitCode: exitCode)))
+          return .send(.repositories(.archiveScriptCompleted(worktreeID: worktreeID, exitCode: exitCode, tabId: tabId)))
         case .delete:
-          return .send(.repositories(.deleteScriptCompleted(worktreeID: worktreeID, exitCode: exitCode)))
+          return .send(.repositories(.deleteScriptCompleted(worktreeID: worktreeID, exitCode: exitCode, tabId: tabId)))
         }
 
       case .terminalEvent:

supacode/Features/Repositories/Reducer/RepositoriesFeature.swift

@@ -198,17 +198,17 @@ struct RepositoriesFeature {
     )
     case consumeSetupScript(Worktree.ID)
     case consumeTerminalFocus(Worktree.ID)
-    case runScriptCompleted(worktreeID: Worktree.ID, exitCode: Int?)
+    case runScriptCompleted(worktreeID: Worktree.ID, exitCode: Int?, tabId: TerminalTabID?)
     case requestArchiveWorktree(Worktree.ID, Repository.ID)
     case requestArchiveWorktrees([ArchiveWorktreeTarget])
     case archiveWorktreeConfirmed(Worktree.ID, Repository.ID)
-    case archiveScriptCompleted(worktreeID: Worktree.ID, exitCode: Int?)
+    case archiveScriptCompleted(worktreeID: Worktree.ID, exitCode: Int?, tabId: TerminalTabID?)
     case archiveWorktreeApply(Worktree.ID, Repository.ID)
     case unarchiveWorktree(Worktree.ID)
     case requestDeleteWorktree(Worktree.ID, Repository.ID)
     case requestDeleteWorktrees([DeleteWorktreeTarget])
     case deleteWorktreeConfirmed(Worktree.ID, Repository.ID)
-    case deleteScriptCompleted(worktreeID: Worktree.ID, exitCode: Int?)
+    case deleteScriptCompleted(worktreeID: Worktree.ID, exitCode: Int?, tabId: TerminalTabID?)
     case deleteWorktreeApply(Worktree.ID, Repository.ID)
     case worktreeDeleted(
       Worktree.ID,
@@ -285,6 +285,7 @@ struct RepositoriesFeature {
     case confirmDeleteWorktree(Worktree.ID, Repository.ID)
     case confirmDeleteWorktrees([DeleteWorktreeTarget])
     case confirmRemoveRepository(Repository.ID)
+    case viewTerminalTab(Worktree.ID, tabId: TerminalTabID)
   }
 
   enum PullRequestAction: Equatable {
@@ -305,6 +306,7 @@ struct RepositoriesFeature {
     case openRepositorySettings(Repository.ID)
     case worktreeCreated(Worktree)
     case runBlockingScript(Worktree, repositoryID: Repository.ID, kind: BlockingScriptKind, script: String)
+    case selectTerminalTab(Worktree.ID, tabId: TerminalTabID)
   }
 
   @Dependency(AnalyticsClient.self) private var analyticsClient
@@ -1371,12 +1373,16 @@ struct RepositoriesFeature {
           }
         )
 
-      case .runScriptCompleted(let worktreeID, _):
+      case .runScriptCompleted(let worktreeID, let exitCode, let tabId):
         guard state.runScriptWorktreeIDs.contains(worktreeID) else {
           repositoriesLogger.debug("Ignoring runScriptCompleted for \(worktreeID): not in runScriptWorktreeIDs")
           return .none
         }
         state.runScriptWorktreeIDs.remove(worktreeID)
+        guard let exitCode, exitCode != 0 else { return .none }
+        state.alert = blockingScriptFailureAlert(
+          kind: .run, exitCode: exitCode, worktreeID: worktreeID, tabId: tabId, state: state
+        )
         return .none
 
       case .archiveWorktreeConfirmed(let worktreeID, let repositoryID):
@@ -1400,7 +1406,7 @@ struct RepositoriesFeature {
         return .send(
           .delegate(.runBlockingScript(worktree, repositoryID: repositoryID, kind: .archive, script: script)))
 
-      case .archiveScriptCompleted(let worktreeID, let exitCode):
+      case .archiveScriptCompleted(let worktreeID, let exitCode, let tabId):
         guard state.archivingWorktreeIDs.contains(worktreeID) else {
           repositoriesLogger.debug("Ignoring archiveScriptCompleted for \(worktreeID): not in archivingWorktreeIDs")
           return .none
@@ -1424,9 +1430,8 @@ struct RepositoriesFeature {
           repositoriesLogger.debug("Archive script cancelled or tab closed for worktree \(worktreeID)")
           return .none
         case let code?:
-          state.alert = messageAlert(
-            title: "Archive script failed",
-            message: "\(blockingScriptExitMessage(code))\nCheck the Archive Script tab for details."
+          state.alert = blockingScriptFailureAlert(
+            kind: .archive, exitCode: code, worktreeID: worktreeID, tabId: tabId, state: state
           )
           return .none
         }
@@ -1652,7 +1657,7 @@ struct RepositoriesFeature {
         return .send(
           .delegate(.runBlockingScript(worktree, repositoryID: repositoryID, kind: .delete, script: script)))
 
-      case .deleteScriptCompleted(let worktreeID, let exitCode):
+      case .deleteScriptCompleted(let worktreeID, let exitCode, let tabId):
         guard state.deleteScriptWorktreeIDs.contains(worktreeID) else {
           repositoriesLogger.debug("Ignoring deleteScriptCompleted for \(worktreeID): not in deleteScriptWorktreeIDs")
           return .none
@@ -1676,9 +1681,8 @@ struct RepositoriesFeature {
           repositoriesLogger.debug("Delete script cancelled or tab closed for worktree \(worktreeID)")
           return .none
         case let code?:
-          state.alert = messageAlert(
-            title: "Delete script failed",
-            message: "\(blockingScriptExitMessage(code))\nCheck the Delete Script tab for details."
+          state.alert = blockingScriptFailureAlert(
+            kind: .delete, exitCode: code, worktreeID: worktreeID, tabId: tabId, state: state
           )
           return .none
         }
@@ -2661,6 +2665,12 @@ struct RepositoriesFeature {
       case .openRepositorySettings(let repositoryID):
         return .send(.delegate(.openRepositorySettings(repositoryID)))
 
+      case .alert(.presented(.viewTerminalTab(let worktreeID, let tabId))):
+        return .merge(
+          .send(.selectWorktree(worktreeID, focusTerminal: true)),
+          .send(.delegate(.selectTerminalTab(worktreeID, tabId: tabId)))
+        )
+
       case .alert(.dismiss):
         state.alert = nil
         return .none
@@ -2891,6 +2901,37 @@ struct RepositoriesFeature {
     )
   }
 
+  private func blockingScriptFailureAlert(
+    kind: BlockingScriptKind,
+    exitCode: Int,
+    worktreeID: Worktree.ID,
+    tabId: TerminalTabID?,
+    state: State
+  ) -> AlertState<Alert> {
+    let worktreeName = state.worktree(for: worktreeID)?.name
+    let repoName = state.repositoryID(containing: worktreeID)
+      .flatMap { state.repositories[id: $0]?.name }
+    let parts = [repoName, worktreeName].compactMap(\.self)
+    if parts.isEmpty {
+      repositoriesLogger.debug("blockingScriptFailureAlert: worktree \(worktreeID) not found in state")
+    }
+    let subtitle = parts.isEmpty ? "Unknown worktree" : parts.joined(separator: " — ")
+    return AlertState {
+      TextState("\(kind.tabTitle) failed")
+    } actions: {
+      if let tabId {
+        ButtonState(action: .viewTerminalTab(worktreeID, tabId: tabId)) {
+          TextState("View Terminal")
+        }
+      }
+      ButtonState(role: .cancel) {
+        TextState("Dismiss")
+      }
+    } message: {
+      TextState("\(subtitle)\n\n\(blockingScriptExitMessage(exitCode))")
+    }
+  }
+
   private func messageAlert(title: String, message: String) -> AlertState<Alert> {
     AlertState {
       TextState(title)

supacode/Features/Terminal/BusinessLogic/WorktreeTerminalManager.swift

@@ -44,6 +44,8 @@ final class WorktreeTerminalManager {
       state.ensureInitialTab(focusing: focusing)
     case .stopRunScript(let worktree):
       _ = state(for: worktree).stopRunScript()
+    case .selectTab(let worktree, let tabId):
+      state(for: worktree).selectTab(tabId)
     case .runBlockingScript(let worktree, let kind, let script):
       _ = state(for: worktree).runBlockingScript(kind: kind, script)
     case .closeFocusedTab(let worktree):
@@ -159,8 +161,8 @@ final class WorktreeTerminalManager {
     state.onTaskStatusChanged = { [weak self] status in
       self?.emit(.taskStatusChanged(worktreeID: worktree.id, status: status))
     }
-    state.onBlockingScriptCompleted = { [weak self] kind, exitCode in
-      self?.emit(.blockingScriptCompleted(worktreeID: worktree.id, kind: kind, exitCode: exitCode))
+    state.onBlockingScriptCompleted = { [weak self] kind, exitCode, tabId in
+      self?.emit(.blockingScriptCompleted(worktreeID: worktree.id, kind: kind, exitCode: exitCode, tabId: tabId))
     }
     state.onCommandPaletteToggle = { [weak self] in
       self?.emit(.commandPaletteToggleRequested(worktreeID: worktree.id))