@phenx-inc/ctlsurf 0.1.0

package/src/main/headless.ts

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+/**
+ * ctlsurf terminal mode (TUI)
+ *
+ * Runs the agent in a PTY with a terminal UI: title bar, status bar,
+ * conversation logging, and WebSocket control. No Electron required.
+ *
+ * Usage:
+ *   ctlsurf --terminal [--agent claude] [--cwd /path] [--api-key KEY] [--base-url URL] [--profile NAME]
+ *
+ * If no --agent is given, shows an interactive agent picker.
+ * Press Ctrl+\ to exit at any time.
+ */
+
+// Prevent EPIPE crashes
+process.stdout?.on?.('error', () => {})
+process.stderr?.on?.('error', () => {})
+process.on('uncaughtException', (err) => {
+  if (err.message === 'write EPIPE') return
+  try { console.error('[uncaught]', err) } catch { /* ignore */ }
+})
+
+import { Orchestrator } from './orchestrator'
+import { getSettingsDir } from './settingsDir'
+import { getBuiltinAgents, getDefaultAgent, isCodingAgent, type AgentConfig } from './agents'
+import { Tui } from './tui'
+
+// ─── CLI arg parsing ──────────────────────────────
+
+interface CliArgs {
+  agent: string | null
+  cwd: string
+  apiKey: string | null
+  baseUrl: string | null
+  profile: string | null
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = {
+    agent: null,
+    cwd: process.env.CTLSURF_WORKER_CWD || process.cwd(),
+    apiKey: null,
+    baseUrl: null,
+    profile: null,
+  }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    const next = argv[i + 1]
+    switch (arg) {
+      case '--agent': args.agent = next; i++; break
+      case '--cwd': args.cwd = next; i++; break
+      case '--api-key': args.apiKey = next; i++; break
+      case '--base-url': args.baseUrl = next; i++; break
+      case '--profile': args.profile = next; i++; break
+      case '--terminal': break
+      case '--desktop': break
+    }
+  }
+  return args
+}
+
+// ─── Main ─────────────────────────────────────────
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2))
+  const settingsDir = getSettingsDir(false)
+
+  const tui = new Tui()
+  const agents = getBuiltinAgents()
+
+  // ─── Agent selection ────────────────────────────
+  let agent: AgentConfig
+
+  if (args.agent) {
+    const found = agents.find(a => a.id === args.agent)
+    agent = found || {
+      id: args.agent,
+      name: args.agent,
+      command: args.agent,
+      args: [],
+      description: `Custom agent: ${args.agent}`,
+    }
+  } else {
+    // Show interactive picker
+    const selectedIdx = await tui.showAgentPicker(agents)
+    agent = agents[selectedIdx]
+  }
+
+  // ─── Start TUI + agent ─────────────────────────
+
+  tui.update({
+    agentName: agent.name,
+    cwd: args.cwd,
+    mode: 'terminal',
+  })
+
+  tui.init()
+
+  const orchestrator = new Orchestrator(settingsDir, {
+    onPtyData: (data) => {
+      tui.writePtyData(data)
+    },
+    onPtyExit: (code) => {
+      tui.destroy()
+      console.log(`Agent exited with code ${code}`)
+      orchestrator.shutdown().then(() => process.exit(code))
+    },
+    onWorkerStatus: (status) => {
+      tui.update({ wsStatus: status })
+    },
+    onWorkerMessage: () => {},
+    onWorkerRegistered: () => {
+      tui.update({ wsStatus: 'connected' })
+    },
+    onCwdChanged: () => {
+      tui.update({ cwd: orchestrator.cwd || '' })
+    },
+  })
+
+  orchestrator.loadSettings()
+
+  if (args.profile) orchestrator.switchProfile(args.profile)
+  if (args.apiKey) orchestrator.overrideApiKey(args.apiKey)
+  if (args.baseUrl) orchestrator.overrideBaseUrl(args.baseUrl)
+
+  // Spawn agent with PTY sized to fit the TUI content area
+  const ptySize = tui.getPtySize()
+  await orchestrator.spawnAgent(agent, args.cwd)
+  orchestrator.resizePty(ptySize.cols, ptySize.rows)
+
+  // For coding agents, send an initial prompt to kick-start them
+  if (isCodingAgent(agent)) {
+    setTimeout(() => {
+      orchestrator.writePty('hello\r')
+    }, 1000)
+  }
+
+  // Pipe stdin to PTY, with Ctrl+\ as the exit key
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true)
+    process.stdin.resume()
+    process.stdin.on('data', (data) => {
+      const str = data.toString()
+      // Ctrl+\ (0x1c) = exit
+      if (str === '\x1c') {
+        shutdown()
+        return
+      }
+      orchestrator.writePty(str)
+    })
+  }
+
+  // Handle terminal resize
+  process.stdout.on('resize', () => {
+    const cols = process.stdout.columns || 80
+    const rows = process.stdout.rows || 24
+    tui.resize(cols, rows)
+    const size = tui.getPtySize()
+    orchestrator.resizePty(size.cols, size.rows)
+  })
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false)
+    }
+    tui.destroy()
+    await orchestrator.shutdown()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+}
+
+main().catch((err) => {
+  process.stdout.write('\x1b[?1049l')
+  console.error('Fatal error:', err)
+  process.exit(1)
+})

package/src/main/index.ts

@@ -0,0 +1,300 @@
+import { app, BrowserWindow, ipcMain, dialog } from 'electron'
+import path from 'path'
+import fs from 'fs'
+
+// Prevent EPIPE crashes when stdout pipe is closed
+process.stdout?.on?.('error', () => {})
+process.stderr?.on?.('error', () => {})
+process.on('uncaughtException', (err) => {
+  if (err.message === 'write EPIPE') return
+  try { console.error('[uncaught]', err) } catch { /* ignore */ }
+})
+function log(...args: unknown[]): void {
+  try { console.log(...args) } catch { /* EPIPE safe */ }
+}
+
+import { AgentConfig, getDefaultAgent, getBuiltinAgents } from './agents'
+import { getSettingsDir } from './settingsDir'
+import { Orchestrator } from './orchestrator'
+
+let mainWindow: BrowserWindow | null = null
+
+// ─── Orchestrator (shared logic) ──────────────────
+
+const orchestrator = new Orchestrator(
+  getSettingsDir(true),
+  {
+    onPtyData: (data) => mainWindow?.webContents.send('pty:data', data),
+    onPtyExit: (code) => mainWindow?.webContents.send('pty:exit', code),
+    onWorkerStatus: (status) => mainWindow?.webContents.send('worker:status', status),
+    onWorkerMessage: (message) => mainWindow?.webContents.send('worker:message', message),
+    onWorkerRegistered: (data) => mainWindow?.webContents.send('worker:registered', data),
+    onCwdChanged: () => mainWindow?.webContents.send('app:cwdChanged'),
+  }
+)
+
+// ─── Window ───────────────────────────────────────
+
+function createWindow(): void {
+  mainWindow = new BrowserWindow({
+    width: 1400,
+    height: 900,
+    minWidth: 600,
+    minHeight: 400,
+    title: 'ctlsurf-worker',
+    titleBarStyle: 'hiddenInset',
+    icon: path.join(__dirname, '../../resources/icon.png'),
+    webPreferences: {
+      preload: path.join(__dirname, '../preload/index.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      webviewTag: true
+    }
+  })
+
+  if (process.env.ELECTRON_RENDERER_URL) {
+    mainWindow.loadURL(process.env.ELECTRON_RENDERER_URL)
+  } else {
+    mainWindow.loadFile(path.join(__dirname, '../renderer/index.html'))
+  }
+
+  mainWindow.on('closed', () => {
+    mainWindow = null
+  })
+}
+
+// ─── IPC Handlers ──────────────────────────────────
+
+ipcMain.handle('pty:spawn', async (_event, agent: AgentConfig, cwd: string) => {
+  await orchestrator.spawnAgent(agent, cwd)
+  return { ok: true }
+})
+
+ipcMain.handle('pty:write', (_event, data: string) => {
+  orchestrator.writePty(data)
+})
+
+ipcMain.handle('pty:resize', (_event, cols: number, rows: number) => {
+  orchestrator.resizePty(cols, rows)
+})
+
+ipcMain.handle('pty:kill', async () => {
+  await orchestrator.killAgent()
+})
+
+ipcMain.handle('agents:list', () => getBuiltinAgents())
+ipcMain.handle('agents:default', () => getDefaultAgent())
+
+ipcMain.handle('app:homePath', () => app.getPath('home'))
+ipcMain.handle('app:cwd', () => process.env.CTLSURF_WORKER_CWD || process.cwd())
+
+ipcMain.handle('app:browseCwd', async () => {
+  if (!mainWindow) return null
+  const result = await dialog.showOpenDialog(mainWindow, {
+    properties: ['openDirectory'],
+    title: 'Select project directory',
+    defaultPath: orchestrator.cwd || process.env.HOME || '/',
+  })
+  if (result.canceled || !result.filePaths[0]) return null
+  return result.filePaths[0]
+})
+
+// ─── Filesystem IPC ───────────────────────────────
+
+ipcMain.handle('fs:readDir', async (_event, dirPath: string) => {
+  try {
+    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true })
+    return entries
+      .filter(e => !e.name.startsWith('.'))
+      .map(e => ({
+        name: e.name,
+        path: path.join(dirPath, e.name),
+        isDirectory: e.isDirectory(),
+      }))
+      .sort((a, b) => {
+        if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1
+        return a.name.localeCompare(b.name)
+      })
+  } catch {
+    return []
+  }
+})
+
+ipcMain.handle('fs:readFile', async (_event, filePath: string) => {
+  try {
+    const content = await fs.promises.readFile(filePath, 'utf-8')
+    return { ok: true, content }
+  } catch (err: any) {
+    return { ok: false, error: err.message }
+  }
+})
+
+ipcMain.handle('fs:writeFile', async (_event, filePath: string, content: string) => {
+  try {
+    await fs.promises.writeFile(filePath, content, 'utf-8')
+    return { ok: true }
+  } catch (err: any) {
+    return { ok: false, error: err.message }
+  }
+})
+
+// ─── Worker IPC ───────────────────────────────────
+
+ipcMain.handle('worker:getStatus', () => orchestrator.workerWs.status)
+ipcMain.handle('worker:getWorkerId', () => orchestrator.workerWs.currentWorkerId)
+
+ipcMain.handle('worker:createProject', async () => {
+  const currentCwd = orchestrator.cwd
+  if (!currentCwd || !orchestrator.ctlsurfApi.getApiKey()) {
+    return { ok: false, error: 'No cwd or API key' }
+  }
+
+  try {
+    const folderName = currentCwd.split('/').filter(Boolean).pop() || 'project'
+    const folder = await orchestrator.ctlsurfApi.createFolder({
+      name: folderName,
+      root_path: currentCwd,
+    })
+
+    await orchestrator.ctlsurfApi.createPage({
+      title: folderName,
+      folder_id: folder.id,
+      cwd: currentCwd,
+      tags: ['project'],
+    })
+
+    if (orchestrator.agent) {
+      orchestrator.connectWorkerWs(orchestrator.agent, currentCwd)
+    }
+
+    log(`[worker] Created project: ${folderName} (${folder.id})`)
+    return { ok: true, folder_id: folder.id }
+  } catch (err: any) {
+    log('[worker] Failed to create project:', err.message)
+    return { ok: false, error: err.message }
+  }
+})
+
+ipcMain.handle('worker:getWebviewInfo', async () => {
+  const profile = orchestrator.getActiveProfile()
+  const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || 'https://app.ctlsurf.com'
+  const frontendUrl = baseUrl.includes('localhost:8000')
+    ? baseUrl.replace(':8000', ':88')
+    : baseUrl
+
+  if (!orchestrator.ctlsurfApi.getApiKey()) {
+    return { frontendUrl: `${frontendUrl}?embed=1`, authenticated: false }
+  }
+
+  try {
+    const { code } = await orchestrator.ctlsurfApi.getAuthCode()
+    let pageUrl = `${frontendUrl}?embed=1&_code=${encodeURIComponent(code)}`
+    const currentCwd = orchestrator.cwd
+
+    if (currentCwd) {
+      try {
+        let folder = null
+        try { folder = await orchestrator.ctlsurfApi.findFolderByPath(currentCwd) } catch { /* not found */ }
+
+        if (!folder) {
+          try {
+            const { execSync } = require('child_process')
+            const gitRemote = execSync('git remote get-url origin', { cwd: currentCwd, encoding: 'utf-8' }).trim()
+            if (gitRemote) {
+              folder = await orchestrator.ctlsurfApi.findFolderByGitRemote(gitRemote)
+            }
+          } catch { /* not a git repo */ }
+        }
+
+        if (folder?.id) {
+          const pages = await orchestrator.ctlsurfApi.getFolderPages(folder.id)
+          const rootPage = pages?.find((p: any) => !p.parent_id)
+          if (rootPage?.id) {
+            pageUrl = `${frontendUrl}/page/${rootPage.id}?embed=1&_code=${encodeURIComponent(code)}`
+          }
+        }
+      } catch { /* No project */ }
+    }
+
+    return { frontendUrl, pageUrl, authenticated: true }
+  } catch (err: any) {
+    log('[worker] Failed to exchange tokens:', err.message)
+    return { frontendUrl: `${frontendUrl}?embed=1`, authenticated: false }
+  }
+})
+
+// ─── Profile IPC ──────────────────────────────────
+
+ipcMain.handle('profiles:list', () => orchestrator.listProfiles())
+ipcMain.handle('profiles:get', (_event, id: string) => orchestrator.getProfile(id))
+ipcMain.handle('profiles:save', (_event, id: string, data: any) => {
+  orchestrator.saveProfile(id, data)
+  return { ok: true }
+})
+ipcMain.handle('profiles:switch', (_event, id: string) => orchestrator.switchProfile(id))
+ipcMain.handle('profiles:delete', (_event, id: string) => orchestrator.deleteProfile(id))
+
+// ─── Legacy Settings IPC ──────────────────────────
+
+ipcMain.handle('settings:get', (_event, key: string) => {
+  const profile = orchestrator.getActiveProfile()
+  if (key === 'ctlsurfApiKey') return profile.apiKey ? '***configured***' : null
+  if (key === 'ctlsurfBaseUrl') return profile.baseUrl || null
+  if (key === 'ctlsurfDataspacePageId') return profile.dataspacePageId || null
+  return null
+})
+
+ipcMain.handle('settings:set', (_event, key: string, value: string) => {
+  const settings = orchestrator.settingsData
+  const profile = settings.profiles[settings.activeProfile]
+  if (!profile) return { ok: false }
+
+  if (key === 'ctlsurfApiKey') profile.apiKey = value
+  else if (key === 'ctlsurfBaseUrl') profile.baseUrl = value
+  else if (key === 'ctlsurfDataspacePageId') profile.dataspacePageId = value
+
+  orchestrator.saveSettings()
+  orchestrator.applyProfile(profile)
+
+  if (key === 'ctlsurfApiKey' && orchestrator.agent && orchestrator.cwd) {
+    orchestrator.workerWs.disconnect()
+    orchestrator.connectWorkerWs(orchestrator.agent, orchestrator.cwd)
+  }
+
+  return { ok: true }
+})
+
+ipcMain.handle('settings:getAll', () => {
+  const profile = orchestrator.getActiveProfile()
+  return {
+    ctlsurfApiKey: profile.apiKey ? '***configured***' : null,
+    ctlsurfDataspacePageId: profile.dataspacePageId || null,
+    activeProfile: orchestrator.settingsData.activeProfile,
+  }
+})
+
+// ─── App lifecycle ─────────────────────────────────
+
+app.whenReady().then(() => {
+  if (process.platform === 'darwin' && app.dock) {
+    const iconPath = path.join(__dirname, '../../resources/icon.png')
+    try {
+      const { nativeImage } = require('electron')
+      app.dock.setIcon(nativeImage.createFromPath(iconPath))
+    } catch { /* ignore */ }
+  }
+
+  orchestrator.loadSettings()
+  createWindow()
+})
+
+app.on('window-all-closed', () => {
+  orchestrator.shutdown()
+  app.quit()
+})
+
+app.on('activate', () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow()
+  }
+})