opencode-multiplexer 0.1.0

package/src/hooks/use-attach.ts

@@ -0,0 +1,144 @@
+import { execSync } from "child_process"
+import { writeFileSync, readFileSync, unlinkSync } from "fs"
+import { tmpdir } from "os"
+import { join } from "path"
+import { render } from "ink"
+import React from "react"
+
+const EXIT_ALT_SCREEN  = "\x1b[?1049l"
+const ENTER_ALT_SCREEN = "\x1b[?1049h"
+const CLEAR_SCREEN     = "\x1b[2J\x1b[H"
+
+// We store the Ink instance so we can unmount and remount it
+let _inkInstance: ReturnType<typeof render> | null = null
+
+// Module-level side-channel for passing editor results across the remount boundary.
+// onResult callbacks are stale closures after remount — use this instead.
+let _pendingEditorResult: string | null = null
+
+export function consumePendingEditorResult(): string | null {
+  const result = _pendingEditorResult
+  _pendingEditorResult = null
+  return result
+}
+
+export function setInkInstance(instance: ReturnType<typeof render>): void {
+  _inkInstance = instance
+}
+
+/**
+ * Yield terminal control to opencode for a specific session.
+ * Exits alt screen, unmounts Ink, runs opencode, re-enters alt screen and remounts.
+ */
+export function yieldToOpencode(sessionId: string, cwd: string): void {
+  if (!_inkInstance) return
+
+  _inkInstance.unmount()
+  _inkInstance = null
+
+  // Exit alt screen so opencode gets a clean normal terminal
+  if (process.stdout.isTTY) process.stdout.write(EXIT_ALT_SCREEN)
+
+  try {
+    execSync(`opencode -s ${sessionId}`, {
+      stdio: "inherit",
+      cwd,
+    })
+  } catch {
+    // User quit opencode (Ctrl-C or q) — normal exit, ignore error
+  }
+
+  // Re-enter alt screen and remount ocm
+  if (process.stdout.isTTY) process.stdout.write(ENTER_ALT_SCREEN + CLEAR_SCREEN)
+  _remountOcm()
+}
+
+/**
+ * Yield terminal control to opencode in a specific directory.
+ * Used for spawning new instances — opencode will create/resume session there.
+ */
+export function yieldToNewOpencode(cwd: string): void {
+  if (!_inkInstance) return
+
+  _inkInstance.unmount()
+  _inkInstance = null
+
+  if (process.stdout.isTTY) process.stdout.write(EXIT_ALT_SCREEN)
+
+  try {
+    execSync("opencode", {
+      stdio: "inherit",
+      cwd,
+    })
+  } catch {
+    // User quit opencode — normal exit
+  }
+
+  if (process.stdout.isTTY) process.stdout.write(ENTER_ALT_SCREEN + CLEAR_SCREEN)
+  _remountOcm()
+}
+
+/**
+ * Open current input text in $EDITOR (Ctrl-X E pattern).
+ * Unmounts Ink, opens editor with text in a temp file,
+ * reads back the result, remounts OCMux, and calls onResult with the edited text.
+ */
+export function openInEditor(currentText: string, onResult: (text: string) => void): void {
+  if (!_inkInstance) return
+
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi"
+  const tmpFile = join(tmpdir(), `ocmux-msg-${Date.now()}.md`)
+
+  _inkInstance.unmount()
+  _inkInstance = null
+
+  if (process.stdout.isTTY) process.stdout.write(EXIT_ALT_SCREEN)
+
+  // Write current text to temp file
+  try { writeFileSync(tmpFile, currentText) } catch { /* ignore */ }
+
+  // Open editor
+  try {
+    execSync(`${editor} ${JSON.stringify(tmpFile)}`, { stdio: "inherit" })
+  } catch { /* non-zero exit is fine */ }
+
+  // Read back
+  let edited = currentText
+  try { edited = readFileSync(tmpFile, "utf-8").trimEnd() } catch { /* ignore */ }
+  try { unlinkSync(tmpFile) } catch { /* ignore */ }
+
+  if (process.stdout.isTTY) process.stdout.write(ENTER_ALT_SCREEN + CLEAR_SCREEN)
+
+  // Store result in module-level slot — the remounted Conversation component
+  // will read this on mount (onResult callback is a stale closure after remount)
+  _pendingEditorResult = edited
+
+  // Remount OCMux
+  import("../app.js").then(({ App }) => {
+    _inkInstance = render(React.createElement(App))
+    setInkInstance(_inkInstance)
+  }).catch(console.error)
+}
+
+/**
+ * Check if opencode binary is available on PATH.
+ */
+export function isOpencodeAvailable(): boolean {
+  try {
+    execSync("which opencode", { stdio: "pipe" })
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Remount Ink after yielding — lazy import to avoid circular deps
+function _remountOcm(): void {
+  // Use dynamic import to get App without circular dependency
+  import("../app.js")
+    .then(({ App }) => {
+      _inkInstance = render(React.createElement(App))
+      setInkInstance(_inkInstance)
+    })
+    .catch(console.error)
+}

package/src/hooks/use-keybindings.ts

@@ -0,0 +1,103 @@
+import { useInput } from "ink"
+import { config } from "../config.js"
+
+type DashboardActions = {
+  onUp?: () => void
+  onDown?: () => void
+  onOpen?: () => void
+  onAttach?: () => void
+  onSpawn?: () => void
+  onExpand?: () => void
+  onCollapse?: () => void
+  onNextNeedsInput?: () => void
+  onKill?: () => void
+  onQuit?: () => void
+  onHelp?: () => void
+  onRescan?: () => void
+}
+
+type ConversationActions = {
+  onBack?: () => void
+  onAttach?: () => void
+  onSend?: () => void
+  onScrollUp?: () => void
+  onScrollDown?: () => void
+  onScrollHalfPageUp?: () => void
+  onScrollHalfPageDown?: () => void
+  onScrollPageUp?: () => void
+  onScrollPageDown?: () => void
+  onScrollBottom?: () => void
+  onScrollTop?: () => void
+}
+
+type SpawnActions = {
+  onCancel?: () => void
+  onConfirm?: () => void
+}
+
+function matchKey(key: string, input: string, inkKey: any): boolean {
+  switch (key) {
+    case "return":
+      return inkKey.return
+    case "escape":
+      return inkKey.escape
+    case "tab":
+      return inkKey.tab && !inkKey.shift
+    case "shift-tab":
+      return inkKey.tab && inkKey.shift
+    case "up":
+      return inkKey.upArrow
+    case "down":
+      return inkKey.downArrow
+    default:
+      // Handle ctrl- prefixed keys like "ctrl-n"
+      if (key.startsWith("ctrl-")) {
+        const letter = key.slice(5)
+        return inkKey.ctrl && !inkKey.tab && !inkKey.return && !inkKey.escape && input === letter
+      }
+      return input === key
+  }
+}
+
+export function useDashboardKeys(actions: DashboardActions) {
+  const kb = config.keybindings.dashboard
+  useInput((input, key) => {
+    if (matchKey(kb.up, input, key) || key.upArrow) actions.onUp?.()
+    else if (matchKey(kb.down, input, key) || key.downArrow) actions.onDown?.()
+    else if (matchKey(kb.open, input, key)) actions.onOpen?.()
+    else if (matchKey(kb.attach, input, key)) actions.onAttach?.()
+    else if (matchKey(kb.spawn, input, key)) actions.onSpawn?.()
+    else if (matchKey(kb.expand, input, key)) actions.onExpand?.()
+    else if (matchKey(kb.collapse, input, key)) actions.onCollapse?.()
+    else if (matchKey(kb.nextNeedsInput, input, key)) actions.onNextNeedsInput?.()
+    else if (matchKey(kb.kill, input, key)) actions.onKill?.()
+    else if (matchKey(kb.quit, input, key)) actions.onQuit?.()
+    else if (matchKey(kb.help, input, key)) actions.onHelp?.()
+    else if (matchKey(kb.rescan, input, key)) actions.onRescan?.()
+  })
+}
+
+export function useConversationKeys(actions: ConversationActions) {
+  const kb = config.keybindings.conversation
+  useInput((input, key) => {
+    if (matchKey(kb.back, input, key) || input === "q") actions.onBack?.()
+    else if (matchKey(kb.attach, input, key)) actions.onAttach?.()
+    else if (matchKey(kb.send, input, key)) actions.onSend?.()
+    else if (matchKey(kb.scrollUp, input, key) || key.upArrow) actions.onScrollUp?.()
+    else if (matchKey(kb.scrollDown, input, key) || key.downArrow) actions.onScrollDown?.()
+    else if (matchKey(kb.scrollHalfPageUp, input, key)) actions.onScrollHalfPageUp?.()
+    else if (matchKey(kb.scrollHalfPageDown, input, key)) actions.onScrollHalfPageDown?.()
+    else if (matchKey(kb.scrollPageUp, input, key)) actions.onScrollPageUp?.()
+    else if (matchKey(kb.scrollPageDown, input, key)) actions.onScrollPageDown?.()
+    else if (matchKey(kb.scrollBottom, input, key) && key.shift) actions.onScrollBottom?.()
+    else if (matchKey(kb.scrollTop, input, key) && !key.shift) actions.onScrollTop?.()
+  })
+}
+
+export function useSpawnKeys(actions: SpawnActions) {
+  const kb = config.keybindings.spawn
+  useInput((input, key) => {
+    if (matchKey(kb.cancel, input, key)) actions.onCancel?.()
+    else if (matchKey(kb.confirm, input, key)) actions.onConfirm?.()
+  })
+}

package/src/hooks/use-vim-navigation.ts

@@ -0,0 +1,43 @@
+import { useInput } from "ink"
+import React from "react"
+
+export interface VimNavigationActions {
+  onUp?: () => void
+  onDown?: () => void
+  onHalfPageUp?: () => void
+  onHalfPageDown?: () => void
+  onTop?: () => void
+  onBottom?: () => void
+  onOpen?: () => void
+  onBack?: () => void
+}
+
+/**
+ * Adds vim-style navigation keys on top of existing keybindings.
+ * Call this alongside useDashboardKeys/useConversationKeys.
+ */
+export function useVimNavigation(actions: VimNavigationActions) {
+  const [pendingG, setPendingG] = React.useState(false)
+
+  useInput((input, key) => {
+    if (input === "g") {
+      if (pendingG) {
+        setPendingG(false)
+        actions.onTop?.()
+      } else {
+        setPendingG(true)
+      }
+      return
+    }
+
+    if (pendingG) setPendingG(false)
+
+    if (input === "j") actions.onDown?.()
+    else if (input === "k") actions.onUp?.()
+    else if (input === "l") actions.onOpen?.()
+    else if (input === "h") actions.onBack?.()
+    else if (input === "G") actions.onBottom?.()
+    else if (key.ctrl && input === "d") actions.onHalfPageDown?.()
+    else if (key.ctrl && input === "u") actions.onHalfPageUp?.()
+  })
+}

package/src/index.tsx

@@ -0,0 +1,52 @@
+#!/usr/bin/env bun
+import React from "react"
+import { render } from "ink"
+import { App } from "./app.js"
+import { setInkInstance } from "./hooks/use-attach.js"
+import { startPoller, stopPoller } from "./poller.js"
+import { config } from "./config.js"
+import { cleanDeadInstances } from "./registry/instances.js"
+
+// Enter alternate screen buffer — keeps our TUI isolated from terminal history.
+// On resize, we clear the alternate screen so Ink always redraws from a clean slate.
+const ENTER_ALT_SCREEN = "\x1b[?1049h"
+const EXIT_ALT_SCREEN  = "\x1b[?1049l"
+const CLEAR_SCREEN     = "\x1b[2J\x1b[H"
+
+function enterAltScreen() {
+  process.stdout.write(ENTER_ALT_SCREEN)
+}
+
+function exitAltScreen() {
+  process.stdout.write(EXIT_ALT_SCREEN)
+}
+
+function cleanup() {
+  stopPoller()
+  exitAltScreen()
+}
+
+async function main() {
+  enterAltScreen()
+
+  // On resize: clear the alternate screen so Ink redraws without stale lines
+  if (process.stdout.isTTY) {
+    process.stdout.on("resize", () => {
+      process.stdout.write(CLEAR_SCREEN)
+    })
+  }
+
+  // Remove stale spawned instances (dead pids / unresponsive ports)
+  await cleanDeadInstances()
+
+  startPoller(config.pollIntervalMs)
+
+  const inkInstance = render(<App />)
+  setInkInstance(inkInstance)
+}
+
+process.on("SIGINT", () => { cleanup(); process.exit(0) })
+process.on("SIGTERM", () => { cleanup(); process.exit(0) })
+process.on("exit", () => { exitAltScreen() })
+
+main().catch(console.error)

package/src/poller.ts

@@ -0,0 +1,270 @@
+import { basename } from "path"
+import { execSync } from "child_process"
+import {
+  getProjects,
+  getSessionById,
+  getSessionStatus,
+  getLastMessagePreview,
+  getSessionModel,
+  getChildSessions,
+  countChildSessions,
+  hasChildSessions,
+  getMostRecentSessionForProject,
+} from "./db/reader.js"
+
+export function shortenModel(model: string): string {
+  let s = model
+  // Strip org prefix e.g. "deepseek-ai/deepseek-v3.2" → "deepseek-v3.2"
+  if (s.includes("/")) s = s.split("/").pop()!
+  // Strip "claude-" prefix
+  s = s.replace(/^claude-/, "")
+  // Strip "antigravity-" prefix
+  s = s.replace(/^antigravity-/, "")
+  // Strip "codex-" from gpt models
+  s = s.replace(/codex-/, "")
+  // Strip "-preview" suffix
+  s = s.replace(/-preview$/, "")
+  return s
+}
+import { useStore, type OcmInstance, type OcmSession, type SessionStatus } from "./store.js"
+import { loadSpawnedInstances } from "./registry/instances.js"
+
+interface RunningProcess {
+  cwd: string
+  sessionId: string | null  // from -s flag, instances.json, or null
+  port?: number              // only for opencode serve processes
+}
+
+/**
+ * Get CWD for a PID. Cross-platform: macOS uses lsof, Linux uses /proc.
+ */
+function getCwdForPid(pid: number): string {
+  try {
+    if (process.platform === "linux") {
+      return execSync(`readlink /proc/${pid}/cwd 2>/dev/null`, {
+        encoding: "utf-8", timeout: 1000,
+      }).trim()
+    } else {
+      const lsofOutput = execSync(`lsof -p ${pid} 2>/dev/null`, {
+        encoding: "utf-8", timeout: 2000,
+      })
+      const cwdLine = lsofOutput.split("\n").find((l) => l.includes(" cwd "))
+      return cwdLine?.trim().split(/\s+/).slice(8).join(" ") ?? ""
+    }
+  } catch {
+    return ""
+  }
+}
+
+/**
+ * Find all currently running opencode processes (TUI and serve) with cwds and session IDs.
+ * TUI pattern:   opencode [-s {sessionId}]
+ * Serve pattern: opencode serve --port {port}
+ */
+function getRunningOpencodeProcesses(): RunningProcess[] {
+  try {
+    const psOutput = execSync("ps -eo pid,args 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 3000,
+    })
+
+    // Load spawned instances to resolve sessionIds for serve processes
+    const spawnedInstances = loadSpawnedInstances()
+    const spawnedByPort = new Map(spawnedInstances.map((i) => [i.port, i]))
+
+    const results: RunningProcess[] = []
+    for (const line of psOutput.split("\n")) {
+      const trimmed = line.trim()
+
+      // Match TUI: "opencode" or "opencode -s {sessionId}"
+      const tuiMatch = trimmed.match(/^(\d+)\s+opencode(?:\s+-s\s+(\S+))?$/)
+      if (tuiMatch) {
+        const pid = parseInt(tuiMatch[1]!, 10)
+        const sessionId = tuiMatch[2] ?? null
+        const cwd = getCwdForPid(pid)
+        if (cwd) results.push({ cwd, sessionId })
+        continue
+      }
+
+      // Match serve: "opencode serve --port {port} ..."
+      const serveMatch = trimmed.match(/^(\d+)\s+opencode\s+serve\s+.*--port\s+(\d+)/)
+      if (serveMatch) {
+        const pid = parseInt(serveMatch[1]!, 10)
+        const port = parseInt(serveMatch[2]!, 10)
+        const spawned = spawnedByPort.get(port)
+        const cwd = spawned?.cwd ?? getCwdForPid(pid)
+        if (cwd) results.push({ cwd, sessionId: spawned?.sessionId ?? null, port })
+        continue
+      }
+    }
+
+    return results
+  } catch {
+    return []
+  }
+}
+
+const STATUS_PRIORITY: Record<SessionStatus, number> = {
+  "needs-input": 0,
+  error: 1,
+  working: 2,
+  idle: 3,
+}
+
+/**
+ * Find the most specific project for a given cwd.
+ * If /Users/joey/repos/project and /Users/joey both match,
+ * prefer /Users/joey/repos/project (longer = more specific).
+ */
+function findBestProject(
+  cwd: string,
+  projects: Array<{ id: string; worktree: string }>,
+): { id: string; worktree: string } | null {
+  let best: { id: string; worktree: string } | null = null
+  let bestLen = -1
+  for (const p of projects) {
+    const isMatch =
+      cwd === p.worktree ||
+      cwd.startsWith(p.worktree + "/") ||
+      p.worktree.startsWith(cwd + "/")
+    if (isMatch && p.worktree.length > bestLen) {
+      best = p
+      bestLen = p.worktree.length
+    }
+  }
+  return best
+}
+
+let _intervalId: ReturnType<typeof setInterval> | null = null
+let _lastPollTime = 0
+
+function loadFromDb(): void {
+  try {
+    const dbProjects = getProjects()
+    const runningProcesses = getRunningOpencodeProcesses()
+
+    // Build ONE OcmInstance per running process.
+    // Processes with -s get their explicit session.
+    // Processes without -s get assigned the Nth most-recent session for their project
+    // (where N is how many other flag-less processes in the same project came before).
+    // This way two flag-less processes in the same dir show different sessions.
+    const ocmInstances: OcmInstance[] = []
+    const seenSessionIds = new Set<string>()
+    // Track how many flag-less processes we've assigned per project
+    const flaglessCountByProject = new Map<string, number>()
+
+    for (const proc of runningProcesses) {
+      const project = findBestProject(proc.cwd, dbProjects)
+      if (!project) continue
+
+      // Resolve the session ID
+      let sessionId = proc.sessionId
+      if (!sessionId) {
+        // Assign the Nth most-recent session to avoid all flag-less processes
+        // in the same directory collapsing to the same session
+        const offset = flaglessCountByProject.get(project.id) ?? 0
+        flaglessCountByProject.set(project.id, offset + 1)
+        const recent = getMostRecentSessionForProject(project.id, offset)
+        sessionId = recent?.id ?? null
+      }
+      if (!sessionId) continue
+
+      // Still deduplicate if two processes explicitly target the same session
+      if (seenSessionIds.has(sessionId)) continue
+      seenSessionIds.add(sessionId)
+
+      const session = getSessionById(sessionId)
+      if (!session) continue
+
+      const status = getSessionStatus(sessionId)
+      const preview = getLastMessagePreview(sessionId)
+      const rawModel = getSessionModel(sessionId)
+
+      // For serve instances, use the actual process cwd as worktree — it's the
+      // authoritative source and must match what's stored in instances.json.
+      // For TUI instances, use the SQLite project worktree (more stable).
+      const instanceWorktree = proc.port ? proc.cwd : project.worktree
+
+      ocmInstances.push({
+        id: `${project.id}-${sessionId}`,
+        sessionId,
+        sessionTitle: session.title || sessionId.slice(0, 20),
+        projectId: project.id,
+        worktree: instanceWorktree,
+        repoName: basename(instanceWorktree),
+        status,
+        lastPreview: preview.text,
+        lastPreviewRole: preview.role,
+        hasChildren: hasChildSessions(sessionId),
+        model: rawModel ? shortenModel(rawModel) : null,
+        port: proc.port ?? null,
+      })
+    }
+
+    // Sort: needs-input first, then working, then idle, then error
+    ocmInstances.sort((a, b) => {
+      const pa = STATUS_PRIORITY[a.status]
+      const pb = STATUS_PRIORITY[b.status]
+      if (pa !== pb) return pa - pb
+      // Secondary sort: repo name alphabetically
+      return a.repoName.localeCompare(b.repoName)
+    })
+
+    useStore.getState().setInstances(ocmInstances)
+
+    // Refresh children for expanded sessions
+    const expandedSessions = useStore.getState().expandedSessions
+    const childScrollOffsets = useStore.getState().childScrollOffsets
+    for (const sessionId of expandedSessions) {
+      try {
+        const offset = childScrollOffsets.get(sessionId) ?? 0
+        const children = getChildSessions(sessionId, 10, offset)
+        const totalCount = countChildSessions(sessionId)
+        const childOcmSessions: OcmSession[] = children.map((c) => {
+          const status = getSessionStatus(c.id)
+          const preview = getLastMessagePreview(c.id)
+          return {
+            id: c.id,
+            projectId: c.projectId,
+            title: c.title,
+            directory: c.directory,
+            status,
+            lastMessagePreview: preview.text,
+            lastMessageRole: preview.role,
+            model: (() => { const m = getSessionModel(c.id); return m ? shortenModel(m) : null })(),
+            timeUpdated: c.timeUpdated,
+            hasChildren: hasChildSessions(c.id),
+          }
+        })
+        useStore.getState().setChildSessions(sessionId, childOcmSessions, totalCount)
+      } catch {
+        // Skip on error
+      }
+    }
+
+    _lastPollTime = Date.now()
+  } catch {
+    // DB may be locked briefly — skip this poll cycle
+  }
+}
+
+export function startPoller(intervalMs = 2000): void {
+  if (_intervalId) return
+  loadFromDb()
+  _intervalId = setInterval(() => { loadFromDb() }, intervalMs)
+}
+
+export function stopPoller(): void {
+  if (_intervalId) {
+    clearInterval(_intervalId)
+    _intervalId = null
+  }
+}
+
+export function refreshNow(): void {
+  loadFromDb()
+}
+
+export function getLastPollTime(): number {
+  return _lastPollTime
+}