backstep 0.1.29 → 0.1.30

package/dist/setup.js

@@ -76,6 +76,15 @@ export async function setup() {
     const cli = join(root, "dist", "cli.js");
     // Without `backstep` on the PATH, the commands printed below go through npx.
     const bs = onPath ? "backstep" : "npx -y backstep";
+    // Only a problem is worth a line here; the summary below says the rest.
+    const bound = ensureUndoKey();
+    if (bound)
+        console.log(`  ${white("!")} ${bound}`);
+    // Servers point at the copy just put in place, which is whole by now.
+    autoWrap(true);
+    wrapServers(cli);
+    // The mod last: installing it makes Claude Code reload Backstep there, which
+    // ends the code that ran this update, so everything else is done first.
     const install = () => run("claude", ["plugin", "install", "backstep", "--marketplace", join(root, "mod"), "--config", `cli=${cli}`]);
     let r = install();
     // Installed before from another copy (the file a person was given, or ~/.backstep before npm worked):
@@ -90,19 +99,14 @@ export async function setup() {
     // was; re-reading the folder and updating brings the mod up to this version.
     run("claude", ["plugin", "marketplace", "update", "backstep"]);
     run("claude", ["plugin", "update", "backstep@backstep"]);
-    // Only a problem is worth a line here; the summary below says the rest.
-    const bound = ensureUndoKey();
-    if (bound)
-        console.log(`  ${white("!")} ${bound}`);
-    // Wrap last, so a failed install never leaves servers pointing at a Backstep that isn't there.
-    autoWrap(true);
-    wrapServers(cli);
     // What's covered and what isn't, said once here and kept up to date by `backstep status`.
     const key = (undoKeys().length ? undoKeys() : defaultKeys()).map(keyLabel).join(" or ");
     console.log(`\n  ${pink("✓")} ${white("Backstep is ready.")} Restart Claude Code, then press ${white(key)} after any turn to undo it.`);
     console.log(dim(`    Want a different key? Just ask Claude: "change my Backstep undo key to ctrl+q"`));
     console.log(dim(`    To remove Backstep, type /uninstall-backstep in Claude Code, or ask Claude to uninstall it.`));
-    printCheck(check(process.cwd()), bs);
+    // An update runs this out of sight, so the summary (a few seconds of checks) is skipped there.
+    if (process.env.BACKSTEP_UPDATING !== "1")
+        printCheck(check(process.cwd()), bs);
     if (telemetryOn()) {
         console.log(dim("  Sends an anonymous install count. Turn it off with BACKSTEP_TELEMETRY=0.\n"));
         await sendInstall();

package/dist/update.js

@@ -80,7 +80,7 @@ export function runUpdate(v, tries = 4) {
         const r = spawnSync("npx", ["-y", "--prefer-online", `backstep@${v}`, "setup"], {
             encoding: "utf8",
             timeout: 5 * 60 * 1000,
-            env: { ...process.env, NO_COLOR: "1", BACKSTEP_TELEMETRY: "0" },
+            env: { ...process.env, NO_COLOR: "1", BACKSTEP_TELEMETRY: "0", BACKSTEP_UPDATING: "1" },
             stdio: ["ignore", "pipe", "pipe"],
             cwd: tmpdir(),
         });

package/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Press ctrl+z to rewind everything Claude did in its last turn: file edits, shell commands, and database and tool changes.",
   "types": "./types/index.d.ts",
   "userConfig": {

package/mod/hooks/register.test.tsx

@@ -271,7 +271,8 @@ test('servers added since setup are wrapped as a session starts', { options: { c
 
 // A claude.ai connector: Backstep can't sit in front of it, so the mod reports
 // the call and, on undo, runs the rule's opposite call through Claude Code.
-function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean; undo?: object }) {
+function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean; mcpThrows?: string; undo?: object }) {
+  const prompts: string[] = []
   const runs: { argv: string[]; stdin?: string }[] = []
   const calls: { server: string; tool: string; args: Record<string, unknown> }[] = []
   const ran: Record<string, unknown>[] = []
@@ -295,6 +296,7 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
   })
   on('mcp.call', (_, e) => {
+    if (opts.mcpThrows) return { value: { content: [{ type: 'text', text: opts.mcpThrows }], isError: true } }
     calls.push({ server: e.server, tool: e.tool, args: e.args })
     if (e.tool === 'notion-fetch') return { value: { content: [{ type: 'text', text: `page ${String(e.args.id)} as it was` }], isError: false } }
     return { value: { content: [{ type: 'text', text: opts.mcpFails ? 'no such page' : 'archived' }], isError: opts.mcpFails === true } }
@@ -303,12 +305,15 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     ran.push({ ...e })
     return { result: { content: [{ type: 'text', text: '{"id":"p1"}' }] }, text: '{"id":"p1"}' }
   })
-  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('prompt.submit', (_, e) => {
+    prompts.push(e.text)
+    return { text: e.text, context: e.context }
+  })
   on('ui.render', ($, e) => {
     const { Text } = $.ui.resolve(e)
     return <Text>engine</Text>
   })
-  return { runs, calls, ran, toasts }
+  return { runs, calls, ran, toasts, prompts }
 }
 
 test('a connector call with an undo rule is undone through Claude Code', { options: { cli: CLI } }, async ($, on) => {
@@ -1251,3 +1256,102 @@ test('dismissing the question about changed files undoes nothing', { options: {
   expect(await ui.find({ type: 'Text', text: /Rewinding|Rewound/ })).toBeFalsy()
   await ui.unmount()
 })
+
+test('an update that reloads the mod partway is finished by the reloaded mod: it says done and takes the warning down', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  let started = false
+  const logs: string[] = []
+  const statuses: (string | undefined)[] = []
+  on('process.run', (_, e) => {
+    const argv = [...e.argv]
+    // The update itself never answers: installing it reloaded the mod that was waiting on it.
+    if (argv.includes('update') && argv.includes('--json')) {
+      started = true
+      return new Promise(() => {})
+    }
+    const stdout = argv.includes('update-check')
+      ? JSON.stringify({ current: started ? '0.2.0' : '0.1.2', latest: '0.2.0', available: !started })
+      : argv.includes('status')
+        ? JSON.stringify({ items: [], suggest: [] })
+        : '[]'
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('ui.status', (_, e) => {
+    statuses.push(e.text)
+    return { value: undefined }
+  })
+  on('tool.register', (_, e) => ({ value: { tool: `mcp__backstep__${e.name}` } }))
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    return { result: { questions, answers: { [questions[0].question]: 'Update' } } }
+  })
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('tool.call', () => ({ result: {} }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+
+  void $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  for (let i = 0; i < 10 && !started; i++) {
+    await settle()
+    await clock.advance(1000)
+  }
+  expect(started).toBe(true)
+  expect(statuses.at(-1)).toContain("don't close this terminal")
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  for (let i = 0; i < 5; i++) {
+    await clock.advance(5000)
+    await settle()
+  }
+  expect(statuses.at(-1)).toBeUndefined()
+  expect(logs.join('\n')).toContain('Backstep is updated to 0.2.0 (you had 0.1.2). It\'s safe to close this terminal now.')
+  await ui.unmount()
+})
+
+test("when auto mode won't let Backstep undo a Notion change, Claude is asked to, and the change counts as undone once it has", { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const refusal = "backstep: $.mcp.call(claude_ai_Notion, notion-delete-pages) refused: The server-side auto mode classifier gave no verdict for mcp__claude_ai_Notion__notion-delete-pages"
+  const asked: string[] = []
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    asked.push(questions[0].question)
+    return { result: { questions, answers: { [questions[0].question]: 'Ask Claude to do it' } } }
+  })
+  const { runs, ran, prompts } = connector(on, {
+    start: { kind: 'reversible', id: 'w1' },
+    undoable: true,
+    mcpThrows: refusal,
+    undo: { id: 'w1', tool: 'notion-create-pages', ok: true, detail: 'Notion: deleted the page', run: { server: 'claude_ai_Notion', tool: 'notion-delete-pages', args: { page_ids: ['p1'] }, label: 'Notion: delete the page Claude made' } },
+  })
+  await $.prompt.submit({ text: 'make a page', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-create-pages', pages: [{ title: 'Test' }], tool_use_id: 'tu1' } as never)
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  await clock.advance(1000)
+  await settle()
+  expect(runs.some((r) => r.argv.includes('settle') && r.argv.includes('--failed'))).toBe(true)
+  expect(asked).toEqual(["Claude Code's auto mode didn't let Backstep undo this by itself: Notion: delete the page Claude made. Ask Claude to undo it?"])
+  expect(prompts.at(-1)).toContain('mcp__claude_ai_Notion__notion-delete-pages with {"page_ids":["p1"]}')
+
+  // Claude makes the call: it isn't recorded as a change of its own, and the change is marked undone.
+  const before = ran.length
+  const watched = runs.filter((r) => r.argv.includes('watch-start')).length
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-delete-pages', page_ids: ['p1'], tool_use_id: 'tu2' } as never)
+  expect(ran.length).toBe(before + 1)
+  expect(runs.filter((r) => r.argv.includes('watch-start')).length).toBe(watched)
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['settle', 'w1'])
+  await ui.unmount()
+})

package/mod/hooks/register.tsx

@@ -7,7 +7,7 @@
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, Register } from 'claude-code'
 
-import type { GithubCode, Rewind, RewindItem, Turn } from '../types'
+import type { GithubCode, Rewind, RewindItem, Turn, Updating } from '../types'
 
 const turns = atom({ plugin: 'backstep', key: 'turns' } as const, [] as Turn[])
 const rewind = atom({ plugin: 'backstep', key: 'rewind' } as const, null as Rewind | null)
@@ -20,6 +20,12 @@ const keys = atom({ plugin: 'backstep', key: 'keys' } as const, ['ctrl+u'] as st
 const githubCode = atom({ plugin: 'backstep', key: 'githubCode' } as const, null as GithubCode | null)
 // Why ctrl+u can't run here, when getbackstep.com says so (a version too old, or no sign-in when one is needed).
 const blocked = atom({ plugin: 'backstep', key: 'blocked' } as const, null as string | null)
+// An update under way. Installing it reloads this mod partway through, which
+// ends the code waiting on it, so the reloaded mod finishes the job: it says
+// the update is done and takes the "don't close" line down.
+const updating = atom({ plugin: 'backstep', key: 'updating' } as const, null as Updating | null)
+// Whether this load of the mod has looked for an update the last one left running.
+let resumed = false
 // Backstep's mark, as on the logo: the front rewind triangle in the terminal's
 // own black or white, the one behind it in the logo's pink.
 const PINK = '#ee7bb6'
@@ -355,19 +361,22 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   }
 
   // Opposite calls on servers only Claude Code is connected to run here, newest first.
+  let handoff: Handoff | null = null
   for (const o of outcomes) {
     if (!o.ok || !o.run) continue
     const run = o.run
     let failed: { tool: string; why: string } | null = null
     // The first opposite call, then any more on the same server (a move back to several places).
-    for (const call of [{ tool: run.tool, args: run.args }, ...(run.more ?? [])]) {
-      const done = await $.mcp.call(run.server, call.tool, call.args).catch((err: unknown) => ({
-        isError: true,
-        content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }],
-      }))
+    const all = [{ tool: run.tool, args: run.args }, ...(run.more ?? [])]
+    for (const [i, call] of all.entries()) {
+      const done = await undoCall($, run.server, call.tool, call.args)
       if (done.isError) {
         const why = done.content.map((c) => (c.type === 'text' ? c.text : '')).join(' ').trim().split('\n')[0] || 'failed'
-        failed = { tool: call.tool, why }
+        // Claude Code's auto mode won't let Backstep make it alone: Claude can, if the person says so.
+        if (REFUSED.test(why)) {
+          handoff = { id: o.id, server: run.server, calls: all.slice(i), label: run.label ?? `${o.tool}: ${call.tool}` }
+          failed = { tool: call.tool, why: "Claude Code's auto mode didn't let Backstep make this change itself" }
+        } else failed = { tool: call.tool, why }
         break
       }
     }
@@ -443,7 +452,9 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   }
 
   // Asked once the band shows what came back: GitHub things first, then pushes, then Vercel.
-  void offerGithubUndo($, outcomes)
+  // A change auto mode wouldn't let Backstep make comes first of all: it's where undo stopped.
+  void (handoff ? offerHandoff($, handoff) : Promise.resolve())
+    .then(() => offerGithubUndo($, outcomes))
     .then((gone) => offerPushUndo($, outcomes, gone.size > 0))
     .then(() => offerVercelUndo($, outcomes))
 
@@ -575,6 +586,56 @@ function undoneLabel(line: string, short: (p: string) => string): string {
   return `${p} ${m[1]}`
 }
 
+// Opposite calls handed to Claude to make, after the person said yes: the call,
+// by tool and arguments, to the action it undoes. Not recorded as Claude's own,
+// and once all of an action's have run, it counts as undone.
+const handedOver = new Map<string, string>()
+
+type Handoff = { id: string; server: string; calls: { tool: string; args: Record<string, unknown> }[]; label: string }
+const HANDOFF = { yes: 'Ask Claude to do it', no: 'Leave it' } as const
+
+// Auto mode's classifier answers only calls a request of Claude's asked for, so it
+// refuses Backstep's own. With the person's yes, the request is theirs: Claude is
+// asked to make exactly these calls, and Backstep marks the change undone once it has.
+async function offerHandoff($: EngineInterface, h: Handoff) {
+  const answer = await $.ui
+    .ask(`Claude Code's auto mode didn't let Backstep undo this by itself: ${h.label}. Ask Claude to undo it?`, { header: 'Backstep', options: [HANDOFF.yes, HANDOFF.no] })
+    .catch(() => null)
+  if (answer !== HANDOFF.yes) return
+  const server = toolServer(h.server)
+  for (const c of h.calls) handedOver.set(undoCallKey(`mcp__${server}__${c.tool}`, c.args), h.id)
+  const steps = h.calls.map((c) => `- mcp__${server}__${c.tool} with ${JSON.stringify(c.args)}`).join('\n')
+  await $.prompt
+    .submit({
+      text: `Undo this with Backstep: ${h.label}. Make exactly ${h.calls.length === 1 ? 'this call' : 'these calls, in order'}, and nothing else:\n${steps}`,
+      wait: false,
+      origin: { kind: 'composer' },
+    } as never)
+    .catch(() => null)
+}
+
+// One opposite call, through Claude Code's own connection to the server.
+async function undoCall($: EngineInterface, server: string, tool: string, args: Record<string, unknown>): Promise<{ isError: boolean; content: { type: string; text?: string }[] }> {
+  return $.mcp.call(server, tool, args).catch((err: unknown) => ({
+    isError: true,
+    content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }],
+  }))
+}
+
+// Claude Code's permission check refused the call (auto mode's classifier
+// answers only calls a request of Claude's asked for), not the server.
+const REFUSED = /\$\.mcp\.call\([^)]*\) refused|auto mode classifier/i
+
+// A server's name as tool names spell it: "claude.ai Notion" is claude_ai_Notion.
+const toolServer = (server: string) => server.replace(/[^A-Za-z0-9_-]/g, '_')
+
+// A call by tool and arguments, the arguments' keys in order, so the same call always reads the same.
+function undoCallKey(tool: string, args: unknown): string {
+  const sorted = (v: unknown): unknown =>
+    Array.isArray(v) ? v.map(sorted) : v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : 1)).map(([k, x]) => [k, sorted(x)])) : v
+  return `${tool} ${JSON.stringify(sorted(args ?? {}))}`
+}
+
 // The action id `backstep snap` printed.
 function savedId(stdout: string): string | null {
   try {
@@ -788,6 +849,40 @@ async function offerUpdate($: EngineInterface) {
   await installUpdate($, u.current, u.latest)
 }
 
+function updated($: EngineInterface, u: Updating) {
+  $.ui.log(`${MARK_TEXT} Backstep is updated to ${u.to}${u.from ? ` (you had ${u.from})` : ''}. It's safe to close ${u.win} now. Restart Claude Code to start using ${u.to}.`)
+  $.ui.toast(`Backstep is updated to ${u.to}. Restart Claude Code to use it.`)
+}
+
+// After a reload in the middle of an update: once the new version is in place,
+// say so and take the "don't close" line down. Setup may still be finishing,
+// so it looks again for a while before giving up.
+async function finishUpdate($: EngineInterface) {
+  const u = await read($, updating)
+  if (!u) return
+  for (let i = 0; i < 60; i++) {
+    const ran = await $.process.run(backstep(['update-check']), { timeoutMs: 15_000 }).catch(() => null)
+    let installed: string | undefined
+    try {
+      installed = (JSON.parse(ran?.stdout || '{}') as { current?: string }).current
+    } catch {
+      installed = undefined
+    }
+    if (installed === u.to) {
+      // Setup may still be wrapping servers: a moment more before saying it's safe to close.
+      await $.clock.sleep(5000)
+      $.ui.status(undefined)
+      await update($, updating, () => null)
+      updated($, u)
+      return
+    }
+    await $.clock.sleep(5000)
+  }
+  $.ui.status(undefined)
+  await update($, updating, () => null)
+  $.ui.log(`${MARK_TEXT} Backstep couldn't confirm the update to ${u.to} finished. If undo doesn't work after restarting Claude Code, run: npx backstep@latest setup`)
+}
+
 // Installs a version, saying not to close the terminal while it runs and which version it ended on.
 async function installUpdate($: EngineInterface, current: string | undefined, latest: string, forced = false): Promise<boolean> {
   const u = { current, latest }
@@ -797,6 +892,7 @@ async function installUpdate($: EngineInterface, current: string | undefined, la
   $.ui.log(`${MARK_TEXT} Updating Backstep${from} to ${u.latest}… Don't close ${win} until it says it's done (about a minute).`)
   $.ui.toast(`Updating Backstep to ${u.latest}. Don't close ${win} until it's done.`, { timeoutMs: 15_000 })
   $.ui.status(`◀◀ Updating Backstep to ${u.latest}… don't close ${win}`)
+  await update($, updating, () => ({ ...(u.current ? { from: u.current } : {}), to: latest, win }))
   const done = await $.process
     .run(backstep(['update', '--version', u.latest, '--json']), { timeoutMs: 600_000 })
     .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
@@ -807,9 +903,9 @@ async function installUpdate($: EngineInterface, current: string | undefined, la
     // keep the error above
   }
   $.ui.status(undefined)
+  await update($, updating, () => null)
   if (r.ok) {
-    $.ui.log(`${MARK_TEXT} Backstep is updated to ${u.latest}${u.current ? ` (you had ${u.current})` : ''}. It's safe to close ${win} now. Restart Claude Code to start using ${u.latest}.`)
-    $.ui.toast(`Backstep is updated to ${u.latest}. Restart Claude Code to use it.`)
+    updated($, { ...(u.current ? { from: u.current } : {}), to: latest, win })
     return true
   } else {
     $.ui.log(`${MARK_TEXT} Backstep couldn't update to ${u.latest}: ${r.detail}. You're still on ${u.current ?? 'the version you had'}${forced ? '' : ', which keeps working'}. To try again, run: npx backstep@latest setup`)
@@ -1004,6 +1100,17 @@ export const register: Register = (on, options) => {
 
   on('tool.call', async ($, e, next) => {
     const tool = String(e.tool)
+    // An opposite call Claude is making for undo, as the person asked: not recorded as a change of its own.
+    const handed = handedOver.size ? undoCallKey(tool, Object.fromEntries(Object.entries(e).filter(([k]) => !RESERVED.has(k)))) : ''
+    const forAction = handed ? handedOver.get(handed) : undefined
+    if (forAction) {
+      const r = (await next(e)) as { deny?: string; isError?: boolean }
+      if (!r.deny && !r.isError) {
+        handedOver.delete(handed)
+        if (![...handedOver.values()].includes(forAction)) await $.process.run(backstep(['settle', forAction])).catch(() => null)
+      }
+      return r as never
+    }
     if (tool === CONNECT || tool === KEY || tool === UNINSTALL) return next(e)
     if (EDIT_TOOLS.has(tool)) {
       const input = e as { file_path?: string; notebook_path?: string }
@@ -1085,6 +1192,10 @@ export const register: Register = (on, options) => {
   })
 
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    if (!resumed) {
+      resumed = true
+      void finishUpdate($)
+    }
     if (e.props.hasSurvey) return next(e)
     const { Box, Button, Text } = $.ui.resolve(e)
     // The logo keeps its own box with a fixed gap after it: a space inside the

package/mod/types/index.d.ts

@@ -21,6 +21,9 @@ export type Turn = {
 export type RewindItem = { label: string; ok: boolean }
 
 // The animation above the prompt while a turn is being rewound.
+// An update under way, kept across the reload it causes, so the reloaded mod can say it's done.
+export type Updating = { from?: string; to: string; win: string }
+
 export type Rewind = {
   phase: 'running' | 'done' | 'failed' | 'empty'
   frame: number
@@ -38,6 +41,6 @@ declare module 'claude-code' {
     // keys: the keys bound to undo, kept here so the band redraws when they change.
     // githubCode: the code GitHub's approval page wants, shown on the band until GitHub answers.
     // blocked: why ctrl+u can't run, when getbackstep.com says this version is too old or a sign-in is needed.
-    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[]; githubCode: GithubCode | null; blocked: string | null }
+    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[]; githubCode: GithubCode | null; blocked: string | null; updating: Updating | null }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "homepage": "https://getbackstep.com",
   "scripts": {