tabby-tabbyspaces 0.0.1 → 0.2.0

package/src/providers/toolbar.provider.ts

@@ -1,29 +1,122 @@
 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 } from '../build-config'
+import { CONFIG_KEY, DISPLAY_NAME, IS_DEV } from '../build-config'
+
+const ICON_GRID = `<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">
+  <rect x="3" y="3" width="7" height="7"/>
+  <rect x="14" y="3" width="7" height="7"/>
+  <rect x="14" y="14" width="7" height="7"/>
+  <rect x="3" y="14" width="7" height="7"/>
+</svg>`
+
+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 app: AppService,
+    private startupService: StartupCommandService,
+    private backgroundService: WorkspaceBackgroundService
   ) {
     super()
+    // 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()
+      this.launchStartupWorkspaces()
+    })
+  }
+
+  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> {
+    const workspaces = this.workspaceService.getWorkspaces()
+    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 [
       {
-        icon: `<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">
-          <rect x="3" y="3" width="7" height="7"/>
-          <rect x="14" y="3" width="7" height="7"/>
-          <rect x="14" y="14" width="7" height="7"/>
-          <rect x="3" y="14" width="7" height="7"/>
-        </svg>`,
+        icon: IS_DEV ? ICON_BOLT : ICON_GRID,
         title: DISPLAY_NAME,
         weight: 5,
         click: () => this.showWorkspaceSelector()
@@ -53,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)
@@ -69,13 +162,20 @@ export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
     this.app.openNewTabRaw({ type: SettingsTabComponent, inputs: { activeTab: CONFIG_KEY } })
   }
 
-  private openWorkspace(workspaceId: string): void {
+  private async openWorkspace(workspaceId: string): Promise<void> {
     const workspaces = this.workspaceService.getWorkspaces()
     const workspace = workspaces.find((w) => w.id === workspaceId)
 
     if (!workspace) return
 
-    const profile = this.workspaceService.generateTabbyProfile(workspace)
+    // Register startup commands BEFORE opening the workspace
+    // Commands will be sent via sendInput() when terminals open
+    const commands = this.workspaceService.collectStartupCommands(workspace)
+    if (commands.length > 0) {
+      this.startupService.registerCommands(commands)
+    }
+
+    const profile = await this.workspaceService.generateTabbyProfile(workspace)
     this.profilesService.openNewTabForProfile(profile)
   }
 }

package/src/services/startupCommand.service.ts

@@ -0,0 +1,140 @@
+import { Injectable } from '@angular/core'
+import { AppService, BaseTabComponent, SplitTabComponent } from 'tabby-core'
+import { BaseTerminalTabComponent } from 'tabby-terminal'
+import { first, timeout, of } from 'rxjs'
+import { catchError } from 'rxjs/operators'
+
+export interface PendingCommand {
+  paneId: string
+  command?: string
+  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()
+
+  constructor(private app: AppService) {
+    this.app.tabOpened$.subscribe((tab) => this.onTabOpened(tab))
+  }
+
+  registerCommands(commands: PendingCommand[]): void {
+    console.log('[TabbySpaces] Registering commands:', commands)
+    for (const cmd of commands) {
+      this.pendingCommands.set(cmd.paneId, cmd)
+    }
+  }
+
+  private onTabOpened(tab: BaseTabComponent): void {
+    console.log('[TabbySpaces] Tab opened:', {
+      type: tab.constructor.name,
+      title: tab.title,
+    })
+
+    // Handle SplitTabComponent - get all child terminal tabs
+    if (tab instanceof SplitTabComponent) {
+      console.log('[TabbySpaces] SplitTabComponent detected, waiting for children...')
+      // Wait for split tab to fully initialize its children
+      setTimeout(() => this.processChildTabs(tab), 300)
+      return
+    }
+
+    // Handle individual terminal tab (shouldn't happen for split-layout, but just in case)
+    if (tab instanceof BaseTerminalTabComponent) {
+      this.processTerminalTab(tab)
+    }
+  }
+
+  private processChildTabs(splitTab: SplitTabComponent): void {
+    // Get all nested tabs from the split container
+    const allTabs = splitTab.getAllTabs()
+    console.log('[TabbySpaces] Found child tabs:', allTabs.length)
+
+    for (const tab of allTabs) {
+      if (tab instanceof BaseTerminalTabComponent) {
+        this.processTerminalTab(tab)
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private processTerminalTab(terminalTab: BaseTerminalTabComponent<any>): void {
+    const paneId = terminalTab.customTitle || terminalTab.title
+    console.log('[TabbySpaces] Processing terminal tab:', {
+      title: terminalTab.title,
+      customTitle: terminalTab.customTitle,
+      paneId,
+      pendingKeys: [...this.pendingCommands.keys()],
+    })
+
+    const pending = this.pendingCommands.get(paneId)
+    if (!pending) {
+      console.log('[TabbySpaces] No matching command for paneId:', paneId)
+      return
+    }
+
+    this.pendingCommands.delete(paneId)
+
+    // Build startup command (cd + command)
+    const fullCommand = this.buildFullCommand(pending)
+    if (!fullCommand) {
+      console.log('[TabbySpaces] No command to send (no cwd or startup command)')
+      return
+    }
+
+    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(),
+        timeout(2000),  // Prevent infinite wait if shell doesn't emit
+        catchError(() => of(null))  // Fallback on timeout/error
+      ).subscribe(() => {
+        // Small delay after prompt renders
+        setTimeout(sendCommand, 100)
+      })
+    } else {
+      console.log('[TabbySpaces] No session.output$, falling back to timeout')
+      setTimeout(sendCommand, 500)
+    }
+  }
+
+  private buildFullCommand(pending: PendingCommand): string | null {
+    return pending.command || null
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private clearProfileArgs(terminalTab: BaseTerminalTabComponent<any>): void {
+    // Clear args from profile to prevent native splits from re-running startup command
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const profile = (terminalTab as any).profile
+    if (profile?.options?.args) {
+      console.log('[TabbySpaces] Clearing profile args to prevent re-run on split')
+      profile.options.args = []
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private setTabTitle(terminalTab: BaseTerminalTabComponent<any>, title: string): void {
+    terminalTab.setTitle(title)
+    terminalTab.customTitle = title
+  }
+}

package/src/services/workspaceBackground.service.ts

@@ -0,0 +1,167 @@
+import { Injectable } from '@angular/core'
+import { AppService, SplitTabComponent } from 'tabby-core'
+import { WorkspaceEditorService } from './workspaceEditor.service'
+import { WorkspaceBackground } from '../models/workspace.model'
+import { CONFIG_KEY } from '../build-config'
+
+/**
+ * Service for applying custom backgrounds to workspace tabs.
+ * Injects CSS dynamically based on workspace configuration.
+ */
+@Injectable({ providedIn: 'root' })
+export class WorkspaceBackgroundService {
+  private styleElement: HTMLStyleElement | null = null
+  private appliedWorkspaces = new Map<string, string>() // workspaceId -> CSS
+
+  constructor(
+    private app: AppService,
+    private workspaceService: WorkspaceEditorService
+  ) {}
+
+  /**
+   * Initialize the service by setting up tab event listeners.
+   * Must be called once during app initialization.
+   */
+  initialize(): void {
+    this.setupTabListeners()
+  }
+
+  private setupTabListeners(): void {
+    // Listen for tab open
+    this.app.tabOpened$.subscribe(tab => this.onTabOpened(tab))
+
+    // Listen for tab close - cleanup
+    this.app.tabClosed$.subscribe(tab => this.onTabClosed(tab))
+  }
+
+  private onTabOpened(tab: unknown): void {
+    if (!(tab instanceof SplitTabComponent)) return
+
+    // Small delay to let Angular finish rendering
+    setTimeout(() => {
+      const workspaceId = this.extractWorkspaceId(tab)
+      if (!workspaceId) return
+
+      const workspace = this.workspaceService.getWorkspaces()
+        .find(w => w.id === workspaceId)
+
+      if (workspace?.background && workspace.background.type !== 'none') {
+        this.applyBackground(workspaceId, workspace.background)
+      }
+    }, 200)
+  }
+
+  private onTabClosed(tab: unknown): void {
+    if (!(tab instanceof SplitTabComponent)) return
+
+    const workspaceId = this.extractWorkspaceId(tab)
+    if (workspaceId) {
+      this.removeBackground(workspaceId)
+    }
+  }
+
+  /**
+   * Extract workspace ID from a SplitTabComponent.
+   * Tries multiple strategies: _recoveredState and child profile ID.
+   */
+  private extractWorkspaceId(tab: SplitTabComponent): string | undefined {
+    const tabAny = tab as any
+
+    // Strategy 1: Check _recoveredState.workspaceId (for restored tabs)
+    if (tabAny._recoveredState?.workspaceId) {
+      return tabAny._recoveredState.workspaceId
+    }
+
+    // Strategy 2: Extract from child profile ID (for freshly opened tabs)
+    const profilePrefix = `split-layout:${CONFIG_KEY}:`
+    for (const child of tab.getAllTabs()) {
+      const profileId = (child as any).profile?.id ?? ''
+      if (profileId.startsWith(profilePrefix)) {
+        // Profile ID format: split-layout:CONFIG_KEY:name:UUID
+        const parts = profileId.split(':')
+        return parts[parts.length - 1]
+      }
+    }
+
+    return undefined
+  }
+
+  private applyBackground(workspaceId: string, bg: WorkspaceBackground): void {
+    // Mark split-tab element with data attribute
+    this.markSplitTabElement(workspaceId)
+
+    // Generate and inject CSS
+    const css = this.generateCSS(workspaceId, bg)
+    this.injectCSS(workspaceId, css)
+  }
+
+  private markSplitTabElement(workspaceId: string): void {
+    // Find split-tab that doesn't have a workspace-id yet
+    const splitTabs = document.querySelectorAll('split-tab')
+    for (let i = splitTabs.length - 1; i >= 0; i--) {
+      const splitTab = splitTabs[i]
+      if (!splitTab.hasAttribute('data-workspace-id')) {
+        splitTab.setAttribute('data-workspace-id', workspaceId)
+        break
+      }
+    }
+  }
+
+  private generateCSS(workspaceId: string, bg: WorkspaceBackground): string {
+    if (bg.type === 'none' || !bg.value) return ''
+
+    return `
+      split-tab[data-workspace-id="${workspaceId}"] {
+        background: ${bg.value} !important;
+      }
+      split-tab[data-workspace-id="${workspaceId}"] .xterm-viewport,
+      split-tab[data-workspace-id="${workspaceId}"] .xterm-screen {
+        background: transparent !important;
+      }
+    `
+  }
+
+  private injectCSS(workspaceId: string, css: string): void {
+    if (!this.styleElement) {
+      this.styleElement = document.createElement('style')
+      this.styleElement.id = 'tabbyspaces-backgrounds'
+      document.head.appendChild(this.styleElement)
+    }
+
+    this.appliedWorkspaces.set(workspaceId, css)
+    this.updateStyleElement()
+  }
+
+  private removeBackground(workspaceId: string): void {
+    this.appliedWorkspaces.delete(workspaceId)
+    this.updateStyleElement()
+  }
+
+  private updateStyleElement(): void {
+    if (this.styleElement) {
+      this.styleElement.textContent = Array.from(this.appliedWorkspaces.values()).join('\n')
+    }
+  }
+
+  /**
+   * Refresh background for a specific workspace.
+   * Call this when workspace background is updated in settings.
+   */
+  refreshWorkspaceBackground(workspaceId: string): void {
+    const workspace = this.workspaceService.getWorkspaces()
+      .find(w => w.id === workspaceId)
+
+    if (!workspace) {
+      this.removeBackground(workspaceId)
+      return
+    }
+
+    if (workspace.background && workspace.background.type !== 'none') {
+      const css = this.generateCSS(workspaceId, workspace.background)
+      this.appliedWorkspaces.set(workspaceId, css)
+    } else {
+      this.appliedWorkspaces.delete(workspaceId)
+    }
+    this.updateStyleElement()
+  }
+}