tabby-tabbyspaces 0.0.1

package/src/index.ts

@@ -0,0 +1,38 @@
+import { NgModule } from '@angular/core'
+import { CommonModule } from '@angular/common'
+import { FormsModule } from '@angular/forms'
+import { ConfigProvider, ToolbarButtonProvider } from 'tabby-core'
+import { SettingsTabProvider } from 'tabby-settings'
+
+import { WorkspaceEditorConfigProvider } from './providers/config.provider'
+import { WorkspaceEditorSettingsProvider } from './providers/settings.provider'
+import { WorkspaceToolbarProvider } from './providers/toolbar.provider'
+import { WorkspaceEditorService } from './services/workspaceEditor.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'
+
+@NgModule({
+  imports: [CommonModule, FormsModule],
+  providers: [
+    { provide: ConfigProvider, useClass: WorkspaceEditorConfigProvider, multi: true },
+    { provide: SettingsTabProvider, useClass: WorkspaceEditorSettingsProvider, multi: true },
+    { provide: ToolbarButtonProvider, useClass: WorkspaceToolbarProvider, multi: true },
+    WorkspaceEditorService,
+  ],
+  declarations: [
+    WorkspaceListComponent,
+    WorkspaceEditorComponent,
+    PaneEditorComponent,
+    SplitPreviewComponent,
+  ],
+})
+export default class WorkspaceEditorModule {}
+
+export {
+  WorkspaceEditorService,
+  WorkspaceEditorConfigProvider,
+  WorkspaceEditorSettingsProvider,
+}

package/src/models/workspace.model.ts

@@ -0,0 +1,126 @@
+// Tabby profile interfaces
+export interface TabbyProfileOptions {
+  command?: string
+  args?: string[]
+  cwd?: string
+  env?: Record<string, string>
+  restoreFromPTYID?: boolean
+  width?: number | null
+  height?: number | null
+  pauseAfterExit?: boolean
+  runAsAdministrator?: boolean
+}
+
+export interface TabbyProfile {
+  id: string
+  type: string
+  name: string
+  group?: string
+  icon?: string
+  color?: string
+  options?: TabbyProfileOptions
+  isBuiltin?: boolean
+  isTemplate?: boolean
+  weight?: number
+  disableDynamicTitle?: boolean
+  terminalColorScheme?: string | null
+  behaviorOnSessionEnd?: string
+}
+
+export interface TabbyRecoveryToken {
+  type: string
+  orientation?: 'h' | 'v'
+  ratios?: number[]
+  children?: TabbyRecoveryToken[]
+  profile?: Partial<TabbyProfile>
+  savedState?: boolean
+  tabTitle?: string
+  tabCustomTitle?: string
+  disableDynamicTitle?: boolean
+}
+
+export interface TabbySplitLayoutProfile {
+  id: string
+  type: 'split-layout'
+  name: string
+  group: string
+  icon?: string
+  color?: string
+  isBuiltin: boolean
+  options: {
+    recoveryToken: TabbyRecoveryToken
+  }
+}
+
+// Workspace interfaces
+export interface WorkspacePane {
+  id: string
+  profileId: string
+  cwd?: string
+  startupCommand?: string
+  title?: string
+}
+
+export interface WorkspaceSplit {
+  orientation: 'horizontal' | 'vertical'
+  ratios: number[]
+  children: (WorkspacePane | WorkspaceSplit)[]
+}
+
+export interface Workspace {
+  id: string
+  name: string
+  icon?: string
+  color?: string
+  root: WorkspaceSplit
+  isDefault?: boolean
+  hotkey?: string
+}
+
+export function isWorkspaceSplit(node: WorkspacePane | WorkspaceSplit): node is WorkspaceSplit {
+  return 'orientation' in node && 'children' in node
+}
+
+export function createDefaultPane(): WorkspacePane {
+  return {
+    id: generateUUID(),
+    profileId: '',
+    cwd: '',
+    startupCommand: '',
+    title: '',
+  }
+}
+
+export function createDefaultSplit(orientation: 'horizontal' | 'vertical' = 'horizontal'): WorkspaceSplit {
+  return {
+    orientation,
+    ratios: [0.5, 0.5],
+    children: [createDefaultPane(), createDefaultPane()],
+  }
+}
+
+export function createDefaultWorkspace(name: string = 'New Workspace'): Workspace {
+  return {
+    id: generateUUID(),
+    name,
+    icon: 'columns',
+    color: '#3b82f6',
+    root: createDefaultSplit(),
+    isDefault: false,
+  }
+}
+
+export function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0
+    const v = c === 'x' ? r : (r & 0x3) | 0x8
+    return v.toString(16)
+  })
+}
+
+export function countPanes(node: WorkspacePane | WorkspaceSplit): number {
+  if (isWorkspaceSplit(node)) {
+    return node.children.reduce((sum, child) => sum + countPanes(child), 0)
+  }
+  return 1
+}

package/src/providers/config.provider.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core'
+import { ConfigProvider } from 'tabby-core'
+import { CONFIG_KEY } from '../build-config'
+
+@Injectable()
+export class WorkspaceEditorConfigProvider extends ConfigProvider {
+  defaults = {
+    [CONFIG_KEY]: {
+      workspaces: [],
+    },
+  }
+}

package/src/providers/settings.provider.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core'
+import { SettingsTabProvider } from 'tabby-settings'
+import { WorkspaceListComponent } from '../components/workspaceList.component'
+import { CONFIG_KEY, DISPLAY_NAME } from '../build-config'
+
+@Injectable()
+export class WorkspaceEditorSettingsProvider extends SettingsTabProvider {
+  id = CONFIG_KEY
+  icon = 'columns'
+  title = DISPLAY_NAME
+
+  getComponentType(): any {
+    return WorkspaceListComponent
+  }
+}

package/src/providers/toolbar.provider.ts

@@ -0,0 +1,81 @@
+import { Injectable } from '@angular/core'
+import { ToolbarButtonProvider, ToolbarButton, ProfilesService, AppService } from 'tabby-core'
+import { WorkspaceEditorService } from '../services/workspaceEditor.service'
+import { SettingsTabComponent } from 'tabby-settings'
+import { CONFIG_KEY, DISPLAY_NAME } from '../build-config'
+import { countPanes } from '../models/workspace.model'
+
+@Injectable()
+export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
+  constructor(
+    private workspaceService: WorkspaceEditorService,
+    private profilesService: ProfilesService,
+    private app: AppService
+  ) {
+    super()
+  }
+
+  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>`,
+        title: DISPLAY_NAME,
+        weight: 5,
+        click: () => this.showWorkspaceSelector()
+      }
+    ]
+  }
+
+  private async showWorkspaceSelector(): Promise<void> {
+    const workspaces = this.workspaceService.getWorkspaces()
+
+    if (workspaces.length === 0) {
+      this.openSettings()
+      return
+    }
+
+    const options = workspaces.map((ws) => ({
+      name: ws.name,
+      description: `${countPanes(ws.root)} panes`,
+      icon: ws.icon || 'grid',
+      color: ws.color,
+      result: ws.id
+    }))
+
+    // Add option to open settings
+    options.push({
+      name: 'Manage Workspaces...',
+      description: 'Create and edit workspaces',
+      icon: 'cog',
+      color: undefined,
+      result: '__settings__'
+    })
+
+    const selectedId = await this.app.showSelector('Select Workspace', options)
+
+    if (selectedId === '__settings__') {
+      this.openSettings()
+    } else if (selectedId) {
+      this.openWorkspace(selectedId)
+    }
+  }
+
+  private openSettings(): void {
+    this.app.openNewTabRaw({ type: SettingsTabComponent, inputs: { activeTab: CONFIG_KEY } })
+  }
+
+  private openWorkspace(workspaceId: string): void {
+    const workspaces = this.workspaceService.getWorkspaces()
+    const workspace = workspaces.find((w) => w.id === workspaceId)
+
+    if (!workspace) return
+
+    const profile = this.workspaceService.generateTabbyProfile(workspace)
+    this.profilesService.openNewTabForProfile(profile)
+  }
+}

package/src/services/workspaceEditor.service.ts

@@ -0,0 +1,228 @@
+import { Injectable } from '@angular/core'
+import { ConfigService, NotificationsService, ProfilesService } from 'tabby-core'
+import {
+  Workspace,
+  WorkspacePane,
+  WorkspaceSplit,
+  isWorkspaceSplit,
+  generateUUID,
+  TabbyProfile,
+  TabbyRecoveryToken,
+  TabbySplitLayoutProfile,
+} from '../models/workspace.model'
+import { CONFIG_KEY, DISPLAY_NAME } from '../build-config'
+
+@Injectable({ providedIn: 'root' })
+export class WorkspaceEditorService {
+  constructor(
+    private config: ConfigService,
+    private notifications: NotificationsService,
+    private profilesService: ProfilesService
+  ) {}
+
+  getWorkspaces(): Workspace[] {
+    return this.config.store[CONFIG_KEY]?.workspaces ?? []
+  }
+
+  async saveWorkspaces(workspaces: Workspace[]): Promise<boolean> {
+    this.config.store[CONFIG_KEY].workspaces = workspaces
+    this.syncTabbyProfiles(workspaces)
+    return await this.saveConfig()
+  }
+
+  async addWorkspace(workspace: Workspace): Promise<void> {
+    const workspaces = this.getWorkspaces()
+    workspaces.push(workspace)
+    await this.saveWorkspaces(workspaces)
+    this.notifications.info(`Workspace "${workspace.name}" created`)
+  }
+
+  async updateWorkspace(workspace: Workspace): Promise<void> {
+    const workspaces = this.getWorkspaces()
+    const index = workspaces.findIndex((w) => w.id === workspace.id)
+    if (index !== -1) {
+      workspaces[index] = workspace
+      await this.saveWorkspaces(workspaces)
+      this.notifications.info(`Workspace "${workspace.name}" updated`)
+    }
+  }
+
+  async deleteWorkspace(workspaceId: string): Promise<void> {
+    const workspaces = this.getWorkspaces()
+    const workspace = workspaces.find((w) => w.id === workspaceId)
+    const filtered = workspaces.filter((w) => w.id !== workspaceId)
+    await this.saveWorkspaces(filtered)
+    if (workspace) {
+      this.notifications.info(`Workspace "${workspace.name}" deleted`)
+    }
+  }
+
+  async getAvailableProfiles(): Promise<TabbyProfile[]> {
+    const allProfiles = await this.profilesService.getProfiles()
+    return allProfiles.filter(
+      (p) => p.type === 'local' && !p.id?.startsWith('split-layout:')
+    ) as TabbyProfile[]
+  }
+
+  private syncTabbyProfiles(workspaces: Workspace[]): void {
+    const profiles: (TabbyProfile | TabbySplitLayoutProfile)[] = this.config.store.profiles ?? []
+
+    // Remove old plugin profiles (mutate in place)
+    for (let i = profiles.length - 1; i >= 0; i--) {
+      if (profiles[i].id?.startsWith(`split-layout:${CONFIG_KEY}:`)) {
+        profiles.splice(i, 1)
+      }
+    }
+
+    // Add new workspace profiles
+    for (const workspace of workspaces) {
+      const tabbyProfile = this.generateTabbyProfile(workspace)
+      profiles.push(tabbyProfile)
+    }
+  }
+
+  generateTabbyProfile(workspace: Workspace): TabbySplitLayoutProfile {
+    const safeName = this.sanitizeForProfileId(workspace.name)
+    return {
+      id: `split-layout:${CONFIG_KEY}:${safeName}:${workspace.id}`,
+      type: 'split-layout',
+      name: workspace.name,
+      group: DISPLAY_NAME,
+      icon: workspace.icon,
+      color: workspace.color,
+      isBuiltin: false,
+      options: {
+        recoveryToken: this.generateRecoveryToken(workspace.root),
+      },
+    }
+  }
+
+  private generateRecoveryToken(split: WorkspaceSplit): TabbyRecoveryToken {
+    return {
+      type: 'app:split-tab',
+      orientation: split.orientation === 'horizontal' ? 'h' : 'v',
+      ratios: split.ratios,
+      children: split.children.map((child) => {
+        if (isWorkspaceSplit(child)) {
+          return this.generateRecoveryToken(child)
+        }
+        return this.generatePaneToken(child)
+      }),
+    }
+  }
+
+  private generatePaneToken(pane: WorkspacePane): TabbyRecoveryToken {
+    const baseProfile = this.getProfileById(pane.profileId)
+
+    if (!baseProfile) {
+      return {
+        type: 'app:local-tab',
+        profile: {
+          type: 'local',
+          name: 'Shell',
+        },
+        savedState: false,
+      }
+    }
+
+    // Build complete profile object like Tabby expects
+    const options = {
+      restoreFromPTYID: false,
+      command: baseProfile.options?.command || '',
+      args: baseProfile.options?.args || [],
+      cwd: pane.cwd || baseProfile.options?.cwd || '',
+      env: baseProfile.options?.env || {},
+      width: null,
+      height: null,
+      pauseAfterExit: false,
+      runAsAdministrator: false,
+    }
+
+    // Handle startup command for different shells
+    if (pane.startupCommand) {
+      const cmd = baseProfile.options?.command || ''
+      if (cmd.includes('nu.exe') || baseProfile.name?.toLowerCase().includes('nushell')) {
+        options.args = ['-e', pane.startupCommand]
+      } else if (cmd.includes('powershell') || cmd.includes('pwsh')) {
+        options.args = ['-NoExit', '-Command', pane.startupCommand]
+      } else if (cmd.includes('cmd.exe')) {
+        options.args = ['/K', pane.startupCommand]
+      } else {
+        options.args = ['-c', pane.startupCommand]
+      }
+    }
+
+    const profile = {
+      id: baseProfile.id,
+      type: 'local',
+      name: baseProfile.name || 'Shell',
+      group: baseProfile.group || '',
+      options,
+      icon: baseProfile.icon || '',
+      color: baseProfile.color || '',
+      disableDynamicTitle: false,
+      weight: 0,
+      isBuiltin: false,
+      isTemplate: false,
+      terminalColorScheme: null,
+      behaviorOnSessionEnd: 'auto',
+    }
+
+    return {
+      type: 'app:local-tab',
+      profile,
+      savedState: false,
+      tabTitle: pane.title || '',
+      tabCustomTitle: pane.title || '',
+      disableDynamicTitle: !!pane.title,
+    }
+  }
+
+  duplicateWorkspace(workspace: Workspace): Workspace {
+    const clone = JSON.parse(JSON.stringify(workspace)) as Workspace
+    clone.id = generateUUID()
+    clone.name = `${workspace.name} (Copy)`
+    clone.isDefault = false
+    this.regenerateIds(clone.root)
+    return clone
+  }
+
+  private regenerateIds(node: WorkspacePane | WorkspaceSplit): void {
+    if (isWorkspaceSplit(node)) {
+      for (const child of node.children) {
+        this.regenerateIds(child)
+      }
+    } else {
+      node.id = generateUUID()
+    }
+  }
+
+  private sanitizeForProfileId(name: string): string {
+    return name
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '')
+      || 'workspace'
+  }
+
+  private getProfileById(profileId: string): TabbyProfile | undefined {
+    const profiles: TabbyProfile[] = this.config.store.profiles ?? []
+    return profiles.find((p) => p.id === profileId && p.type === 'local')
+  }
+
+  getProfileName(profileId: string): string | undefined {
+    return this.getProfileById(profileId)?.name
+  }
+
+  private async saveConfig(): Promise<boolean> {
+    try {
+      await this.config.save()
+      return true
+    } catch (error) {
+      this.notifications.error('Failed to save configuration')
+      console.error('TabbySpaces save error:', error)
+      return false
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "tabby-core": ["node_modules/tabby-core"],
+      "tabby-settings": ["node_modules/tabby-settings"],
+      "tabby-local": ["node_modules/tabby-local"],
+      "tabby-terminal": ["node_modules/tabby-terminal"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/webpack.config.js

@@ -0,0 +1,62 @@
+const path = require('path')
+const webpack = require('webpack')
+
+module.exports = (env = {}) => ({
+  target: 'node',
+  entry: './src/index.ts',
+  context: __dirname,
+  devtool: 'source-map',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'index.js',
+    pathinfo: true,
+    libraryTarget: 'umd',
+    publicPath: 'auto',
+  },
+  resolve: {
+    modules: ['.', 'src', 'node_modules'],
+    extensions: ['.ts', '.js'],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: {
+          loader: 'ts-loader',
+          options: {
+            configFile: path.resolve(__dirname, 'tsconfig.json'),
+          },
+        },
+      },
+      {
+        test: /\.pug$/,
+        use: ['apply-loader', 'pug-loader'],
+      },
+      {
+        test: /\.scss$/,
+        use: ['to-string-loader', 'css-loader', 'sass-loader'],
+      },
+      {
+        test: /\.css$/,
+        use: ['to-string-loader', 'css-loader'],
+      },
+    ],
+  },
+  externals: [
+    'fs',
+    'path',
+    'electron',
+    /^rxjs/,
+    /^@angular/,
+    /^@ng-bootstrap/,
+    /^tabby-/,
+    /^zone\.js/,
+  ],
+  plugins: [
+    new webpack.DefinePlugin({
+      __CONFIG_KEY__: JSON.stringify(env.dev ? 'tabbyspaces_dev' : 'tabbyspaces'),
+      __DISPLAY_NAME__: JSON.stringify(env.dev ? 'TabbySpaces DEV' : 'TabbySpaces'),
+      __IS_DEV__: env.dev ? 'true' : 'false',
+    }),
+  ],
+})