claude-bulkhead 0.2.2 → 0.3.0

package/src/explain.js

@@ -0,0 +1,251 @@
+'use strict'
+const os = require('os')
+const path = require('path')
+const { enabled, setting, withWayOut } = require('./hook')
+const { allowHint } = require('./allow-hint')
+const { useColor, paint, shortPath, option, numberOption, rejectArgs } = require('./cli-util')
+
+const USAGE = `usage: bulkhead explain [--cwd DIR] [--session-id ID|PID] [--timeout MS] [--json] -- <command...>
+
+Runs the command through every Bash guard the way the PreToolUse hook would, against the
+sessions, processes, ports and git tree on this machine right now. Nothing is executed and
+nothing is logged. For each guard it prints pass or block, the rule, who owns the thing that is
+in the way, the message the agent would see, and how to allow it once or for good.
+--session-id explains it as that session (a session id or its pid); without it the command is
+judged as a new session that none of the running ones is. --timeout is the tool call's timeout
+in milliseconds, which wait-guard reads (the Bash tool's default is 120000).`
+
+// the order the hook runs them in (bash-guards.js)
+const ORDER = require('./bash-guards').ORDER.map(([name]) => name)
+const PREVIEW_SESSION = 'explain-preview'
+
+// Reads the process table at most once, and only when a guard asks for it.
+function lazy(fn) {
+  let v
+  let done = false
+  return () => (done ? v : ((done = true), (v = fn())))
+}
+
+function liveContext(opts = {}) {
+  const { readProcesses } = require('./processes')
+  const { readSessionFiles } = require('./sessions')
+  const { readMemory } = require('./memory')
+  const { listening } = require('./port-guard')
+  const files = lazy(() => readSessionFiles())
+  const snapshot = lazy(() => readProcesses())
+  return { files, snapshot, memory: () => readMemory(), probe: listening, mode: 'sh', ...opts }
+}
+
+// The session the command is judged as: { sessionId, pid } from --session-id (an id or a pid),
+// or a new session no running one is.
+function whoAmI(ctx, wanted) {
+  if (!wanted) {
+    // run from a Claude Code Bash tool: the session the shell belongs to
+    const f = ctx.files().get(Number(process.env.CLAUDE_PID))
+    return f && f.sessionId ? { sessionId: f.sessionId, pid: Number(process.env.CLAUDE_PID), given: false, inferred: true } : { sessionId: PREVIEW_SESSION, pid: null, given: false }
+  }
+  for (const [pid, f] of ctx.files()) {
+    if (f.sessionId === wanted || String(pid) === String(wanted)) return { sessionId: f.sessionId || String(pid), pid, given: true, cwd: f.cwd }
+  }
+  return { sessionId: String(wanted), pid: null, given: true, unknown: true }
+}
+
+// Session owning each process in the snapshot, to say whose `node` a kill by name would stop.
+function killEvidence(command, ctx) {
+  try {
+    const kill = require('./kill-guard')
+    const { findSessions, assignOwners } = require('./sessions')
+    const name = require('./allow-hint').killName(command)
+    const snap = ctx.snapshot()
+    if (!name || !snap) return []
+    const sessions = findSessions(snap, ctx.files())
+    const owner = assignOwners(snap.procs, new Set(sessions.map(s => s.pid)))
+    const names = [name]
+    const groups = new Map()
+    for (const p of snap.procs) {
+      if (!kill.nameHits(p.name, names)) continue
+      const key = owner.get(p.pid) || 0
+      if (!groups.has(key)) groups.set(key, [])
+      groups.get(key).push(p.pid)
+    }
+    const lines = [...groups].map(([pid, pids]) => {
+      const s = sessions.find(x => x.pid === pid)
+      const list = `${pids.slice(0, 4).join(', ')}${pids.length > 4 ? ', ...' : ''}`
+      return `${name} pid ${list} ${s ? `runs in the session with pid ${s.pid} (${shortPath(s.cwd)})` : 'belongs to no Claude session'}`
+    })
+    return lines.slice(0, 6)
+  } catch {
+    return []
+  }
+}
+
+function ownerLine(owner, what) {
+  return `${what} belongs to the session with pid ${owner.pid} (${shortPath(owner.cwd)})`
+}
+
+// One check per guard; each returns null (pass) or { rule, message, evidence: [text] }.
+const CHECKS = {
+  'kill-guard': async (cmd, ctx) => {
+    const kill = require('./kill-guard')
+    // the same process-table context the hook uses, seen from the session explain speaks for;
+    // a new session (no pid) counts every running session as another one
+    const owners = require('./kill-owners').makeContext({
+      cwd: ctx.cwd, off: kill.RULES.filter(rule => !enabled(rule)),
+      snapshot: ctx.snapshot, files: ctx.files, self: () => (ctx.who && ctx.who.pid) || -1,
+    })
+    const hit = kill.classify(cmd, {
+      allowNames: setting('killGuard.allowNames', []), extraSharedNames: setting('killGuard.extraSharedNames', []),
+    }, ctx.mode, owners)
+    if (!hit) return null
+    const evidence = killEvidence(cmd, ctx)
+    return {
+      rule: hit.rule, message: `${kill.message(hit.why, process.platform, hit.rule)}`,
+      evidence: evidence.length ? evidence : [hit.why],
+    }
+  },
+  'wait-guard': async (cmd, ctx) => {
+    const wait = require('./wait-guard')
+    const verdict = wait.judge(cmd, ctx.timeout, setting('waitGuard.limitSeconds', 180), ctx.mode)
+    if (!verdict) return null
+    return { rule: verdict.rule, message: wait.message(verdict), evidence: [`estimated wait ${verdict.est} s, the limit is ${verdict.maxSec} s`] }
+  },
+  'memory-guard': async (cmd, ctx) => {
+    let mem = null
+    const hit = require('./memory-guard').decide(cmd, () => (mem = ctx.memory()), undefined, ctx.mode)
+    if (!hit) return null
+    const evidence = hit.rule === 'low-memory' && mem
+      ? [`${mem.freeGb.toFixed(1)} GB of ${mem.totalGb.toFixed(1)} GB RAM is free`]
+      : ['the command writes a slot file by hand']
+    return { ...hit, evidence }
+  },
+  'port-guard': async (cmd, ctx) => {
+    const { inspect, checkKill } = require('./port-guard')
+    const who = ctx.who
+    const common = {
+      probe: ctx.probe, snapshot: ctx.snapshot, files: ctx.files, mode: ctx.mode,
+      // the session the command is judged as; a new session when none was named, so every running one is "another"
+      self: procs => who.pid || (!who.given && require('./sessions').ownSession(procs)) || -1,
+    }
+    const hit = await inspect(cmd, { cwd: ctx.cwd, ...common })
+    if (hit) return { rule: hit.rule, message: hit.message, evidence: [ownerLine(hit.owner, `${hit.name} pid ${hit.pid} on port ${hit.port}`)] }
+    const kill = await checkKill(cmd, common)
+    if (kill) return { rule: kill.rule, message: kill.message, evidence: [ownerLine(kill.owner, `${kill.name} pid ${kill.pid} on port ${kill.port}`)] }
+    return null
+  },
+  'checkout-guard': async (cmd, ctx) => {
+    const hit = require('./checkout-guard').classify(cmd, {
+      cwd: ctx.cwd, sessionId: ctx.who.sessionId, mode: ctx.mode, files: ctx.files, platform: ctx.platform, home: ctx.home, isAlive: ctx.isAlive, run: ctx.run,
+    })
+    if (!hit) return null
+    const evidence = hit.owner ? [ownerLine(hit.owner, 'the tree')] : [hit.rule]
+    return { rule: hit.rule, message: hit.why, evidence }
+  },
+  'disk-guard': async (cmd, ctx) => {
+    const hit = require('./disk-guard').check(cmd, { mode: ctx.mode })
+    return hit ? { rule: hit.rule, message: hit.why, evidence: [hit.rule] } : null
+  },
+  'secrets-guard': async (cmd, ctx) => {
+    const secrets = require('./secrets-guard')
+    const hit = secrets.classifyCommand(cmd, {
+      cwd: ctx.cwd, mode: ctx.mode, extra: setting('secretsGuard.extraPatterns', []), allow: setting('secretsGuard.allow', []),
+    })
+    return hit ? { rule: hit.rule, message: secrets.message(hit), evidence: [`${hit.label}: ${hit.what}`] } : null
+  },
+  basics: async (cmd, ctx) => {
+    const basics = require('./basics')
+    const why = basics.check(cmd, { cwd: ctx.cwd, mode: ctx.mode, run: ctx.run })
+    if (!why) return null
+    const rule = basics.ruleOf(why)
+    return { rule, message: why, evidence: [why.split('\n')[0].replace(/^\[bulkhead\] basics: /, '')] }
+  },
+}
+
+// Every guard's verdict on the command, in the order the hooks run them.
+async function explain(command, opts = {}) {
+  const ctx = liveContext(opts)
+  ctx.cwd = path.resolve(opts.cwd || process.cwd())
+  ctx.who = whoAmI(ctx, opts.sessionId)
+  const guards = []
+  for (const guard of ORDER) {
+    if (!enabled(guard)) {
+      guards.push({ guard, status: 'off' })
+      continue
+    }
+    let hit = null
+    try { hit = await CHECKS[guard](command, ctx) } catch (e) { guards.push({ guard, status: 'error', error: e.message }); continue }
+    if (!hit) {
+      guards.push({ guard, status: 'pass' })
+      continue
+    }
+    const hint = allowHint(guard, hit.rule, { command, message: hit.message })
+    const message = hit.rule === 'self-allow' ? hit.message : withWayOut(hit.message, { code: '<code>', json: hint.json })
+    guards.push({
+      guard, status: 'block', rule: hit.rule, evidence: hit.evidence, message,
+      allowOnce: hit.rule !== 'self-allow', config: hint.json, disable: hint.disable,
+    })
+  }
+  return { command, cwd: ctx.cwd, session: ctx.who, blocked: guards.some(g => g.status === 'block'), guards }
+}
+
+function render(r, { color = false, home = os.homedir() } = {}) {
+  const out = []
+  const b = s => paint(color, 'bold', s)
+  out.push(`${b('command')}  ${r.command}`)
+  out.push(`${b('folder')}   ${shortPath(r.cwd, home)}`)
+  out.push(`${b('as')}       ${r.session.given ? `session ${r.session.sessionId}${r.session.pid ? ` (pid ${r.session.pid})` : ' (not running)'}` : r.session.inferred ? `this shell's session (pid ${r.session.pid})` : 'a new session (--session-id names one)'}`)
+  const blockers = r.guards.filter(g => g.status === 'block')
+  out.push(`${b('verdict')}  ${blockers.length ? paint(color, 'red', `BLOCKED by ${blockers.map(g => `${g.guard} ${g.rule}`).join(', ')}`) : paint(color, 'green', 'passes every guard')}`)
+  out.push('')
+  for (const g of r.guards) {
+    if (g.status === 'pass') out.push(`${g.guard.padEnd(15)} ${paint(color, 'green', 'pass')}`)
+    else if (g.status === 'off') out.push(`${g.guard.padEnd(15)} ${paint(color, 'gray', 'off (turned off in the config or BULKHEAD_DISABLE)')}`)
+    else if (g.status === 'error') out.push(`${g.guard.padEnd(15)} ${paint(color, 'yellow', `could not be checked: ${g.error}`)}`)
+    else {
+      out.push(`${g.guard.padEnd(15)} ${paint(color, 'red', 'BLOCK')}  rule ${g.rule}`)
+      for (const e of g.evidence) out.push(`  evidence   ${e}`)
+      out.push('  the agent sees:')
+      for (const line of g.message.split('\n')) out.push(`    ${line}`)
+      if (g.allowOnce) out.push('  allow once   the user runs `bulkhead allow <code>` in their terminal; the code is in the real block message')
+      if (g.config) out.push(`  allow always ${g.config} in .claude/bulkhead.json`)
+      if (g.disable) out.push(`  or           BULKHEAD_DISABLE=${g.disable}`)
+      if (!g.allowOnce) out.push('  not allowable: only the user can approve, and not through the agent')
+    }
+    out.push('')
+  }
+  return out.join('\n').replace(/\n+$/, '')
+}
+
+// Everything after `--` is the command: several words are quoted back as a shell line.
+function commandFrom(args) {
+  const sep = args.indexOf('--')
+  const words = sep >= 0 ? args.slice(sep + 1) : null
+  if (!words || !words.length) return null
+  if (words.length === 1) return words[0]
+  return words.map(a => (/^[\w@%+=:,./-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`)).join(' ')
+}
+
+async function main(args, { stdout = process.stdout, stderr = process.stderr, env = process.env, context } = {}) {
+  if (args.includes('--help') || args.includes('-h')) return stdout.write(USAGE + '\n')
+  const sep = args.indexOf('--')
+  const opts = sep >= 0 ? args.slice(0, sep) : args
+  if (rejectArgs('explain', opts, { flags: ['json'], valued: ['cwd', 'session-id', 'timeout'] }, stderr, USAGE)) return
+  const command = commandFrom(args)
+  if (!command) {
+    stderr.write(USAGE + '\n')
+    process.exitCode = 1
+    return
+  }
+  const cwd = option(opts, 'cwd')
+  const sessionId = option(opts, 'session-id')
+  const timeout = numberOption(opts, 'timeout')
+  if (timeout.error) {
+    stderr.write(`bulkhead explain: ${timeout.error}\n`)
+    process.exitCode = 1
+    return
+  }
+  const r = await explain(command, { cwd: typeof cwd === 'string' ? cwd : undefined, sessionId: typeof sessionId === 'string' ? sessionId : undefined, timeout: timeout.value, ...context })
+  if (opts.includes('--json')) return stdout.write(JSON.stringify(r, null, 2) + '\n')
+  stdout.write(render(r, { color: useColor(stdout, env) }) + '\n')
+}
+
+module.exports = { main, explain, render, commandFrom, USAGE, ORDER }

package/src/git-info.js

@@ -0,0 +1,55 @@
+'use strict'
+const fs = require('fs')
+const path = require('path')
+
+// Branch and worktree of a folder, from the files in .git. No git process: this runs for every
+// session on every `bulkhead status` / `top` refresh.
+
+const realIo = {
+  read: p => { try { return fs.readFileSync(p, 'utf8') } catch { return null } },
+  isDir: p => { try { return fs.statSync(p).isDirectory() } catch { return false } },
+  isFile: p => { try { return fs.statSync(p).isFile() } catch { return false } },
+}
+
+// "ref: refs/heads/feat/x" is a branch; anything else is a detached commit.
+function parseHead(text) {
+  const t = String(text || '').trim()
+  const m = /^ref:\s*refs\/heads\/(.+)$/.exec(t)
+  if (m) return { branch: m[1], detached: false }
+  if (/^ref:/.test(t)) return { branch: t.replace(/^ref:\s*/, ''), detached: false }
+  return /^[0-9a-f]{7,64}$/i.test(t) ? { branch: t.slice(0, 7), detached: true } : null
+}
+
+function parseGitFile(text) {
+  const m = /^gitdir:\s*(.+)$/m.exec(String(text || ''))
+  return m ? m[1].trim() : null
+}
+
+// A linked worktree's gitdir is <repo>/.git/worktrees/<name>; a submodule's is .../modules/<name>.
+const LINKED = /\/worktrees\/[^/]+\/?$/
+
+function head(file, io) {
+  return parseHead(io.read(file)) || { branch: null, detached: false }
+}
+
+// { root, branch, detached, worktree } for the nearest repository at or above `dir`, or null.
+function gitInfo(dir, io = realIo) {
+  if (!dir) return null
+  let cur = path.resolve(dir)
+  for (let i = 0; i < 40; i++) {
+    const dot = path.join(cur, '.git')
+    if (io.isDir(dot)) return { root: cur, worktree: false, ...head(path.join(dot, 'HEAD'), io) }
+    if (io.isFile(dot)) {
+      const gitdir = parseGitFile(io.read(dot))
+      if (!gitdir) return { root: cur, worktree: false, branch: null, detached: false }
+      const abs = path.resolve(cur, gitdir)
+      return { root: cur, worktree: LINKED.test(gitdir.replace(/\\/g, '/')), ...head(path.join(abs, 'HEAD'), io) }
+    }
+    const up = path.dirname(cur)
+    if (up === cur) return null
+    cur = up
+  }
+  return null
+}
+
+module.exports = { gitInfo, parseHead, parseGitFile }

package/src/gitargs.js

@@ -0,0 +1,82 @@
+'use strict'
+const path = require('path')
+const shell = require('./shell')
+
+// Options that go before the git subcommand and take a value in the next word.
+const GLOBAL_VALUED = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env', '--attr-source', '--super-prefix', '--exec-path'])
+
+// git [global options] <sub> args. Takes the words of one command; returns null for anything that
+// is not git. dir is where git runs (-C applied); workTree and gitDir are set by --work-tree and
+// --git-dir (or GIT_WORK_TREE and GIT_DIR written in front of the command, see `env`); opts are
+// those two as absolute options to hand to a git run that must see the same repository.
+function gitCall(t, cwd, env = {}) {
+  if (shell.bin(t[0] || '') !== 'git') return null
+  let dir = cwd
+  let workTree = env.GIT_WORK_TREE ? path.resolve(cwd, env.GIT_WORK_TREE) : null
+  let gitDir = env.GIT_DIR ? path.resolve(cwd, env.GIT_DIR) : null
+  let bare = false
+  let i = 1
+  for (; i < t.length && t[i].startsWith('-') && t[i] !== '-'; i++) {
+    const a = t[i]
+    const eq = a.indexOf('=')
+    const name = a.startsWith('--') && eq > 0 ? a.slice(0, eq) : a
+    const inline = a.startsWith('--') && eq > 0
+    const value = () => (inline ? a.slice(eq + 1) : t[++i])
+    const v = GLOBAL_VALUED.has(name) && (inline || name !== '--exec-path') ? value() : null
+    if (name === '-C' && v) dir = path.resolve(dir, v)
+    else if (name === '--git-dir' && v) gitDir = path.resolve(dir, v)
+    else if (name === '--work-tree' && v) workTree = path.resolve(dir, v)
+    else if (name === '--bare') bare = true
+  }
+  const opts = []
+  if (gitDir) opts.push(`--git-dir=${gitDir}`)
+  if (workTree) opts.push(`--work-tree=${workTree}`)
+  return { dir, sub: t[i], args: t.slice(i + 1), workTree, gitDir, bare, opts }
+}
+
+// The working tree a call acts on: the one --work-tree names, the folder git runs in when only
+// --git-dir is given (git takes the current directory as the tree then), else git rev-parse.
+function treeOf(call, run) {
+  if (call.bare) throw new Error('bare repository')
+  if (call.workTree) return call.workTree
+  if (call.gitDir) return call.dir
+  return run(['rev-parse', '--show-toplevel'], call.dir)
+}
+
+// Short-flag clusters and long options of one git subcommand. valuedShort lists the single letters
+// that take a value (the rest of the cluster, or the next word); valuedLong the long names that
+// take one in the next word. Returns { short: Set of letters, long: Set of names without --,
+// pos: words that are not options (everything after -- included), after: the words after -- }.
+function parseArgs(args, { valuedShort = '', valuedLong = [] } = {}) {
+  const short = new Set()
+  const long = new Set()
+  const pos = []
+  const after = []
+  const valued = new Set(valuedLong)
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '--') { after.push(...args.slice(i + 1)); pos.push(...args.slice(i + 1)); break }
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=')
+      const name = eq > 0 ? a.slice(2, eq) : a.slice(2)
+      long.add(name)
+      if (eq < 0 && valued.has(name)) i++
+    } else if (a.length > 1 && a[0] === '-') {
+      for (let k = 1; k < a.length; k++) {
+        short.add(a[k])
+        if (valuedShort.includes(a[k])) { if (k === a.length - 1) i++; break }
+      }
+    } else pos.push(a)
+  }
+  return { short, long, pos, after }
+}
+
+// GIT_WORK_TREE=/x GIT_DIR=/x/.git git ...: the assignments are dropped from the words of a
+// command, so they are read from its text.
+function gitEnv(text) {
+  const env = {}
+  for (const m of String(text).matchAll(/(?:^|[\s;&|(])GIT_(WORK_TREE|DIR)=("[^"]*"|'[^']*'|[^\s;&|)]+)/g)) env[`GIT_${m[1]}`] = m[2].replace(/^["']|["']$/g, '')
+  return env
+}
+
+module.exports = { gitCall, gitEnv, treeOf, parseArgs }

package/src/hook.js

@@ -39,19 +39,47 @@ function log(name, line) {
   try {
     const dir = stateDir()
     fs.mkdirSync(dir, { recursive: true })
-    fs.appendFileSync(path.join(dir, 'guards.log'), `${new Date().toISOString()} ${name} ${line}\n`)
+    const file = path.join(dir, 'guards.log')
+    const text = `${new Date().toISOString()} ${name} ${line}\n`
+    let size = 0
+    try { size = fs.statSync(file).size } catch {}
+    // kept to about 1 MB, the previous MB in guards.log.1
+    if (size + text.length > 1024 * 1024) require('./events').rotate(file, 1024 * 1024 - text.length)
+    fs.appendFileSync(file, text)
   } catch {}
 }
 
-// Records a block in guards.log and events.jsonl and returns the hook result that stops the call.
 // One line for the agent and the person reading it: a block can be intentional, and the answer
-// to that is a question to the user, not a way around the guard.
-const ASK_USER = 'If the user wants this on purpose, ask them: they can allow it in .claude/bulkhead.json (see docs/configuration.md).'
+// to that is a question to the user, not a way around the guard. <code> is the allow-once code
+// of this block; blocked() fills it in, and adds the config snippet of the rule that fired.
+const ASK_USER = 'If the user wants this on purpose, ask them to run `bulkhead allow <code>` in their own terminal (allows it once), or allow it in .claude/bulkhead.json.'
+
+// The block text with the one-line way out: the allow-once command and the exact config snippet.
+function withWayOut(message, { code = null, json = null } = {}) {
+  const once = code ? `run \`bulkhead allow ${code}\` in their own terminal (allows it once)` : null
+  const perm = json ? `set ${json} in .claude/bulkhead.json` : null
+  const how = [once, perm].filter(Boolean).join(', or ')
+  const line = how ? `If the user wants this on purpose, ask them to ${how}.` : ''
+  const body = message.includes(ASK_USER) ? message.split(ASK_USER).join(line).replace(/\n+$/, '') : message
+  return line && !message.includes(ASK_USER) ? `${body}\n${line}` : body
+}
 
+// Records a block in guards.log and events.jsonl and returns the hook result that stops the call.
+// Returns nothing when the user allowed this exact command once (bulkhead allow <code>).
 function blocked(name, rule, input, message, command = input && input.tool_input && input.tool_input.command) {
+  const cwd = input && input.cwd
+  const allow = rule === 'self-allow' ? null : require('./allow-once')
+  if (allow && allow.consume(name, rule, command, cwd)) {
+    log(name, `allowed once ${rule}: ${oneLine(command || '')}`)
+    return undefined
+  }
   log(name, `blocked ${rule}: ${oneLine(command || '')}`)
   recordEvent(name, rule, input, command)
-  return { block: message }
+  let code = null
+  if (allow) code = allow.issue({ guard: name, rule, command, cwd, session: input && input.session_id })
+  let json = null
+  try { json = require('./allow-hint').allowHint(name, rule, { command, message }).json } catch {}
+  return { block: withWayOut(message, { code, json }) }
 }
 
 function recordEvent(name, rule, input = {}, command = null, extra = {}) {
@@ -62,6 +90,8 @@ function recordEvent(name, rule, input = {}, command = null, extra = {}) {
     session: input.session_id || null,
     project: process.env.CLAUDE_PROJECT_DIR || input.cwd || null,
     command,
+    // set by `bulkhead hook --agent <name>`; absent for Claude Code
+    ...(process.env.BULKHEAD_AGENT ? { agent: process.env.BULKHEAD_AGENT } : {}),
     ...extra,
   })
 }
@@ -75,6 +105,8 @@ function oneLine(s, max = 300) {
 // { output: object } to print JSON, or a promise of either. Any error lets the call through.
 function runHook(name, handler) {
   if (!enabled(name)) return
+  // process reads give up sooner inside a hook: a slow ps lets the tool call through instead of stalling it
+  process.env.BULKHEAD_IN_HOOK = '1'
   let raw = ''
   process.stdin.setEncoding('utf8')
   process.stdin.on('data', d => (raw += d))
@@ -91,4 +123,4 @@ function runHook(name, handler) {
 }
 
 module.exports = {
-  ASK_USER, runHook, enabled, setting, envNumber, log, oneLine, stateDir, blocked, recordEvent }
+  ASK_USER, withWayOut, runHook, enabled, setting, envNumber, log, oneLine, stateDir, blocked, recordEvent }