backstep 0.1.14 → 0.1.16

package/dist/adapters/fs.js

@@ -24,6 +24,13 @@ function sizeOf(p, budget) {
     return total;
 }
 // Returns null when a path is too large to copy; the caller then can't promise undo.
+// Whether a path sits in the folder Claude Code has open. Edits elsewhere belong to
+// other projects: Backstep never records them, so undo here can never touch them.
+export function insideDir(path, dir) {
+    const p = resolvePath(path, dir);
+    const d = resolve(dir).replace(/\/$/, "");
+    return p === d || p.startsWith(d + "/");
+}
 export function snapshotPaths(actionId, paths, cwd) {
     const dir = snapshotDir(actionId);
     const seen = new Set();

package/dist/cli.js

@@ -5,7 +5,7 @@ import { runProxy } from "./proxy.js";
 import { startUi } from "./ui/server.js";
 import { Store, snapshotDir } from "./store.js";
 import { pruneDatabaseCopies, undoAction, undoRun, undoSince } from "./undo.js";
-import { snapshotPaths } from "./adapters/fs.js";
+import { insideDir, snapshotPaths } from "./adapters/fs.js";
 import { notePushed, snapshotSqlite, snapshotTree } from "./adapters/tree.js";
 import { revertPush } from "./push.js";
 import { ghMade, grantScope, undoGh } from "./github.js";
@@ -24,8 +24,16 @@ import { autoWrap, printChanges, unwrapServers, wrapServers } from "./servers.js
 import { disconnectSupabase, dismissSupabase, firebaseConn, postgresUrl, restKey } from "./supabase.js";
 // The Supabase projects a shell command could change: those in the folder it
 // works in (or a level or two below), when the command is one that reaches a database.
+// A command that `cd`s into another project is out of scope: only the open folder is tracked.
+function scopedDir(command, cwd) {
+    const d = commandDir(command, cwd);
+    return insideDir(d, cwd) ? d : null;
+}
 function reachedProjects(command, cwd) {
-    const dirs = supabaseDirs(commandDir(command, cwd));
+    const at = scopedDir(command, cwd);
+    if (!at)
+        return [];
+    const dirs = supabaseDirs(at);
     return touchesDatabase(command) || touchesSupabase(command, dirs.length > 0) ? dirs : [];
 }
 // Every database a shell command could change, by folder: Supabase, other Postgres, Firebase.
@@ -33,7 +41,8 @@ function reachedDatabases(command, cwd) {
     const out = [];
     for (const d of reachedProjects(command, cwd))
         out.push({ dir: d, service: "supabase" });
-    for (const d of dbDirs(commandDir(command, cwd))) {
+    const at = scopedDir(command, cwd);
+    for (const d of at ? dbDirs(at) : []) {
         const u = projectUses(d);
         if (u.postgres && (touchesDatabase(command) || touchesSupabase(command, true)))
             out.push({ dir: d, service: "postgres" });
@@ -307,10 +316,17 @@ async function main() {
             args: sep === -1 ? rest : rest.slice(0, sep),
             options: { session: { type: "string" }, tool: { type: "string" }, cwd: { type: "string" } },
         });
-        const paths = sep === -1 ? [] : rest.slice(sep + 1);
-        if (!values.session || !values.tool || paths.length === 0) {
+        const asked = sep === -1 ? [] : rest.slice(sep + 1);
+        if (!values.session || !values.tool || asked.length === 0) {
             throw new Error("usage: backstep snap --session <id> --tool <name> [--cwd <dir>] -- <paths...>");
         }
+        // Claude Code names the folder it has open: a file in another project is left out entirely.
+        const scope = values.cwd;
+        const paths = scope ? asked.filter((p) => insideDir(p, scope)) : asked;
+        if (paths.length === 0) {
+            console.log(JSON.stringify({ outside: true, undoable: false }));
+            return;
+        }
         const store = new Store();
         const run = store.sessionRun("claude-code", `session:${values.session}`);
         const a = store.addAction({
@@ -541,11 +557,12 @@ async function main() {
                 until: { type: "string" },
                 json: { type: "boolean", default: false },
                 "via-claude-code": { type: "boolean", default: false },
+                session: { type: "string" },
             },
         });
         const store = new Store();
         const outcomes = values.since
-            ? await undoSince(store, Number(values.since), values.until ? Number(values.until) : undefined, { viaClaudeCode: values["via-claude-code"] })
+            ? await undoSince(store, Number(values.since), values.until ? Number(values.until) : undefined, { viaClaudeCode: values["via-claude-code"], session: values.session })
             : values.run
                 ? await undoRun(store, values.run)
                 : await undoAction(store, positionals[0] ?? "");

package/dist/undo.js

@@ -201,9 +201,21 @@ export async function undoRun(store, runId) {
 // Everything any agent did in a window of time: what one turn of a chat did,
 // across Claude's own edits and every server wrapped by Backstep.
 export async function undoSince(store, since, until = Date.now(), opts = {}) {
-    const inWindow = store.db
+    let inWindow = store.db
         .prepare("SELECT * FROM actions WHERE created_at >= ? AND created_at <= ? ORDER BY created_at, seq")
         .all(since, until);
+    if (opts.session) {
+        const mine = `session:${opts.session}`;
+        const commands = new Map();
+        inWindow = inWindow.filter((a) => {
+            if (!commands.has(a.run_id))
+                commands.set(a.run_id, store.getRun(a.run_id)?.command);
+            const command = commands.get(a.run_id);
+            // Another session's run: never ours to undo. Servers wrapped by `backstep wrap`
+            // record under their own runs and stay included, as before.
+            return !(command?.startsWith("session:") && command !== mine);
+        });
+    }
     return undoAll(store, inWindow.filter(undoable), opts);
 }
 async function undoAll(store, actions, opts = {}) {

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

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

@@ -60,6 +60,39 @@ test('an edit is snapshotted and the band offers to undo the turn', { options: {
   }
 })
 
+test('edits outside the open folder are never tracked', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { runs } = engine(on, { exitCode: 0, stdout: '[]' })
+
+  await $.prompt.submit({ text: 'fix the other project', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Write', file_path: '/other-project/src/new.ts', content: 'x' })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo-sibling/a.ts', old_string: 'a', new_string: 'b' })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/../other-project/a.ts', old_string: 'a', new_string: 'b' })
+
+  expect(runs.filter((r) => r.includes('snap'))).toEqual([])
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text', text: /nothing to undo yet/ }))?.text).toBeTruthy()
+  await ui.unmount()
+})
+
+test('a long last turn stays on one line with a fixed gap after the logo', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  engine(on, { exitCode: 0, stdout: '[]' }, { kind: 'write', undoable: true })
+
+  await $.prompt.submit({ text: 'scrap that, lets try making the whole thing much longer than fits', wait: false, origin: { kind: 'composer' } })
+  for (const f of ['a', 'b', 'c']) await $.tool.call({ tool: 'Edit', file_path: `/repo/src/${f}.ts`, old_string: 'a', new_string: 'b' })
+  for (let i = 0; i < 8; i++) await $.tool.call({ tool: 'Bash', command: `touch x${i}` })
+
+  const ui = await $.ui.mount({ ...BAND, props: { ...BAND.props, bodyColumns: 60 }, surface: 'terminal' })
+  const line = await ui.find({ type: 'Text', text: /Last turn/ })
+  // No leading space to be trimmed on a wrap: the gap is the logo box's own margin.
+  expect(line?.text).toMatch(/^Last turn:/)
+  expect(line?.props.wrap).toBe('truncate-end')
+  expect(await ui.find({ type: 'Box', props: { flexShrink: 0, marginRight: 1 } })).toBeTruthy()
+  expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
+  await ui.unmount()
+})
+
 test('pressing undo rewinds the turn and tells Claude on the next prompt', { options: { cli: CLI } }, async ($, on) => {
   const clock = mock.clock(on, { now: 5000 })
   const { runs, prompts } = engine(on, {
@@ -75,7 +108,7 @@ test('pressing undo rewinds the turn and tells Claude on the next prompt', { opt
   const pressed = ui.press({ key: 'undo' })
   await clock.settle()
   expect((await ui.find({ type: 'Text', text: /Rewinding/ }))?.text).toBeTruthy()
-  expect(runs.at(-1)).toEqual(['node', '--disable-warning=ExperimentalWarning', CLI, 'undo', '--since', '5000', '--json', '--via-claude-code'])
+  expect(runs.at(-1)).toEqual(['node', '--disable-warning=ExperimentalWarning', CLI, 'undo', '--since', '5000', '--session', 's1', '--json', '--via-claude-code'])
 
   await clock.advance(1000)
   await pressed
@@ -141,7 +174,8 @@ test('with nothing to undo the band still holds the key, and a press says there
 
   const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect((await ui.find({ type: 'Text', text: /nothing to undo yet/ }))).toBeTruthy()
-  // The mark: the front triangle in the terminal's own color, the one behind in the logo's pink.
+  // The gap after the mark is its own fixed margin, so a long line can't squeeze it away.
+  expect((await ui.find({ type: 'Text', text: /nothing to undo yet/ }))?.text).toMatch(/^Backstep is on/)  // The mark: the front triangle in the terminal's own color, the one behind in the logo's pink.
   expect((await ui.find({ type: 'Text', text: '◀', props: { color: '#ee7bb6' } }))).toBeTruthy()
   await ui.press({ key: 'undo' })
   expect(toasts[0]).toContain('Nothing to undo yet')
@@ -666,7 +700,7 @@ test('when the last turn only committed and pushed, undo offers to take back the
   await clock.advance(1000)
   await pressed
   // Both turns: everything since the first one started.
-  expect(runs.find((r) => r.includes('undo'))?.slice(3)).toEqual(['undo', '--since', '5000', '--json', '--via-claude-code'])
+  expect(runs.find((r) => r.includes('undo'))?.slice(3)).toEqual(['undo', '--since', '5000', '--session', 's1', '--json', '--via-claude-code'])
   await ui.unmount()
 })
 

package/mod/hooks/register.tsx

@@ -183,6 +183,19 @@ async function offerPushUndo($: EngineInterface, outcomes: Outcome[], repoGone =
 // The first press asks, right there above the prompt; a second press within a
 // few seconds undoes. A dialog would take the band off screen, and with it the
 // key, which would then suspend Claude Code in a terminal.
+// Whether a file path is inside the folder this session has open.
+function within(path: string, cwd: string): boolean {
+  const abs = path.startsWith('/') ? path : `${cwd}/${path}`
+  const parts: string[] = []
+  for (const seg of abs.split('/')) {
+    if (seg === '..') parts.pop()
+    else if (seg && seg !== '.') parts.push(seg)
+  }
+  const p = '/' + parts.join('/')
+  const d = cwd.replace(/\/+$/, '')
+  return p === d || p.startsWith(d + '/')
+}
+
 async function pressUndo($: EngineInterface) {
   if (await read($, rewind)) return
   const target = (await read($, turns)).findLast(hasWork)
@@ -218,7 +231,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   const cwd = await $.session.cwd()
   const short = (p: string) => (p.startsWith(cwd + '/') ? p.slice(cwd.length + 1) : p)
   const [ran] = await Promise.all([
-    $.process.run(backstep(['undo', '--since', String(target.startedAt), '--json', '--via-claude-code'])).catch((err: unknown) => ({
+    $.process.run(backstep(['undo', '--since', String(target.startedAt), '--session', await $.session.id(), '--json', '--via-claude-code'])).catch((err: unknown) => ({
       exitCode: 1,
       stdout: '',
       stderr: err instanceof Error ? err.message : String(err),
@@ -712,9 +725,11 @@ export const register: Register = (on, options) => {
     if (EDIT_TOOLS.has(tool)) {
       const input = e as { file_path?: string; notebook_path?: string }
       const path = input.file_path ?? input.notebook_path
-      if (path) {
+      const cwd = await $.session.cwd()
+      // Only the open folder is tracked: an edit in another project is never
+      // recorded, so undoing here can never delete or roll back files there.
+      if (path && within(path, cwd)) {
         const t = await current($)
-        const cwd = await $.session.cwd()
         const sid = await $.session.id()
         // A failed snapshot never blocks the edit; it just won't be undoable.
         const snap = await $.process
@@ -778,14 +793,21 @@ export const register: Register = (on, options) => {
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
     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
+    // text next to it gets trimmed when a long line wraps, crushing the two together.
+    const mark = () => (
+      <Box flexShrink={0} marginRight={1}>
+        <Text bold>◀</Text>
+        <Text color={PINK} bold>◀</Text>
+      </Box>
+    )
     const r = await read($, rewind)
 
     if (r?.phase === 'running') {
       return (
         <Box>
-          <Text bold>◀</Text>
-          <Text color={PINK} bold>◀</Text>
-          <Text bold> Rewinding </Text>
+          {mark()}
+          <Text bold>Rewinding </Text>
           <Text>{bar(r.frame)}</Text>
           <Text dimColor> undoing the last turn…</Text>
         </Box>
@@ -797,9 +819,8 @@ export const register: Register = (on, options) => {
     const step = waiting ? (
       <Box flexDirection="column" marginTop={r ? 1 : 0}>
         <Box>
-          <Text bold>◀</Text>
-          <Text color={PINK} bold>◀</Text>
-          <Text color="warning" bold>{` One more step to ${waiting.what}:`}</Text>
+          {mark()}
+          <Text color="warning" bold>{`One more step to ${waiting.what}:`}</Text>
         </Box>
         <Text>{'   Paste this code on the GitHub page that just opened, then press Authorize:'}</Text>
         <Box>
@@ -858,9 +879,8 @@ export const register: Register = (on, options) => {
         return (
           <Box flexDirection="column">
             <Box>
-              <Text bold>◀</Text>
-              <Text color={PINK} bold>◀</Text>
-              <Text color="warning" bold>{' That turn only saved and pushed to git.'}</Text>
+              {mark()}
+              <Text color="warning" bold>{'That turn only saved and pushed to git.'}</Text>
             </Box>
             <Text dimColor>{`   Undo it and the turn before it${quoted(before, 50)}?`}</Text>
             <Box>
@@ -881,9 +901,8 @@ export const register: Register = (on, options) => {
       return (
         <Box flexDirection="column">
           <Box>
-            <Text bold>◀</Text>
-            <Text color={PINK} bold>◀</Text>
-            <Text color="warning" bold>{" Undo Claude's last turn?"}</Text>
+            {mark()}
+            <Text color="warning" bold>{"Undo Claude's last turn?"}</Text>
           </Box>
           <Text dimColor>{`   ${quoted(target, 50).trim() || 'That turn'} · ${summary(target)}`}</Text>
           <Box>
@@ -903,13 +922,16 @@ export const register: Register = (on, options) => {
     // with nothing to undo, a press says so rather than doing nothing.
     return (
       <Box>
-        <Text bold>◀</Text>
-        <Text color={PINK} bold>◀</Text>
-        <Text> </Text>
-        <Text dimColor>{target ? `Last turn:${quoted(target, 28)} · ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
-        <Button key="undo" action={UNDO_ACTION} plain dimColor onPress={() => void pressUndo($)}>
-          {`${label} to undo`}
-        </Button>
+        {mark()}
+        {/* One line: a long summary is cut short so the key to press always shows. */}
+        <Box flexShrink={1} minWidth={0}>
+          <Text dimColor wrap="truncate-end">{target ? `Last turn:${quoted(target, 28)} · ${summary(target)}` : 'Backstep is on · nothing to undo yet'}</Text>
+        </Box>
+        <Box flexShrink={0} marginLeft={2}>
+          <Button key="undo" action={UNDO_ACTION} plain dimColor onPress={() => void pressUndo($)}>
+            {`${label} to undo`}
+          </Button>
+        </Box>
       </Box>
     )
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "scripts": {
     "dev": "node src/cli.ts",