claude-bulkhead 0.2.2 → 0.3.0

package/src/top.js

@@ -5,7 +5,10 @@ const { stateDir } = require('./hook')
 const { tailEvents } = require('./events')
 const { limits } = require('./slots')
 const { size, when } = require('./status')
-const { useColor, paint, shortPath, option, fit, rejectArgs } = require('./cli-util')
+const { useColor, paint, fit, rejectArgs, numberOption } = require('./cli-util')
+const { homeShort, fitPath, stateLabel, needsUserFirst, branchLabel, mcpLine } = require('./session-info')
+
+const shortPath = (p, home) => homeShort(p, home) || '(unknown)'
 
 const USAGE = `usage: bulkhead top [--interval=SECONDS] [--once]
 
@@ -43,9 +46,11 @@ const cell = (s, width, right = false) => {
 // project column shrinks. Widths are fixed except the project and ports columns.
 const COLUMNS = [
   { key: 'pid', title: 'PID', width: 7 },
+  { key: 'state', title: 'STATE', width: 20 },
   { key: 'started', title: 'STARTED', width: 12, drop: 2 },
-  { key: 'project', title: 'PROJECT', width: 12, flex: true },
-  { key: 'rss', title: 'RSS', width: 7, right: true },
+  { key: 'project', title: 'PROJECT', width: 20, flex: true },
+  { key: 'branch', title: 'BRANCH', width: 18, drop: 5 },
+  { key: 'rss', title: 'RSS', width: 7, right: true, drop: 6 },
   { key: 'bar', title: '', width: 10, drop: 1 },
   { key: 'procs', title: 'PROCS', width: 5, right: true, drop: 4 },
   { key: 'ports', title: 'PORTS', width: 6, grow: 22, drop: 3 },
@@ -54,11 +59,14 @@ const COLUMNS = [
 function layout(width) {
   let cols = COLUMNS.slice()
   const total = cs => cs.reduce((n, c) => n + c.width, 0) + (cs.length - 1) * 2
-  for (const d of [1, 2, 3, 4]) {
+  for (const d of [1, 2, 3, 4, 5, 6]) {
     if (total(cols) <= width) break
     cols = cols.filter(c => c.drop !== d)
   }
   cols = cols.map(c => ({ ...c }))
+  // the state text shrinks (needs perm…) before the project column is squeezed out
+  const state = cols.find(c => c.key === 'state')
+  if (state && total(cols) > width) state.width = Math.max(7, state.width - (total(cols) - width))
   let spare = width - total(cols)
   const ports = cols.find(c => c.key === 'ports')
   if (ports && spare > 0) {
@@ -112,24 +120,31 @@ function frame(view, { width = 100, height = 40, color = false, home = os.homedi
   lines.push('')
 
   // sessions
-  const sessions = st.sessions
+  const sessions = needsUserFirst(st.sessions)
   const cols = layout(width)
-  lines.push(c('bold', fit(`SESSIONS ${sessions.length}`, width)))
+  const needy = sessions.filter(s => s.state === 'permission' || s.state === 'waiting').length
+  lines.push(c('bold', fit(`SESSIONS ${sessions.length}`, width)) + (needy && width >= 24 + 12 ? c('yellow', `  ${needy} waiting for you`) : ''))
   lines.push(c('dim', cols.map(col => cell(col.title, col.width, col.right)).join('  ').trimEnd()))
   const maxRss = Math.max(1, ...sessions.map(s => s.rss))
 
   // what has to fit below the session rows
   const slotRows = st.slots.length + (st.queue || []).length
   const events = view.events || []
-  const below = 2 + (slotRows ? slotRows + 1 : 1) + 2 + Math.max(1, events.length)
+  const dupes = (st.mcp || []).filter(g => g.duplicate)
+  const below = 2 + (slotRows ? slotRows + 1 : 1) + 2 + Math.max(1, events.length) + (dupes.length ? dupes.length + 2 : 0)
   const room = Math.max(1, height - lines.length - below)
   const shown = sessions.length > room ? sessions.slice(0, Math.max(0, room - 1)) : sessions
   for (const s of shown) {
     const parts = cols.map(col => {
       switch (col.key) {
         case 'pid': return cell(s.pid, col.width)
+        case 'state': return c(s.state === 'permission' ? 'red' : s.state === 'waiting' ? 'yellow' : s.state === 'working' ? 'green' : 'dim', cell(stateLabel(s, now), col.width))
         case 'started': return cell(when(s.start, now), col.width)
-        case 'project': return cell(shortPath(s.cwd, home), col.width)
+        case 'branch': return cell(branchLabel(s), col.width)
+        case 'project': {
+          const tag = s.agent && s.agent !== 'claude' ? `[${s.agent}] ` : ''
+          return cell(tag + fitPath(shortPath(s.cwd, home), Math.max(4, col.width - tag.length)), col.width)
+        }
         case 'rss': return cell(size(s.rss), col.width, true)
         case 'bar': return c('cyan', meter(s.rss / maxRss, col.width))
         case 'procs': return cell(s.children == null ? '-' : s.children, col.width, true)
@@ -142,6 +157,11 @@ function frame(view, { width = 100, height = 40, color = false, home = os.homedi
   if (shown.length < sessions.length) lines.push(c('dim', fit(`... ${sessions.length - shown.length} more`, width)))
   if (!sessions.length) lines.push(c('dim', 'no Claude sessions found'))
   lines.push('')
+  if (dupes.length) {
+    lines.push(c('bold', 'DUPLICATE MCP SERVERS'))
+    for (const g of dupes) lines.push(c('yellow', fit(`${mcpLine(g, size)}  sessions ${g.sessions.join(', ')}`, width)))
+    lines.push('')
+  }
 
   // slots and queue
   const queue = st.queue || []
@@ -296,10 +316,15 @@ function snapshot({ stdout = process.stdout, env = process.env } = {}) {
 function main(args, { stdin = process.stdin, stdout = process.stdout, env = process.env } = {}) {
   if (args.includes('--help') || args.includes('-h')) return stdout.write(USAGE + '\n')
   if (rejectArgs('top', args, { flags: ['once'], valued: ['interval'] }, process.stderr, USAGE)) return
+  const every = numberOption(args, 'interval', { min: 0.5, inclusive: true })
+  if (every.error) {
+    process.stderr.write(`bulkhead top: ${every.error}\n`)
+    process.exitCode = 1
+    return
+  }
   if (args.includes('--once') || !stdout.isTTY || !stdin.isTTY) return snapshot({ stdout, env })
-  const sec = Number(option(args, 'interval'))
-  const interval = sec >= 0.5 ? sec * 1000 : defaultInterval()
+  const interval = every.value ? every.value * 1000 : defaultInterval()
   return live({ stdin, stdout, env, interval }).then(() => process.exit(0))
 }
 
-module.exports = { main, frame, layout, live, snapshot, workerScanner, defaultInterval, ALT_ON, ALT_OFF, SHOW }
+module.exports = { main, frame, layout, live, snapshot, workerScanner, defaultInterval, ALT_ON, ALT_OFF, SHOW, USAGE }

package/src/wait-guard.js

@@ -52,6 +52,43 @@ function follows(argv) {
   return false
 }
 
+// Code with its string literals and comments blanked: a sleep inside a quoted file body or a
+// comment is text, not a wait. lang is 'python', 'js' or 'secs' (ruby, perl, php).
+function blankText(code, lang) {
+  code = String(code).slice(0, 200000)
+  let out = ''
+  let i = 0
+  const n = code.length
+  while (i < n) {
+    const c = code[i]
+    if ((c === '#' && lang !== 'js') || (c === '/' && code[i + 1] === '/' && lang === 'js')) {
+      const nl = code.indexOf('\n', i)
+      i = nl < 0 ? n : nl
+      continue
+    }
+    if (c === '/' && code[i + 1] === '*' && lang === 'js') {
+      const end = code.indexOf('*/', i + 2)
+      i = end < 0 ? n : end + 2
+      continue
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      const q = lang === 'python' && code.startsWith(c.repeat(3), i) ? c.repeat(3) : c
+      i += q.length
+      while (i < n && !code.startsWith(q, i)) {
+        if (code[i] === '\\') i++
+        else if (q.length === 1 && q !== '`' && code[i] === '\n') break
+        i++
+      }
+      i += q.length
+      out += '""'
+      continue
+    }
+    out += c
+    i++
+  }
+  return out
+}
+
 // A loop inside an interpreter's code: Infinity for while loops, the count for range(N),
 // N.times or for (i = 0; i < N; ...), and 1 for no loop.
 function codeLoops(code) {
@@ -63,28 +100,34 @@ function codeLoops(code) {
   return best
 }
 
-// Worst-case wait in seconds of python -c, node -e, ruby -e, perl -e or php -r code:
-// sleep(300), time.sleep(300), sleep 300, setTimeout(f, 300000).
-function codeWait(code) {
-  const s = []
-  for (const m of code.matchAll(/\bsleep\s*\(?\s*(\d+(?:\.\d+)?)\s*\)?/g)) s.push(Number(m[1]))
-  for (const m of code.matchAll(/\bsetTimeout\s*\(([^;]{0,300}?),\s*(\d+(?:\.\d+)?)\s*\)/g)) s.push(Number(m[2]) / 1000)
+// Worst-case wait in seconds of python -c, node -e, ruby -e, perl -e or php -r code, or of a
+// python or node heredoc: time.sleep(300) and asyncio.sleep(300) wait seconds, sleep(500) and
+// setTimeout(f, 500) in JavaScript wait milliseconds. Strings that code hands to a shell
+// (os.system('sleep 300'), execSync("sleep 300")) are shell waits.
+function codeWait(code, lang = 'secs') {
+  const text = blankText(code, lang)
+  const s = shell.embeddedShell(code).flatMap(sleeps)
+  const unit = lang === 'js' ? 1000 : 1
+  for (const m of text.matchAll(/\bsleep\s*\(?\s*(\d+(?:\.\d+)?)\s*\)?/g)) s.push(Number(m[1]) / unit)
+  for (const m of text.matchAll(/\bsetTimeout\s*\(([^;]{0,300}?),\s*(\d+(?:\.\d+)?)\s*\)/g)) s.push(Number(m[2]) / 1000)
   if (!s.length) return 0
-  const loops = codeLoops(code)
+  const loops = codeLoops(text)
   return loops > 1 ? loops * s.reduce((a, b) => Math.max(a, b), 0) : s.reduce((a, b) => a + b, 0)
 }
 
+const INTERPRETER_WORD = /\b(?:python[\d.]*|py|pythonw|node|nodejs|deno|bun|ruby|perl|php|lua)\b/
 const INTERPRETER = /^(?:python[\d.]*|py|pythonw|node|deno|bun|ruby|perl|php)$/
-const INTERPRETER_HEREDOC = /(?:^|[\s;&|(])(?:python[\d.]*|py|node|deno|bun|ruby|perl|php)(?:\.exe)?(?:\s+-)?\s*$/
 const CODE_FLAG = { python: /^-c$/, node: /^(?:-e|--eval|-p|--print)$/, ruby: /^-e$/, perl: /^-[Ee]$/, php: /^-r$/ }
+const langOf = b => (/^py/.test(b) ? 'python' : /^(?:node|nodejs|deno|bun)$/.test(b) ? 'js' : 'secs')
 
+// { code, lang } of an interpreter command line, or null.
 function codeOf(argv) {
   const b = shell.bin(argv[0])
   if (!INTERPRETER.test(b)) return null
   const kind = /^py/.test(b) ? 'python' : /^(?:node|deno|bun)$/.test(b) ? 'node' : b
-  if (/^(?:deno|bun)$/.test(b) && argv[1] === 'eval') return argv[2] || null
+  if (/^(?:deno|bun)$/.test(b) && argv[1] === 'eval') return argv[2] ? { code: argv[2], lang: 'js' } : null
   const i = argv.findIndex((a, k) => k > 0 && CODE_FLAG[kind].test(a))
-  return i > 0 ? argv[i + 1] || null : null
+  return i > 0 && argv[i + 1] ? { code: argv[i + 1], lang: langOf(b) } : null
 }
 
 // Inert commands only print or search text: echo "sleep 600", git log -S "sleep 300".
@@ -106,7 +149,7 @@ function scan(text, mode) {
     const detached = s.remote && argv.some(v => v === '-d' || v === '--detach')
     if (INERT.test(shell.bin(argv[0])) || BACKGROUND.test(argv[0]) || detached) { cut.push([s.argv[0].s, c.e]); continue }
     const src = codeOf(argv)
-    if (src) code.push(codeWait(src))
+    if (src) code.push(codeWait(src.code, src.lang))
     if (follows(argv)) follow = true
   }
   if (!cut.length) return { text, code, follow }
@@ -160,6 +203,13 @@ function hasLoop(cmd) {
     /ForEach-Object|\|\s*%\s*\{/i.test(cmd)
 }
 
+// Is the end of this text inside a for, while or until loop that has not reached its done?
+function inLoop(before) {
+  const opened = (before.match(/\b(?:for|while|until)\b/g) || []).length
+  const closed = (before.match(/\bdone\b/g) || []).length
+  return opened > closed
+}
+
 const QUOTED = /"[^"]*"|'[^']*'/g
 
 const OPENERS = new Set(['do', 'if', 'case'])
@@ -170,7 +220,9 @@ const CLOSERS = new Set(['done', 'fi', 'esac'])
 // backgrounds both. Quotes, loops, groups and subshells are kept whole.
 function topLevelLists(cmd) {
   const out = []
-  let depth = 0
+  // what is open: 'p' parenthesis, 'b' brace, 'w' loop, if or case. A `)` that ends a case pattern
+  // (haeon) cmd;;) has no ( to close and must not close the case.
+  const open = []
   let start = 0
   let quote = null
   const push = (end, op) => {
@@ -186,16 +238,19 @@ function topLevelLists(cmd) {
     }
     if (c === '\\') { i++; continue }
     if (c === '"' || c === "'") { quote = c; continue }
-    if (c === '(' || c === '{') { depth++; continue }
-    if (c === ')' || c === '}') { depth = Math.max(0, depth - 1); continue }
+    if (c === '(' || c === '{') { open.push(c === '(' ? 'p' : 'b'); continue }
+    if (c === ')' || c === '}') {
+      if (open[open.length - 1] === (c === ')' ? 'p' : 'b')) open.pop()
+      continue
+    }
     if (/[a-z]/i.test(c) && (i === 0 || /[\s;&|]/.test(cmd[i - 1]))) {
       const word = /^[\w.-]+/.exec(cmd.slice(i, i + 64))[0]
-      if (OPENERS.has(word)) depth++
-      else if (CLOSERS.has(word)) depth = Math.max(0, depth - 1)
+      if (OPENERS.has(word)) open.push('w')
+      else if (CLOSERS.has(word) && open[open.length - 1] === 'w') open.pop()
       i += word.length - 1
       continue
     }
-    if (depth) continue
+    if (open.length) continue
     if (c === ';' || c === '\n') push(i, c)
     else if (c === '&') {
       const prev = cmd[i - 1]
@@ -221,22 +276,31 @@ function dropBackgrounded(cmd) {
 
 // Worst-case wait in seconds, capped by the tool timeout. Returns null when within the limit.
 function judge(cmd, timeoutMs, maxSec = 180, mode = 'sh') {
-  const opened = shell.unwrap(shell.prepare(String(cmd || ''), mode), mode, 0, { remote: true })
+  const raw = String(cmd || '')
+  // a heredoc that a shell runs, here or over ssh, is shell text; one that python or node reads is code
+  const opened = shell.unwrap(shell.prepare(raw, mode, ['shell', 'remote']), mode, 0, { remote: true })
   const { text, code, follow } = scan(dropBackgrounded(opened), mode)
-  // python3 - <<'EOF' ... EOF: the body is the interpreter's code
-  if (opened.includes('<<')) {
-    for (const d of shell.heredocs(opened, prefix => INTERPRETER_HEREDOC.test(prefix))) code.push(codeWait(d.body))
+  // python3 - <<'EOF' ... EOF: the body is the interpreter's code, in its own language. Its waits
+  // are added to the shell's, not multiplied by a shell loop that ended before it.
+  let after = 0
+  if (raw.includes('<<') && INTERPRETER_WORD.test(raw)) {
+    for (const d of shell.heredocs(raw, (prefix, rest) => shell.consumerOf(prefix, rest, mode).kind === 'interp')) {
+      const w = codeWait(d.body, langOf(shell.consumerOf(d.prefix, d.rest, mode).bin))
+      if (inLoop(raw.slice(0, d.start))) code.push(w)
+      else after += w
+    }
   }
   // Quoted text is an argument, not shell code: a `for (` inside node -e "..." is not a loop.
   const bare = text.replace(QUOTED, '_')
   const s = sleeps(bare).concat(code.filter(n => n > 0))
   if (follow) s.push(Infinity)
-  if (!s.length) return null
+  if (!s.length && !after) return null
   const wrapped = bare.match(/\b(?:g?timeout)\s+(?:-\w+\s+)*(\d+)s?\b/)
   if (wrapped && Number(wrapped[1]) <= maxSec) return null
   const cap = Number(timeoutMs) > 0 ? Number(timeoutMs) / 1000 : DEFAULT_TOOL_TIMEOUT_S
   const loop = hasLoop(bare)
-  const worst = loop ? loopCount(bare) * s.reduce((a, b) => Math.max(a, b), 0) : s.reduce((a, b) => a + b, 0)
+  const inShell = !s.length ? 0 : loop ? loopCount(bare) * s.reduce((a, b) => Math.max(a, b), 0) : s.reduce((a, b) => a + b, 0)
+  const worst = inShell + after
   const est = Math.min(worst, cap)
   return est > maxSec ? { est, maxSec, rule: follow && !loop ? 'follow' : loop ? 'poll-loop' : 'long-sleep' } : null
 }
@@ -250,14 +314,14 @@ function message({ est, maxSec }) {
     'For a one-off check, skip the sleep and read the output file now.'
 }
 
-if (require.main === module) {
-  runHook('wait-guard', input => {
-    const ti = input.tool_input || {}
-    if (ti.run_in_background || typeof ti.command !== 'string') return
-    const verdict = judge(ti.command, ti.timeout, setting('waitGuard.limitSeconds', 180), shell.modeFor(input))
-    if (!verdict) return
-    return blocked('wait-guard', verdict.rule, input, `${message(verdict)}\n${ASK_USER}`)
-  })
+function handle(input) {
+  const ti = input.tool_input || {}
+  if (ti.run_in_background || typeof ti.command !== 'string') return
+  const verdict = judge(ti.command, ti.timeout, setting('waitGuard.limitSeconds', 180), shell.modeFor(input))
+  if (!verdict) return
+  return blocked('wait-guard', verdict.rule, input, `${message(verdict)}\n${ASK_USER}`)
 }
 
-module.exports = { judge, message, topLevelLists, dropBackgrounded }
+if (require.main === module) runHook('wait-guard', handle)
+
+module.exports = { handle, judge, message, topLevelLists, dropBackgrounded }