cru-teams 1.0.0

package/src/commands/logs.ts

@@ -0,0 +1,302 @@
+import { z } from 'incur'
+import { readTeamConfig, listTeams } from '@/lib/teams'
+import { loadPanes } from '@/lib/panes'
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { homedir } from 'node:os'
+
+const COLORS: Record<string, string> = {
+  blue: '\x1b[34m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+  purple: '\x1b[35m',
+  cyan: '\x1b[36m',
+}
+const AUTO_COLORS = ['cyan', 'blue', 'green', 'yellow', 'magenta', 'red']
+const DIM = '\x1b[2m'
+const BOLD = '\x1b[1m'
+const RESET = '\x1b[0m'
+
+type MsgKind = 'chat' | 'task' | 'idle' | 'shutdown'
+
+interface Event {
+  ts: number
+  type: 'created' | 'joined' | 'message'
+  kind?: MsgKind
+  team?: string
+  agent?: string
+  color?: string
+  from?: string
+  to?: string
+  text?: string
+}
+
+function readInboxes(teamName: string): Event[] {
+  const inboxDir = join(homedir(), '.claude', 'teams', teamName, 'inboxes')
+  if (!existsSync(inboxDir)) return []
+
+  const events: Event[] = []
+  for (const file of readdirSync(inboxDir)) {
+    if (!file.endsWith('.json')) continue
+    const to = basename(file, '.json')
+    try {
+      const messages = JSON.parse(readFileSync(join(inboxDir, file), 'utf-8'))
+      for (const msg of messages) {
+        let text = msg.summary || msg.text
+        let kind: MsgKind = 'chat'
+        try {
+          const parsed = JSON.parse(msg.text)
+          switch (parsed.type) {
+            case 'task_assignment':
+              text = parsed.subject || parsed.description || 'assigned'
+              kind = 'task'
+              break
+            case 'shutdown_request':
+              text = parsed.reason || 'requested'
+              kind = 'shutdown'
+              break
+            case 'shutdown_approved':
+              text = 'approved'
+              kind = 'shutdown'
+              break
+            case 'idle_notification':
+              kind = 'idle'
+              text = parsed.idleReason || 'available'
+              break
+          }
+        } catch {}
+
+        events.push({
+          ts: new Date(msg.timestamp).getTime(),
+          type: 'message',
+          kind,
+          from: msg.from,
+          to,
+          text,
+          color: msg.color,
+        })
+      }
+    } catch {}
+  }
+  return events
+}
+
+function teamEvents(teamName: string): { events: Event[]; colorMap: Record<string, string> } {
+  const config = readTeamConfig(teamName)
+  const colorMap: Record<string, string> = {}
+
+  // 1. Seed from cru-panes.json (most reliable — has colors from spawn time)
+  const cruPanes = loadPanes(teamName)
+  if (cruPanes) {
+    for (const w of cruPanes.workers) {
+      if (w.color && COLORS[w.color]) colorMap[w.name] = w.color
+    }
+  }
+
+  // 2. Layer on Claude config members (may have colors for registered workers)
+  for (const m of config.members) {
+    if (!colorMap[m.name] && m.color && COLORS[m.color]) colorMap[m.name] = m.color
+  }
+
+  const events: Event[] = []
+
+  events.push({ ts: config.createdAt, type: 'created', team: teamName })
+
+  for (const m of config.members) {
+    if (m.agentType === 'team-lead') continue
+    events.push({ ts: m.joinedAt, type: 'joined', team: teamName, agent: m.name, color: m.color })
+  }
+
+  const msgEvents = readInboxes(teamName)
+  // Build colorMap from inbox message colors (workers may not be in config yet)
+  for (const e of msgEvents) {
+    e.team = teamName
+    if (e.color && e.from && !colorMap[e.from]) {
+      colorMap[e.from] = e.color
+    }
+  }
+  events.push(...msgEvents)
+
+  return { events, colorMap }
+}
+
+function truncate(s: string, n: number): string {
+  if (!s) return ''
+  const oneline = s.replace(/\n/g, ' ').trim()
+  return oneline.length > n ? `${oneline.slice(0, n)}…` : oneline
+}
+
+function time(ts: number): string {
+  const d = new Date(ts)
+  return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}`
+}
+
+function hashColor(name: string): string {
+  let h = 0
+  for (let i = 0; i < name.length; i++) h = ((h << 5) - h + name.charCodeAt(i)) | 0
+  return AUTO_COLORS[Math.abs(h) % AUTO_COLORS.length]
+}
+
+function colorize(name: string, color: string | undefined, colorMap?: Record<string, string>): string {
+  if (!color && colorMap) {
+    if (!colorMap[name]) colorMap[name] = hashColor(name)
+    color = colorMap[name]
+  }
+  if (name === 'team-lead') return `${BOLD}${name}${RESET}`
+  const c = color && COLORS[color]
+  return c ? `${c}${name}${RESET}` : name
+}
+
+function formatEvents(
+  events: Event[],
+  colorMap: Record<string, string>,
+  opts: { full?: boolean; showTeam?: boolean },
+): string {
+  const lines: string[] = []
+
+  for (const e of events) {
+    const t = `${DIM}${time(e.ts)}${RESET}`
+    const prefix = opts.showTeam ? `${DIM}${e.team}${RESET} ` : ''
+    switch (e.type) {
+      case 'created':
+        lines.push(`${t}  ${prefix}${DIM}◉ team created${RESET}`)
+        break
+      case 'joined':
+        lines.push(`${t}  ${prefix}${colorize('⊕', e.color, colorMap)} ${colorize(e.agent!, e.color, colorMap)} joined`)
+        break
+      case 'message': {
+        const from = colorize(e.from!, colorMap[e.from!], colorMap)
+        const to = colorize(e.to!, colorMap[e.to!], colorMap)
+        const text = opts.full ? e.text : truncate(e.text || '', 80)
+        switch (e.kind) {
+          case 'task':
+            lines.push(`${t}  ${prefix}${BOLD}◉${RESET} ${from} → ${to}: ${text}`)
+            break
+          case 'idle':
+            lines.push(`${t}  ${prefix}${DIM}○${RESET} ${from} ${DIM}idle${RESET}`)
+            break
+          case 'shutdown':
+            lines.push(`${t}  ${prefix}${DIM}⊘${RESET} ${from} → ${to}${DIM}: ${text}${RESET}`)
+            break
+          default:
+            lines.push(`${t}  ${prefix}● ${from} → ${to}: ${text}`)
+            break
+        }
+        break
+      }
+    }
+  }
+
+  return lines.join('\n')
+}
+
+export const logs = {
+  description: 'Show team activity log',
+  args: z.object({
+    team: z.string().optional().describe('Team name (omit to show all teams)'),
+  }),
+  options: z.object({
+    full: z.boolean().default(false).describe('Show full message text'),
+    last: z.coerce.number().optional().describe('Show only the last N events'),
+    follow: z.boolean().default(false).describe('Follow live events'),
+  }),
+  alias: { follow: 'f' },
+  async run(c) {
+    const fixedTeam = c.args.team
+    const getTeams = () => fixedTeam ? [fixedTeam] : listTeams()
+
+    const teamNames = getTeams()
+    if (teamNames.length === 0) return { events: [], message: 'No teams found' }
+
+    const mergedColorMap: Record<string, string> = {}
+
+    const collectEvents = () => {
+      const names = getTeams()
+      const events: Event[] = []
+      for (const name of names) {
+        try {
+          const result = teamEvents(name)
+          events.push(...result.events)
+          Object.assign(mergedColorMap, result.colorMap)
+        } catch {}
+      }
+      events.sort((a, b) => a.ts - b.ts)
+      return { events, teams: names }
+    }
+
+    const { events: allEvents } = collectEvents()
+
+    const limit = c.options.last ?? (fixedTeam ? undefined : 50)
+    const display = limit ? allEvents.slice(-limit) : allEvents
+
+    if (c.agent) {
+      return {
+        teams: teamNames,
+        events: display.map((e) => ({
+          time: new Date(e.ts).toISOString(),
+          type: e.type,
+          ...(e.team ? { team: e.team } : {}),
+          ...(e.agent ? { agent: e.agent } : {}),
+          ...(e.from ? { from: e.from, to: e.to } : {}),
+          ...(e.text ? { text: e.text } : {}),
+        })),
+      }
+    }
+
+    const showTeam = !fixedTeam || teamNames.length > 1
+    if (!showTeam) {
+      const created = new Date(allEvents[0]?.ts || Date.now())
+      const date = created.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+      console.log(`\n${BOLD}${teamNames[0]}${RESET} ${DIM}— ${date}${RESET}\n`)
+    } else {
+      console.log()
+    }
+
+    const fmtOpts = { full: c.options.full, showTeam }
+    console.log(formatEvents(display, mergedColorMap, fmtOpts))
+
+    if (!c.options.follow) {
+      console.log(`\n${DIM}Run with -f to follow live${RESET}\n`)
+      return
+    }
+
+    // Follow mode: poll for new events every 2s
+    console.log(`${DIM}following — c: clear, q: quit${RESET}\n`)
+
+    let lastTs = allEvents.length > 0 ? allEvents[allEvents.length - 1].ts : 0
+    const poll = () => {
+      const { events: fresh } = collectEvents()
+
+      const newEvents = fresh.filter((e) => e.ts > lastTs)
+      if (newEvents.length > 0) {
+        process.stdout.write(formatEvents(newEvents, mergedColorMap, fmtOpts) + '\n')
+        lastTs = newEvents[newEvents.length - 1].ts
+      }
+    }
+
+    const interval = setInterval(poll, 2000)
+    const quit = () => {
+      clearInterval(interval)
+      if (process.stdin.isTTY) process.stdin.setRawMode(false)
+      console.log(`\n${DIM}stopped${RESET}`)
+      process.exit(0)
+    }
+
+    // Handle keyboard input
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true)
+      process.stdin.resume()
+      process.stdin.on('data', (key) => {
+        if (key[0] === 3 || key[0] === 0x71) quit() // Ctrl+C or q
+        if (key[0] === 0x63 || key[0] === 12) { // c or Ctrl+L
+          process.stdout.write('\x1b[2J\x1b[H') // clear screen
+        }
+      })
+    }
+
+    process.on('SIGINT', quit)
+    await new Promise(() => {})
+  },
+}

package/src/commands/panes.ts

@@ -0,0 +1,376 @@
+import { z } from 'incur'
+import { loadConfig } from '@/lib/config'
+import { readTeamConfig, findTeamWindow, findTeamForCurrentWindow } from '@/lib/teams'
+import {
+  currentPane, paneWindow, getWindowDimensions, listWindowPanes,
+  killPane, applyGrid, listPaneDetails,
+} from '@/lib/tmux'
+import { computeGrid } from '@/lib/layout'
+import { loadPanes, savePanes } from '@/lib/panes'
+import { inGhostty } from '@/lib/env'
+
+/**
+ * Ghostty+tmux mirror flow:
+ * Workers live in a headless tmux with a CUSTOM SOCKET (tmux -L claude-swarm-*).
+ * We find the socket, discover worker panes, break each into its own tmux window,
+ * create Ghostty splits, and attach each to a session-group view.
+ *
+ * Uses INCREMENTAL mirroring: opens each pane as soon as the worker spawns,
+ * without waiting for all workers to be ready.
+ */
+function runGridGhostty(c) {
+  const {
+    findBestSwarm,
+    getWorkerPanes,
+    mirrorSingleWorker,
+    setRemainOnExit,
+  } = require('@/lib/mirror')
+  const {
+    currentTerminal,
+    focusTerminal,
+  } = require('@/lib/ghostty')
+
+  const teamName = c.args.team
+  const expectedWorkers = c.options.expect
+  const deadline = Date.now() + 60_000
+
+  // 1. Find the swarm socket
+  // Only poll if --expect was passed (the skill sets this when workers are spawning).
+  // Otherwise check once and fail fast — the user called this directly.
+  let swarm: { socket: string; session: string } | null = null
+  if (expectedWorkers) {
+    while (Date.now() < deadline) {
+      swarm = findBestSwarm(expectedWorkers)
+      if (swarm) break
+      Bun.sleepSync(200)
+    }
+  } else {
+    swarm = findBestSwarm()
+  }
+
+  if (!swarm) {
+    return c.error({
+      code: 'NO_SWARM',
+      message: 'No claude-swarm tmux session found. Is a Claude Code team running?',
+    })
+  }
+
+  console.log(`  [grid] found swarm: ${swarm.socket}/${swarm.session}`)
+
+  // Keep dead panes visible after worker exits
+  setRemainOnExit(swarm.socket)
+
+  // 2. Incrementally mirror workers as they appear
+  const leadTerminalId = currentTerminal()
+  const mirrored = new Map<string, { ghosttyTerminal: string; viewSession: string }>()
+
+  while (Date.now() < deadline) {
+    const allWorkers = getWorkerPanes(swarm.socket)
+    const newWorkers = allWorkers.filter(p => !mirrored.has(p))
+
+    for (const paneId of newWorkers) {
+      const idx = mirrored.size
+      const splitDir: 'right' | 'down' = idx === 0 ? 'right' : 'down'
+      const splitTarget = idx === 0
+        ? leadTerminalId
+        : [...mirrored.values()].pop()!.ghosttyTerminal
+
+      const result = mirrorSingleWorker(
+        swarm.socket, swarm.session,
+        paneId, idx, splitTarget, splitDir,
+      )
+      mirrored.set(paneId, result)
+    }
+
+    // All expected workers mirrored
+    if (expectedWorkers && mirrored.size >= expectedWorkers) break
+
+    // No expected count — wait for workers to stop appearing
+    if (!expectedWorkers && mirrored.size > 0 && newWorkers.length === 0) {
+      Bun.sleepSync(3000) // give stragglers 3s
+      const finalWorkers = getWorkerPanes(swarm.socket)
+      if (finalWorkers.filter(p => !mirrored.has(p)).length === 0) break
+      continue
+    }
+
+    Bun.sleepSync(200)
+  }
+
+  if (mirrored.size === 0) {
+    return c.error({
+      code: 'NO_WORKERS',
+      message: 'No worker panes found in swarm.',
+    })
+  }
+
+  // 3. Focus lead
+  focusTerminal(leadTerminalId)
+
+  // 4. Save pane tracking
+  if (teamName) {
+    const mirrors = [...mirrored.entries()]
+    savePanes(teamName, {
+      leadPane: leadTerminalId,
+      windowId: leadTerminalId, // Ghostty doesn't have tmux-style window IDs; use lead terminal as key
+      backend: 'ghostty',
+      createdAt: Date.now(),
+      workers: mirrors.map(([, m], i) => ({
+        name: `worker-${i + 1}`,
+        paneId: m.ghosttyTerminal,
+        color: ['green', 'blue', 'yellow', 'magenta', 'cyan', 'red'][i % 6],
+      })),
+    })
+  }
+
+  return {
+    applied: true,
+    backend: 'ghostty+tmux',
+    swarm: `${swarm.socket}/${swarm.session}`,
+    workers: mirrored.size,
+    mirrors: [...mirrored.entries()].map(([paneId, m]) => ({
+      tmux: paneId,
+      ghostty: m.ghosttyTerminal,
+      view: m.viewSession,
+    })),
+  }
+}
+
+function runGrid(c) {
+  // Ghostty: mirror tmux panes into native splits
+  if (inGhostty()) {
+    return runGridGhostty(c)
+  }
+
+  const conf = loadConfig()
+
+  if (c.options['lead-size'] != null) conf.layout.lead.size = c.options['lead-size']
+  if (c.options['lead-position']) conf.layout.lead.position = c.options['lead-position']
+  if (c.options.fill) conf.layout.grid.fill = c.options.fill
+  if (c.options['max-cols'] != null) conf.layout.grid.maxCols = c.options['max-cols']
+  if (c.options['max-rows'] != null) conf.layout.grid.maxRows = c.options['max-rows']
+
+  const teamName = c.args.team
+  let windowId: string | null = null
+  let leadPaneId: string | null = null
+  let workerPaneIds: Set<string> | null = null
+  let cruPanesData: ReturnType<typeof loadPanes> = null
+
+  if (teamName) {
+    cruPanesData = loadPanes(teamName)
+    if (cruPanesData) {
+      windowId = cruPanesData.windowId
+      workerPaneIds = new Set(cruPanesData.workers.map((w) => w.paneId))
+    } else {
+      windowId = findTeamWindow(teamName)
+      const teamConf = readTeamConfig(teamName)
+      workerPaneIds = new Set(
+        teamConf.members.filter((m) => m.tmuxPaneId).map((m) => m.tmuxPaneId),
+      )
+    }
+  } else {
+    leadPaneId = currentPane()
+    windowId = paneWindow(leadPaneId)
+  }
+
+  if (!windowId) return c.error({ code: 'NO_WINDOW', message: 'Could not find terminal window' })
+
+  if (c.options.expect) {
+    const expectedTotal = c.options.expect + 1
+    const deadline = Date.now() + 30_000
+    while (Date.now() < deadline) {
+      if (listWindowPanes(windowId).length >= expectedTotal) break
+      Bun.sleepSync(500)
+    }
+  }
+
+  const { w: W, h: H } = getWindowDimensions(windowId)
+  const panes = listWindowPanes(windowId)
+
+  if (panes.length < 2) {
+    return c.error({ code: 'NO_WORKERS', message: 'Only one pane in window — nothing to arrange' })
+  }
+
+  let leadPane, workerPanes
+  if (workerPaneIds) {
+    leadPane = panes.find((p) => !workerPaneIds.has(p.id))
+    workerPanes = panes.filter((p) => workerPaneIds.has(p.id))
+  } else {
+    leadPane = panes.find((p) => p.id === leadPaneId)
+    workerPanes = panes.filter((p) => p.id !== leadPaneId)
+  }
+
+  if (!leadPane) return c.error({ code: 'NO_LEAD', message: 'Could not identify lead pane' })
+  if (workerPanes.length === 0) return c.error({ code: 'NO_WORKERS', message: 'No worker panes found' })
+
+  applyGrid(windowId, leadPane.id, workerPanes.map((p) => p.id), conf.layout)
+
+  const N = workerPanes.length
+  const { cols, rows } = computeGrid(N, conf.layout)
+  const grid = []
+  let idx = 0
+  for (let r = 0; r < rows; r++) {
+    const row = []
+    for (let col = 0; col < cols; col++) {
+      if (idx < N) {
+        const cruWorker = cruPanesData?.workers[idx]
+        row.push(cruWorker?.name || `pane-${idx + 1}`)
+        idx++
+      }
+    }
+    grid.push(row)
+  }
+
+  return {
+    applied: true,
+    window: windowId,
+    dimensions: `${W}x${H}`,
+    lead: { position: conf.layout.lead.position, size: `${conf.layout.lead.size}%` },
+    workers: N,
+    grid_size: `${rows}x${cols}`,
+    grid,
+  }
+}
+
+function runClose(c) {
+  let teamName = c.args.team
+  if (!teamName && !inGhostty()) {
+    try { teamName = findTeamForCurrentWindow() } catch {}
+  }
+  if (!teamName) return c.error({ code: 'NO_TEAM', message: 'No team specified and none found in current window' })
+  const closed: Array<{ name: string; pane: string }> = []
+
+  const cruPanes = loadPanes(teamName)
+  if (cruPanes && cruPanes.workers.length > 0) {
+    // Use the right kill method based on how panes were tracked
+    const killFn = cruPanes.backend === 'ghostty'
+      ? (id: string) => { try { require('@/lib/ghostty').closeTerminal(id) } catch (e) { console.warn(`[close] failed to close Ghostty terminal ${id}: ${e}`) } }
+      : (id: string) => killPane(id)
+
+    for (const w of cruPanes.workers) {
+      killFn(w.paneId)
+      closed.push({ name: w.name, pane: w.paneId })
+    }
+
+    // If mirrored, also clean up tmux view sessions on the custom socket
+    if (cruPanes.backend === 'ghostty') {
+      try {
+        const { findSwarmSockets } = require('@/lib/mirror')
+        const { execFileSync } = require('node:child_process')
+        for (const socket of findSwarmSockets()) {
+          try {
+            const sessions = execFileSync(
+              'tmux', ['-L', socket, 'list-sessions', '-F', '#{session_name}'],
+              { encoding: 'utf-8', timeout: 3000 },
+            ).trim().split('\n')
+            for (const name of sessions) {
+              if (name.startsWith('view-')) {
+                try { execFileSync('tmux', ['-L', socket, 'kill-session', '-t', name], { timeout: 3000 }) } catch {}
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+  } else {
+    try {
+      const config = readTeamConfig(teamName)
+      const workers = config.members.filter((m) => m.tmuxPaneId)
+      for (const member of workers) {
+        killPane(member.tmuxPaneId)
+        closed.push({ name: member.name, pane: member.tmuxPaneId })
+      }
+    } catch {}
+  }
+
+  if (closed.length === 0 && inGhostty()) {
+    // Fallback: close all non-lead Ghostty terminals
+    // Uses process-tree-based currentTerminal() — works regardless of focus
+    try {
+      const { currentTerminal, listAllTerminals, closeTerminal } = require('@/lib/ghostty')
+      const lead = currentTerminal()
+      const allTerminals = listAllTerminals()
+      for (const id of allTerminals) {
+        if (id !== lead) {
+          closeTerminal(id)
+          closed.push({ name: `pane-${closed.length + 1}`, pane: id })
+        }
+      }
+    } catch {}
+  } else if (closed.length === 0) {
+    try {
+      const lead = currentPane()
+      const windowId = paneWindow(lead)
+      const panes = listWindowPanes(windowId)
+      for (const p of panes) {
+        if (p.id !== lead) {
+          killPane(p.id)
+          closed.push({ name: `pane-${closed.length + 1}`, pane: p.id })
+        }
+      }
+    } catch {}
+  }
+
+  return { team: teamName, closed: closed.length, panes: closed }
+}
+
+function runList(c) {
+  if (inGhostty()) {
+    const { ghostty, currentTerminal, listAllTerminals } = require('@/lib/ghostty')
+    const allIds = listAllTerminals()
+    // Get working directories for all terminals
+    let dirs: string[] = []
+    try {
+      const raw = ghostty('get working directory of every terminal')
+      dirs = raw.split(', ')
+    } catch {}
+    let currentId: string | null = null
+    try { currentId = currentTerminal() } catch {}
+    const panes = allIds.map((id: string, i: number) => ({
+      id,
+      index: i,
+      cwd: dirs[i] || '',
+      current: id === currentId,
+    }))
+    return { backend: 'ghostty', panes }
+  }
+
+  const teamName = c.args.team
+  let windowId: string | null = null
+
+  if (teamName) {
+    windowId = findTeamWindow(teamName)
+  } else {
+    try {
+      const lead = currentPane()
+      windowId = paneWindow(lead)
+    } catch {}
+  }
+
+  if (!windowId) return c.error({ code: 'NO_WINDOW', message: 'Could not find terminal window' })
+
+  const info = listPaneDetails(windowId)
+  return { window: windowId, panes: info }
+}
+
+export const panes = {
+  description: 'Manage terminal panes (list, grid layout, close)',
+  args: z.object({
+    action: z.enum(['list', 'grid', 'close']).default('list').describe('Action: list, grid, or close'),
+    team: z.string().optional().describe('Team name (omit to auto-detect)'),
+  }),
+  options: z.object({
+    'lead-size': z.coerce.number().optional().describe('Grid: override lead size (%)'),
+    'lead-position': z.enum(['left', 'right', 'top', 'bottom']).optional().describe('Grid: override lead position'),
+    fill: z.enum(['row', 'column']).optional().describe('Grid: override fill direction'),
+    'max-cols': z.coerce.number().optional().describe('Grid: max columns'),
+    'max-rows': z.coerce.number().optional().describe('Grid: max rows'),
+    expect: z.coerce.number().optional().describe('Grid: wait for N worker panes before applying'),
+  }),
+  run(c) {
+    switch (c.args.action) {
+      case 'grid': return runGrid(c)
+      case 'close': return runClose(c)
+      case 'list': return runList(c)
+    }
+  },
+}