cru-teams 1.0.0

package/src/lib/mirror.ts

@@ -0,0 +1,149 @@
+/**
+ * Mirror tmux panes into native Ghostty splits.
+ *
+ * When Claude Code spawns a team via Agent tool, workers end up in a
+ * headless tmux session using a CUSTOM SOCKET: `tmux -L claude-swarm-<PID>`.
+ * These don't show up in the default `tmux list-sessions`.
+ *
+ * This module:
+ * 1. Finds claude-swarm socket files in /tmp/tmux-<uid>/
+ * 2. Queries each socket for worker panes
+ * 3. Breaks panes into separate tmux windows
+ * 4. Creates Ghostty splits, each running `tmux -L <socket> attach -t <view>`
+ *
+ * Result: each Ghostty split shows a real tmux pane with full interactivity.
+ * Workers retain all team features (SendMessage, tasks, team bar).
+ */
+
+import { execFileSync } from 'node:child_process'
+import { readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { splitTerminal, sendCommand } from './ghostty'
+
+/** Run a tmux command on a specific socket (or default). */
+function tmuxSocket(args: string[], socket?: string): string {
+  const fullArgs = socket ? ['-L', socket, ...args] : args
+  return execFileSync('tmux', fullArgs, { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+}
+
+/** Find claude-swarm tmux socket names, newest first. */
+export function findSwarmSockets(): string[] {
+  const uid = process.getuid?.() ?? 501
+  const sockDir = join('/tmp', `tmux-${uid}`)
+  try {
+    return readdirSync(sockDir)
+      .filter((f) => f.startsWith('claude-swarm-'))
+      .map((f) => ({ name: f, mtime: statSync(join(sockDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime)
+      .map((f) => f.name)
+  } catch {
+    return []
+  }
+}
+
+/** Check if a PID is still running. */
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Find live swarm sockets that have active sessions. */
+export function findLiveSwarms(): Array<{ socket: string; session: string; paneCount: number }> {
+  const results: Array<{ socket: string; session: string; paneCount: number }> = []
+
+  for (const socket of findSwarmSockets()) {
+    const pid = Number(socket.replace('claude-swarm-', ''))
+    if (pid && !isPidAlive(pid)) continue
+
+    try {
+      const sessions = tmuxSocket(['list-sessions', '-F', '#{session_name}'], socket)
+        .split('\n').filter(Boolean)
+        .filter(s => !s.startsWith('view-'))
+      if (sessions.length === 0) continue
+      const session = sessions[0]
+
+      const allPanes = tmuxSocket(['list-panes', '-a', '-F', '#{pane_id}'], socket)
+        .split('\n').filter(Boolean)
+      const uniquePanes = [...new Set(allPanes)]
+
+      results.push({ socket, session, paneCount: uniquePanes.length })
+    } catch {
+      // Server not running — skip
+    }
+  }
+  return results
+}
+
+/** Find the swarm with the most panes (most likely the current team). */
+export function findBestSwarm(expectedWorkers?: number): { socket: string; session: string } | null {
+  const swarms = findLiveSwarms()
+  if (swarms.length === 0) return null
+
+  if (expectedWorkers) {
+    const match = swarms.find((s) => s.paneCount >= expectedWorkers)
+    if (match) return match
+  }
+
+  swarms.sort((a, b) => b.paneCount - a.paneCount)
+  return swarms[0]
+}
+
+/** Get worker pane IDs from a swarm socket. All panes are workers (lead runs in user's terminal). */
+export function getWorkerPanes(socket: string, _session?: string): string[] {
+  try {
+    const allPanes = tmuxSocket(['list-panes', '-a', '-F', '#{pane_id}'], socket)
+      .split('\n').filter(Boolean)
+    return [...new Set(allPanes)].sort()
+  } catch {
+    return []
+  }
+}
+
+/** Enable remain-on-exit globally so panes stay visible after worker exits. */
+export function setRemainOnExit(socket: string): void {
+  try { tmuxSocket(['set-option', '-g', 'remain-on-exit', 'on'], socket) } catch {}
+}
+
+/**
+ * Mirror a single tmux worker pane into a Ghostty split.
+ * Used for incremental mirroring — opens each pane as soon as the worker spawns.
+ */
+export function mirrorSingleWorker(
+  socket: string,
+  session: string,
+  paneId: string,
+  index: number,
+  splitTarget: string,
+  splitDirection: 'right' | 'down',
+): { ghosttyTerminal: string; viewSession: string } {
+  const windowName = `worker-${index + 1}`
+  const viewName = `view-${index + 1}`
+
+  // Break pane into its own tmux window
+  try {
+    tmuxSocket(['break-pane', '-s', paneId, '-d', '-n', windowName], socket)
+  } catch (e: any) {
+    console.error(`  [mirror] break-pane ${paneId}: ${e.message}`)
+  }
+
+  // Create a session group member pointing at the worker's window
+  try { tmuxSocket(['kill-session', '-t', viewName], socket) } catch {}
+  tmuxSocket(['new-session', '-d', '-t', session, '-s', viewName], socket)
+  tmuxSocket(['set-option', '-t', viewName, 'status', 'off'], socket)
+  tmuxSocket(['select-window', '-t', `${viewName}:${windowName}`], socket)
+
+  // Create Ghostty split
+  const newTermId = splitTerminal(splitTarget, splitDirection)
+  Bun.sleepSync(300)
+
+  // Attach to the view session via the custom socket
+  sendCommand(newTermId, `tmux -L ${socket} attach -t ${viewName}`)
+  Bun.sleepSync(200)
+
+  console.log(`  [mirror] ${windowName} (${paneId}) → ghostty:${newTermId}`)
+  return { ghosttyTerminal: newTermId, viewSession: viewName }
+}

package/src/lib/panes.ts

@@ -0,0 +1,62 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { teamsDir } from './paths'
+import { listAllPaneIds } from './tmux'
+
+export interface PaneRecord {
+  leadPane: string
+  windowId: string
+  workers: Array<{ name: string; paneId: string; color: string }>
+  createdAt: number
+  backend?: 'tmux' | 'ghostty'
+}
+
+function panePath(teamName: string): string {
+  return join(teamsDir(), teamName, 'cru-panes.json')
+}
+
+export function savePanes(teamName: string, record: PaneRecord): void {
+  const dir = join(teamsDir(), teamName)
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(panePath(teamName), JSON.stringify(record, null, 2))
+}
+
+export function loadPanes(teamName: string): PaneRecord | null {
+  try {
+    return JSON.parse(readFileSync(panePath(teamName), 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+/** Check if a team has live worker panes. */
+export function isTeamAlive(teamName: string): boolean {
+  try {
+    const cruPanes = loadPanes(teamName)
+
+    // For ghostty-tracked teams, check via AppleScript
+    if (cruPanes?.backend === 'ghostty') {
+      try {
+        const { listAllTerminals } = require('./ghostty')
+        const allTerminals = new Set(listAllTerminals())
+        return cruPanes.workers.some((w) => allTerminals.has(w.paneId))
+      } catch (e) {
+        console.warn(`[isTeamAlive] failed to query Ghostty for team "${teamName}": ${e}`)
+        return false
+      }
+    }
+
+    // For tmux teams, check pane IDs
+    const allPanes = new Set(listAllPaneIds())
+
+    if (cruPanes && cruPanes.workers.some((w) => allPanes.has(w.paneId))) return true
+
+    // Fallback: check Claude's team config for tmuxPaneId entries
+    // Late require to avoid circular dep (teams.ts imports panes.ts)
+    const { readTeamConfig } = require('./teams')
+    const config = readTeamConfig(teamName)
+    return config.members.some((m: any) => m.tmuxPaneId && allPanes.has(m.tmuxPaneId))
+  } catch {
+    return false
+  }
+}

package/src/lib/paths.ts

@@ -0,0 +1,6 @@
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+export function teamsDir(): string {
+  return join(homedir(), '.claude', 'teams')
+}

package/src/lib/preflight.ts

@@ -0,0 +1,94 @@
+import { hasBinary, inTmux, inGhostty, detectTerminal } from '@/lib/env'
+
+const INSTALL_HINTS: Record<string, Record<string, string>> = {
+  tmux: {
+    darwin: 'brew install tmux',
+    linux: 'sudo apt install tmux  # or your package manager',
+    fallback: 'https://github.com/tmux/tmux/wiki/Installing',
+  },
+  claude: {
+    all: 'npm install -g @anthropic-ai/claude-code',
+    docs: 'https://docs.anthropic.com/en/docs/claude-code',
+  },
+}
+
+function platformHint(tool: string): string {
+  const hints = INSTALL_HINTS[tool]
+  if (!hints) return ''
+  if (hints.all) return hints.all
+  const platform = process.platform
+  return hints[platform] || hints.fallback || ''
+}
+
+interface PreflightError {
+  check: string
+  message: string
+  hint?: string
+}
+
+type Check = 'tmux' | 'tmux-session' | 'claude' | 'pane-session' | 'terminal'
+
+/**
+ * Run preflight checks. Returns { ok, errors, terminal }.
+ */
+export function preflight(...checks: Check[]): { ok: boolean; errors: PreflightError[]; terminal: string } {
+  const terminal = detectTerminal()
+  const tmuxCmd = terminal === 'iterm2' ? 'tmux -CC' : 'tmux'
+  const errors: PreflightError[] = []
+
+  for (const check of checks) {
+    switch (check) {
+      case 'tmux':
+        if (!hasBinary('tmux')) {
+          errors.push({ check: 'tmux', message: 'tmux is not installed', hint: platformHint('tmux') })
+        }
+        break
+
+      case 'tmux-session':
+        if (!hasBinary('tmux')) {
+          errors.push({ check: 'tmux', message: 'tmux is not installed', hint: platformHint('tmux') })
+        } else if (!inTmux()) {
+          errors.push({ check: 'tmux-session', message: 'Not inside a tmux session', hint: tmuxCmd })
+        }
+        break
+
+      case 'claude':
+        if (!hasBinary('claude')) {
+          errors.push({ check: 'claude', message: 'Claude Code CLI is not installed', hint: platformHint('claude') })
+        }
+        break
+
+      case 'pane-session':
+        if (inGhostty()) {
+          if (process.platform !== 'darwin') {
+            errors.push({ check: 'pane-session', message: 'Ghostty AppleScript is only available on macOS' })
+          } else {
+            try {
+              const { isGhosttyScriptable } = require('./ghostty')
+              if (!isGhosttyScriptable()) {
+                errors.push({ check: 'pane-session', message: 'Ghostty is not responding to AppleScript. Check that macos-applescript is enabled.' })
+              }
+            } catch {
+              errors.push({ check: 'pane-session', message: 'Cannot connect to Ghostty via AppleScript' })
+            }
+          }
+        } else if (!hasBinary('tmux')) {
+          errors.push({ check: 'pane-session', message: 'tmux is not installed (or use Ghostty for native pane support)', hint: platformHint('tmux') })
+        } else if (!inTmux()) {
+          errors.push({ check: 'pane-session', message: 'Not inside a tmux session (or use Ghostty for native pane support)', hint: tmuxCmd })
+        }
+        break
+
+      case 'terminal':
+        if (terminal === 'vscode') {
+          errors.push({
+            check: 'terminal',
+            message: 'VS Code terminal cannot display tmux panes. Use iTerm2 or a standalone terminal with tmux.',
+          })
+        }
+        break
+    }
+  }
+
+  return { ok: errors.length === 0, errors, terminal }
+}

package/src/lib/teams.ts

@@ -0,0 +1,57 @@
+import { readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { teamsDir } from './paths'
+import { loadPanes } from './panes'
+import { currentPane, paneWindow, tmux } from './tmux'
+
+export function readTeamConfig(teamName: string): any {
+  const p = join(teamsDir(), teamName, 'config.json')
+  return JSON.parse(readFileSync(p, 'utf-8'))
+}
+
+export function listTeams(): string[] {
+  const dir = teamsDir()
+  try {
+    return readdirSync(dir).filter((d) => {
+      try {
+        readFileSync(join(dir, d, 'config.json'), 'utf-8')
+        return true
+      } catch {
+        return false
+      }
+    })
+  } catch {
+    return []
+  }
+}
+
+/** Find which team owns the current terminal window. */
+export function findTeamForCurrentWindow(): string | null {
+  const windowId = paneWindow(currentPane())
+  for (const name of listTeams()) {
+    const panes = loadPanes(name)
+    if (panes?.windowId === windowId) return name
+  }
+  return null
+}
+
+export function findTeamWindow(teamName: string): string | null {
+  // Primary: cru's own pane tracking
+  const cruPanes = loadPanes(teamName)
+  if (cruPanes) return cruPanes.windowId
+
+  // Fallback: search via Claude's team config
+  const config = readTeamConfig(teamName)
+  const workerPaneIds = config.members
+    .filter((m: any) => m.tmuxPaneId)
+    .map((m: any) => m.tmuxPaneId)
+  if (workerPaneIds.length === 0) return null
+
+  // Search all panes to find which window contains a worker pane
+  const lines = tmux('list-panes', '-a', '-F', '#{window_id} #{pane_id}').split('\n')
+  for (const line of lines) {
+    const [winId, paneId] = line.split(' ')
+    if (paneId === workerPaneIds[0]) return winId
+  }
+  return null
+}

package/src/lib/tmux.ts

@@ -0,0 +1,167 @@
+import { execFileSync } from 'node:child_process'
+import { buildLayout } from './layout'
+
+export interface PaneInfo {
+  id: string
+  index: number
+}
+
+export interface PaneDetails {
+  id: string
+  index: number
+  width: number
+  height: number
+  left: number
+  top: number
+  pid: number
+}
+
+/** Run a tmux command safely (no shell interpolation). */
+export function tmux(...args: string[]): string {
+  return execFileSync('tmux', args, { encoding: 'utf-8' }).trim()
+}
+
+export function tmuxChecksum(layout: string): string {
+  let csum = 0
+  for (const c of layout) {
+    csum = ((csum >> 1) + ((csum & 1) << 15)) & 0xffff
+    csum = (csum + c.charCodeAt(0)) & 0xffff
+  }
+  return csum.toString(16).padStart(4, '0')
+}
+
+export function getWindowDimensions(windowId: string): { w: number; h: number } {
+  // display-message can return empty in control mode — use list-windows as fallback
+  const dims = tmux('display-message', '-t', windowId, '-p', '#{window_width}x#{window_height}')
+  if (dims && dims.includes('x')) {
+    const [w, h] = dims.split('x').map(Number)
+    if (w && h) return { w, h }
+  }
+  const fallback = tmux('list-windows', '-a', '-F', '#{window_id} #{window_width} #{window_height}')
+    .split('\n')
+    .find((l) => l.startsWith(windowId + ' '))
+  if (fallback) {
+    const [, w, h] = fallback.split(' ')
+    return { w: Number(w), h: Number(h) }
+  }
+  throw new Error(`Cannot get dimensions for window ${windowId}`)
+}
+
+export function listWindowPanes(windowId: string): PaneInfo[] {
+  return tmux('list-panes', '-t', windowId, '-F', '#{pane_id} #{pane_index}')
+    .split('\n')
+    .map((l) => {
+      const [id, idx] = l.split(' ')
+      return { id, index: Number(idx) }
+    })
+}
+
+export function listAllPaneIds(): string[] {
+  return tmux('list-panes', '-a', '-F', '#{pane_id}').split('\n')
+}
+
+export function applyLayout(windowId: string, layoutStr: string): void {
+  const full = `${tmuxChecksum(layoutStr)},${layoutStr}`
+  tmux('select-layout', '-t', windowId, full)
+}
+
+/** Get the current pane ID (the pane running this process). */
+export function currentPane(): string {
+  // TMUX_PANE is set per-pane by tmux — most reliable source
+  const envPane = process.env.TMUX_PANE
+  if (envPane) {
+    // Verify it still exists (can be stale in iTerm2 tmux -CC)
+    try {
+      const allPanes = tmux('list-panes', '-a', '-F', '#{pane_id}').split('\n')
+      if (allPanes.includes(envPane)) return envPane
+    } catch {}
+  }
+  // Fallback — may not work in control mode but worth trying
+  return tmux('display-message', '-p', '#{pane_id}')
+}
+
+/** Get the window ID for a given pane. */
+export function paneWindow(paneId: string): string {
+  // display-message can return empty in tmux control mode (tmux -CC / VS Code)
+  const result = tmux('display-message', '-t', paneId, '-p', '#{window_id}')
+  if (result) return result
+
+  // Fallback: search all panes
+  const lines = tmux('list-panes', '-a', '-F', '#{pane_id} #{window_id}').split('\n')
+  for (const line of lines) {
+    const [pid, wid] = line.split(' ')
+    if (pid === paneId) return wid
+  }
+  throw new Error(`Cannot find window for pane ${paneId}`)
+}
+
+/** Split a pane and return the new pane ID. */
+export function splitPane(targetPane: string, { horizontal = false } = {}): string {
+  const flag = horizontal ? '-v' : '-h'
+  return tmux('split-window', flag, '-t', targetPane, '-P', '-F', '#{pane_id}')
+}
+
+/** Send keys to a pane (runs a command). */
+export function sendKeys(paneId: string, text: string): void {
+  tmux('send-keys', '-t', paneId, text, 'Enter')
+}
+
+/** Kill a specific pane. */
+export function killPane(paneId: string): void {
+  try {
+    tmux('kill-pane', '-t', paneId)
+  } catch {
+    // pane may already be dead
+  }
+}
+
+/** Select (focus) a pane. */
+export function selectPane(paneId: string): void {
+  tmux('select-pane', '-t', paneId)
+}
+
+export function listPaneDetails(windowId: string): PaneDetails[] {
+  return tmux('list-panes', '-t', windowId, '-F', '#{pane_id} #{pane_index} #{pane_width} #{pane_height} #{pane_left} #{pane_top} #{pane_pid}')
+    .split('\n')
+    .map((l) => {
+      const [id, index, width, height, left, top, pid] = l.split(' ')
+      return { id, index: Number(index), width: Number(width), height: Number(height), left: Number(left), top: Number(top), pid: Number(pid) }
+    })
+}
+
+export function swapPanes(a: string, b: string): void {
+  tmux('swap-pane', '-d', '-s', a, '-t', b)
+}
+
+/** Apply a grid layout: lead pane on one side, workers in a grid on the other. */
+export function applyGrid(windowId: string, leadPaneId: string, workerPaneIds: string[], conf: LayoutConf): void {
+  const { w: W, h: H } = getWindowDimensions(windowId)
+  const leadId = leadPaneId.replace('%', '')
+  const workerIds = workerPaneIds.map((p) => p.replace('%', ''))
+  const layoutStr = buildLayout(W, H, leadId, workerIds, conf)
+  applyLayout(windowId, layoutStr)
+
+  // Fix pane assignment for right/bottom — tmux assigns by window order, not layout IDs
+  const pos = conf.lead.position
+  if (pos === 'right' || pos === 'bottom') {
+    const posKey = pos === 'right' ? 'pane_left' : 'pane_top'
+    const afterInfo = tmux('list-panes', '-t', windowId, '-F', `#{pane_id} #{${posKey}}`)
+      .split('\n')
+      .map((l) => { const [id, v] = l.split(' '); return { id, pos: Number(v) } })
+
+    const leadAfter = afterInfo.find((p) => p.id === leadPaneId)
+    const maxPos = Math.max(...afterInfo.map((p) => p.pos))
+    if (leadAfter && leadAfter.pos !== maxPos) {
+      const paneAtLeadPos = afterInfo.find((p) => p.pos === maxPos)
+      if (paneAtLeadPos) {
+        swapPanes(leadPaneId, paneAtLeadPos.id)
+      }
+    }
+  }
+}
+
+// Re-export layout config type for callers
+export interface LayoutConf {
+  lead: { position: 'left' | 'right' | 'top' | 'bottom'; size: number }
+  grid: { fill: 'row' | 'column'; maxCols: number | null; maxRows: number | null }
+}