blast-radius

1// Blast Radius: hold a risky Bash command, show what it would change, and let the person decide.
2
3const PANE = "blast-radius";
4const MAX_LINES = 12;
5const SHELL_BREAK = /^(?:;|&&|\|\||\||&|>|>>|<)$/;
6
7// The call being held, if any. Module state is fine here: a hold never outlives the hook call.
8let held = null;
9
10export function register(on) {
11  on("tool.call", { tool: "Bash" }, async ($, e, next) => {
12    const risk = classify(String(e.command ?? ""));
13    if (risk === null) return next(e); // everything else runs as normal
14
15    // One hold at a time; a second risky call waits for the first decision.
16    while (held !== null && !next.signal.aborted) await $.process.run(["sleep", "0.25"]);
17    if (next.signal.aborted) return { deny: "Blast Radius: the turn was interrupted before this command was reviewed." };
18
19    const report = await measure($, risk, await $.session.cwd());
20    const call = { command: String(e.command), risk, report, decision: null, where: "pane" };
21    held = call;
22    try {
23      const opened = await $.ui.open({ id: PANE, title: "Blast Radius", focus: true });
24      if (!opened.isPlaced) call.where = "band"; // too narrow for a pane: draw above the prompt
25      $.ui.invalidate("ui.render");
26      while (call.decision === null && !next.signal.aborted) {
27        await $.process.run(["sleep", "0.25"]); // time inside $ calls doesn't count against the hook's time limit
28      }
29    } finally {
30      held = null;
31      await $.ui.close({ id: PANE });
32      $.ui.invalidate("ui.render");
33    }
34    if (call.decision === "proceed") return next(e); // let it run
35    const why = call.decision === "cancel" ? "the user pressed Cancel" : "the turn was interrupted";
36    return { deny: `Blast Radius held this command: ${why}. It would have: ${report.summary}.` };
37  });
38
39  on("ui.render", { component: "Pane", requestId: PANE }, ($, e, next) => {
40    if (held === null || held.where !== "pane") return next(e);
41    const { Box, Text, Button } = $.ui.resolve(e);
42    return card(Box, Text, Button, held, { columns: e.props.bodyColumns });
43  });
44
45  on("ui.render", { component: "AbovePrompt" }, ($, e, next) => {
46    if (held === null || held.where !== "band" || e.props.hasSurvey) return next(e);
47    const { Box, Text, Button } = $.ui.resolve(e);
48    return card(Box, Text, Button, held, { columns: e.props.bodyColumns, border: true });
49  });
50}
51
52function decide(call, decision) {
53  return () => {
54    if (call.decision === null) call.decision = decision;
55  };
56}
57
58function card(Box, Text, Button, call, { columns, border = false }) {
59  const width = Math.max(20, (columns ?? 80) - 4);
60  return Box({
61    flexDirection: "column",
62    paddingX: 1,
63    ...(border ? { borderStyle: "round", borderColor: "yellow" } : {}),
64    children: [
65      Text({ color: "yellow", bold: true, children: `⚠  ${call.risk.label}` }),
66      Text({ children: clip(`$ ${call.command}`, width) }),
67      Text({ children: `It would ${call.report.summary}.` }),
68      ...call.report.lines.map((line) => Text({ dimColor: true, children: clip(`  ${line}`, width) })),
69      Box({
70        flexDirection: "row",
71        gap: 2,
72        children: [
73          Button({ key: "proceed", label: "Proceed", hotkey: "1", onPress: decide(call, "proceed") }),
74          Button({ key: "cancel", label: "Cancel", hotkey: "2", onPress: decide(call, "cancel") }),
75        ],
76      }),
77    ],
78  });
79}
80
81function classify(command) {
82  const words = command.trim().split(/\s+/);
83  for (let i = 0; i < words.length; i += 1) {
84    const at = i === 0 || SHELL_BREAK.test(words[i - 1]) ? words[i] : null;
85    if (at === "rm") {
86      const args = untilBreak(words, i + 1);
87      const flags = args.filter((a) => a.startsWith("-") && a !== "--");
88      if (flags.some((f) => /^-[a-zA-Z]*[rR]/.test(f) || f === "--recursive")) {
89        return { kind: "remove", label: "rm -r", targets: args.filter((a) => !a.startsWith("-")) };
90      }
91    }
92    if (at === "git") {
93      const args = untilBreak(words, i + 1);
94      const sub = args.find((a) => !a.startsWith("-"));
95      if (sub === "reset" && args.includes("--hard")) return { kind: "reset", label: "git reset --hard", targets: [] };
96      if (sub === "clean") return { kind: "clean", label: "git clean", targets: args.filter((a) => /^-[a-zA-Z]*[dx]/.test(a)) };
97      if (sub === "push" && args.some((a) => a === "-f" || a.startsWith("--force"))) {
98        return { kind: "force-push", label: "git push --force", targets: [] };
99      }
100    }
101  }
102  if (/\b(?:manage\.py\s+migrate|rails\s+db:migrate|rake\s+db:migrate|prisma\s+migrate\s+deploy|alembic\s+upgrade)\b/.test(command)) {
103    return { kind: "migrate", label: "database migration", targets: [] };
104  }
105  return null;
106}
107
108function untilBreak(words, from) {
109  const out = [];
110  for (let i = from; i < words.length && !SHELL_BREAK.test(words[i]); i += 1) out.push(words[i]);
111  return out;
112}
113
114// Each report comes from the tools' own dry runs. Arguments go in as an argv array,
115// so nothing in a path is run as shell code.
116async function measure($, risk, cwd) {
117  const run = (argv) => $.process.run(argv, { cwd });
118  if (risk.kind === "remove") {
119    const files = [];
120    for (const target of risk.targets) {
121      const found = await run(["find", target, "-type", "f"]);
122      if (found.exitCode === 0) files.push(...lines(found.stdout));
123    }
124    return report(`delete ${files.length} file${files.length === 1 ? "" : "s"} under ${risk.targets.join(" ") || "nothing"}`, files);
125  }
126  if (risk.kind === "reset") {
127    const status = await run(["git", "status", "--porcelain"]);
128    const changed = lines(status.stdout).filter((l) => !l.startsWith("??"));
129    return report(`discard uncommitted changes in ${changed.length} file${changed.length === 1 ? "" : "s"}`, changed);
130  }
131  if (risk.kind === "clean") {
132    const flags = risk.targets.join("").replace(/[^dx]/g, "");
133    const dry = await run(["git", "clean", `-n${flags}`]);
134    const paths = lines(dry.stdout).map((l) => l.replace(/^Would remove /, ""));
135    return report(`remove ${paths.length} untracked path${paths.length === 1 ? "" : "s"}`, paths);
136  }
137  if (risk.kind === "force-push") {
138    const log = await run(["git", "log", "--oneline", "HEAD..@{upstream}"]);
139    const commits = log.exitCode === 0 ? lines(log.stdout) : [];
140    return report(`overwrite ${commits.length} commit${commits.length === 1 ? "" : "s"} on the remote`, commits);
141  }
142  return report("run database migrations, which have no dry run here", []);
143}
144
145function report(summary, all) {
146  const shown = all.slice(0, MAX_LINES);
147  if (all.length > shown.length) shown.push(`… and ${all.length - shown.length} more`);
148  return { summary, lines: shown };
149}
150
151function lines(text) {
152  return String(text ?? "").split("\n").map((l) => l.trimEnd()).filter(Boolean);
153}
154
155function clip(text, width) {
156  return text.length > width ? `${text.slice(0, width - 1)}…` : text;
157}
158

1export type BlastRiskKind = "remove" | "reset" | "clean" | "force-push" | "migrate";
2
3export type BlastRisk = { kind: BlastRiskKind; label: string; targets: string[] };
4
5export type BlastReport = { summary: string; lines: string[] };
6