@phenx-inc/ctlsurf 0.1.0

package/src/main/orchestrator.ts

@@ -0,0 +1,404 @@
+import path from 'path'
+import fs from 'fs'
+import os from 'os'
+
+import { PtyManager } from './pty'
+import { AgentConfig, isCodingAgent } from './agents'
+import { CtlsurfApi } from './ctlsurfApi'
+import { ConversationBridge } from './bridge'
+import { WorkerWsClient, type WorkerWsStatus, type IncomingMessage } from './workerWs'
+
+function log(...args: unknown[]): void {
+  try { console.log(...args) } catch { /* EPIPE safe */ }
+}
+
+// ─── Types ────────────────────────────────────────
+
+export interface Profile {
+  name: string
+  apiKey: string
+  baseUrl: string
+  dataspacePageId: string
+}
+
+export interface SettingsData {
+  activeProfile: string
+  profiles: Record<string, Profile>
+  ctlsurfApiKey?: string
+  ctlsurfBaseUrl?: string
+  ctlsurfDataspacePageId?: string
+}
+
+export interface OrchestratorEvents {
+  onPtyData: (data: string) => void
+  onPtyExit: (code: number) => void
+  onWorkerStatus: (status: string) => void
+  onWorkerMessage: (message: IncomingMessage) => void
+  onWorkerRegistered: (data: { worker_id: string; folder_id: string | null; status: string }) => void
+  onCwdChanged: () => void
+}
+
+// ─── Orchestrator ─────────────────────────────────
+
+const DEFAULT_PROFILES: Record<string, Profile> = {
+  production: {
+    name: 'Production',
+    apiKey: '',
+    baseUrl: 'https://app.ctlsurf.com',
+    dataspacePageId: '',
+  },
+}
+
+const TERM_STREAM_INTERVAL_MS = 50
+
+export class Orchestrator {
+  private settingsDir: string
+  private events: OrchestratorEvents
+
+  // Core services
+  readonly ctlsurfApi = new CtlsurfApi()
+  readonly bridge = new ConversationBridge(this.ctlsurfApi)
+  readonly workerWs: WorkerWsClient
+
+  // State
+  private ptyManager: PtyManager | null = null
+  private currentAgent: AgentConfig | null = null
+  private currentCwd: string | null = null
+  private settings: SettingsData = {
+    activeProfile: 'production',
+    profiles: { ...DEFAULT_PROFILES },
+  }
+
+  // Terminal stream batching
+  private termStreamBuffer = ''
+  private termStreamTimer: ReturnType<typeof setTimeout> | null = null
+
+  constructor(settingsDir: string, events: OrchestratorEvents) {
+    this.settingsDir = settingsDir
+    this.events = events
+
+    this.workerWs = new WorkerWsClient({
+      onStatusChange: (status: WorkerWsStatus) => {
+        log(`[worker-ws] Status: ${status}`)
+        events.onWorkerStatus(status)
+      },
+      onMessage: (message: IncomingMessage) => {
+        log(`[worker-ws] Incoming message: ${message.id} (${message.type})`)
+        events.onWorkerMessage(message)
+        this.workerWs.sendAck(message.id)
+
+        if (message.type === 'prompt' || message.type === 'task_dispatch') {
+          if (this.ptyManager) {
+            this.ptyManager.write(message.content + '\r')
+            this.bridge.feedInput(message.content)
+          }
+        }
+      },
+      onRegistered: (data) => {
+        log(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`)
+        events.onWorkerRegistered(data)
+        if (!data.folder_id) {
+          events.onWorkerStatus('no_project')
+        }
+      },
+      onTerminalInput: (data: string) => {
+        this.ptyManager?.write(data)
+      },
+    })
+  }
+
+  // ─── Settings ───────────────────────────────────
+
+  getActiveProfile(): Profile {
+    return this.settings.profiles[this.settings.activeProfile] || this.settings.profiles.production || DEFAULT_PROFILES.production
+  }
+
+  get settingsData(): SettingsData {
+    return this.settings
+  }
+
+  get cwd(): string | null {
+    return this.currentCwd
+  }
+
+  get agent(): AgentConfig | null {
+    return this.currentAgent
+  }
+
+  applyProfile(profile: Profile): void {
+    const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY || ''
+    if (apiKey) {
+      this.ctlsurfApi.setApiKey(apiKey)
+      this.workerWs.setApiKey(apiKey)
+    } else {
+      this.ctlsurfApi.setApiKey('')
+      this.workerWs.setApiKey(null)
+    }
+
+    const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || 'https://app.ctlsurf.com'
+    this.ctlsurfApi.setBaseUrl(baseUrl)
+    this.workerWs.setBaseUrl(baseUrl)
+
+    log(`[settings] Profile applied: ${profile.name} (${baseUrl})`)
+  }
+
+  loadSettings(): void {
+    // Ensure settings dir exists
+    try { fs.mkdirSync(this.settingsDir, { recursive: true }) } catch { /* ignore */ }
+
+    const settingsPath = path.join(this.settingsDir, 'settings.json')
+    try {
+      if (fs.existsSync(settingsPath)) {
+        const raw = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'))
+
+        if (!raw.profiles) {
+          this.settings = {
+            activeProfile: 'production',
+            profiles: {
+              production: {
+                name: 'Production',
+                apiKey: raw.ctlsurfApiKey || '',
+                baseUrl: raw.ctlsurfBaseUrl || 'https://app.ctlsurf.com',
+                dataspacePageId: raw.ctlsurfDataspacePageId || '',
+              },
+            },
+          }
+          this.saveSettings()
+          log('[settings] Migrated legacy settings to profiles')
+        } else {
+          this.settings = raw as SettingsData
+          if (!this.settings.profiles.production) {
+            this.settings.profiles.production = { ...DEFAULT_PROFILES.production }
+          }
+        }
+      }
+    } catch {
+      this.settings = {
+        activeProfile: 'production',
+        profiles: { ...DEFAULT_PROFILES },
+      }
+    }
+
+    this.applyProfile(this.getActiveProfile())
+  }
+
+  saveSettings(): void {
+    const settingsPath = path.join(this.settingsDir, 'settings.json')
+    try {
+      fs.mkdirSync(this.settingsDir, { recursive: true })
+      fs.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2))
+    } catch (err: any) {
+      log('[settings] Failed to save:', err.message)
+    }
+  }
+
+  overrideApiKey(key: string): void {
+    this.ctlsurfApi.setApiKey(key)
+    this.workerWs.setApiKey(key)
+  }
+
+  overrideBaseUrl(url: string): void {
+    this.ctlsurfApi.setBaseUrl(url)
+    this.workerWs.setBaseUrl(url)
+  }
+
+  // ─── Profile CRUD ───────────────────────────────
+
+  listProfiles() {
+    return {
+      activeProfile: this.settings.activeProfile,
+      profiles: Object.entries(this.settings.profiles).map(([id, p]) => ({
+        id,
+        name: p.name,
+        baseUrl: p.baseUrl,
+        hasApiKey: !!p.apiKey,
+        dataspacePageId: p.dataspacePageId || null,
+      })),
+    }
+  }
+
+  getProfile(profileId: string) {
+    const p = this.settings.profiles[profileId]
+    if (!p) return null
+    return {
+      id: profileId,
+      name: p.name,
+      baseUrl: p.baseUrl,
+      hasApiKey: !!p.apiKey,
+      dataspacePageId: p.dataspacePageId || '',
+    }
+  }
+
+  saveProfile(profileId: string, data: { name: string; apiKey?: string; baseUrl: string; dataspacePageId: string }) {
+    const existing = this.settings.profiles[profileId]
+    this.settings.profiles[profileId] = {
+      name: data.name,
+      apiKey: data.apiKey !== undefined ? data.apiKey : (existing?.apiKey || ''),
+      baseUrl: data.baseUrl || 'https://app.ctlsurf.com',
+      dataspacePageId: data.dataspacePageId || '',
+    }
+    this.saveSettings()
+
+    if (profileId === this.settings.activeProfile) {
+      this.applyProfile(this.settings.profiles[profileId])
+      if (this.currentAgent && this.currentCwd) {
+        this.workerWs.disconnect()
+        this.connectWorkerWs(this.currentAgent, this.currentCwd)
+      }
+    }
+  }
+
+  switchProfile(profileId: string): { ok: boolean; error?: string } {
+    if (!this.settings.profiles[profileId]) return { ok: false, error: 'Profile not found' }
+    this.workerWs.disconnect()
+    this.settings.activeProfile = profileId
+    this.saveSettings()
+    this.applyProfile(this.getActiveProfile())
+    if (this.currentAgent && this.currentCwd) {
+      this.connectWorkerWs(this.currentAgent, this.currentCwd)
+    }
+    return { ok: true }
+  }
+
+  deleteProfile(profileId: string): { ok: boolean; error?: string } {
+    if (profileId === 'production') return { ok: false, error: 'Cannot delete Production profile' }
+    if (!this.settings.profiles[profileId]) return { ok: false, error: 'Profile not found' }
+
+    if (this.settings.activeProfile === profileId) {
+      this.workerWs.disconnect()
+      this.settings.activeProfile = 'production'
+      this.applyProfile(this.getActiveProfile())
+      if (this.currentAgent && this.currentCwd) {
+        this.connectWorkerWs(this.currentAgent, this.currentCwd)
+      }
+    }
+
+    delete this.settings.profiles[profileId]
+    this.saveSettings()
+    return { ok: true }
+  }
+
+  // ─── PTY & Agent ────────────────────────────────
+
+  async spawnAgent(agent: AgentConfig, cwd: string): Promise<void> {
+    if (this.ptyManager) {
+      await this.bridge.endSession()
+      this.ptyManager.kill()
+    }
+
+    this.currentAgent = agent
+    const prevCwd = this.currentCwd
+    this.currentCwd = cwd
+    if (prevCwd !== cwd) {
+      this.events.onCwdChanged()
+    }
+
+    this.ptyManager = new PtyManager(agent, cwd)
+
+    this.ptyManager.onData((data: string) => {
+      this.events.onPtyData(data)
+      this.bridge.feedOutput(data)
+      this.streamTerminalData(data)
+    })
+
+    const thisPtyManager = this.ptyManager
+
+    this.ptyManager.onExit(async (exitCode: number) => {
+      this.events.onPtyExit(exitCode)
+      await this.bridge.endSession(exitCode)
+      if (thisPtyManager === this.ptyManager && this.currentAgent && isCodingAgent(this.currentAgent)) {
+        this.workerWs.disconnect()
+      }
+    })
+
+    const profile = this.getActiveProfile()
+    const dataspacePageId = profile.dataspacePageId || process.env.CTLSURF_DATASPACE_PAGE_ID || ''
+    if (dataspacePageId && this.ctlsurfApi.getApiKey()) {
+      await this.bridge.startSession(dataspacePageId, agent.name, cwd)
+    }
+
+    if (isCodingAgent(agent)) {
+      this.connectWorkerWs(agent, cwd)
+    } else {
+      this.workerWs.disconnect()
+      this.checkProjectStatus(cwd)
+    }
+  }
+
+  writePty(data: string): void {
+    this.ptyManager?.write(data)
+    this.bridge.feedInput(data)
+  }
+
+  resizePty(cols: number, rows: number): void {
+    this.ptyManager?.resize(cols, rows)
+    this.workerWs.sendTerminalResize(cols, rows)
+  }
+
+  async killAgent(): Promise<void> {
+    await this.bridge.endSession()
+    this.ptyManager?.kill()
+    this.ptyManager = null
+    if (this.currentAgent && isCodingAgent(this.currentAgent)) {
+      this.workerWs.disconnect()
+    }
+  }
+
+  // ─── Worker WebSocket ───────────────────────────
+
+  connectWorkerWs(agent: AgentConfig, cwd: string): void {
+    const profile = this.getActiveProfile()
+    const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY
+    if (!apiKey) {
+      log('[worker-ws] No API key, skipping WS connect')
+      return
+    }
+
+    this.workerWs.connect({
+      machine: os.hostname(),
+      cwd,
+      agent: agent.name,
+    })
+  }
+
+  private async checkProjectStatus(cwd: string): Promise<void> {
+    if (!this.ctlsurfApi.getApiKey()) {
+      this.events.onWorkerStatus('no_project')
+      return
+    }
+    try {
+      const folder = await this.ctlsurfApi.findFolderByPath(cwd)
+      if (!folder?.id) {
+        this.events.onWorkerStatus('no_project')
+      }
+    } catch {
+      this.events.onWorkerStatus('no_project')
+    }
+  }
+
+  private streamTerminalData(data: string): void {
+    this.termStreamBuffer += data
+    if (!this.termStreamTimer) {
+      this.termStreamTimer = setTimeout(() => {
+        if (this.termStreamBuffer) {
+          this.workerWs.sendTerminalData(this.termStreamBuffer)
+          this.termStreamBuffer = ''
+        }
+        this.termStreamTimer = null
+      }, TERM_STREAM_INTERVAL_MS)
+    }
+  }
+
+  // ─── Shutdown ───────────────────────────────────
+
+  async shutdown(): Promise<void> {
+    await this.bridge.endSession()
+    this.ptyManager?.kill()
+    this.ptyManager = null
+    this.workerWs.disconnect()
+    if (this.termStreamTimer) {
+      clearTimeout(this.termStreamTimer)
+      this.termStreamTimer = null
+    }
+  }
+}

package/src/main/pty.ts

@@ -0,0 +1,65 @@
+import { createRequire } from 'module'
+import { AgentConfig } from './agents'
+
+// Use createRequire to load native module at runtime, bypassing bundler
+const require = createRequire(import.meta.url)
+const pty = require('node-pty')
+
+export class PtyManager {
+  private process: any | null = null
+  private dataCallbacks: ((data: string) => void)[] = []
+  private exitCallbacks: ((code: number) => void)[] = []
+
+  constructor(agent: AgentConfig, cwd: string) {
+    const shell = agent.command
+    const args = agent.args || []
+
+    try {
+      console.log(`[pty] Spawning: ${shell} ${args.join(' ')} in ${cwd}`)
+    } catch {
+      // Ignore EPIPE errors when stdout is closed
+    }
+
+    this.process = pty.spawn(shell, args, {
+      name: 'xterm-256color',
+      cwd,
+      env: process.env as Record<string, string>,
+      cols: 80,
+      rows: 24
+    })
+
+    this.process.onData((data: string) => {
+      for (const cb of this.dataCallbacks) {
+        cb(data)
+      }
+    })
+
+    this.process.onExit(({ exitCode }: { exitCode: number }) => {
+      for (const cb of this.exitCallbacks) {
+        cb(exitCode)
+      }
+      this.process = null
+    })
+  }
+
+  write(data: string): void {
+    this.process?.write(data)
+  }
+
+  resize(cols: number, rows: number): void {
+    this.process?.resize(cols, rows)
+  }
+
+  kill(): void {
+    this.process?.kill()
+    this.process = null
+  }
+
+  onData(cb: (data: string) => void): void {
+    this.dataCallbacks.push(cb)
+  }
+
+  onExit(cb: (code: number) => void): void {
+    this.exitCallbacks.push(cb)
+  }
+}

package/src/main/settingsDir.ts

@@ -0,0 +1,17 @@
+import path from 'path'
+import os from 'os'
+
+export function getSettingsDir(useElectron: boolean): string {
+  if (useElectron) {
+    const { app } = require('electron')
+    return app.getPath('userData')
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'ctlsurf-worker')
+  }
+  return path.join(
+    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
+    'ctlsurf-worker'
+  )
+}