@ucsandman/legcli 0.9.0 → 0.10.0

package/src/redact.mjs

@@ -11,19 +11,37 @@ const PATTERNS = [
   ['Anthropic key (sk-ant-)', /(?<![A-Za-z0-9_-])sk-ant-[A-Za-z0-9_-]{8,}/g],
   ['DashClaw key (oc_live_)', /(?<![A-Za-z0-9_-])oc_live_[a-f0-9]\w*/g],
   ['bearer token', /Bearer\s+[A-Za-z0-9._-]{16,}/g],
-  ['GitHub token (ghp_)', /(?<![A-Za-z0-9_-])ghp_[A-Za-z0-9]{20,}/g],
-  ['GitHub server token (ghs_)', /(?<![A-Za-z0-9_-])ghs_[A-Za-z0-9]{20,}/g],
+  ['GitHub token (gh[pousr]_)', /(?<![A-Za-z0-9_-])gh[pousr]_[A-Za-z0-9]{20,}/g],
   ['GitHub fine-grained token (github_pat_)', /(?<![A-Za-z0-9_-])github_pat_[A-Za-z0-9_]{20,}/g],
   ['AWS key (AKIA)', /(?<![A-Za-z0-9_-])AKIA[0-9A-Z]{12,}/g],
-  ['Slack token (xox)', /(?<![A-Za-z0-9_-])xox[bp]-\S*/g],
-  ['key=value secret', /api[_-]?key\s*[=:]\s*\S+/gi],
+  ['Slack token (xox/xapp)', /(?<![A-Za-z0-9_-])(?:xox[baprs]|xapp)-\S+/g],
+  ['key=value secret', /api[_-]?key[ \t]*[=:][ \t]*\S+/gi],
+  // shapes a discovered transcript from another agent carries that the list
+  // above missed (measured 2026-09-16: 15 of 18 common shapes went through)
+  ['Stripe key (sk_live_/rk_live_)', /(?<![A-Za-z0-9_-])[sr]k_(?:live|test)_[A-Za-z0-9]{8,}/g],
+  ['Google API key (AIza)', /(?<![A-Za-z0-9_-])AIza[0-9A-Za-z_-]{30,}/g],
+  ['xAI key (xai-)', /(?<![A-Za-z0-9_-])xai-[A-Za-z0-9]{16,}/g],
+  ['npm token (npm_)', /(?<![A-Za-z0-9_-])npm_[A-Za-z0-9]{20,}/g],
+  ['GitLab token (glpat-)', /(?<![A-Za-z0-9_-])glpat-[A-Za-z0-9_-]{16,}/g],
+  ['Hugging Face token (hf_)', /(?<![A-Za-z0-9_-])hf_[A-Za-z0-9]{20,}/g],
+  ['JWT', /(?<![A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g],
+  ['private key block', /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g],
+  // a digit or two capitals somewhere: base64 of any credential has one of
+  // them, "Basic authentication/authorization" in prose has neither
+  ['basic auth header', /Basic\s+(?=[A-Za-z0-9+/=]*(?:[0-9]|[A-Z][A-Za-z0-9+/=]*[A-Z]))[A-Za-z0-9+/=]{16,}/g],
+  ['URL with credentials', /(?<=[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)[^\s@/]{4,}(?=@)/gi],
+  // an environment-style NAME (upper case): `cache_key = build(...)` and
+  // `refresh_token: string` in code are not secrets; a value never crosses a
+  // line break, so `SECRET_KEY=` at the end of a line takes nothing after it
+  ['env-style secret assign', /(?:[A-Z0-9_]*_(?:KEY|TOKEN|SECRET|PASSWORD)|aws_secret_access_key)[ \t]*[=:][ \t]*["']?[^\s"',;]{8,}/g],
+  ['password=value', /\b(?:password|passwd)[ \t]*[=:][ \t]*["']?[^\s"',;]{8,}/gi],
 ]
 
 export const SECRET_RES = PATTERNS.map(([, re]) => re)
 // non-global copies for `.test()` (a /g regex carries lastIndex state)
 export const SECRET_PATTERNS = PATTERNS.map(([name, re]) => [name, new RegExp(re.source, re.flags.replace('g', ''))])
 
-const ENV_KEYS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'OPENAI_API_KEY', 'DASHCLAW_API_KEY', 'BATON_TOKEN', 'GITHUB_TOKEN', 'GH_TOKEN']
+const ENV_KEYS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'OPENAI_API_KEY', 'DASHCLAW_API_KEY', 'LEG_TOKEN', 'BATON_TOKEN', 'LEG_LICENSE_PRIVATE_KEY', 'BATON_LICENSE_PRIVATE_KEY', 'GITHUB_TOKEN', 'GH_TOKEN', 'STRIPE_SECRET_KEY', 'STRIPE_TEST_SECRET_KEY', 'RESEND_API_KEY', 'NPM_TOKEN']
 let envValues = null
 function heldValues() {
   if (envValues) return envValues

package/src/server.mjs

@@ -5,8 +5,8 @@
 // LEG_BIND (127.0.0.1) + LEG_PORT (4747) + LEG_TOKEN are the
 // multiplayer seams (src/auth.mjs). BATON_* names still work as fallback.
 import http from 'node:http'
-import { spawnSync } from 'node:child_process'
-import { existsSync, readFileSync, statSync, rmSync, watch as fsWatch, mkdirSync, openSync, fstatSync, readSync, closeSync } from 'node:fs'
+import { spawnSync, execFile } from 'node:child_process'
+import { existsSync, readFileSync, readdirSync, statSync, rmSync, watch as fsWatch, mkdirSync, openSync, fstatSync, readSync, closeSync } from 'node:fs'
 import { join, dirname, resolve, extname, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { checkBind, authorize, remoteAddress, presentedToken, isLoopback, isLoopbackRequest, tokenMatches } from './auth.mjs'
@@ -33,6 +33,8 @@ import { readUsage, recordUsage, usageIsStale, candidates, isAvailable } from '.
 import { readAccounts, envFor, LAYOUT } from './accounts.mjs'
 import { readCodexUsage } from './taps/codex.mjs'
 import { readPreferences, writePreferences, normalizeHandoffOrder, requireHandoffOrder } from './preferences.mjs'
+import { listHistory, findRecord, recordDetail, refreshIndex, readIndex, providerSupport, HistoryInputError, PROVIDER_NAMES } from './history/index.mjs'
+import { listWorktrees } from './history/worktrees.mjs'
 
 const SELF = fileURLToPath(import.meta.url)
 export function resolveBoardDir() {
@@ -226,6 +228,64 @@ async function adaptersInfo() {
 }
 
 // ---- sessions (baton claude|codex|agy) ----
+// The worktree list runs git once per known repository: cached for a short
+// while so a board that polls does not fork fifty processes a second.
+const WORKTREES_TTL = 20000
+const worktreesCache = new Map()
+// A stale index is refreshed by a child `leg history refresh`, never in this
+// process: the scan stats thousands of files and walks every cwd, and inside
+// the board's event loop that is seconds of no SSE frames and no clicks. The
+// child takes the same index lock a CLI refresh would, so the two never tear
+// one file; the next listing reads what it wrote.
+const LEG_BIN = join(dirname(SELF), '..', 'bin', 'leg.mjs')
+let historyRefreshing = false
+function backgroundHistoryRefresh() {
+  if (historyRefreshing) return
+  historyRefreshing = true
+  try {
+    execFile(process.execPath, [LEG_BIN, 'history', 'refresh', '--json'], { env: process.env, windowsHide: true, timeout: 120000 }, () => { historyRefreshing = false })
+  } catch { historyRefreshing = false }
+}
+function worktreesFor({ repo = null, dirty = true } = {}) {
+  const key = `${repo ?? ''}|${dirty}`
+  const hit = worktreesCache.get(key)
+  if (hit && Date.now() - hit.at < WORKTREES_TTL) return hit.data
+  const data = listWorktrees({ repo, dirty, dirtyLimit: 20, repoLimit: 20 })
+  worktreesCache.set(key, { at: Date.now(), data })
+  return data
+}
+
+// canLand shells out to git several times for one worktree, and the view runs
+// it for every terminal that ever had one — over a second of subprocesses on a
+// board with a few dozen records, paid again on every SSE push. A terminal that
+// has ended never moves, so the answer is cached against the record's own
+// revision with the short TTL the trunk already uses, which still notices a
+// commit made by hand in the worktree within that window.
+// A terminal that is still running can change what it can land from one turn to
+// the next. One that has ended only moves if someone works in its worktree by
+// hand, and a landing clears this cache outright, so it is re-read a great deal
+// less often.
+const CAN_LAND_TTL = 15000
+const CAN_LAND_TTL_ENDED = 60000
+const canLandCache = new Map()
+function canLandFor(s) {
+  const key = `${s.session_id}|${s.updated_at ?? ''}`
+  const hit = canLandCache.get(key)
+  if (hit && Date.now() < hit.until) return hit.data
+  const data = canLand(s)
+  // Expiries are spread across the window instead of falling together: twenty
+  // worktrees re-read in one pass is another second of git inside the event
+  // loop, which is the stall this cache exists to remove. Staggered, the board
+  // pays for about one of them per push and never blocks on the set.
+  const ttl = isActive(s) ? CAN_LAND_TTL : CAN_LAND_TTL_ENDED
+  const until = Date.now() + ttl / 2 + Math.random() * ttl
+  // the key carries updated_at, so a busy terminal leaves a dead entry per
+  // write: drop the whole map rather than grow it for the life of the process
+  if (canLandCache.size > 500) canLandCache.clear()
+  canLandCache.set(key, { until, data })
+  return data
+}
+
 const trunkCache = new Map()
 function trunkFor(repo) {
   const hit = trunkCache.get(repo)
@@ -293,7 +353,7 @@ export function sessionsView({ viewer = null, share = null } = {}) {
     const preferredNext = chain[0] ?? null
     const availabilityKnown = Boolean(s.installed)
     const eligibleNext = availabilityKnown ? (chain.find((next) => s.installed[next.agent] !== false && isAvailable(readUsage(next.agent, next.account))) ?? null) : null
-    const can = s.worktree ? canLand(s) : { ok: false, blockers: [{ code: 'no_worktree', message: 'this terminal works in the checkout itself: there is no branch of its own to land', fix: null }] }
+    const can = s.worktree ? canLandFor(s) : { ok: false, blockers: [{ code: 'no_worktree', message: 'this terminal works in the checkout itself: there is no branch of its own to land', fix: null }] }
     return {
       ...s,
       handoff_order: handoffOrder,
@@ -376,7 +436,7 @@ function serveStatic(res, urlPath) {
 }
 
 // ---- SSE: watch $BATON_HOME/cards for fs events and push only what changed ----
-function createSse({ healthIntervalMs = 10000, debounceMs = 30, viewFor = () => sessionsView(), reauth = (c) => c.viewer } = {}) {
+function createSse({ healthIntervalMs = 10000, debounceMs = 30, sessionsDebounceMs = 300, sessionsMinIntervalMs = 2000, viewFor = () => sessionsView(), reauth = (c) => c.viewer } = {}) {
   const clients = new Set() // { res, viewer, token, loopback, sig }
   let watcher = null
   let healthTimer = null
@@ -426,13 +486,70 @@ function createSse({ healthIntervalMs = 10000, debounceMs = 30, viewFor = () =>
   }
   let sessionsWatcher = null
   let sessionsTimer = null
-  const pushSessions = () => { sessionsTimer = null; try { broadcast('sessions', (viewer) => viewFor(viewer)) } catch (err) { log(`sessions view: ${err.message}`) } }
+  let lastSessionsPush = 0
+  const pushSessions = () => {
+    sessionsTimer = null
+    try { broadcast('sessions', (viewer) => viewFor(viewer)) } catch (err) { log(`sessions view: ${err.message}`) }
+    lastSessionsPush = Date.now()
+    // the health tick pushes on its own schedule: record what it sent, so the
+    // next watcher hint is measured against the page's real contents
+    lastFingerprint = sessionsFingerprint()
+  }
+  // One live agent rewrites its record about every six seconds and takes a
+  // control lock about once a second, and every one of those touches the
+  // sessions tree. Rebuilding the whole view costs a second or more of `git`,
+  // so a watcher that answers every touch turns a single running terminal into
+  // a permanent busy loop on the one event loop this board serves every
+  // request from: the board then takes seconds to hand over a stylesheet and
+  // `leg` itself times out probing /api/health.
+  //
+  // A watcher event is only a hint. Locks and the temp files an atomic write
+  // leaves behind are dropped by name, but taking a lock inside a session
+  // directory also changes that directory's own mtime, and that event arrives
+  // carrying nothing but the directory name — no filter on the name can tell
+  // it from a real write. So the hint is checked against the data: a stat over
+  // the files the view is actually built from costs a fraction of a
+  // millisecond and answers the question the event cannot.
+  const NOISE = /(\.lock|\.tmp)$/i
+  const sessionsChangeMatters = (filename) => !filename || !NOISE.test(String(filename))
+  const sessionsFingerprint = () => {
+    const root = sessionsRoot()
+    let dirs
+    try { dirs = readdirSync(root) } catch { return '' }
+    let sig = ''
+    for (const name of dirs) {
+      if (!name.startsWith('s-')) continue
+      for (const file of ['session.json', 'land.json', 'requests.json']) {
+        try { const st = statSync(join(root, name, file)); sig += `${name}/${file}:${st.mtimeMs}:${st.size};` } catch { /* not written yet */ }
+      }
+    }
+    return sig
+  }
+  let lastFingerprint = null
+  const pushIfChanged = () => {
+    sessionsTimer = null
+    const sig = sessionsFingerprint()
+    // the hint was noise: the view would rebuild to exactly what the page
+    // already has, so nothing is rebuilt and nothing is sent
+    if (sig === lastFingerprint) return
+    lastFingerprint = sig
+    pushSessions()
+  }
+  const scheduleSessionsPush = () => {
+    if (sessionsTimer) return
+    const wait = Math.max(sessionsDebounceMs, sessionsMinIntervalMs - (Date.now() - lastSessionsPush))
+    sessionsTimer = setTimeout(pushIfChanged, wait)
+  }
   const startWatch = () => {
     if (watcher) return
     try {
       const sdir = sessionsRoot()
       mkdirSync(sdir, { recursive: true })
-      sessionsWatcher = fsWatch(realPath(sdir), { recursive: true }, () => { if (!sessionsTimer) sessionsTimer = setTimeout(pushSessions, 300) })
+      // the client that opened this watch was handed the current view with its
+      // hello frame, so the fingerprint starts from what it already has: an
+      // unprimed one makes the first hint of any kind look like a change
+      lastFingerprint = sessionsFingerprint()
+      sessionsWatcher = fsWatch(realPath(sdir), { recursive: true }, (_event, filename) => { if (sessionsChangeMatters(filename)) scheduleSessionsPush() })
     } catch (err) { log(`sessions watch: ${err.message}`); sessionsWatcher = null }
     // watch the real long path: libuv's recursive watcher asserts when the
     // watched dir is an 8.3 short path (fs-event.c, seen on a GitHub runner)
@@ -575,7 +692,9 @@ export function createBoardServer({ bind, port, token = process.env.LEG_TOKEN ||
     const guest = shared && viewer.role !== 'owner'
     const ownsSession = (s) => !shared || viewer.role === 'owner' || (s.owner ?? share.owner) === viewer.name
     const parts = path.split('/').filter(Boolean) // ['api', ...]
-    if (guest && ['cards', 'floor', 'presets', 'adapters', 'leases', 'trunk'].includes(parts[1])) return send(res, 403, { error: 'the pipeline board belongs to the owner of this machine' })
+    // history and worktrees are the whole machine's project map (every path,
+    // every conversation on it): the owner's, never a guest's, as a group
+    if (guest && ['cards', 'floor', 'presets', 'adapters', 'leases', 'trunk', 'history', 'worktrees'].includes(parts[1])) return send(res, 403, { error: 'the pipeline board belongs to the owner of this machine' })
     try {
       if (req.method === 'GET' && path === '/api/health') {
         const you = { ...viewer, share: { on: shared, people: shared ? share.people.length : 0 } }
@@ -738,7 +857,9 @@ export function createBoardServer({ bind, port, token = process.env.LEG_TOKEN ||
           if (why) return send(res, 409, { error: why })
           landSession(sess, { by: actor.id, autoCommit: true })
             .catch((err) => log(`land ${id}: ${err.message}`))
-            .finally(() => { trunkCache.clear(); try { sse.broadcast('sessions', (v) => viewFor(v)) } catch {} })
+            // a landing moves the branch under every worktree cut from it, so
+            // the cached land-ability goes with the cached trunk
+            .finally(() => { trunkCache.clear(); canLandCache.clear(); try { sse.broadcast('sessions', (v) => viewFor(v)) } catch {} })
           log(`land requested for ${id} by ${actor.id}`)
           return send(res, 202, { ok: true, requested: 'land' })
         }
@@ -766,6 +887,63 @@ export function createBoardServer({ bind, port, token = process.env.LEG_TOKEN ||
           return send(res, 200, { removed: id, worktree })
         }
       }
+      // ---- history: the read-only index over every agent's own store ----
+      if (parts[1] === 'history') {
+        const q = url.searchParams
+        const int = (v, def, max) => { const n = parseInt(v ?? '', 10); return Number.isFinite(n) && n >= 0 ? Math.min(n, max) : def }
+        if (req.method === 'GET' && parts.length === 2) {
+          const provider = q.get('provider') || null
+          if (provider && provider.split(',').some((p) => !PROVIDER_NAMES.includes(p.trim()))) return send(res, 400, { error: `unknown provider in "${provider}" (${PROVIDER_NAMES.join('|')})` })
+          const tri = (v) => (v === '1' || v === 'true' ? true : v === '0' || v === 'false' ? false : null)
+          const explicitRefresh = tri(q.get('refresh')) === true
+          let refreshArg = null
+          if (!explicitRefresh) {
+            const idx = readIndex()
+            if (idx) {
+              const age = idx.refreshed_at ? Date.now() - Date.parse(idx.refreshed_at) : Infinity
+              if (age > 60000) backgroundHistoryRefresh()
+              refreshArg = false
+            }
+          } else {
+            refreshArg = true
+          }
+          return send(res, 200, listHistory({
+            provider, repo: q.get('repo') || null, search: q.get('search') || null,
+            before: q.get('before') || null,
+            // never the whole index in one response: a page is 1 to 200 rows
+            limit: Math.max(1, int(q.get('limit'), 50, 200)), offset: int(q.get('offset'), 0, 1e6),
+            managed: tri(q.get('managed')), live: tri(q.get('live')), includeHidden: tri(q.get('hidden')) === true,
+            refresh: refreshArg,
+          }))
+        }
+        if (req.method === 'GET' && parts[2] === 'providers') return send(res, 200, { providers: providerSupport() })
+        if (req.method === 'POST' && parts[2] === 'refresh') {
+          const body = await readBody(req)
+          const t = Date.now()
+          try {
+            const r = refreshIndex({ force: body.full === true })
+            return send(res, 200, { ms: Date.now() - t, refreshed_at: r.index.refreshed_at, stats: r.stats })
+          } catch (err) { return send(res, 409, { error: `refresh did not run: ${err.message}` }) }
+        }
+        if (req.method === 'GET' && parts.length === 3) {
+          // the id is a lookup key, never a path: findRecord compares strings,
+          // and the transcript it names is read only from inside a known store
+          let rec
+          let wanted
+          try { wanted = decodeURIComponent(parts[2]) } catch { return send(res, 400, { error: 'malformed id' }) }
+          try { rec = findRecord(wanted, { refresh: false }) } catch (err) {
+            if (err instanceof HistoryInputError) return send(res, 400, { error: err.message })
+            throw err
+          }
+          if (!rec) return send(res, 404, { error: `no conversation matches ${parts[2]}` })
+          return send(res, 200, recordDetail(rec, { messages: int(q.get('messages'), 8, 50) }))
+        }
+        return send(res, 404, { error: 'not found' })
+      }
+      if (req.method === 'GET' && path === '/api/worktrees') {
+        const q = url.searchParams
+        return send(res, 200, worktreesFor({ repo: q.get('repo') || null, dirty: q.get('dirty') !== '0' }))
+      }
       if (req.method === 'GET' && path === '/api/floor') return send(res, 200, floor(listCards()))
       if (req.method === 'GET' && path === '/api/trunk') return send(res, 200, trunk(listCards(), parseSince(url.searchParams.get('since'))))
       if (req.method === 'GET' && path === '/api/leases') return send(res, 200, { leases: held(listCards()) })

package/src/sessions.mjs

@@ -85,6 +85,15 @@ export function updateSession(id, patch, { event } = {}) {
     const delta = typeof patch === 'function' ? patch(cur) : patch
     const next = { ...cur, ...delta, updated_at: now() }
     if (delta.limits && cur.limits) next.limits = { ...cur.limits, ...delta.limits }
+    // every agent conversation this session has been: a hand-off overwrites
+    // agent_session_id with the next agent's, and history (src/history) still
+    // needs to know the earlier legs were this session's too
+    if (delta.agent_session_id && delta.agent_session_id !== cur.agent_session_id) {
+      const seen = cur.agent_sessions ?? []
+      if (!seen.some((x) => x.agent === next.agent && x.agent_session_id === delta.agent_session_id)) {
+        next.agent_sessions = [...seen, { agent: next.agent, agent_session_id: delta.agent_session_id, transcript_path: delta.transcript_path ?? null, at: now() }].slice(-24)
+      }
+    }
     writeJsonAtomic(join(sessionDir(id), 'session.json'), next)
     if (event) appendEvent(id, event)
     return next

package/src/taps/claude.mjs

@@ -60,11 +60,12 @@ function textOf(content) {
   return ''
 }
 
-// Last human/assistant messages from a Claude Code transcript (jsonl).
-export function transcriptTail(path, limit = 8) {
-  if (!path || !existsSync(path)) return []
+// Human/assistant messages from Claude Code transcript lines (jsonl). Shared
+// with history discovery, which hands in the tail of a file it never reads whole.
+export function messagesFromLines(lines, limit = 8) {
+  if (!(limit > 0)) return []
   const out = []
-  for (const line of readFileSync(path, 'utf8').split('\n')) {
+  for (const line of lines) {
     if (!line) continue
     let j
     try { j = JSON.parse(line) } catch { continue }
@@ -77,6 +78,12 @@ export function transcriptTail(path, limit = 8) {
   return out.slice(-limit)
 }
 
+// Last human/assistant messages from a Claude Code transcript (jsonl).
+export function transcriptTail(path, limit = 8) {
+  if (!path || !existsSync(path)) return []
+  return messagesFromLines(readFileSync(path, 'utf8').split('\n'), limit)
+}
+
 export function firstPrompt(path) {
   const t = transcriptTail(path, 1000).find((m) => m.role === 'user')
   return t ? t.text.slice(0, 500) : null