@ucsandman/legcli 0.7.0

package/src/launcher.mjs

@@ -0,0 +1,272 @@
+// launcher — the one command. `leg up` runs preflight, spawns the board
+// server (scheduler + merge queue run inside it) as an argv child, waits for
+// /api/health, opens the board, streams prefixed redacted logs, and tears
+// everything down on Ctrl-C. `up --dry` prints what would run. `down`,
+// `status`, `open` are the other three verbs. No shell anywhere.
+import http from 'node:http'
+import { spawn, spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { redact } from './redact.mjs'
+import { home, listCards, readRuns } from './store.mjs'
+import { names as adapterNames, get as getAdapter, isFake } from './adapters/index.mjs'
+import { resolveChb, chbVersion } from './handoff.mjs'
+import { schedulerStatus, MAX_CONCURRENT } from './scheduler.mjs'
+import { enabledSyncs } from './sync/index.mjs'
+
+const SRC = dirname(fileURLToPath(import.meta.url))
+const SERVER = process.env.LEG_SERVER_SCRIPT || process.env.BATON_SERVER_SCRIPT || join(SRC, 'server.mjs')
+const VERSION = JSON.parse(readFileSync(join(SRC, '..', 'package.json'), 'utf8')).version
+const HEALTH_TIMEOUT_MS = Number(process.env.LEG_HEALTH_TIMEOUT_MS || process.env.BATON_HEALTH_TIMEOUT_MS || 20000)
+
+// Every launcher line goes through here: one prefix, one redaction pass.
+export function out(prefix, line, stream = process.stdout) {
+  stream.write(`[${prefix}] ${redact(String(line)).replace(/\r?\n$/, '')}\n`)
+}
+
+export function pidfile() { const leg = join(home(), 'leg.pid'); const baton = join(home(), 'baton.pid'); if (existsSync(leg)) return leg; if (existsSync(baton)) return baton; return leg; }
+
+function readPidfile() {
+  try { return JSON.parse(readFileSync(pidfile(), 'utf8')) } catch { return null }
+}
+
+function pidAlive(pid) {
+  if (!pid) return false
+  try { process.kill(pid, 0); return true } catch { return false }
+}
+
+function version(bin, args = ['--version']) {
+  const r = spawnSync(bin, args, { windowsHide: true, encoding: 'utf8', timeout: 8000 })
+  if (r.error || r.status !== 0) return null
+  return (r.stdout || r.stderr).trim().split('\n')[0].slice(0, 60)
+}
+
+const INSTALL_HINT = {
+  claude: 'https://claude.com/claude-code (then `claude` to log in)',
+  codex: 'npm i -g @openai/codex (then `codex login`)',
+  agy: 'Antigravity CLI (`agy`), log in once interactively',
+}
+
+// Rows: [name, status, detail]. Nothing here is fatal except "no adapter at all".
+export async function preflight() {
+  const rows = []
+  rows.push(['node', 'ok', process.version])
+  rows.push(['git', version('git') ? 'ok' : 'missing', version('git') ?? 'install git'])
+  try { resolveChb(); rows.push(['context-handoff-bundle', 'ok', chbVersion() ?? 'version unknown']) } catch { rows.push(['context-handoff-bundle', 'missing', 'pip install -U context-handoff-bundle']) }
+  let present = 0
+  for (const name of adapterNames()) {
+    if (isFake(name)) continue
+    const a = await getAdapter(name)
+    const { bin, viaNode, entry } = a.resolve()
+    const v = viaNode ? version(process.execPath, [entry, '--version']) : version(bin)
+    if (v) { present += 1; rows.push([name, 'ok', `${v} (${viaNode ? entry : bin})`]) } else rows.push([name, 'missing', INSTALL_HINT[name] ?? 'not on PATH'])
+  }
+  rows.push(['fake adapters', 'ok', 'fake, fake-claude, fake-codex, fake-agy (tests and demo)'])
+  return { rows, adapters_present: present }
+}
+
+export function printPreflight({ rows }) {
+  const w = Math.max(...rows.map((r) => r[0].length))
+  for (const [name, status, detail] of rows) out('preflight', `${name.padEnd(w)}  ${status.padEnd(7)}  ${detail}`)
+}
+
+export function plannedProcesses({ port = Number(process.env.LEG_PORT || process.env.BATON_PORT || 4747), bind = process.env.LEG_BIND || process.env.BATON_BIND || '127.0.0.1' } = {}) {
+  const procs = [{
+    prefix: 'server', bin: process.execPath, argv: [SERVER], env: { BATON_PORT: String(port), BATON_BIND: bind },
+    note: 'board + API + scheduler + merge queue',
+  }]
+  const on = enabledSyncs()
+  const syncs = [
+    { prefix: 'sync:workboard', enabled: on.includes('workboard'), note: 'OpenClaw Workboard mirror (BATON_SYNC_WORKBOARD=1); runs inside the ledger, no extra process' },
+    { prefix: 'sync:dashclaw', enabled: on.includes('dashclaw'), note: 'DashClaw action recording (BATON_SYNC_DASHCLAW=1 + DASHCLAW_URL + DASHCLAW_API_KEY); runs inside the ledger' },
+  ]
+  return { procs, syncs }
+}
+
+export function openBoard(url) {
+  const argv = process.platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+    : process.platform === 'darwin' ? ['open', [url]] : ['xdg-open', [url]]
+  try {
+    const child = spawn(argv[0], argv[1], { windowsHide: true, detached: true, stdio: 'ignore' })
+    child.on('error', () => {})
+    child.unref()
+    return true
+  } catch { return false }
+}
+
+function health(port, bind) {
+  return new Promise((resolvePromise) => {
+    const req = http.get({ host: bind === '0.0.0.0' ? '127.0.0.1' : bind, port, path: '/api/health', timeout: 2000 }, (res) => {
+      let d = ''
+      res.on('data', (c) => { d += c })
+      res.on('end', () => { try { resolvePromise(res.statusCode === 200 ? JSON.parse(d) : null) } catch { resolvePromise(null) } })
+    })
+    req.on('error', () => resolvePromise(null))
+    req.on('timeout', () => { req.destroy(); resolvePromise(null) })
+  })
+}
+
+// A pid is not a board: nothing clears the pidfile when the board dies with it,
+// and after a reboot that pid usually belongs to something else. Something has
+// to answer on the port — a 401 from a guarded board counts, so does a slow one.
+function listening(port, bind) {
+  return new Promise((resolvePromise) => {
+    const req = http.get({ host: bind === '0.0.0.0' ? '127.0.0.1' : bind, port, path: '/api/health', timeout: 2000 }, (res) => { res.resume(); resolvePromise(true) })
+    req.on('socket', (s) => s.on('connect', () => resolvePromise(true)))
+    req.on('error', () => resolvePromise(false))
+    req.on('timeout', () => { req.destroy(); resolvePromise(false) })
+  })
+}
+
+async function boardAlive(pf) {
+  if (!pf || !pidAlive(pf.pid)) return false
+  return await listening(pf.port, pf.bind ?? '127.0.0.1')
+}
+
+function pipeLines(stream, prefix, onLine) {
+  let buf = ''
+  stream.setEncoding('utf8')
+  stream.on('data', (chunk) => {
+    buf += chunk
+    let i
+    while ((i = buf.indexOf('\n')) !== -1) {
+      const line = buf.slice(0, i)
+      buf = buf.slice(i + 1)
+      if (line.trim()) { out(prefix, line); onLine?.(line) }
+    }
+  })
+  stream.on('end', () => { if (buf.trim()) { out(prefix, buf); onLine?.(buf) } })
+}
+
+function killTree(pid) {
+  if (!pidAlive(pid)) return
+  if (process.platform === 'win32') spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true, encoding: 'utf8' })
+  else { try { process.kill(pid, 'SIGTERM') } catch {} setTimeout(() => { try { process.kill(pid, 'SIGKILL') } catch {} }, 2000).unref() }
+}
+
+// Agents started by the orchestrator run under their own detached supervisors;
+// on teardown kill every run that is still active so nothing burns tokens.
+function killActiveAgents() {
+  let n = 0
+  for (const card of listCards()) {
+    for (const run of readRuns(card.card_id)) {
+      if (!['launching', 'running'].includes(run.status)) continue
+      for (const pid of [run.agent_pid, run.supervisor_pid]) if (pidAlive(pid)) { killTree(pid); n += 1 }
+    }
+  }
+  return n
+}
+
+export async function up({ dry = false, open = true, port = Number(process.env.LEG_PORT || process.env.BATON_PORT || 4747), bind = process.env.LEG_BIND || process.env.BATON_BIND || '127.0.0.1' } = {}) {
+  out('baton', `baton ${VERSION} — home ${home()}`)
+  const pf = await preflight()
+  printPreflight(pf)
+  if (pf.adapters_present === 0) out('baton', 'no real coding-agent CLI found; fake adapters still work for the demo', process.stderr)
+  const plan = plannedProcesses({ port, bind })
+  for (const s of plan.syncs) out('baton', `${s.prefix}: ${s.enabled ? 'on' : 'off'} (${s.note})`)
+  if (dry) {
+    out('baton', 'dry run: nothing spawned. Would run:')
+    for (const p of plan.procs) out('baton', `${p.prefix}: ${JSON.stringify([p.bin, ...p.argv])} env ${JSON.stringify(p.env)}`)
+    out('baton', `then poll http://${bind}:${port}/api/health, ${open ? 'open the board' : 'not open the board'}, write ${pidfile()}`)
+    return 0
+  }
+  const existing = readPidfile()
+  if (existing && existing.pid !== process.pid && await boardAlive(existing)) {
+    out('baton', `already running (pid ${existing.pid}, port ${existing.port}); use \`baton down\` first`, process.stderr)
+    return 1
+  }
+  if (existing) { try { rmSync(pidfile(), { force: true }) } catch {} }
+  mkdirSync(home(), { recursive: true })
+  const [p] = plan.procs
+  const child = spawn(p.bin, p.argv, { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, ...p.env, LEG_QUIET: '0', BATON_QUIET: '0' } })
+  let actualPort = port
+  const lastLines = []
+  const remember = (line) => { lastLines.push(line); if (lastLines.length > 12) lastLines.shift(); const m = /listening on http:\/\/[^:]+:(\d+)/.exec(line); if (m) actualPort = Number(m[1]) }
+  pipeLines(child.stdout, p.prefix, remember)
+  pipeLines(child.stderr, p.prefix, remember)
+  let exited = null
+  child.on('exit', (code) => { exited = code ?? -1 })
+
+  const t0 = Date.now()
+  let ok = null
+  while (Date.now() - t0 < HEALTH_TIMEOUT_MS && exited === null) {
+    ok = await health(actualPort, bind)
+    if (ok) break
+    await new Promise((r) => setTimeout(r, 250))
+  }
+  if (!ok) {
+    out('baton', `server not healthy after ${Math.round((Date.now() - t0) / 1000)} s${exited !== null ? ` (exited ${exited})` : ''}; last lines:`, process.stderr)
+    for (const l of lastLines) out(p.prefix, l, process.stderr)
+    killTree(child.pid)
+    return 1
+  }
+  const url = `http://${bind === '0.0.0.0' ? '127.0.0.1' : bind}:${actualPort}`
+  writeFileSync(pidfile(), JSON.stringify({ pid: process.pid, port: actualPort, bind, children: [child.pid], started_at: new Date().toISOString() }, null, 2) + '\n')
+  out('baton', `ready ${url}  (scheduler max ${MAX_CONCURRENT}, ${ok.cards} card${ok.cards === 1 ? '' : 's'})`)
+  if (open) out('baton', openBoard(url) ? `opened ${url}` : `could not open a browser; visit ${url}`)
+  out('baton', 'Ctrl-C stops everything')
+
+  return await new Promise((resolvePromise) => {
+    let stopping = false
+    const stop = (why) => {
+      if (stopping) return
+      stopping = true
+      out('baton', `stopping (${why})`)
+      const agents = killActiveAgents()
+      if (agents) out('baton', `killed ${agents} running agent/supervisor process(es)`)
+      killTree(child.pid)
+      try { rmSync(pidfile(), { force: true }) } catch {}
+      out('baton', 'stopped')
+      resolvePromise(0)
+    }
+    process.on('SIGINT', () => stop('SIGINT'))
+    process.on('SIGTERM', () => stop('SIGTERM'))
+    process.on('SIGBREAK', () => stop('SIGBREAK'))
+    child.on('exit', (code) => { if (!stopping) { out('baton', `server exited ${code}`, process.stderr); try { rmSync(pidfile(), { force: true }) } catch {} resolvePromise(code === 0 ? 0 : 1) } })
+  })
+}
+
+// Stop the board process and nothing else. Sharing the board with someone is a
+// configuration change: it restarts the listener, it does not end the runs.
+export async function stopBoard() {
+  const pf = readPidfile()
+  if (!pf) return { stopped: false, stale: false }
+  const alive = await boardAlive(pf)
+  if (alive) for (const pid of [...(pf.children ?? []), pf.pid]) killTree(pid)
+  try { rmSync(pidfile(), { force: true }) } catch {}
+  return { stopped: alive, stale: !alive, pid: pf.pid, port: pf.port }
+}
+
+export async function down() {
+  const pf = readPidfile()
+  if (!pf) { out('baton', 'not running'); return 0 }
+  const agents = killActiveAgents()
+  const board = await stopBoard()
+  out('baton', `stopped (pid ${pf.pid}, port ${pf.port}${agents ? `, ${agents} agent process(es) killed` : ''}${board.stale ? ', stale pidfile' : ''})`)
+  return 0
+}
+
+export async function status() {
+  const pf = readPidfile()
+  const running = await boardAlive(pf)
+  if (pf && !running) { try { rmSync(pidfile(), { force: true }) } catch {} }
+  const cards = listCards()
+  const by = (key) => Object.entries(cards.reduce((m, c) => { m[c[key]] = (m[c[key]] ?? 0) + 1; return m }, {})).map(([k, v]) => `${k}=${v}`).join(' ') || '(none)'
+  if (running) {
+    const up = Math.round((Date.now() - Date.parse(pf.started_at)) / 1000)
+    out('baton', `running  pid ${pf.pid}  port ${pf.port}  up ${Math.floor(up / 60)}m${up % 60}s  http://127.0.0.1:${pf.port}`)
+  } else {
+    out('baton', pf ? `stopped (pid ${pf.pid} is not answering on port ${pf.port}; cleared the stale pidfile)` : 'stopped')
+  }
+  const s = schedulerStatus()
+  out('baton', `scheduler ${s.running ? `running (pid ${s.pid})` : 'stopped'}  max concurrent ${MAX_CONCURRENT}`)
+  out('baton', `cards ${cards.length}  by status: ${by('status')}`)
+  out('baton', `by station: ${by('station')}`)
+  return running ? 0 : 3
+}
+
+export function listHomeRuns() {
+  const root = join(home(), 'cards')
+  return existsSync(root) ? readdirSync(root).length : 0
+}

package/src/leases.mjs

@@ -0,0 +1,86 @@
+// leases — pure helpers for deciding whether two cards' claimed leases (glob-ish
+// path patterns) could touch the same files. Used to gate parallel station starts.
+//
+// The overlap check is a deliberate approximation biased toward false positives:
+// when unsure we say overlapping, because a wrongly serialized card costs minutes
+// and a wrongly parallel card can corrupt a merge.
+
+// Backslashes to forward slashes, strip a leading './' or '/', collapse repeated
+// slashes, strip a trailing '/'. Anything empty (or '**' itself) is the wildcard
+// lease that overlaps everything.
+export function normalize(p) {
+  if (p === null || p === undefined || p === '' || p === '**') return '**'
+  let s = String(p).replace(/\\/g, '/')
+  s = s.replace(/^\.\//, '').replace(/^\/+/, '')
+  s = s.replace(/\/+/g, '/')
+  s = s.replace(/\/$/, '')
+  return s === '' ? '**' : s
+}
+
+// Path segments before the first segment that contains a glob character.
+export function literalPrefix(p) {
+  const s = normalize(p)
+  if (s === '**') return []
+  const segments = s.split('/')
+  const idx = segments.findIndex((seg) => seg.includes('*') || seg.includes('?'))
+  return idx === -1 ? segments : segments.slice(0, idx)
+}
+
+// See file header: approximation biased toward false positives.
+export function overlap(a, b) {
+  const na = normalize(a)
+  const nb = normalize(b)
+  if (na === '**' || nb === '**') return true
+  if (na === nb) return true
+  const pa = literalPrefix(a)
+  const pb = literalPrefix(b)
+  const len = Math.min(pa.length, pb.length)
+  for (let i = 0; i < len; i++) {
+    if (pa[i] !== pb[i]) return false
+  }
+  return true
+}
+
+export function anyOverlap(listA, listB) {
+  const a = listA && listA.length ? listA : ['**']
+  const b = listB && listB.length ? listB : ['**']
+  for (const x of a) {
+    for (const y of b) {
+      if (overlap(x, y)) return true
+    }
+  }
+  return false
+}
+
+// Every overlapping (holder lease, candidate lease) pair, in running order.
+export function conflicts(candidate, running) {
+  const candLeases = candidate.leases && candidate.leases.length ? candidate.leases : ['**']
+  const out = []
+  for (const holder of running) {
+    const holderLeases = holder.leases && holder.leases.length ? holder.leases : ['**']
+    for (const hLease of holderLeases) {
+      for (const cLease of candLeases) {
+        if (overlap(hLease, cLease)) {
+          out.push({ holder: holder.card_id, lease: hLease, against: cLease })
+        }
+      }
+    }
+  }
+  return out
+}
+
+// One row per lease of every running/handing_off card, sorted by card_id then lease.
+export function held(cards) {
+  const out = []
+  for (const card of cards) {
+    if (card.status !== 'running' && card.status !== 'handing_off') continue
+    const leases = card.leases && card.leases.length ? card.leases : ['**']
+    for (const lease of leases) {
+      out.push({ lease, card_id: card.card_id, station: card.station, since: card.updated_at })
+    }
+  }
+  out.sort((x, y) => (x.card_id === y.card_id
+    ? (x.lease < y.lease ? -1 : x.lease > y.lease ? 1 : 0)
+    : (x.card_id < y.card_id ? -1 : 1)))
+  return out
+}