tabby-tabbyspaces 0.1.0 → 0.2.1

package/src/components/workspaceList.component.ts

@@ -1,17 +1,23 @@
 import { Component, OnInit, OnDestroy, AfterViewInit, ChangeDetectorRef, ElementRef, NgZone } from '@angular/core'
+import { NgbModal } from '@ng-bootstrap/ng-bootstrap'
 import { ConfigService, ProfilesService } from 'tabby-core'
 import { Subscription } from 'rxjs'
 import { StartupCommandService } from '../services/startupCommand.service'
 import { WorkspaceEditorService } from '../services/workspaceEditor.service'
+import { DeleteConfirmModalComponent } from './deleteConfirmModal.component'
 import {
   Workspace,
   WorkspacePane,
   WorkspaceSplit,
+  TabbyProfile,
   countPanes,
   createDefaultWorkspace,
+  deepClone,
   isWorkspaceSplit,
 } from '../models/workspace.model'
 
+const SETTINGS_MAX_WIDTH = '876px'
+
 @Component({
   selector: 'workspace-list',
   template: require('./workspaceList.component.pug'),
@@ -23,6 +29,8 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
   editingWorkspace: Workspace | null = null
   isCreatingNew = false
   openingWorkspaceId: string | null = null
+  displayTabs: Array<{ workspace: Workspace; isNew: boolean }> = []
+  private cachedProfiles: TabbyProfile[] = []
   private configSubscription: Subscription | null = null
 
   constructor(
@@ -30,16 +38,18 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
     private workspaceService: WorkspaceEditorService,
     private profilesService: ProfilesService,
     private startupService: StartupCommandService,
+    private modalService: NgbModal,
     private cdr: ChangeDetectorRef,
     private elementRef: ElementRef,
     private zone: NgZone
   ) {}
 
-  ngOnInit(): void {
+  async ngOnInit(): Promise<void> {
     this.loadWorkspaces()
     this.autoSelectFirst()
+    this.cachedProfiles = await this.workspaceService.getAvailableProfiles()
     this.configSubscription = this.config.changed$.subscribe(() => {
-      this.loadWorkspaces()
+      this.zone.run(() => this.loadWorkspaces())
     })
   }
 
@@ -48,7 +58,7 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
     setTimeout(() => {
       const parent = this.elementRef.nativeElement.closest('settings-tab-body') as HTMLElement
       if (parent) {
-        parent.style.maxWidth = '876px'
+        parent.style.maxWidth = SETTINGS_MAX_WIDTH
       }
     }, 0)
   }
@@ -62,7 +72,8 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
   selectWorkspace(workspace: Workspace): void {
     this.isCreatingNew = false
     this.selectedWorkspace = workspace
-    this.editingWorkspace = JSON.parse(JSON.stringify(workspace))
+    this.editingWorkspace = deepClone(workspace)
+    this.updateDisplayTabs()
   }
 
   isSelected(workspace: Workspace): boolean {
@@ -74,18 +85,26 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
   }
 
   loadWorkspaces(): void {
+    const previousSelectedId = this.selectedWorkspace?.id
     this.workspaces = this.workspaceService.getWorkspaces()
-    this.cdr.detectChanges()
+
+    // Re-sync selectedWorkspace to point to object in new array
+    // This prevents stale reference after delete/reload operations
+    if (previousSelectedId) {
+      this.selectedWorkspace = this.workspaces.find(w => w.id === previousSelectedId) || null
+    }
+
+    this.updateDisplayTabs()
   }
 
-  async createWorkspace(): Promise<void> {
-    const profiles = await this.workspaceService.getAvailableProfiles()
-    const defaultProfileId = profiles[0]?.id || ''
+  createWorkspace(): void {
+    const defaultProfileId = this.cachedProfiles[0]?.id || ''
     const workspace = createDefaultWorkspace()
     this.setProfileForAllPanes(workspace.root, defaultProfileId)
     this.selectedWorkspace = null
     this.editingWorkspace = workspace
     this.isCreatingNew = true
+    this.updateDisplayTabs()
     this.cdr.detectChanges()
   }
 
@@ -105,33 +124,48 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
     event.stopPropagation()
     const clone = this.workspaceService.duplicateWorkspace(workspace)
     await this.workspaceService.addWorkspace(clone)
-    this.loadWorkspaces()
 
-    // Select the duplicated workspace
-    const duplicated = this.workspaces.find((w) => w.id === clone.id)
-    if (duplicated) {
-      this.selectWorkspace(duplicated)
-    }
-    this.cdr.detectChanges()
+    this.zone.run(() => {
+      this.loadWorkspaces()
+      const duplicated = this.workspaces.find((w) => w.id === clone.id)
+      if (duplicated) {
+        this.selectWorkspace(duplicated)
+      }
+    })
   }
 
   async deleteWorkspace(event: MouseEvent, workspace: Workspace): Promise<void> {
     event.stopPropagation()
-    if (confirm(`Delete workspace "${workspace.name}"?`)) {
-      const currentIndex = this.workspaces.findIndex((w) => w.id === workspace.id)
-      await this.workspaceService.deleteWorkspace(workspace.id)
-      this.loadWorkspaces()
 
-      // Select next workspace after deletion
-      if (this.workspaces.length > 0) {
-        const nextIndex = Math.min(currentIndex, this.workspaces.length - 1)
-        this.selectWorkspace(this.workspaces[nextIndex])
-      } else {
+    const confirmed = await this.confirmDelete(workspace.name)
+    if (!confirmed) return
+
+    const wasSelected = this.selectedWorkspace?.id === workspace.id
+    const deletedIndex = this.workspaces.findIndex((w) => w.id === workspace.id)
+
+    await this.workspaceService.deleteWorkspace(workspace.id)
+
+    this.zone.run(() => {
+      this.loadWorkspaces()
+      if (this.workspaces.length === 0) {
         this.selectedWorkspace = null
         this.editingWorkspace = null
         this.isCreatingNew = false
+      } else if (wasSelected) {
+        const nextIndex = Math.min(deletedIndex, this.workspaces.length - 1)
+        this.selectWorkspace(this.workspaces[nextIndex])
       }
-      this.cdr.detectChanges()
+    })
+  }
+
+  private async confirmDelete(name: string): Promise<boolean> {
+    const modalRef = this.modalService.open(DeleteConfirmModalComponent)
+    modalRef.componentInstance.workspaceName = name
+    try {
+      await modalRef.result
+      return true
+    } catch {
+      return false
     }
   }
 
@@ -142,15 +176,16 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
     } else {
       await this.workspaceService.updateWorkspace(workspace)
     }
-    this.loadWorkspaces()
-    this.isCreatingNew = false
 
-    // Select the saved workspace
-    const saved = this.workspaces.find((w) => w.id === workspace.id)
-    if (saved) {
-      this.selectWorkspace(saved)
-    }
-    this.cdr.detectChanges()
+    // Wrap state changes in zone.run to ensure proper change detection
+    this.zone.run(() => {
+      this.loadWorkspaces()
+      this.isCreatingNew = false
+      const saved = this.workspaces.find((w) => w.id === workspace.id)
+      if (saved) {
+        this.selectWorkspace(saved)
+      }
+    })
   }
 
   onEditorCancel(): void {
@@ -162,10 +197,11 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
       } else {
         this.selectedWorkspace = null
         this.editingWorkspace = null
+        this.updateDisplayTabs()
       }
     } else if (this.selectedWorkspace) {
       // Reset to original workspace data
-      this.editingWorkspace = JSON.parse(JSON.stringify(this.selectedWorkspace))
+      this.editingWorkspace = deepClone(this.selectedWorkspace)
     }
     this.cdr.detectChanges()
   }
@@ -183,6 +219,24 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
     return JSON.stringify(this.editingWorkspace) !== JSON.stringify(this.selectedWorkspace)
   }
 
+  // Update display tabs array (call after state changes)
+  private updateDisplayTabs(): void {
+    const tabs = this.workspaces.map(w => ({ workspace: w, isNew: false }))
+    if (this.isCreatingNew && this.editingWorkspace) {
+      tabs.push({ workspace: this.editingWorkspace, isNew: true })
+    }
+    this.displayTabs = tabs
+  }
+
+  isTabSelected(tab: { workspace: Workspace; isNew: boolean }): boolean {
+    if (tab.isNew) return true
+    return this.selectedWorkspace?.id === tab.workspace.id
+  }
+
+  trackByTab(index: number, tab: { workspace: Workspace; isNew: boolean }): string {
+    return tab.isNew ? '__new__' : tab.workspace.id
+  }
+
   async openWorkspace(event: MouseEvent, workspace: Workspace): Promise<void> {
     event.stopPropagation()
     if (this.openingWorkspaceId) return
@@ -203,4 +257,5 @@ export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit
       this.cdr.detectChanges()
     }
   }
+
 }

package/src/index.ts

@@ -9,11 +9,13 @@ import { WorkspaceEditorSettingsProvider } from './providers/settings.provider'
 import { WorkspaceToolbarProvider } from './providers/toolbar.provider'
 import { WorkspaceEditorService } from './services/workspaceEditor.service'
 import { StartupCommandService } from './services/startupCommand.service'
+import { WorkspaceBackgroundService } from './services/workspaceBackground.service'
 
 import { WorkspaceListComponent } from './components/workspaceList.component'
 import { WorkspaceEditorComponent } from './components/workspaceEditor.component'
 import { PaneEditorComponent } from './components/paneEditor.component'
 import { SplitPreviewComponent } from './components/splitPreview.component'
+import { DeleteConfirmModalComponent } from './components/deleteConfirmModal.component'
 
 @NgModule({
   imports: [CommonModule, FormsModule],
@@ -23,12 +25,14 @@ import { SplitPreviewComponent } from './components/splitPreview.component'
     { provide: ToolbarButtonProvider, useClass: WorkspaceToolbarProvider, multi: true },
     WorkspaceEditorService,
     StartupCommandService,
+    WorkspaceBackgroundService,
   ],
   declarations: [
     WorkspaceListComponent,
     WorkspaceEditorComponent,
     PaneEditorComponent,
     SplitPreviewComponent,
+    DeleteConfirmModalComponent,
   ],
 })
 export default class WorkspaceEditorModule {}

package/src/models/workspace.model.ts

@@ -38,6 +38,8 @@ export interface TabbyRecoveryToken {
   tabCustomTitle?: string
   disableDynamicTitle?: boolean
   cwd?: string
+  // Allow custom properties (matches Tabby's RecoveryToken interface)
+  [key: string]: any
 }
 
 export interface TabbySplitLayoutProfile {
@@ -59,7 +61,6 @@ export interface WorkspacePane {
   profileId: string
   cwd?: string
   startupCommand?: string
-  title?: string
 }
 
 export interface WorkspaceSplit {
@@ -68,29 +69,71 @@ export interface WorkspaceSplit {
   children: (WorkspacePane | WorkspaceSplit)[]
 }
 
+export interface WorkspaceBackground {
+  type: 'none' | 'solid' | 'gradient' | 'image'
+  value: string  // CSS value: hex, gradient string, or URL
+}
+
 export interface Workspace {
   id: string
   name: string
   icon?: string
   color?: string
+  background?: WorkspaceBackground
   root: WorkspaceSplit
   launchOnStartup?: boolean
 }
 
+// Preset backgrounds for quick selection
+export const BACKGROUND_PRESETS: WorkspaceBackground[] = [
+  { type: 'none', value: '' },
+  // Existing presets
+  { type: 'gradient', value: 'linear-gradient(132deg, transparent 83%, rgba(6, 220, 249, 0.18) 100%), linear-gradient(210deg, transparent 85%, rgba(139, 92, 246, 0.2) 100%)' },
+  { type: 'gradient', value: 'linear-gradient(135deg, rgba(16, 185, 129, 0.15) 0%, transparent 50%)' },
+  { type: 'gradient', value: 'linear-gradient(45deg, rgba(239, 68, 68, 0.1) 0%, transparent 50%)' },
+  { type: 'gradient', value: 'linear-gradient(135deg, rgba(59, 130, 246, 0.15) 0%, transparent 50%)' },
+  { type: 'gradient', value: 'linear-gradient(225deg, transparent 70%, rgba(249, 115, 22, 0.15) 100%)' },
+  { type: 'gradient', value: 'linear-gradient(180deg, rgba(139, 92, 246, 0.1) 0%, transparent 40%)' },
+  // New presets
+  { type: 'gradient', value: 'linear-gradient(315deg, transparent 80%, rgba(236, 72, 153, 0.15) 100%)' }, // Pink bottom-right
+  { type: 'gradient', value: 'linear-gradient(0deg, rgba(6, 182, 212, 0.12) 0%, transparent 35%)' }, // Cyan bottom
+  { type: 'gradient', value: 'linear-gradient(45deg, transparent 85%, rgba(234, 179, 8, 0.18) 100%), linear-gradient(225deg, transparent 85%, rgba(249, 115, 22, 0.15) 100%)' }, // Gold corners
+  { type: 'gradient', value: 'linear-gradient(160deg, rgba(34, 197, 94, 0.12) 0%, transparent 40%)' }, // Green top-left
+  { type: 'gradient', value: 'linear-gradient(200deg, transparent 75%, rgba(99, 102, 241, 0.18) 100%)' }, // Indigo bottom-left
+  { type: 'gradient', value: 'linear-gradient(135deg, rgba(20, 184, 166, 0.1) 0%, transparent 50%), linear-gradient(315deg, rgba(139, 92, 246, 0.1) 0%, transparent 50%)' }, // Teal + Violet diagonal
+  { type: 'gradient', value: 'linear-gradient(90deg, rgba(239, 68, 68, 0.08) 0%, transparent 30%, transparent 70%, rgba(59, 130, 246, 0.08) 100%)' }, // Red-Blue sides
+  { type: 'gradient', value: 'linear-gradient(180deg, transparent 60%, rgba(16, 185, 129, 0.12) 100%)' }, // Emerald bottom fade
+  { type: 'gradient', value: 'linear-gradient(45deg, rgba(168, 85, 247, 0.1) 0%, transparent 40%), linear-gradient(225deg, rgba(6, 182, 212, 0.1) 0%, transparent 40%)' }, // Purple + Cyan corners
+  { type: 'gradient', value: 'linear-gradient(150deg, transparent 70%, rgba(251, 146, 60, 0.15) 100%), linear-gradient(30deg, transparent 70%, rgba(251, 146, 60, 0.1) 100%)' }, // Warm orange accents
+]
+
+/**
+ * Type guard to check if a node is a WorkspaceSplit.
+ * @param node - The node to check
+ * @returns True if the node is a WorkspaceSplit
+ */
 export function isWorkspaceSplit(node: WorkspacePane | WorkspaceSplit): node is WorkspaceSplit {
   return 'orientation' in node && 'children' in node
 }
 
+/**
+ * Creates a new pane with default configuration.
+ * @returns A new WorkspacePane with generated UUID and empty settings
+ */
 export function createDefaultPane(): WorkspacePane {
   return {
     id: generateUUID(),
     profileId: '',
     cwd: '',
     startupCommand: '',
-    title: '',
   }
 }
 
+/**
+ * Creates a new split with two default panes.
+ * @param orientation - Split direction ('horizontal' or 'vertical'), defaults to 'horizontal'
+ * @returns A new WorkspaceSplit with two panes at 50/50 ratio
+ */
 export function createDefaultSplit(orientation: 'horizontal' | 'vertical' = 'horizontal'): WorkspaceSplit {
   return {
     orientation,
@@ -118,14 +161,21 @@ const WORKSPACE_ICONS = [
   'bug', 'wrench', 'cube', 'layer-group', 'sitemap', 'project-diagram'
 ]
 
+/** Returns a random color from the workspace color palette. */
 export function getRandomColor(): string {
   return WORKSPACE_COLORS[Math.floor(Math.random() * WORKSPACE_COLORS.length)]
 }
 
+/** Returns a random icon from the workspace icon set. */
 export function getRandomIcon(): string {
   return WORKSPACE_ICONS[Math.floor(Math.random() * WORKSPACE_ICONS.length)]
 }
 
+/**
+ * Creates a new workspace with default configuration.
+ * @param name - Display name for the workspace (optional)
+ * @returns A new Workspace with generated UUID, random icon/color, and a default split
+ */
 export function createDefaultWorkspace(name: string = ''): Workspace {
   return {
     id: generateUUID(),
@@ -137,6 +187,7 @@ export function createDefaultWorkspace(name: string = ''): Workspace {
   }
 }
 
+/** Generates a random UUID v4 string. */
 export function generateUUID(): string {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
     const r = (Math.random() * 16) | 0
@@ -145,9 +196,36 @@ export function generateUUID(): string {
   })
 }
 
+/**
+ * Recursively counts the total number of panes in a split tree.
+ * @param node - The root node to count from
+ * @returns Total number of panes in the tree
+ */
 export function countPanes(node: WorkspacePane | WorkspaceSplit): number {
   if (isWorkspaceSplit(node)) {
     return node.children.reduce((sum, child) => sum + countPanes(child), 0)
   }
   return 1
 }
+
+/**
+ * Creates a deep clone of an object, preserving type information.
+ * More efficient than JSON.parse(JSON.stringify()) for simple objects.
+ * @param obj - The object to clone
+ * @returns A deep copy of the object
+ */
+export function deepClone<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(item => deepClone(item)) as T
+  }
+  const cloned = {} as T
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key])
+    }
+  }
+  return cloned
+}

package/src/providers/toolbar.provider.ts

@@ -1,7 +1,9 @@
 import { Injectable } from '@angular/core'
-import { ToolbarButtonProvider, ToolbarButton, ProfilesService, AppService } from 'tabby-core'
+import { ToolbarButtonProvider, ToolbarButton, ProfilesService, AppService, SplitTabComponent } from 'tabby-core'
+import { BaseTerminalTabComponent } from 'tabby-terminal'
 import { WorkspaceEditorService } from '../services/workspaceEditor.service'
 import { StartupCommandService } from '../services/startupCommand.service'
+import { WorkspaceBackgroundService } from '../services/workspaceBackground.service'
 import { SettingsTabComponent } from 'tabby-settings'
 import { CONFIG_KEY, DISPLAY_NAME, IS_DEV } from '../build-config'
 
@@ -15,24 +17,51 @@ const ICON_GRID = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" f
 const ICON_BOLT = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
   <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>
 </svg>`
+
+const SELECTOR_SETTINGS_ID = '__settings__'
+
 import { countPanes } from '../models/workspace.model'
 
+/** Recovery token structure for workspace tabs */
+interface RecoveryTokenWithWorkspace {
+  workspaceId?: string
+}
+
 @Injectable()
 export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
   constructor(
     private workspaceService: WorkspaceEditorService,
     private profilesService: ProfilesService,
     private app: AppService,
-    private startupService: StartupCommandService
+    private startupService: StartupCommandService,
+    private backgroundService: WorkspaceBackgroundService
   ) {
     super()
-    // Delay startup tasks to ensure Tabby config is loaded
-    setTimeout(() => {
-      // Cleanup orphaned profiles from previous plugin versions (one-time migration)
+    // Initialize background service to listen for tab events
+    this.backgroundService.initialize()
+
+    // Wait for Tabby to finish recovery before launching startup workspaces
+    this.waitForTabbyReady().then(() => {
       this.workspaceService.cleanupOrphanedProfiles()
-      // Launch workspaces marked for startup
       this.launchStartupWorkspaces()
-    }, 500)
+    })
+  }
+
+  private waitForTabbyReady(): Promise<void> {
+    return new Promise(resolve => {
+      let lastTabCount = -1
+      const checkStable = () => {
+        const currentCount = this.app.tabs.length
+        if (currentCount === lastTabCount && currentCount >= 0) {
+          resolve()
+        } else {
+          lastTabCount = currentCount
+          setTimeout(checkStable, 300)
+        }
+      }
+      // Initial delay to let Tabby start loading
+      setTimeout(checkStable, 500)
+    })
   }
 
   private async launchStartupWorkspaces(): Promise<void> {
@@ -40,10 +69,50 @@ export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
     const startupWorkspaces = workspaces.filter(w => w.launchOnStartup)
 
     for (const workspace of startupWorkspaces) {
+      if (this.isWorkspaceAlreadyOpen(workspace.id)) {
+        console.log(`[TabbySpaces] Workspace "${workspace.name}" already open, skipping`)
+        continue
+      }
       await this.openWorkspace(workspace.id)
     }
   }
 
+  /**
+   * Type-safe helper to extract workspace ID from tab's recovery token.
+   */
+  private getRecoveryWorkspaceId(tab: unknown): string | undefined {
+    if (tab && typeof tab === 'object' && 'recoveryToken' in tab) {
+      const token = (tab as { recoveryToken?: RecoveryTokenWithWorkspace }).recoveryToken
+      return token?.workspaceId
+    }
+    return undefined
+  }
+
+  private isWorkspaceAlreadyOpen(workspaceId: string): boolean {
+    const profilePrefix = `split-layout:${CONFIG_KEY}:`
+
+    for (const tab of this.app.tabs) {
+      if (tab instanceof SplitTabComponent) {
+        // Strategy 1: Check recoveryToken.workspaceId (for restored tabs)
+        if (this.getRecoveryWorkspaceId(tab) === workspaceId) {
+          return true
+        }
+
+        // Strategy 2: Check profile ID (for freshly opened tabs)
+        for (const child of tab.getAllTabs()) {
+          if (child instanceof BaseTerminalTabComponent) {
+            const profileId = child.profile?.id ?? ''
+            // Strict matching: prefix + workspaceId at the end
+            if (profileId.startsWith(profilePrefix) && profileId.endsWith(`:${workspaceId}`)) {
+              return true
+            }
+          }
+        }
+      }
+    }
+    return false
+  }
+
   provide(): ToolbarButton[] {
     return [
       {
@@ -77,12 +146,12 @@ export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
       description: 'Create and edit workspaces',
       icon: 'cog',
       color: undefined,
-      result: '__settings__'
+      result: SELECTOR_SETTINGS_ID
     })
 
     const selectedId = await this.app.showSelector('Select Workspace', options)
 
-    if (selectedId === '__settings__') {
+    if (selectedId === SELECTOR_SETTINGS_ID) {
       this.openSettings()
     } else if (selectedId) {
       this.openWorkspace(selectedId)

package/src/services/startupCommand.service.ts

@@ -1,7 +1,8 @@
 import { Injectable } from '@angular/core'
 import { AppService, BaseTabComponent, SplitTabComponent } from 'tabby-core'
 import { BaseTerminalTabComponent } from 'tabby-terminal'
-import { Subscription, first, timer, switchMap } from 'rxjs'
+import { first, timeout, of } from 'rxjs'
+import { catchError } from 'rxjs/operators'
 
 export interface PendingCommand {
   paneId: string
@@ -9,13 +10,21 @@ export interface PendingCommand {
   originalTitle: string
 }
 
+/**
+ * Handles startup commands for workspace panes.
+ *
+ * This service listens to tab open events and sends startup commands
+ * to terminals that match registered pane IDs.
+ *
+ * NOTE: This is a module-level singleton that lives for the app lifetime.
+ * The tabOpened$ subscription intentionally runs forever - no cleanup needed.
+ */
 @Injectable()
 export class StartupCommandService {
   private pendingCommands: Map<string, PendingCommand> = new Map()
-  private subscription: Subscription
 
   constructor(private app: AppService) {
-    this.subscription = this.app.tabOpened$.subscribe((tab) => this.onTabOpened(tab))
+    this.app.tabOpened$.subscribe((tab) => this.onTabOpened(tab))
   }
 
   registerCommands(commands: PendingCommand[]): void {
@@ -84,40 +93,27 @@ export class StartupCommandService {
 
     console.log('[TabbySpaces] Command matched, waiting for shell output...:', fullCommand)
 
+    // Unified command sender - reduces duplication
+    const sendCommand = () => {
+      console.log('[TabbySpaces] Shell ready, sending command:', fullCommand)
+      terminalTab.sendInput(fullCommand + '\r')
+      this.clearProfileArgs(terminalTab)
+      this.setTabTitle(terminalTab, pending.originalTitle)
+    }
+
     // Wait for shell to emit first output (prompt), then send command
     if (terminalTab.session?.output$) {
       terminalTab.session.output$.pipe(
-        first(),                      // Wait for first output (shell prompt)
-        switchMap(() => timer(100))   // Small buffer after prompt renders
+        first(),
+        timeout(2000),  // Prevent infinite wait if shell doesn't emit
+        catchError(() => of(null))  // Fallback on timeout/error
       ).subscribe(() => {
-        console.log('[TabbySpaces] Shell ready, sending command:', fullCommand)
-        terminalTab.sendInput(fullCommand + '\r')
-
-        // Clear profile args to prevent native splits from re-running command
-        this.clearProfileArgs(terminalTab)
-
-        // Reset title - either to original or clear for dynamic shell title
-        if (pending.originalTitle) {
-          terminalTab.setTitle(pending.originalTitle)
-        } else {
-          terminalTab.customTitle = ''
-        }
+        // Small delay after prompt renders
+        setTimeout(sendCommand, 100)
       })
     } else {
       console.log('[TabbySpaces] No session.output$, falling back to timeout')
-      // Fallback if session not available yet
-      setTimeout(() => {
-        terminalTab.sendInput(fullCommand + '\r')
-
-        // Clear profile args to prevent native splits from re-running command
-        this.clearProfileArgs(terminalTab)
-
-        if (pending.originalTitle) {
-          terminalTab.setTitle(pending.originalTitle)
-        } else {
-          terminalTab.customTitle = ''
-        }
-      }, 500)
+      setTimeout(sendCommand, 500)
     }
   }
 
@@ -136,7 +132,9 @@ export class StartupCommandService {
     }
   }
 
-  ngOnDestroy(): void {
-    this.subscription?.unsubscribe()
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private setTabTitle(terminalTab: BaseTerminalTabComponent<any>, title: string): void {
+    terminalTab.setTitle(title)
+    terminalTab.customTitle = title
   }
 }