backstep 0.1.31 → 0.1.32

package/dist/adapters/tree.js

@@ -195,6 +195,7 @@ function projectGit(root, actionId, pushes) {
 // Returns null when the folder can't be snapshotted: the home folder or the
 // whole disk, or a folder too big to stage in time.
 export function snapshotTree(actionId, cwd, opts = {}) {
+    lastTreeError = null;
     const root = projectRoot(cwd);
     if (isDiskRoot(root) || root === homedir() || root === resolve(homeDir()))
         return null;
@@ -206,10 +207,13 @@ export function snapshotTree(actionId, cwd, opts = {}) {
         git(["update-ref", `refs/backstep/${actionId}`, commit], { gitDir, workTree: root });
         return { adapter: "tree", root, gitDir, commit, git: projectGit(root, actionId, opts.pushes === true) };
     }
-    catch {
+    catch (err) {
+        lastTreeError = (err instanceof Error ? err.stderr || err.message : String(err)).trim().split("\n").find(Boolean) ?? null;
         return null;
     }
 }
+// Why the last snapshot couldn't be made, in git's words: null when it was too big or the folder is off limits.
+export let lastTreeError = null;
 // Once the command has run: the folder as it left it, kept like the snapshot before it.
 export function recordTreeAfter(u, actionId) {
     const tree = stage(u.gitDir, u.root);

package/dist/cli.js

@@ -6,7 +6,7 @@ import { startUi } from "./ui/server.js";
 import { Store, snapshotDir } from "./store.js";
 import { pendingManual, pruneDatabaseCopies, undoAction, undoRun, undoSince } from "./undo.js";
 import { insideDir, recordAfter, snapshotPaths } from "./adapters/fs.js";
-import { notePushed, recordTreeAfter, snapshotSqlite, snapshotTree } from "./adapters/tree.js";
+import { lastTreeError, notePushed, recordTreeAfter, snapshotSqlite, snapshotTree } from "./adapters/tree.js";
 import { revertPush } from "./push.js";
 import { ghMade, grantScope, openPage, undoGh } from "./github.js";
 import { accessNow, accessOnline, currentNote, login, logout, requireAccess } from "./account.js";
@@ -520,13 +520,14 @@ async function main() {
         const kind = plan.kind === "outbound" && saved && /database|request/.test(plan.reason ?? "") ? "write" : plan.kind;
         if (kind !== plan.kind)
             store.updateAction(a.id, { kind: "reversible", reason: null });
+        const unsaved = lastTreeError ? `Backstep couldn't save a copy first (${lastTreeError})` : "Backstep couldn't save a copy first (the folder is too big, or it's your whole home folder)";
         if (!undo && kind !== "outbound")
-            store.updateAction(a.id, { kind: "write", reason: "project too large to snapshot" });
+            store.updateAction(a.id, { kind: "write", reason: unsaved });
         if (missed.length)
             store.updateAction(a.id, { reason: `couldn't save the database first: ${missed[0]}` });
         if (dbs.length)
             await pruneDatabaseCopies(store).catch(() => { });
-        console.log(JSON.stringify({ kind, reason: kind === plan.kind ? plan.reason : undefined, id: a.id, undoable: undo !== null, db: saved }));
+        console.log(JSON.stringify({ kind, reason: !undo && kind !== "outbound" ? unsaved : kind === plan.kind ? plan.reason : undefined, id: a.id, undoable: undo !== null, db: saved }));
         return;
     }
     // Before a shell command, from the Claude Code mod: does it reach a Supabase project Backstep

package/dist/shell.js

@@ -10,6 +10,8 @@ const READ_PROGRAMS = new Set([
     "cut", "tr", "column", "jq", "yq", "date", "whoami", "id", "uname", "env", "printenv", "ps", "top", "uptime",
     "basename", "dirname", "realpath", "readlink", "md5", "md5sum", "shasum", "sha256sum", "true", "false", "test", "[",
     "sleep", "man", "tldr", "history", "lsof", "hostname", "cal", "nproc",
+    // Opening a page, a file or an app in it changes nothing here by itself.
+    "open", "xdg-open",
 ]);
 const READ_GIT = new Set([
     "status", "log", "diff", "show", "blame", "grep", "ls-files", "ls-tree", "rev-parse", "describe", "shortlog",

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

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "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

@@ -373,9 +373,14 @@ test('a Notion move: the pages are read first, and undo runs every opposite call
   await ui.unmount()
 })
 
-test('when the opposite call fails, the rewind says so', { options: { cli: CLI } }, async ($, on) => {
+test('when the opposite call fails, the rewind says so, plainly', { options: { cli: CLI } }, async ($, on) => {
   const clock = mock.clock(on, { now: 5000 })
-  const { runs } = connector(on, { start: { kind: 'reversible', id: 'w1' }, undoable: true, mcpFails: true })
+  const { runs } = connector(on, {
+    start: { kind: 'reversible', id: 'w1' },
+    undoable: true,
+    mcpFails: true,
+    undo: { id: 'w1', tool: 'notion-create-pages', ok: true, detail: 'runs notion-delete-pages', run: { server: 'claude_ai_Notion', tool: 'notion-delete-pages', args: { page_ids: ['p1'] }, label: 'Notion: moved the pages Claude made to Trash' } },
+  })
 
   await $.prompt.submit({ text: 'make a page', wait: false, origin: { kind: 'composer' } })
   await $.tool.call({ tool: 'mcp__claude_ai_Notion__create-page', title: 'Plan' } as never)
@@ -385,7 +390,8 @@ test('when the opposite call fails, the rewind says so', { options: { cli: CLI }
   await clock.advance(1000)
   await pressed
   expect(runs.at(-1)?.argv.slice(3)).toEqual(['settle', 'w1', '--failed', 'no such page'])
-  expect((await ui.find({ type: 'Text', text: /no such page/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /no such page/ }))?.text).toContain(`Couldn't move the pages Claude made to Trash: Notion said "no such page"`)
+  expect(await ui.find({ type: 'Text', text: /notion-delete-pages failed/ })).toBeFalsy()
   await ui.unmount()
 })
 
@@ -1355,7 +1361,8 @@ test("when auto mode won't let Backstep undo a Notion change, Claude is asked to
   // 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'], user_confirmed: true, tool_use_id: 'tu2' } as never)
+  // Claude adds an argument of its own (Notion's telemetry): still the same call.
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-delete-pages', page_ids: ['p1'], user_confirmed: true, telemetry: { intent: 'undo' }, 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'])

package/mod/hooks/register.tsx

@@ -395,7 +395,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
     }
     if (failed) {
       o.ok = false
-      o.detail = `${failed.tool} failed: ${failed.why}`
+      o.detail = couldnt(run.label, failed.why, `undo ${o.tool}`)
       await $.process.run(backstep(['settle', o.id, '--failed', failed.why])).catch(() => null)
       break
     }
@@ -415,7 +415,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
         .filter(Boolean)
         .map((line): RewindItem => (o.pending ? { label: undoneLabel(line, short), ok: true, pending: true, action: o.id } : { label: undoneLabel(line, short), ok: true })),
     )
-  const stopped = outcomes.filter((o) => !o.ok).map((o) => ({ label: `${o.tool}: ${o.detail.split('\n')[0] ?? 'failed'}`, ok: false }))
+  const stopped = outcomes.filter((o) => !o.ok).map((o) => { const line = o.detail.split('\n')[0] ?? 'failed'; return { label: line.startsWith("Couldn't ") ? line : `${o.tool}: ${line}`, ok: false } })
   // A push, or something made on GitHub, is offered back below, so it isn't listed as lost.
   const offered = outcomes.some((o) => o.ok && o.pushed)
   const offeredGh = outcomes.some((o) => o.ok && o.github?.length)
@@ -599,13 +599,31 @@ 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>()
+// Opposite calls handed to Claude to make after the person pressed undo: the call
+// and the action it undoes. Not recorded as Claude's own, and once all of an
+// action's have run, it counts as undone.
+type Handed = { tool: string; args: Record<string, unknown>; action: string }
+const handedOver: Handed[] = []
+
+// Claude's call is the one handed over when it's the same tool with the same
+// values for every argument Backstep gave; Claude adds its own (Notion's telemetry, say).
+function handedCall(tool: string, args: Record<string, unknown>): Handed | undefined {
+  return handedOver.find((h) => h.tool === tool && Object.entries(h.args).every(([k, v]) => undoCallKey('', v) === undoCallKey('', args[k])))
+}
 
 type Handoff = { id: string; server: string; calls: { tool: string; args: Record<string, unknown> }[]; label: string }
 
+// A change that didn't come back, said plainly: "Notion: moved the pages Claude made to Trash"
+// that failed reads "Couldn't move the pages Claude made to Trash: Notion said "no such page"".
+const INFINITIVE: Record<string, string> = { moved: 'move', restored: 'restore', put: 'put', archived: 'archive', deleted: 'delete', removed: 'remove', ran: 'run', closed: 'close', reopened: 'reopen', set: 'set' }
+function couldnt(label: string | undefined, why: string, fallback: string): string {
+  const reason = why.replace(/^(backstep|error):\s*/i, '').split(/(?<=\.)\s/)[0].slice(0, 140)
+  const m = label?.match(/^(?:([A-Z][\w.]*(?: [A-Z][\w.]*)*): )?(\w+)\s(.*)$/)
+  const verb = m ? INFINITIVE[m[2]] : undefined
+  const what = m && verb ? `${verb} ${m[3]}` : fallback
+  return m?.[1] ? `Couldn't ${what}: ${m[1]} said "${reason}"` : `Couldn't ${what}: ${reason}`
+}
+
 // Said after "Rewound …" while Claude still has some of it to finish.
 function finishing(items: RewindItem[]): string {
   const n = items.filter((i) => i.pending).length
@@ -620,7 +638,7 @@ async function handOff($: EngineInterface, list: Handoff[]) {
   for (const h of list) {
     const server = toolServer(h.server)
     for (const c of h.calls) {
-      handedOver.set(undoCallKey(`mcp__${server}__${c.tool}`, c.args), h.id)
+      handedOver.push({ tool: `mcp__${server}__${c.tool}`, args: c.args, action: h.id })
       steps.push(`- mcp__${server}__${c.tool} with ${JSON.stringify(c.args)}`)
     }
   }
@@ -638,7 +656,7 @@ async function handOff($: EngineInterface, list: Handoff[]) {
 async function handedBack($: EngineInterface, action: string, ok: boolean, why?: string) {
   await update($, rewind, (r) => {
     if (!r) return r
-    const items = r.items.map((i) => (i.pending && i.action === action ? (ok ? { ...i, pending: false } : { label: `${i.label}: Claude couldn't (${why ?? 'it failed'})`, ok: false }) : i))
+    const items = r.items.map((i) => (i.pending && i.action === action ? (ok ? { ...i, pending: false } : { label: couldnt(i.label, why ?? 'it failed', 'finish undoing it'), ok: false }) : i))
     const undone = items.filter((i) => i.ok)
     // "Rewound 2 changes from the last turn. Claude is finishing it." loses its last sentence once Claude has.
     const [rewound, ...rest] = r.message.replace(/ Claude is finishing [^.]*\./, '').split(/(?<=\.) /)
@@ -1139,19 +1157,22 @@ 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 handed = handedOver.length ? handedCall(tool, Object.fromEntries(Object.entries(e).filter(([k]) => !RESERVED.has(k)))) : undefined
+    if (handed) {
+      const forAction = handed.action
       const r = (await next(e)) as { deny?: string; isError?: boolean; text?: string }
+      const drop = (which: (h: Handed) => boolean) => {
+        for (let i = handedOver.length - 1; i >= 0; i--) if (which(handedOver[i])) handedOver.splice(i, 1)
+      }
       if (!r.deny && !r.isError) {
-        handedOver.delete(handed)
-        if (![...handedOver.values()].includes(forAction)) {
+        drop((h) => h === handed)
+        if (!handedOver.some((h) => h.action === forAction)) {
           await $.process.run(backstep(['settle', forAction])).catch(() => null)
           await handedBack($, forAction, true)
         }
       } else {
         const why = (r.deny ?? r.text ?? 'it failed').trim().split('\n')[0]
-        for (const [k, a] of handedOver) if (a === forAction) handedOver.delete(k)
+        drop((h) => h.action === forAction)
         await $.process.run(backstep(['settle', forAction, '--failed', why])).catch(() => null)
         await handedBack($, forAction, false, why)
       }

package/package.json

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