blast-radius

1// Copyright 2026 Anthropic PBC
2// SPDX-License-Identifier: Apache-2.0
3//
4// Modified in the awesome-claude fork (2026): renamed from blast-radius.mjs to
5// register.tsx and typed for TypeScript; the drawing moved to view.tsx, which
6// keeps upstream's terminal drawing and adds a desktop one, with the kit's
7// column view switch kept in the mod's state (`columns`). The holding,
8// classifying and measuring logic is upstream's, unchanged.
9//
10// Blast Radius: holds a risky Bash command and shows what it would change.
11//
12// tool.call (Bash): if the command is risky, work out its blast radius, open a
13// pane with Proceed and Cancel, and hold the call until one is pressed.
14// ui.render (Pane): draws the report. If the surface won't place the pane (a
15// narrow terminal), the same report is drawn in the AbovePrompt band instead.
16//
17// Holding: a hook has 10 s of its own time, but time spent inside a `$` call is
18// free. So the hold loop waits on a short `$.process.run(["sleep", ...])` until
19// a button's onPress sets the decision.
20//
21// The host reads `on(...)` and `$.noun.method(...)` from source, so they are
22// spelled literally, and helpers that take `$` are top-level functions.
23
24import { atom, read, update } from 'claude-code'
25import type { EngineInterface, Register } from 'claude-code'
26import { holdButtons } from '@kit/ui'
27
28import { renderApp, renderTerminal } from './view'
29import type { AppElements, Held, Report, Risk } from './view'
30
31type $ = EngineInterface
32
33const PANE_ID = "blast-radius";
34const POLL_SECONDS = "0.25";
35const HOLD_LIMIT_MS = 10 * 60 * 1000;
36const LIST_MAX = 10;
37
38// The call being held, or null. One at a time: Bash calls in a turn run in order.
39let held: Held | null = null;
40
41/** Whether a wide app pane flows the report's lines into columns; the pane's footer switch flips it. */
42const columnsView = atom({ plugin: "blast-radius", key: "columns" } as const, true);
43
44/** The report for the surface, drawn with the kit: in cells on the terminal, as the app's elsewhere. */
45async function draw($: $, e: any, state: Held, band: boolean) {
46  const columnsOn = await read($, columnsView);
47  // Buttons keep their press handles across redraws, so a click made just before one still lands.
48  const els = holdButtons($.ui.resolve(e), e);
49  const columns = Number(e.props?.bodyColumns ?? 40);
50  // The rows it has (the band's most, or the pane's body), so the list is cut before the actions are.
51  const rows = Number(e.props?.maxRows ?? e.props?.scroll?.bodyRows) || undefined;
52  // The switch is drawn in the pane alone; the band above the prompt keeps to the hold.
53  const flow = { on: columnsOn, ...(band ? {} : { toggle: () => void update($, columnsView, (was) => !was).catch(() => undefined) }) };
54  return e.surface === "terminal" ? renderTerminal(els, state, columns, { band, focused: e.props?.isFocused, rows }) :renderApp(els as unknown as AppElements, state, columns, { band, flow });
55}
56
57export const register: Register = (on) => {
58  on("tool.call", { tool: "Bash" }, async ($, e, next) => {
59    const risk = classify(String((e as any).command ?? ""));
60    if (risk === null) {
61      return next(e);
62    }
63    // One hold at a time. If another risky call is already held (a subagent's,
64    // say), wait until it is answered. `held` is claimed with no await between
65    // the check and the claim, so two waiting calls can't both get through.
66    while (held !== null) {
67      if (next.signal.aborted) {
68        return { deny: "Blast Radius held this command and did not run it: the turn was interrupted. Do not retry it unless the user asks you to." };
69      }
70      await $.process.run(["sleep", POLL_SECONDS], { timeoutMs: 5000 });
71    }
72    const mine: Held = { command: String((e as any).command), risk, report: null, decision: null, where: "pane" };
73    held = mine;
74
75    let opened = { isPlaced: false };
76    let decision: string | null;
77    let summary = risk.label;
78    try {
79      // Measure where the command will run: the session folder, moved by any
80      // `cd dir &&` or `git -C dir` earlier in the same command line.
81      const sessionCwd = await $.session.cwd();
82      const cwd = risk.dir ? await resolveDir($, sessionCwd, risk.dir) : sessionCwd;
83      mine.report = cwd === null
84        ? { summary: `${risk.label} in ${risk.dir}`, lines: [], note: `Couldn't find the folder ${risk.dir}, so I couldn't measure what this would change.` }
85        : await measure($, risk, cwd);
86      summary = mine.report.summary;
87
88      opened = await $.ui.open({ id: PANE_ID, title: "Blast Radius", focus: true, rows: paneRows(mine.report) });
89      if (!opened.isPlaced) {
90        mine.where = "band";
91      }
92      $.ui.invalidate("ui.render");
93
94      const startedAt = await $.clock.now();
95      while (mine.decision === null) {
96        if (next.signal.aborted) {
97          mine.decision = "interrupted";
98          break;
99        }
100        if ((await $.clock.now()) - startedAt > HOLD_LIMIT_MS) {
101          mine.decision = "timeout";
102          break;
103        }
104        await $.process.run(["sleep", POLL_SECONDS], { timeoutMs: 5000 });
105      }
106    } catch {
107      mine.decision = "error"; // anything unexpected refuses the command
108    } finally {
109      decision = mine.decision;
110      // Close this call's pane before releasing the hold, so the next call's
111      // pane can't be the one that gets closed.
112      try {
113        if (opened.isPlaced) {
114          await $.ui.close({ id: PANE_ID });
115        }
116      } catch {
117        // the pane is already gone
118      }
119      if (held === mine) {
120        held = null;
121      }
122      $.ui.invalidate("ui.render");
123    }
124
125    if (decision === "proceed") {
126      $.ui.toast("Blast Radius: running it");
127      return next(e);
128    }
129    const why = ({
130      cancel: "the user pressed Cancel",
131      timeout: "no answer within 10 minutes",
132      interrupted: "the turn was interrupted",
133      error: "Blast Radius hit an error while holding it",
134    } as Record<string, string>)[decision ?? ""] ?? "no answer was recorded";
135    return {
136      deny: `Blast Radius held this command and did not run it: ${why}. It would have: ${summary}. Do not retry it unless the user asks you to.`,
137    };
138  });
139
140  on("ui.render", { component: "Pane" }, ($, e, next) => {
141    if (e.requestId !== PANE_ID || held === null || held.report === null) {
142      return next(e);
143    }
144    return draw($, e, held, false);
145  });
146
147  on("ui.render", { component: "AbovePrompt" }, ($, e, next) => {
148    if (held === null || held.report === null || held.where !== "band") {
149      return next(e);
150    }
151    return draw($, e, held, true);
152  });
153};
154
155// ---- What counts as risky -------------------------------------------------
156
157// sudo options that take a value, so the value isn't read as the command.
158const SUDO_VALUE_OPTIONS = new Set(["-u", "-g", "-C", "-D", "-h", "-p", "-r", "-t", "-T", "-U"]);
159// Commands that only read, so a bare word "migrate" in them isn't a migration.
160const READ_ONLY = new Set(["ls", "cat", "echo", "printf", "grep", "rg", "find", "less", "head", "tail", "cd", "git"]);
161
162/** A folder a later `cd arg` moves to, given the folder so far (null = the session folder). */
163function joinDir(dir: string | null, arg: string | undefined): string {
164  if (arg === undefined || arg === "~" || arg.startsWith("/") || arg.startsWith("~/")) {
165    return arg ?? "~";
166  }
167  return dir ? `${dir}/${arg}` : arg;
168}
169
170/** The first risky segment of a shell command, or null. */
171function classify(command: string): Risk | null {
172  let dir: string | null = null; // where a `cd` earlier on the line moved to; null means the session folder
173  const scopes: (string | null)[] = []; // dir to restore when a ( subshell ) closes
174  const pushed: (string | null)[] = []; // pushd stack, for popd
175  for (const raw of command.split(/&&|\|\||;|\||\n/)) {
176    const opens = (raw.match(/^\s*\(+/)?.[0].trim().length) ?? 0;
177    // Trailing redirects and & don't hide a closing ) : `(cd sub && make) > log`.
178    const tail = raw.replace(/(?:\s*(?:\d*>>?|&>>?|<)\s*\S+|\s*&)+\s*$/, "");
179    const closes = (tail.match(/\)+\s*$/)?.[0].trim().length) ?? 0;
180    for (let k = 0; k < opens; k += 1) {
181      scopes.push(dir);
182    }
183    const risk = classifySegment(raw, dir, pushed);
184    if (risk !== null && risk.cd === undefined) {
185      return risk;
186    }
187    if (risk !== null) {
188      dir = risk.cd; // a cd, pushd or popd moved the folder
189    }
190    for (let k = 0; k < closes && scopes.length > 0; k += 1) {
191      dir = scopes.pop() as string | null; // a cd inside ( ... ) doesn't outlive it
192    }
193  }
194  return null;
195}
196
197// Words that can come before the real command without changing what it does.
198const PREFIXES = new Set(["command", "exec", "env", "nohup", "time", "then", "do", "else", "!"]);
199
200/** One segment: a risk, { cd } for a folder change, or null. */
201function classifySegment(segment: string, dir: string | null, pushed: (string | null)[]): any {
202  {
203    const words: any[] = tokenize(segment.trim().replace(/^[({]+\s*/, "").replace(/\s*[)}]+$/, ""));
204    while (words.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0])) {
205      words.shift(); // leading VAR=value
206    }
207    if (words[0] === "sudo") {
208      words.shift();
209      while (words.length > 0 && words[0].startsWith("-")) {
210        const option = words.shift();
211        if (SUDO_VALUE_OPTIONS.has(option)) {
212          words.shift();
213        }
214      }
215    }
216    while (words.length > 0 && (PREFIXES.has(words[0]) || /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]))) {
217      words.shift();
218    }
219    if (words[0] === "nice") {
220      words.shift();
221      if (words[0] === "-n") {
222        words.splice(0, 2);
223      } else if (/^-\d+$/.test(words[0] ?? "")) {
224        words.shift();
225      }
226    }
227    const [first, ...args] = words;
228    if (first === undefined) {
229      return null;
230    }
231    const cmd = first.replace(/^\\/, ""); // \rm skips aliases; it's still rm
232    if (cmd === "cd") {
233      return { cd: args[0] === "-" ? "-" : joinDir(dir, args[0]) };
234    }
235    if (cmd === "pushd") {
236      pushed.push(dir);
237      return { cd: joinDir(dir, args[0]) };
238    }
239    if (cmd === "popd") {
240      return { cd: pushed.length > 0 ? pushed.pop() : "-" };
241    }
242    if (cmd === "rm" || cmd.endsWith("/rm")) {
243      const flags = args.filter((a) => a.startsWith("-"));
244      const recursive = flags.some((f) => f === "--recursive" || (/^-[^-]/.test(f) && /[rR]/.test(f)));
245      const force = flags.some((f) => f === "--force" || (/^-[^-]/.test(f) && f.includes("f")));
246      if (recursive || force) {
247        const targets = args.filter((a) => !a.startsWith("-") || a === "-");
248        return { kind: "rm", label: `rm ${flags.join(" ")}`.trim(), targets, dir };
249      }
250    }
251    if (cmd === "git") {
252      // Git's own options come before the subcommand; -C moves where it runs.
253      let gitDir = dir;
254      let i = 0;
255      while (i < args.length && args[i].startsWith("-")) {
256        if (args[i] === "-C" && i + 1 < args.length) {
257          gitDir = joinDir(gitDir, args[i + 1]);
258          i += 2;
259        } else if (args[i] === "-c" && i + 1 < args.length) {
260          i += 2;
261        } else {
262          i += 1;
263        }
264      }
265      const sub = args[i];
266      const rest = args.slice(i + 1);
267      if (sub === "reset" && rest.includes("--hard")) {
268        return { kind: "git-reset", label: "git reset --hard", args: rest, dir: gitDir };
269      }
270      if (sub === "clean") {
271        return { kind: "git-clean", label: "git clean", args: rest, dir: gitDir };
272      }
273      if (sub === "push" && rest.some((a) => a === "--force" || a === "-f" || a.startsWith("--force-with-lease") || /^\+/.test(a))) {
274        return { kind: "git-push-force", label: "git push --force", args: rest, dir: gitDir };
275      }
276      const stagedOnly = sub === "restore" && rest.includes("--staged") && !rest.includes("--worktree") && !rest.includes("-W");
277      if ((sub === "checkout" || sub === "restore") && rest.includes(".") && !stagedOnly) {
278        return { kind: "git-checkout", label: `git ${sub} -- .`, args: rest, dir: gitDir };
279      }
280    }
281    const joined = words.join(" ");
282    if (/\balembic\s+upgrade\b/.test(joined)) {
283      return { kind: "migrate", tool: "alembic", label: "alembic upgrade", dir };
284    }
285    if (/\bdb:migrate(?!:status\b)/.test(joined)) {
286      return { kind: "migrate", tool: "rails", label: "db:migrate", dir };
287    }
288    if (/\bprisma\s+migrate\b/.test(joined)) {
289      return { kind: "migrate", tool: "prisma", label: "prisma migrate", dir };
290    }
291    if (/\bmanage\.py\s+migrate\b/.test(joined)) {
292      return { kind: "migrate", tool: "django", label: "manage.py migrate", dir };
293    }
294    if (!READ_ONLY.has(cmd) && args.includes("migrate")) {
295      return { kind: "migrate", tool: "unknown", label: "migrate", dir };
296    }
297  }
298  return null;
299}
300
301// Resolves a `cd` target to an absolute folder, or null if it doesn't exist.
302// The target is passed as an argument, never as source.
303const CD_SCRIPT = `unset CDPATH; d="$1"; case "$d" in "~") d="$HOME";; "~/"*) d="$HOME/\${d#\\~/}";; esac; cd -- "$d" 2>/dev/null && pwd -P`;
304
305async function resolveDir($: $, sessionCwd: string, dir: string): Promise<string | null> {
306  if (dir === "-") {
307    return null; // `cd -` depends on the shell's history
308  }
309  const run = await $.process.run(["bash", "-c", CD_SCRIPT, "blast-radius", dir], { cwd: sessionCwd, timeoutMs: 5000 });
310  const out = run.stdout.trim();
311  return run.exitCode === 0 && out !== "" ? out : null;
312}
313
314/** Splits one segment into words, honouring quotes. Good enough to read flags and paths. */
315function tokenize(text: string): string[] {
316  const words: string[] = [];
317  const re = /"((?:[^"\\]|\\.)*)"|'([^']*)'|(\S+)/g;
318  let m;
319  while ((m = re.exec(text)) !== null) {
320    words.push((m[1] ?? m[2] ?? m[3])!);
321  }
322  return words;
323}
324
325// ---- Measuring the blast radius -------------------------------------------
326
327/** { summary, lines, note } for the pane. Never throws: a failed read is said, not hidden. */
328async function measure($: $, risk: Risk, cwd: string): Promise<Report> {
329  try {
330    if (risk.kind === "rm") {
331      return await measureRm($, risk, cwd);
332    }
333    if (risk.kind === "migrate") {
334      return await measureMigrations($, risk, cwd);
335    }
336    return await measureGit($, risk, cwd);
337  } catch (error: any) {
338    return { summary: `${risk.label} (could not measure it)`, lines: [], note: `Could not measure: ${String(error?.message ?? error).slice(0, 200)}` };
339  }
340}
341
342// The paths are passed to bash as arguments, never as source, so nothing in
343// them runs. compgen -G expands a glob without command substitution.
344const RM_SCRIPT = `
345shopt -s nullglob dotglob
346paths=()
347for p in "$@"; do
348  case "$p" in "~"|"~/"*) p="$HOME\${p#\\~}";; esac
349  if [[ "$p" == *[*?[]* ]]; then
350    while IFS= read -r m; do paths+=("$m"); done < <(compgen -G "$p")
351  elif [[ -e "$p" || -L "$p" ]]; then
352    paths+=("$p")
353  fi
354done
355if (( \${#paths[@]} == 0 )); then echo "0 0 0"; exit 0; fi
356# A relative path gets ./ in front, so find never reads a name like -delete as an action.
357for i in "\${!paths[@]}"; do case "\${paths[$i]}" in /*) ;; *) paths[$i]="./\${paths[$i]}";; esac; done
358files=$(find "\${paths[@]}" \\( -type f -o -type l \\) 2>/dev/null | wc -l | tr -d ' ')
359kb=$(du -skc "\${paths[@]}" 2>/dev/null | tail -n1 | cut -f1)
360echo "$files $(( \${kb:-0} * 1024 )) \${#paths[@]}"
361find "\${paths[@]}" \\( -type f -o -type l \\) 2>/dev/null | head -n ${LIST_MAX}
362`;
363
364async function measureRm($: $, risk: any, cwd: string): Promise<Report> {
365  if (risk.targets.length === 0) {
366    return { summary: "rm with no paths", lines: [], note: "No paths to expand." };
367  }
368  const run = await $.process.run(["bash", "-c", RM_SCRIPT, "blast-radius", ...risk.targets], { cwd, timeoutMs: 15000 });
369  const [head, ...rest] = run.stdout.split("\n").filter((l) => l !== "");
370  const [files, bytes, found] = (head ?? "0 0 0").split(" ").map(Number);
371  if (!found) {
372    return { summary: `delete nothing: no file matches ${risk.targets.join(" ")}`, lines: [], note: "The paths don't exist, so rm has nothing to remove." };
373  }
374  if (!files) {
375    return { summary: `delete ${found} ${found === 1 ? "path" : "paths"} with no files in ${found === 1 ? "it" : "them"}`, lines: [], note: `Paths: ${risk.targets.join(" ")}` };
376  }
377  return {
378    summary: `delete ${files} ${files === 1 ? "file" : "files"} (about ${size(bytes as number)})`,
379    lines: rest.map((l) => l.replace(/^\.\//, "")),
380    more: Math.max(0, files - rest.length),
381    note: `Paths: ${risk.targets.join(" ")}`,
382  };
383}
384
385async function measureGit($: $, risk: any, cwd: string): Promise<Report> {
386  if (risk.kind === "git-push-force") {
387    return await measurePush($, risk, cwd);
388  }
389  if (risk.kind === "git-clean") {
390    const flags = [];
391    const paths = [];
392    for (let i = 0; i < risk.args.length; i += 1) {
393      const a = risk.args[i];
394      if (a === "--") {
395        paths.push(...risk.args.slice(i + 1));
396        break;
397      }
398      if (a === "-e" || a === "--exclude") {
399        flags.push(a, risk.args[i + 1] ?? "");
400        i += 1;
401      } else if (a.startsWith("--exclude=") || /^-e./.test(a)) {
402        flags.push(a);
403      } else if (/^-[a-zA-Z]+$/.test(a)) {
404        const kept = a.replace(/[finq]/g, ""); // -n is added below; -f, -i and -q would change the dry run
405        if (kept !== "-") {
406          flags.push(kept);
407        }
408      } else if (!a.startsWith("-")) {
409        paths.push(a);
410      }
411    }
412    const run = await $.process.run(["git", "clean", "-n", ...flags, "--", ...paths], { cwd, timeoutMs: 15000 });
413    if (run.exitCode !== 0) {
414      return { summary: "git clean (could not dry-run it)", lines: [], note: run.stderr.trim().slice(0, 200) };
415    }
416    const gone = run.stdout.split("\n").filter((l) => l.startsWith("Would remove ")).map((l) => l.slice(13));
417    return {
418      summary: gone.length === 0 ? "remove nothing: no untracked files match" : `remove ${gone.length} untracked ${gone.length === 1 ? "path" : "paths"}`,
419      lines: gone.slice(0, LIST_MAX),
420      more: Math.max(0, gone.length - LIST_MAX),
421      note: "From git clean -n. Untracked files are not in git, so they can't be recovered.",
422    };
423  }
424  const status = await $.process.run(["git", "status", "--porcelain"], { cwd, timeoutMs: 15000 });
425  if (status.exitCode !== 0) {
426    return { summary: `${risk.label} (not a git repo here?)`, lines: [], note: status.stderr.trim().slice(0, 200) };
427  }
428  const rows = status.stdout.split("\n").filter((l) => l.length > 3 && !l.startsWith("??"));
429  // reset --hard drops staged and unstaged changes; checkout -- . drops unstaged ones.
430  const lost = risk.kind === "git-reset" ? rows : rows.filter((l) => l[1] !== " ");
431  const stat = await $.process.run(["git", "diff", "--shortstat", risk.kind === "git-reset" ? "HEAD" : "--"], { cwd, timeoutMs: 15000 });
432  return {
433    summary: lost.length === 0 ? "discard nothing: no uncommitted changes" : `discard uncommitted changes in ${lost.length} ${lost.length === 1 ? "file" : "files"}`,
434    lines: lost.slice(0, LIST_MAX).map((l) => `${l.slice(0, 2)} ${l.slice(3)}`),
435    more: Math.max(0, lost.length - LIST_MAX),
436    note: stat.stdout.trim() !== "" ? `${stat.stdout.trim()}. Uncommitted changes can't be recovered.` : "From git status --porcelain.",
437  };
438}
439
440async function measurePush($: $, risk: any, cwd: string): Promise<Report> {
441  const positional = risk.args.filter((a: string) => !a.startsWith("-"));
442  const remote = positional[0] ?? "origin";
443  // A refspec is src:dst. With no colon, the local branch of the same name is pushed.
444  const spec = (positional[1] ?? "").replace(/^\+/, "");
445  let [source, branch] = spec.includes(":") ? spec.split(":") : [spec, spec];
446  branch = (branch ?? "").replace(/^refs\/heads\//, "");
447  if (!branch) {
448    const head = await $.process.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], { cwd, timeoutMs: 10000 });
449    branch = head.stdout.trim();
450    source = "HEAD";
451  } else if (branch === "HEAD") {
452    // `git push origin HEAD` pushes the current branch to its namesake.
453    const head = await $.process.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], { cwd, timeoutMs: 10000 });
454    branch = head.stdout.trim();
455    source = "HEAD";
456  }
457  source = source || "HEAD";
458  const ref = `${remote}/${branch}`;
459  const known = await $.process.run(["git", "rev-parse", "--verify", "--quiet", ref], { cwd, timeoutMs: 10000 });
460  if (known.exitCode !== 0) {
461    return { summary: `force-push to ${ref}`, lines: [], note: `No local copy of ${ref}, so I can't tell which commits the push would drop. Run git fetch first.` };
462  }
463  const log = await $.process.run(["git", "log", "--oneline", "--no-decorate", `${source}..${ref}`], { cwd, timeoutMs: 15000 });
464  const dropped = log.stdout.split("\n").filter((l) => l !== "");
465  return {
466    summary: dropped.length === 0 ? `force-push to ${ref}: drops no commits` : `force-push to ${ref}: drops ${dropped.length} ${dropped.length === 1 ? "commit" : "commits"}`,
467    lines: dropped.slice(0, LIST_MAX),
468    more: Math.max(0, dropped.length - LIST_MAX),
469    note: `Commits on ${ref} that ${source} doesn't have, as of the last fetch.`,
470  };
471}
472
473const MIGRATION_LISTERS: Record<string, { argv: string[]; pending: (l: string) => boolean; strip: (l: string) => string }> = {
474  django: { argv: ["python3", "manage.py", "showmigrations", "--plan"], pending: (l) => l.startsWith("[ ]"), strip: (l) => l.slice(4) },
475  alembic: { argv: ["alembic", "history", "-r", "current:head"], pending: (l) => l.includes("->"), strip: (l) => l },
476  rails: { argv: ["bin/rails", "db:migrate:status"], pending: (l) => /^\s*down\b/.test(l), strip: (l) => l.trim() },
477  prisma: { argv: ["npx", "--no-install", "prisma", "migrate", "status"], pending: (l) => /^\s{2}\S/.test(l), strip: (l) => l.trim() },
478};
479
480async function measureMigrations($: $, risk: any, cwd: string): Promise<Report> {
481  const lister = MIGRATION_LISTERS[risk.tool];
482  if (lister === undefined) {
483    return { summary: "run migrations", lines: [], note: "I can't list the pending migrations for this tool, so the list is not shown." };
484  }
485  let run: { exitCode: number; stdout: string; stderr: string };
486  try {
487    run = await $.process.run(lister.argv, { cwd, timeoutMs: 20000 });
488  } catch (error: any) {
489    run = { exitCode: -1, stdout: "", stderr: String(error?.message ?? error) };
490  }
491  if (run.exitCode !== 0) {
492    return { summary: `run ${risk.label}`, lines: [], note: `Couldn't list pending migrations (${lister.argv.join(" ")} failed).` };
493  }
494  const pending = run.stdout.split("\n").filter(lister.pending).map(lister.strip);
495  return {
496    summary: pending.length === 0 ? `run ${risk.label}: nothing pending` : `apply ${pending.length} pending ${pending.length === 1 ? "migration" : "migrations"}`,
497    lines: pending.slice(0, LIST_MAX),
498    more: Math.max(0, pending.length - LIST_MAX),
499    note: `From ${lister.argv.join(" ")}.`,
500  };
501}
502
503function size(bytes: number) {
504  if (!Number.isFinite(bytes) || bytes < 1024) {
505    return `${bytes || 0} B`;
506  }
507  const units = ["KB", "MB", "GB", "TB"];
508  let n = bytes;
509  let i = -1;
510  while (n >= 1024 && i < units.length - 1) {
511    n /= 1024;
512    i += 1;
513  }
514  return `${n.toFixed(n < 10 ? 1 : 0)} ${units[i]}`;
515}
516
517// ---- Drawing --------------------------------------------------------------
518
519// The drawing itself is in view.tsx.
520
521function paneRows(report: Report) {
522  return Math.min(24, 9 + report.lines.length + (report.more ? 1 : 0));
523}
524

1// Copyright 2026 Anthropic PBC
2// SPDX-License-Identifier: Apache-2.0
3//
4// Modified in the awesome-claude fork (2026): this file is new. It holds
5// `renderTerminal`, upstream's `draw()` from blast-radius.mjs redrawn with the
6// kit's terminal components (same border, report and buttons), and
7// `renderApp`, a desktop drawing of the same report built with the kit.
8
9import type { Elements, RenderElement } from 'claude-code'
10
11import { C, GRAY } from '@kit/tokens'
12import { EDGE, SPACE, TERM_ROLES, kit } from '@kit/ui'
13import type { FlowSwitch } from '@kit/ui'
14
15/** What a risky command is, from the classifier. */
16export type Risk = {
17  kind: 'rm' | 'git-reset' | 'git-clean' | 'git-push-force' | 'git-checkout' | 'migrate'
18  label: string
19  dir: string | null
20  targets?: string[]
21  args?: string[]
22  tool?: string
23}
24
25/** What the command would change, as measured: { summary, lines, more, note }. */
26export type Report = { summary: string; lines: string[]; more?: number; note?: string }
27
28/** The call being held, which the buttons answer. */
29export type Held = {
30  command: string
31  risk: Risk
32  report: Report | null
33  decision: string | null
34  where: 'pane' | 'band'
35}
36
37export type AppElements = Pick<Elements['desktop'], 'Box' | 'Text' | 'Button' | 'Svg'> & Partial<Pick<Elements['desktop'], 'Code'>>
38
39/** The buttons answer the call this drawing was made for, never whichever one is held now. */
40const decider = (state: Held) => (choice: string) => () => {
41  if (state.decision === null) {
42    state.decision = choice
43  }
44}
45
46/** The line beside the buttons, drawn on the terminal only where it fits whole. */
47const HINT = 'Claude is waiting on your answer'
48/** Who's asking, in the band. */
49const WHO = 'Blast Radius'
50
51/**
52 * The terminal, in the pane or the band: the desktop's report in cells, inside
53 * the one round border in the warning colour (the band that has to stop the person).
54 * The command is the one bold thing; what it would do and the list under it are
55 * quiet; each fact is said once (no label that restates the command, no key hints
56 * that restate the buttons' hotkeys, no "Paths:" note that restates its paths):
57 *
58 *   ╭──────────────────────────────────────────────╮
59 *   │ ▲ rm -rf build                  Blast Radius │   (bold command; who, in the band only)
60 *   │                                              │
61 *   │ Would delete 1284 files (about 46 MB)        │   (Would dim)
62 *   │                                              │
63 *   │ □ build/index.html                           │   (dim)
64 *   │   + 1274 more                                │
65 *   │                                              │
66 *   │ Claude is waiting on…  1: Proceed  2: Cancel │   (Proceed red; Cancel focused)
67 *   ╰──────────────────────────────────────────────╯
68 *
69 * `rows` is how many rows the band or pane has: the list is cut to fit it, so
70 * the actions always show.
71 */
72export function renderTerminal(t: any, state: Held, columns = 40, opts: { band?: boolean; focused?: boolean; rows?: number } = {}): RenderElement {
73  const { Box, Text } = t
74  // Inside the border and its one-cell padding: four cells fewer than the pane's body.
75  const inner = Math.max(1, Math.floor(columns) - 4)
76  // The kit takes the pane's columns and leaves its 2-cell gutter off them, so `k.width` is the inside.
77  // The band has no focus prop; left out, it counts as focused.
78  const k = kit({ Box, Text, Button: t.Button }, 'terminal', inner + 2, { focused: opts.focused })
79  const report = state.report!
80  const { kind } = state.risk
81  const decide = decider(state)
82
83  // A note that only lists the command's own paths says nothing the head doesn't.
84  const note = report.note && !restates(report.note, state.command) ? report.note : null
85  const noteRows = note ? ([...note].length > inner ? 2 : 1) : 0
86
87  // Border 2, head 1, blank 1, Would 1, blank 1 above the list, blank 1 and the actions 1: 8 rows besides the list and note.
88  const room = opts.rows ? Math.max(0, Math.floor(opts.rows) - 8 - noteRows) : Infinity
89  let shown = report.lines.length
90  let more = report.more ?? 0
91  if (shown + (more ? 1 : 0) > room) {
92    // One row goes to `+ N more`.
93    shown = Math.max(0, Math.min(shown, room - 1))
94    more += report.lines.length - shown
95  }
96  const lines = report.lines.slice(0, shown).map((line, i) => {
97    const it = item(kind, line)
98    const right = [it.before, it.after].filter((x): x is string => Boolean(x))
99    // Files and folders are paths: cut in the middle, so the name at the end stays.
100    return k.item(`l${i}`, { lead: it.icon, text: it.text, right, dim: true, path: it.icon === 'file' || it.icon === 'folder' })
101  })
102  if (more && room > 0) lines.push(k.item('more', { text: `+ ${more} more`, dim: true, indent: 2 }))
103
104  // Proceed runs the command: red, as on the desktop. Cancel holds the focus, so Enter refuses, as upstream.
105  const buttons = k.actions('actions', [
106    { key: 'proceed', label: 'Proceed', hotkey: '1', tone: 'danger', onPress: decide('proceed') },
107    { key: 'cancel', label: 'Cancel', hotkey: '2', autoFocus: true, onPress: decide('cancel') },
108  ])
109  // `1: Proceed  2: Cancel` is 21 cells; the hint shows only when it fits beside them whole.
110  const hint = inner >= 21 + k.space.group + HINT.length
111  // The band names the mod (the pane's title does that), right of the command when the whole command fits beside it: lead 2, the command, 1, the name.
112  const who = opts.band && 2 + [...state.command].length + k.space.item + WHO.length <= inner
113
114  return (
115    <Box flexDirection="column" width="100%" minWidth={0} borderStyle="round" borderColor={k.ink(C.warn).color} paddingX={1}>
116      {/* The command is the head: the one strong thing. Who's asking shows only beside the whole command. */}
117      {k.item('head', { lead: 'alert', leadColor: C.warn, text: state.command, bold: true, right: who ? [WHO] : [] })}
118      {/* One sentence, `Would delete 8 files`, rather than a label column: it keeps 6 more cells for the summary at 40 columns. */}
119      <Box key="sum" flexDirection="row" gap={k.space.pair} minWidth={0} marginTop={k.space.block}>
120        <Box flexShrink={0}>
121          <Text {...TERM_ROLES.label}>Would</Text>
122        </Box>
123        <Box minWidth={0} flexShrink={1}>
124          <Text wrap="truncate">{report.summary}</Text>
125        </Box>
126      </Box>
127      {lines.length || note ? (
128        <Box key="list" flexDirection="column" minWidth={0} marginTop={k.space.block}>
129          {lines}
130          {/* A long note (why it couldn't measure) gets two lines before it's cut. */}
131          {note ? k.note('note', note, 'empty', { lines: 2 }) : null}
132        </Box>
133      ) : null}
134      <Box key="buttons" flexDirection="row" justifyContent={hint ? 'space-between' : 'flex-end'} gap={k.space.group} minWidth={0} marginTop={k.space.block}>
135        {hint ? (
136          <Box key="hint" flexShrink={1} minWidth={0}>
137            <Text dimColor wrap="truncate">
138              {HINT}
139            </Text>
140          </Box>
141        ) : null}
142        {buttons}
143      </Box>
144    </Box>
145  )
146}
147
148/** Whether a note only lists paths the command already shows (`Paths: build`). */
149const restates = (note: string, command: string) => {
150  const paths = /^Paths: (.+)$/.exec(note)?.[1]
151  return paths !== undefined && paths.split(' ').every(p => command.includes(p))
152}
153
154/** The icon beside the summary: what kind of loss it is. */
155const SUMMARY_ICON: Record<Risk['kind'], string> = {
156  rm: 'trash',
157  'git-clean': 'trash',
158  'git-reset': 'trash',
159  'git-checkout': 'trash',
160  'git-push-force': 'repo-push',
161  migrate: 'arrow-up',
162}
163
164/** A summary that says nothing would be lost isn't drawn in red. */
165export const harmless = (summary: string) => /\bnothing\b|drops no commits/.test(summary)
166
167/** One listed line, split for the desktop: its icon, a grey mark before the text, the text, a grey mark after. */
168const item = (kind: Risk['kind'], line: string): { icon: string; before?: string; text: string; after?: string } => {
169  if (kind === 'git-push-force') {
170    const space = line.indexOf(' ')
171    return space > 0 ? { icon: 'git-commit', before: line.slice(0, space), text: line.slice(space + 1) } : { icon: 'git-commit', text: line }
172  }
173  if (kind === 'git-reset' || kind === 'git-checkout') {
174    // `XY path`, as the terminal shows it: the status letters go to the right.
175    return { icon: 'file', text: line.slice(3), after: line.slice(0, 2).trim() }
176  }
177  if (kind === 'migrate') return { icon: 'arrow-up', text: line }
178  return { icon: line.endsWith('/') ? 'folder' : 'file', text: line }
179}
180
181/**
182 * The app surfaces (desktop, VS Code, mobile), in the band or a pane:
183 *
184 *   [alert] rm -rf                                  (Blast Radius, in the band)
185 *   rm -rf build                                    (the command, as code)
186 *   [trash] delete 1284 files (about 46 MB)         (red)
187 *   [file]  build/index.html
188 *           + 1274 more
189 *   Paths: build                                    (grey)
190 *   [Proceed] [Cancel]  Claude is waiting on your answer
191 */
192export const renderApp = (els: AppElements, state: Held, columns: number, opts: { band?: boolean; flow?: FlowSwitch } = {}): RenderElement => {
193  const { Box, Text, Button, Code } = els
194  const k = kit(els, 'desktop', columns, { flow: opts.flow })
195  const report = state.report!
196  const { kind } = state.risk
197  const decide = decider(state)
198
199  // Every line starts with the same icon column, so text starts at one x.
200  const lead = (icon: RenderElement | null) => (
201    <Box key="lead" width={2} flexShrink={0} flexDirection="row" alignItems="center">
202      {icon}
203    </Box>
204  )
205  const row = (key: string, l: (RenderElement | null)[], r: (RenderElement | null)[] = [], marginTop = 0) => (
206    <Box key={key} flexDirection="row" justifyContent="space-between" gap={SPACE.item} width="100%" minWidth={0} marginTop={marginTop}>
207      <Box flexDirection="row" alignItems="center" flexShrink={1} minWidth={0} overflow="hidden">
208        {l}
209      </Box>
210      {r.length ? (
211        <Box flexDirection="row" alignItems="center" gap={SPACE.item} flexShrink={0}>
212          {r}
213        </Box>
214      ) : null}
215    </Box>
216  )
217
218  const loss = harmless(report.summary) ? undefined : C.bad
219  const lines = report.lines.map((line, i) => {
220    const it = item(kind, line)
221    return row(
222      `l${i}`,
223      [
224        lead(k.icon(it.icon, GRAY.dark)),
225        it.before ? (
226          <Box key="b" flexShrink={0} marginRight={SPACE.pair}>
227            <Text color={GRAY.mid}>{it.before}</Text>
228          </Box>
229        ) : null,
230        <Text key="t" wrap="truncate">
231          {it.text}
232        </Text>,
233      ],
234      it.after ? [<Text key="a" color={GRAY.mid}>{it.after}</Text>] : [],
235    )
236  })
237
238  // The column view's switch, on a pane wide enough for columns: a footer band across the pane, under the body's edges.
239  const footer = k.footer()
240  const page = (
241    <Box key="page" flexDirection="column" width="100%" minWidth={0} paddingLeft={EDGE.left} paddingRight={EDGE.right} marginTop={1}>
242      {row(
243        'head',
244        [
245          lead(k.icon('alert', C.warn)),
246          <Text key="t" bold wrap="truncate">
247            {state.risk.label}
248          </Text>,
249        ],
250        opts.band ? [<Text key="who" color={GRAY.dark}>Blast Radius</Text>] : [],
251      )}
252      <Box key="cmd" width="100%" minWidth={0} marginTop={SPACE.block}>
253        {Code ? (
254          <Code source={state.command} language="bash" wrap="truncate-end" />
255        ) : (
256          <Text wrap="truncate">{state.command}</Text>
257        )}
258      </Box>
259      {row(
260        'sum',
261        [
262          lead(k.icon(SUMMARY_ICON[kind], loss ?? GRAY.dark)),
263          <Text key="t" color={loss} wrap="truncate">
264            {report.summary}
265          </Text>,
266        ],
267        [],
268        SPACE.block,
269      )}
270      {lines.length || report.more ? (
271        <Box key="list" flexDirection="column" width="100%" minWidth={0} marginTop={SPACE.block / 2}>
272          {/* In columns when the pane is wide (each line whole, read down then across); one stack otherwise. */}
273          {k.flow('lines', lines)}
274          {report.more
275            ? row('more', [
276                lead(null),
277                <Text key="t" color={GRAY.mid} wrap="truncate">
278                  {`+ ${report.more} more`}
279                </Text>,
280              ])
281            : null}
282        </Box>
283      ) : null}
284      {report.note ? (
285        <Box key="note" width="100%" minWidth={0} marginTop={SPACE.block}>
286          <Text color={GRAY.mid} wrap="wrap">
287            {report.note}
288          </Text>
289        </Box>
290      ) : null}
291      <Box key="buttons" flexDirection="row" alignItems="center" gap={SPACE.item} width="100%" minWidth={0} marginTop={SPACE.block * 1.5}>
292        {/* Proceed runs the command: its label in red, the colour of what it would destroy.
293            The kit's danger action, as the desktop draws no coloured Text inside a Button. */}
294        {k.action({ key: 'proceed', label: 'Proceed', hotkey: '1', tone: 'danger', onPress: decide('proceed') })}
295        {/* Cancel is the main button and holds the focus, so Enter refuses. */}
296        <Button key="cancel" label="Cancel" hotkey="2" variant="primary" autoFocus onPress={decide('cancel')} />
297        <Box key="hint" flexShrink={1} minWidth={0}>
298          <Text color={GRAY.mid} wrap="truncate">
299            Claude is waiting on your answer
300          </Text>
301        </Box>
302      </Box>
303    </Box>
304  )
305  return footer ? (
306    <Box flexDirection="column" width="100%" minWidth={0}>
307      {page}
308      {footer}
309    </Box>
310  ) : (
311    page
312  )
313}
314

1// The state contract: what blast-radius keeps in `$.state`. The held call itself
2// lives in the hooks module; only the person's view setting is state.
3
4/** Whether a wide app pane flows the report's lines into columns (the footer's switch); on until flipped. */
5export type ColumnsView = boolean
6
7declare module 'claude-code' {
8  interface PluginState {
9    'blast-radius': {
10      columns: ColumnsView
11    }
12  }
13}
14