@vladimirven/openswe 0.1.0

package/src/core/session.ts

@@ -0,0 +1,423 @@
+/**
+ * Session lifecycle manager (Tmux Backend)
+ *
+ * Coordinates Tmux sessions, output parsing, and state transitions.
+ * Handles session completion.
+ */
+
+import {
+  getSession,
+  getSessionsByStatus,
+  updateSessionStatus,
+  updateSessionPhase,
+  incrementRetryCount,
+  setPid,
+  setAISessionData,
+  setLines,
+  isValidPhase,
+  getProject,
+} from "../store"
+import type { AISessionData } from "../store"
+import type { GlobalConfig, AIBackend } from "../config"
+import { createParser } from "./parser"
+import type { ParsedEvent } from "./parser"
+import { TmuxManager } from "./tmux"
+import { logger } from "../utils/logger"
+import { getSessionLogPath } from "../workspace/paths"
+import { dirname } from "path"
+import { mkdir, open } from "fs/promises"
+import { getProvider } from "../providers"
+import type { Provider } from "../providers"
+
+export interface StartSessionOptions {
+  sessionId: string
+  prompt?: string
+  resumeSessionId?: string
+  aiSessionData?: AISessionData | null
+}
+
+interface ActiveSession {
+  stopTail: () => void
+  logPath: string
+}
+
+export class SessionManager {
+  private config: GlobalConfig
+  private processManager: TmuxManager
+  private activeSessions: Map<string, ActiveSession>
+  private projectRoot: string
+  private provider: Provider
+  private parseOutputLine: (line: string) => ParsedEvent | null
+
+  private static readonly ANSI_ESCAPE_REGEX = /\x1b\[[0-9;]*[A-Za-z]/g
+  private static readonly ANSI_OSC_REGEX = /\x1b\][^\x07]*(?:\x07|\x1b\\)/g
+
+  constructor(
+    config: GlobalConfig,
+    projectRoot: string,
+    processManager?: TmuxManager
+  ) {
+    this.config = config
+    this.projectRoot = projectRoot
+    this.processManager = processManager ?? new TmuxManager()
+    this.activeSessions = new Map()
+
+    // Initialize provider based on config
+    this.provider = getProvider(config.ai.backend)
+    this.parseOutputLine = createParser(this.provider.parserPatterns)
+
+    // Start background poller for session health/exit detection
+    setInterval(() => this.checkSessionHealth(), 2000)
+  }
+
+  /**
+   * Get the current AI provider
+   */
+  getProvider(): Provider {
+    return this.provider
+  }
+
+  /**
+   * Switch to a different AI provider at runtime
+   * @param backend - The backend to switch to
+   */
+  setProvider(backend: AIBackend): void {
+    this.provider = getProvider(backend)
+    this.parseOutputLine = createParser(this.provider.parserPatterns)
+    this.config.ai.backend = backend
+  }
+
+  /**
+   * Recover sessions that were active/running
+   *
+   * Handles edge cases:
+   * - Sessions marked "active" in DB but not in tmux → mark as "paused"
+   * - Tmux sessions running but session marked "paused" → re-mark as "active"
+   * - Log orphaned tmux sessions for manual cleanup
+   */
+  async recoverSessions(): Promise<void> {
+    const activeIds = await this.processManager.listActiveSessions()
+    const dbActiveSessions = getSessionsByStatus("active")
+    const dbPausedSessions = getSessionsByStatus("paused")
+
+    // Track which tmux sessions we've matched to DB sessions
+    const matchedTmuxIds = new Set<string>()
+
+    // 1. Handle sessions marked "active" in DB
+    for (const session of dbActiveSessions) {
+      if (activeIds.includes(session.id)) {
+        // DB active + tmux running → recover (attach log tail)
+        logger.info(`Recovering active session "${session.name}" (found in tmux)`)
+        await this.attachLogTail(session.id)
+        matchedTmuxIds.add(session.id)
+      } else {
+        // DB active + tmux not running → crashed/finished while app was closed
+        logger.warn(`Session "${session.name}" marked active but not found in tmux. Marking as paused.`)
+        updateSessionStatus(session.id, "paused")
+        setPid(session.id, null)
+      }
+    }
+
+    // 2. Handle sessions marked "paused" in DB but still running in tmux
+    for (const session of dbPausedSessions) {
+      if (activeIds.includes(session.id)) {
+        // DB paused + tmux running → re-activate
+        logger.info(`Session "${session.name}" found running in tmux (was marked paused). Re-activating.`)
+        updateSessionStatus(session.id, "active")
+        await this.attachLogTail(session.id)
+        matchedTmuxIds.add(session.id)
+      }
+    }
+
+    // 3. Log orphaned tmux sessions (running in tmux but no matching DB session)
+    for (const tmuxId of activeIds) {
+      if (!matchedTmuxIds.has(tmuxId)) {
+        const session = getSession(tmuxId)
+        if (!session) {
+          logger.warn(`Orphaned tmux session found: openswe-${tmuxId} (no DB record). Consider killing it manually with: tmux kill-session -t openswe-${tmuxId}`)
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if active sessions are still running
+   */
+  private async checkSessionHealth() {
+    for (const [sessionId, sessionData] of this.activeSessions) {
+      const isRunning = await this.processManager.isRunning(sessionId)
+      if (!isRunning) {
+        // Process exited!
+        this.handleExit(sessionId)
+      }
+    }
+  }
+
+  async startSession(options: StartSessionOptions): Promise<void> {
+    const session = getSession(options.sessionId)
+    if (!session) {
+      throw new Error(`Session not found: ${options.sessionId}`)
+    }
+
+    try {
+      updateSessionStatus(session.id, "active")
+
+      // Auto-transition phase: planning if prompt-driven, working if interactive
+      updateSessionPhase(session.id, options.prompt ? "planning" : "working")
+
+      if (options.aiSessionData !== undefined) {
+        setAISessionData(session.id, options.aiSessionData)
+      }
+
+      const logPath = getSessionLogPath(this.projectRoot, session.id)
+      await this.ensureLogFile(logPath)
+
+      // Use session's backend if available, otherwise fall back to global config
+      const backend = options.aiSessionData?.backend ?? session.aiSessionData?.backend ?? this.config.ai.backend
+      const provider = getProvider(backend)
+      const providerConfig = this.config.ai[backend] as unknown as Record<string, unknown>
+
+      // Build spawn command using the session's provider
+      const spawnCmd = provider.buildSpawnCommand(
+        session,
+        options.prompt,
+        options.resumeSessionId,
+        providerConfig
+      )
+
+      // Filter env to remove undefined values
+      const baseEnv = Object.fromEntries(
+        Object.entries(process.env).filter(([, v]) => v !== undefined)
+      ) as Record<string, string>
+
+      // Merge provider-specific env vars
+      const env = { ...baseEnv, ...spawnCmd.env }
+
+      // Spawn tmux session
+      const pid = await this.processManager.spawn(
+        session.id,
+        spawnCmd.command,
+        spawnCmd.args,
+        session.worktreePath,
+        env,
+        logPath
+      )
+
+      setPid(session.id, pid)
+
+      // Start tailing logs for parsing
+      await this.attachLogTail(session.id)
+
+    } catch (error) {
+      updateSessionStatus(session.id, "failed")
+      logger.error(`Failed to start session ${session.id}:`, error)
+      throw error
+    }
+  }
+
+  private async attachLogTail(sessionId: string): Promise<void> {
+    const logPath = getSessionLogPath(this.projectRoot, sessionId)
+    await this.ensureLogFile(logPath)
+
+    // Use tail -f to stream logs
+    const tailProc = Bun.spawn(["tail", "-f", "-n", "+1", logPath], {
+      stdout: "pipe",
+      stderr: "pipe"
+    })
+
+    // Consume stream
+    const reader = tailProc.stdout.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ""
+
+    const readLoop = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          
+          buffer += decoder.decode(value, { stream: true })
+          const lines = buffer.split("\n")
+          
+          // Process all complete lines
+          buffer = lines.pop() || "" // Keep last incomplete line
+          
+          for (const line of lines) {
+            this.handleOutputLine(sessionId, line)
+          }
+        }
+      } catch (e) {
+        // Tail killed
+      }
+    }
+
+    readLoop()
+
+    const errorReader = tailProc.stderr.getReader()
+    const handleError = async () => {
+      try {
+        const { value } = await errorReader.read()
+        if (value) {
+          const msg = new TextDecoder().decode(value)
+          if (msg.trim()) {
+            logger.warn(`Log tail error for ${sessionId}: ${msg.trim()}`)
+          }
+        }
+      } catch {
+        // Ignore tail stderr errors
+      }
+    }
+
+    handleError()
+
+    this.activeSessions.set(sessionId, {
+      logPath,
+      stopTail: () => {
+        tailProc.kill()
+      }
+    })
+  }
+
+  async pauseSession(sessionId: string): Promise<void> {
+    await this.processManager.kill(sessionId)
+    this.cleanupSession(sessionId)
+    updateSessionStatus(sessionId, "paused")
+    setPid(sessionId, null)
+  }
+
+  async stopSession(sessionId: string): Promise<void> {
+    await this.processManager.kill(sessionId)
+    this.cleanupSession(sessionId)
+    updateSessionStatus(sessionId, "queued")
+    setPid(sessionId, null)
+  }
+
+  /**
+   * Get the current visual state of the session for preview
+   */
+  async getSnapshot(sessionId: string): Promise<string[]> {
+    try {
+      const snapshot = await this.processManager.getSnapshot(sessionId)
+      // Save to DB for persistence/caching if needed?
+      // For now just return
+      setLines(sessionId, snapshot.lines) // Update DB cache for when we are offline/paused
+      return snapshot.lines
+    } catch {
+      // If session not running, return cached lines from DB
+      const session = getSession(sessionId)
+      // return session?.outputBuffer ... (need to fetch from OB table)
+      return []
+    }
+  }
+
+  /**
+   * Get command to attach to this session
+   */
+  getAttachCommand(sessionId: string): string[] {
+    return this.processManager.getAttachCommand(sessionId)
+  }
+
+  /**
+   * Resize the session terminal
+   */
+  async resizeSession(sessionId: string, cols: number, rows: number): Promise<void> {
+    await this.processManager.resize(sessionId, cols, rows)
+  }
+
+  private cleanupSession(sessionId: string) {
+    const active = this.activeSessions.get(sessionId)
+    if (active) {
+      active.stopTail()
+      this.activeSessions.delete(sessionId)
+    }
+  }
+
+  private handleOutputLine(sessionId: string, line: string): void {
+    const normalizedLine = this.normalizeOutputLine(line)
+
+    // Parse protocol events for state management using provider-specific patterns
+    const event = this.parseOutputLine(normalizedLine)
+    if (!event) return
+
+    switch (event.type) {
+      case "working":
+        updateSessionPhase(sessionId, "working")
+        break
+      case "done":
+        updateSessionPhase(sessionId, "completed")
+        this.handleSessionCompletion(sessionId).catch((err) => {
+          logger.error(`Session completion handler failed for ${sessionId}:`, err)
+        })
+        break
+    }
+  }
+
+  private normalizeOutputLine(line: string): string {
+    return line
+      .replace(SessionManager.ANSI_OSC_REGEX, "")
+      .replace(SessionManager.ANSI_ESCAPE_REGEX, "")
+      .replace(/\r/g, "")
+  }
+
+  private async ensureLogFile(logPath: string): Promise<void> {
+    const logDir = dirname(logPath)
+    try {
+      await mkdir(logDir, { recursive: true })
+      const handle = await open(logPath, "a")
+      await handle.close()
+    } catch (error) {
+      logger.warn(`Failed to initialize log file ${logPath}:`, error)
+    }
+  }
+
+  private async handleSessionCompletion(sessionId: string): Promise<void> {
+    const session = getSession(sessionId)
+    if (!session) return
+
+    this.completeSession(sessionId)
+    logger.info(`Session ${session.name} completed`)
+  }
+
+  private completeSession(sessionId: string) {
+    updateSessionPhase(sessionId, "completed")
+    updateSessionStatus(sessionId, "completed")
+    setPid(sessionId, null)
+    // We don't necessarily kill the tmux session immediately? 
+    // Or do we? If it's done, opencode process likely exited.
+    // If not, we should probably leave it for user to inspect until they delete?
+    // Let's leave it running if it's still there (e.g. if opencode waits for keypress at end)
+    // But usually we want to free resources.
+    // For now: Leave it. `handleExit` will clean it up if process exits.
+  }
+
+  private handleExit(sessionId: string): void {
+    this.cleanupSession(sessionId)
+    
+    const session = getSession(sessionId)
+    if (!session) return
+
+    if (session.status === "completed" || session.status === "failed") {
+      setPid(sessionId, null)
+      return
+    }
+
+    // Determine if it was a success or failure exit?
+    // We don't have exit code from polling. 
+    // But if we didn't get [OPENSWE:DONE], it's likely a crash or manual exit.
+    
+    // Check if phase is completed
+    if (session.phase === "completed") {
+      updateSessionStatus(sessionId, "completed")
+    } else {
+      const retryCount = incrementRetryCount(sessionId)
+      if (retryCount >= 2) {
+        updateSessionStatus(sessionId, "failed")
+      } else {
+        // Auto-restart? Or just queue?
+        // Logic says "queued" to retry.
+        updateSessionStatus(sessionId, "queued")
+      }
+    }
+    setPid(sessionId, null)
+  }
+}

package/src/core/tmux.ts

@@ -0,0 +1,206 @@
+/**
+ * Tmux Process Manager
+ * 
+ * Manages sessions using tmux.
+ * - Sessions are named "openswe-<id>"
+ * - Output is piped to a log file for parsing
+ * - Visual state is retrieved via capture-pane
+ */
+
+import type { ProcessManager, ProcessSnapshot } from "./process-manager"
+import { logger } from "../utils/logger"
+import { shellQuote } from "../utils/shell"
+
+export class TmuxManager implements ProcessManager {
+  private prefix = "openswe-"
+  private serverInitialized = false
+
+  /**
+   * Ensure tmux server is running before any operations
+   */
+  private async ensureServer(): Promise<void> {
+    if (this.serverInitialized) return
+
+    const proc = Bun.spawn(["tmux", "start-server"], {
+      stderr: "pipe",
+      stdout: "ignore"
+    })
+    const exitCode = await proc.exited
+
+    if (exitCode !== 0) {
+      const err = await new Response(proc.stderr).text()
+      throw new Error(`Failed to start tmux server: ${err}`)
+    }
+
+    this.serverInitialized = true
+  }
+
+  private getSessionName(id: string): string {
+    return `${this.prefix}${id}`
+  }
+
+  private getIdFromSessionName(name: string): string | null {
+    if (name.startsWith(this.prefix)) {
+      return name.slice(this.prefix.length)
+    }
+    return null
+  }
+
+  async spawn(id: string, command: string, args: string[], cwd: string, env: Record<string, string>, logPath: string): Promise<number> {
+    await this.ensureServer()
+
+    const sessionName = this.getSessionName(id)
+
+    // Construct the command string safely
+    // We use 'script' or simple pipe to capture output while keeping it interactive-ish
+    // But opencode is a TUI, so we just want to run it.
+    // To capture output for the parser, we use 'pipe' but we also need the TUI to work in tmux.
+    // The trick: tmux runs the command. We don't strictly need to pipe purely for the parser if we rely on capture-pane,
+    // BUT the parser needs the hidden markers [OPENSWE:...] which might be scrolled off screen.
+    // So we DO need to pipe stdout.
+    
+    // Using `tee` might buffer or mess up TUI.
+    // Better approach: Let tmux handle the TUI.
+    // For parsing markers: We can use `tmux pipe-pane` to stream output to a file!
+    
+    const fullCommand = `${shellQuote(command)} ${args.map(shellQuote).join(" ")}`
+    
+    // 1. Create detached session
+    // -d: detached
+    // -s: session name
+    // -c: working directory
+    // -x: width (default 80 is too small for modern screens)
+    // -y: height (default 24 is too small)
+    const createProc = Bun.spawn([
+      "tmux", "new-session", 
+      "-d", 
+      "-s", sessionName, 
+      "-x", "140",
+      "-y", "50",
+      "-c", cwd,
+      // We start with a shell to ensure env vars are loaded if needed, or just run the command
+      fullCommand
+    ], {
+      env: { ...process.env, ...env },
+      stderr: "pipe"
+    })
+
+    const createExit = await createProc.exited
+    if (createExit !== 0) {
+      const err = await new Response(createProc.stderr).text()
+      throw new Error(`Failed to create tmux session: ${err}`)
+    }
+
+    // 2. Enable logging (pipe-pane) to capture stream for parser
+    // This logs everything printed to the pane to a file
+    // Escape the logPath for shell safety (single quotes, escape internal single quotes)
+    const escapedLogPath = logPath.replace(/'/g, "'\\''")
+    const pipeProc = Bun.spawn([
+      "tmux", "pipe-pane",
+      "-t", sessionName,
+      `cat >> '${escapedLogPath}'`  // Use append mode and single quotes for safety
+    ], { stderr: "pipe" })
+
+    const pipeExit = await pipeProc.exited
+    if (pipeExit !== 0) {
+      const err = await new Response(pipeProc.stderr).text()
+      logger.warn(`pipe-pane setup failed for ${sessionName}: ${err}`)
+    }
+
+    // 2.5 Disable status bar to reclaim vertical space
+    await Bun.spawn(["tmux", "set-option", "-t", sessionName, "status", "off"], { stderr: "ignore" }).exited
+
+    // 3. Get PID of the process inside tmux (approximate)
+    // tmux list-panes -t session -F "#{pane_pid}"
+    const pidProc = Bun.spawn(["tmux", "list-panes", "-t", sessionName, "-F", "#{pane_pid}"], { stdout: "pipe" })
+    const pidStr = await new Response(pidProc.stdout).text()
+    return parseInt(pidStr.trim(), 10)
+  }
+
+  async isRunning(id: string): Promise<boolean> {
+    await this.ensureServer()
+
+    const sessionName = this.getSessionName(id)
+    const proc = Bun.spawn(["tmux", "has-session", "-t", sessionName], { stderr: "ignore" })
+    const exitCode = await proc.exited
+    return exitCode === 0
+  }
+
+  async kill(id: string): Promise<void> {
+    const sessionName = this.getSessionName(id)
+    // Kill the session
+    const proc = Bun.spawn(["tmux", "kill-session", "-t", sessionName], { stderr: "ignore" })
+    await proc.exited
+  }
+
+  async getSnapshot(id: string): Promise<ProcessSnapshot> {
+    await this.ensureServer()
+
+    // Verify session exists first to avoid capture-pane errors
+    if (!(await this.isRunning(id))) {
+      return { lines: [], cursor: null }
+    }
+
+    const sessionName = this.getSessionName(id)
+
+    // capture-pane -p (print) -e (include escape sequences for colored preview)
+    // The Preview component uses ansi-parser to render colored output
+
+    const proc = Bun.spawn(["tmux", "capture-pane", "-pet", sessionName], { stdout: "pipe", stderr: "pipe" })
+    const exitCode = await proc.exited
+
+    if (exitCode !== 0) {
+      logger.warn(`capture-pane failed for ${sessionName}`)
+      return { lines: [], cursor: null }
+    }
+
+    const output = await new Response(proc.stdout).text()
+
+    // Get lines
+    const lines = output.split("\n")
+    // Note: We used to trim trailing empty lines here, but that causes the
+    // preview to look "short" when the terminal has empty space at the bottom.
+    // We now preserve all lines to show the full terminal height.
+
+    return {
+      lines,
+      cursor: null // TODO: Could get cursor pos via tmux display-message
+    }
+  }
+
+  async sendInput(id: string, data: string): Promise<void> {
+    const sessionName = this.getSessionName(id)
+    // send-keys is mainly for strings. For control chars it's trickier.
+    // simpler approach: just send keys.
+    await Bun.spawn(["tmux", "send-keys", "-t", sessionName, data]).exited
+  }
+
+  async listActiveSessions(): Promise<string[]> {
+    try {
+      await this.ensureServer()
+
+      // List sessions with format: name
+      const proc = Bun.spawn(["tmux", "list-sessions", "-F", "#{session_name}"], { stdout: "pipe", stderr: "ignore" })
+      const output = await new Response(proc.stdout).text()
+
+      const ids: string[] = []
+      for (const line of output.split("\n")) {
+        const id = this.getIdFromSessionName(line.trim())
+        if (id) ids.push(id)
+      }
+      return ids
+    } catch {
+      return []
+    }
+  }
+
+  getAttachCommand(id: string): string[] {
+    return ["tmux", "attach-session", "-t", this.getSessionName(id)]
+  }
+
+  async resize(id: string, cols: number, rows: number): Promise<void> {
+    const sessionName = this.getSessionName(id)
+    // resize-window sets the size of the window (and thus the detached session)
+    await Bun.spawn(["tmux", "resize-window", "-t", sessionName, "-x", cols.toString(), "-y", rows.toString()], { stderr: "ignore" }).exited
+  }
+}

package/src/git/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Git module
+ *
+ * Re-exports all git operations for cleaner imports.
+ */
+
+export * from "./repo"
+export * from "./worktree"