backstep 0.1.20 → 0.1.22

package/dist/adapters/fs.js

@@ -2,14 +2,12 @@
 // Restoring "the state each path was in" handles writes, edits, deletes,
 // creates and moves with one rule.
 import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join } from "node:path";
 import { snapshotDir } from "../store.js";
+import { insidePath, resolveIn } from "../paths.js";
 const MAX_BYTES = 50 * 1024 * 1024;
 export function resolvePath(p, cwd) {
-    if (p === "~" || p.startsWith("~/"))
-        return join(homedir(), p.slice(1));
-    return resolve(cwd, p);
+    return resolveIn(p, cwd);
 }
 function sizeOf(p, budget) {
     const st = lstatSync(p);
@@ -27,9 +25,7 @@ function sizeOf(p, budget) {
 // 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 + "/");
+    return insidePath(resolvePath(path, dir), dir);
 }
 export function snapshotPaths(actionId, paths, cwd) {
     const dir = snapshotDir(actionId);

package/dist/adapters/tree.js

@@ -6,7 +6,8 @@
 import { createHash } from "node:crypto";
 import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readdirSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isDiskRoot } from "../paths.js";
 import { execFileSync } from "node:child_process";
 import { homeDir, snapshotDir } from "../store.js";
 const SQLITE_BUDGET = () => Number(process.env.BACKSTEP_DB_SNAPSHOT_MB ?? 250) * 1024 * 1024;
@@ -26,6 +27,8 @@ function isSqlite(path) {
 // SQLite database files in a project, four folders deep at most.
 export function sqliteFiles(root) {
     const out = [];
+    // Backstep's own folder holds its live history: never saved or put back as a project's database.
+    const own = resolve(homeDir());
     const walk = (dir, depth) => {
         let entries = [];
         try {
@@ -37,7 +40,7 @@ export function sqliteFiles(root) {
         for (const e of entries) {
             const p = join(dir, e.name);
             if (e.isDirectory()) {
-                if (depth > 0 && !SKIP_DIRS.test(e.name))
+                if (depth > 0 && !SKIP_DIRS.test(e.name) && resolve(p) !== own)
                     walk(p, depth - 1);
             }
             else if (/\.(db|sqlite3?|db3)$/i.test(e.name) && isSqlite(p))
@@ -137,7 +140,9 @@ function tryGit(args, cwd) {
 }
 // The project a command runs in: its git repository, or the folder itself.
 export function projectRoot(cwd) {
-    return tryGit(["rev-parse", "--show-toplevel"], cwd) ?? resolve(cwd);
+    // git answers C:/Users/me/app on Windows; resolve gives the system's own spelling.
+    const top = tryGit(["rev-parse", "--show-toplevel"], cwd);
+    return resolve(top ?? cwd);
 }
 function shadowFor(root) {
     const gitDir = join(homeDir(), "trees", createHash("sha256").update(root).digest("hex").slice(0, 16) + ".git");
@@ -147,7 +152,7 @@ function shadowFor(root) {
         mkdirSync(join(gitDir, "info"), { recursive: true });
         // Backstep's own folder, when it sits inside the project, holds the live journal: never snapshotted.
         const own = relative(root, resolve(homeDir()));
-        const skipOwn = own && !own.startsWith("..") && !isAbsolute(own) ? [`/${own}/`] : [];
+        const skipOwn = own && !own.startsWith("..") && !isAbsolute(own) ? [`/${own.split(sep).join("/")}/`] : [];
         writeFileSync(join(gitDir, "info", "exclude"), [...EXCLUDE, ...skipOwn].join("\n") + "\n");
         writeFileSync(join(gitDir, "description"), `Backstep snapshots of ${root}\n`);
     }
@@ -191,7 +196,7 @@ function projectGit(root, actionId, pushes) {
 // whole disk, or a folder too big to stage in time.
 export function snapshotTree(actionId, cwd, opts = {}) {
     const root = projectRoot(cwd);
-    if (root === "/" || root === homedir() || root === resolve(homeDir()))
+    if (isDiskRoot(root) || root === homedir() || root === resolve(homeDir()))
         return null;
     try {
         const gitDir = shadowFor(root);

package/dist/check.js

@@ -2,7 +2,7 @@
 // what to connect next. Setup prints it, `backstep status` prints it, and the
 // Claude Code mod checks it as a session starts, so nobody assumes a service
 // is covered when it isn't.
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { configServers, projectConnected, projectUses, supabaseDirs } from "./connect.js";
 import { supabaseProjects } from "./supabase.js";
 import { watchRules } from "./watch.js";

package/dist/connect.js

@@ -7,7 +7,7 @@
 //  - Firebase: undo runs through Firebase's own MCP server, so there's nothing
 //    to connect once Claude can reach Firebase. When the project uses Firebase
 //    and Claude can't, this adds that server (behind Backstep).
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -107,7 +107,7 @@ export function firebaseCreds(dir) {
     const vars = envVars(dir);
     const named = vars.find(([k]) => k === "GOOGLE_APPLICATION_CREDENTIALS")?.[1] ?? process.env.GOOGLE_APPLICATION_CREDENTIALS;
     if (named) {
-        const f = named.startsWith("/") ? named : join(dir, named);
+        const f = resolve(dir, named);
         if (existsSync(f))
             return f;
     }

package/dist/github.js

@@ -1,7 +1,7 @@
 // Things Claude makes on GitHub with the gh command line (a repository, an
 // issue, a pull request, a release), noted from what gh printed, so undo can
 // offer to take them away again with gh itself, signed in as the person.
-import { spawn, spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "./spawn.js";
 const CREATES = /\bgh\s+(repo|issue|pr|release)\s+create\b/g;
 const URL = /https:\/\/github\.com\/([\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(issues|pull)\/(\d+)|\/releases\/tag\/([^\s)]+))?(?=[\s)'"]|$)/g;
 // What a gh command made, from the command and what it printed.

package/dist/paths.js

@@ -0,0 +1,31 @@
+// Paths on every system Claude Code runs on. Windows writes C:\Users\me\app,
+// and its Bash (Git Bash) writes the same folder as /c/Users/me/app; macOS and
+// Linux write /Users/me/app. Each check here takes the path module to use, so
+// tests can ask the Windows question on any machine.
+import nodePath from "node:path";
+import { homedir } from "node:os";
+const native = nodePath;
+const isWin = (p) => p.sep === "\\";
+// A path as Git Bash on Windows writes it (/c/Users/me), turned into Windows' own (C:\Users\me).
+export function fromShellPath(raw, p = native) {
+    if (!isWin(p))
+        return raw;
+    const m = raw.match(/^\/([a-zA-Z])(\/.*)?$/);
+    return m ? p.normalize(`${m[1].toUpperCase()}:${m[2] ?? "\\"}`) : raw;
+}
+// A path a tool or command named, made absolute against the folder it ran in. `~` is the home folder.
+export function resolveIn(raw, cwd, p = native, home = homedir()) {
+    if (raw === "~" || raw.startsWith("~/") || (isWin(p) && raw.startsWith("~\\")))
+        return p.join(home, raw.slice(1));
+    return p.resolve(fromShellPath(cwd, p), fromShellPath(raw, p));
+}
+// Whether `path` is `dir` or inside it. Windows ignores letter case in paths.
+export function insidePath(path, dir, p = native) {
+    const rel = p.relative(p.resolve(fromShellPath(dir, p)), p.resolve(fromShellPath(path, p)));
+    return rel === "" || (rel !== ".." && !rel.startsWith(".." + p.sep) && !p.isAbsolute(rel));
+}
+// The root of a disk: / on macOS and Linux, C:\ on Windows.
+export function isDiskRoot(dir, p = native) {
+    const abs = p.resolve(dir);
+    return p.parse(abs).root === abs;
+}

package/dist/servers.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";

package/dist/setup.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { cpSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,7 +13,7 @@ import { sendInstall, telemetryOn } from "./telemetry.js";
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
 function run(cmd, args) {
     const r = spawnSync(cmd, args, { encoding: "utf8" });
-    return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim(), missing: r.error !== undefined };
+    return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim(), missing: Boolean(r.error) };
 }
 // npx runs us from a cache that gets cleaned, so the mod needs a lasting copy.
 // A global install also puts `backstep` on the PATH; where npm's global folder
@@ -53,7 +53,7 @@ export async function setup() {
     if (run("claude", ["--version"]).missing) {
         throw new Error("Claude Code isn't installed (no `claude` on PATH). Install it from https://claude.com/claude-code, then run this again.");
     }
-    const { root, onPath } = ROOT.includes("/_npx/") ? keepCopy() : { root: ROOT, onPath: true };
+    const { root, onPath } = /[\\/]_npx[\\/]/.test(ROOT) ? keepCopy() : { root: ROOT, onPath: true };
     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";

package/dist/shell.js

@@ -1,6 +1,7 @@
 // Decides what a shell command Claude is about to run could do, before it runs.
 // Reads pass straight through; commands that reach outside the machine can't be
 // taken back, so they're held; everything else gets the project snapshotted.
+import { resolveIn } from "./paths.js";
 // Programs that only look. A pipeline or chain is a read only if every part is.
 const READ_PROGRAMS = new Set([
     "ls", "ll", "la", "cat", "head", "tail", "less", "more", "grep", "egrep", "fgrep", "rg", "ag", "fd", "find", "tree",
@@ -139,7 +140,7 @@ export function commandDir(command, cwd) {
     const to = m?.[1] ?? m?.[2] ?? m?.[3];
     if (!to)
         return cwd;
-    return to.startsWith("/") ? to : to.startsWith("~") ? to.replace(/^~/, process.env.HOME ?? "~") : `${cwd.replace(/\/$/, "")}/${to}`;
+    return resolveIn(to, cwd);
 }
 // Commands that change Firebase's data some other way than its MCP server.
 const FIREBASE_DATA = /\bfirebase(-tools)?\s+(firestore:|database:)|firestore\.googleapis\.com|firebaseio\.com|firebasedatabase\.app/;

package/dist/spawn.js

@@ -0,0 +1,6 @@
+// Starting other programs (claude, npm, npx, gh) the same way on every system.
+// On Windows most of them are .cmd scripts, which Node's own spawn can't start
+// without a shell; cross-spawn finds them and quotes their arguments safely.
+import crossSpawn from "cross-spawn";
+export const spawnSync = crossSpawn.sync;
+export const spawn = crossSpawn.spawn;

package/dist/undo.js

@@ -8,6 +8,7 @@ import { snapshotDir } from "./store.js";
 import { dbKey, firebaseConn, freshUrl, restKey } from "./supabase.js";
 import { undoFirebase } from "./adapters/firestore.js";
 import { undoRest } from "./adapters/rest.js";
+import { insidePath } from "./paths.js";
 const INVERSE_TIMEOUT_MS = 20_000;
 // Database copies sit in the person's own database, so only the newest few per
 // database are kept; older commands keep their file undo but not their database undo.
@@ -60,7 +61,7 @@ function overlaps(a, b) {
         return true;
     if (!a.startsWith("fs:") || !b.startsWith("fs:"))
         return false;
-    return a.startsWith(b + "/") || b.startsWith(a + "/");
+    return insidePath(a.slice(3), b.slice(3)) || insidePath(b.slice(3), a.slice(3));
 }
 // Failed calls stay undoable: a tool can change things before it errors out.
 function undoable(a) {

package/dist/uninstall.js

@@ -6,7 +6,7 @@
 //   4. the Claude Code plugin and its source are removed
 //   5. ~/.backstep (history, snapshots, saved connections) is deleted
 //   6. the global npm package, when setup installed one
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, rmSync } from "node:fs";
 import { homeDir, Store } from "./store.js";
 import { unwrapServers } from "./servers.js";
@@ -23,9 +23,12 @@ async function dropDatabaseCopies() {
     if (!existsSync(homeDir()))
         return null;
     const store = new Store();
+    // Closed right after reading: Windows won't delete a file that's still open.
+    const copies = store.databaseCopies();
+    store.close();
     const urls = new Map();
     let dropped = 0;
-    for (const a of store.databaseCopies()) {
+    for (const a of copies) {
         const u = JSON.parse(a.undo);
         for (const d of u.dbs ?? []) {
             const url = await freshUrl(d.url).catch(() => d.url);

package/dist/update.js

@@ -2,7 +2,7 @@
 // whether npm has a newer version; if so it asks the person, and an update
 // runs the new version's own setup, the same command a first install runs.
 // Off with BACKSTEP_UPDATE_CHECK=0.
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homeDir } from "./store.js";

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

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

@@ -11,11 +11,11 @@ const CLI = '/opt/backstep/cli.js'
 
 // The engine beneath the mod: a repo at /repo, and a Backstep CLI whose
 // `undo` answers with `undo`. Every argv the mod runs is recorded.
-function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: string }, shell: object = { kind: 'read', undoable: false }) {
+function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: string }, shell: object = { kind: 'read', undoable: false }, cwd = '/repo') {
   const runs: string[][] = []
   const logs: string[] = []
   const prompts: { text: string; context?: readonly string[] }[] = []
-  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.cwd', () => ({ value: cwd }))
   on('session.id', () => ({ value: 's1' }))
   on('ui.log', (_, e) => {
     logs.push(e.text)
@@ -75,6 +75,25 @@ test('edits outside the open folder are never tracked', { options: { cli: CLI }
   await ui.unmount()
 })
 
+test('on Windows, edits in the open folder are tracked however the path is written, and others never are', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { runs } = engine(on, { exitCode: 0, stdout: '[]' }, undefined, 'C:\\Users\\me\\app')
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: 'C:\\Users\\me\\app\\src\\a.ts', old_string: 'a', new_string: 'b' })
+  await $.tool.call({ tool: 'Edit', file_path: 'c:/users/me/APP/src/b.ts', old_string: 'a', new_string: 'b' })
+  await $.tool.call({ tool: 'Write', file_path: '/c/Users/me/app/src/c.ts', content: 'x' })
+  await $.tool.call({ tool: 'Write', file_path: 'C:\\Users\\me\\app-old\\x.ts', content: 'x' })
+  await $.tool.call({ tool: 'Write', file_path: 'C:\\Users\\me\\app\\..\\other\\x.ts', content: 'x' })
+  await $.tool.call({ tool: 'Write', file_path: 'D:\\Users\\me\\app\\x.ts', content: 'x' })
+
+  expect(runs.filter((r) => r.includes('snap')).map((r) => r.at(-1))).toEqual([
+    'C:\\Users\\me\\app\\src\\a.ts',
+    'c:/users/me/APP/src/b.ts',
+    '/c/Users/me/app/src/c.ts',
+  ])
+})
+
 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 })

package/mod/hooks/register.tsx

@@ -183,17 +183,38 @@ 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}`
+// Whether a file path is inside the folder this session has open. Works for
+// macOS and Linux paths (/Users/me/app), Windows ones (C:\Users\me\app, any
+// letter case) and Git Bash's spelling of them (/c/Users/me/app).
+function normPath(path: string, cwd: string): string {
+  const win = /^[a-zA-Z]:[\\/]/.test(cwd) || cwd.startsWith('\\\\')
+  let raw = path.replace(/\\/g, '/')
+  if (win) raw = raw.replace(/^\/([a-zA-Z])(?=\/|$)/, '$1:')
+  const base = cwd.replace(/\\/g, '/')
+  const absolute = win ? /^[a-zA-Z]:\//.test(raw) || raw.startsWith('//') : raw.startsWith('/')
+  const abs = absolute ? raw : `${base}/${raw}`
+  const unc = win && abs.startsWith('//')
   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 + '/')
+  const p = (unc ? '//' : win ? '' : '/') + parts.join('/')
+  return win ? p.toLowerCase() : p
+}
+
+function within(path: string, cwd: string): boolean {
+  const p = normPath(path, cwd)
+  const d = normPath('.', cwd)
+  return p === d || p.startsWith(d.replace(/\/$/, '') + '/')
+}
+
+// A file's path from the session's folder, for showing; anything else as given.
+function relPath(path: string, cwd: string): string {
+  if (!within(path, cwd)) return path
+  const slashed = path.replace(/\\/g, '/')
+  const base = cwd.replace(/\\/g, '/').replace(/\/$/, '')
+  return slashed.length > base.length + 1 && slashed.toLowerCase().startsWith(base.toLowerCase() + '/') ? slashed.slice(base.length + 1) : path
 }
 
 async function pressUndo($: EngineInterface) {
@@ -229,7 +250,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 short = (p: string) => relPath(p, cwd)
   const [ran] = await Promise.all([
     $.process.run(backstep(['undo', '--since', String(target.startedAt), '--session', await $.session.id(), '--json', '--via-claude-code'])).catch((err: unknown) => ({
       exitCode: 1,
@@ -805,7 +826,7 @@ export const register: Register = (on, options) => {
         if (snap?.exitCode === 0) {
           await bump($, t.id, (x) => ({ ...x, gitOnly: false, edits: x.edits + 1, files: x.files.includes(path) ? x.files : [...x.files, path] }))
         } else {
-          await bump($, t.id, (x) => lostOne({ ...x, gitOnly: false }, `edit to ${path.split('/').pop()}: Backstep couldn't save a copy first`))
+          await bump($, t.id, (x) => lostOne({ ...x, gitOnly: false }, `edit to ${path.split(/[\\/]/).pop()}: Backstep couldn't save a copy first`))
         }
       }
     } else if (tool === 'Bash') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "homepage": "https://getbackstep.com",
   "scripts": {
@@ -15,6 +15,7 @@
   "type": "module",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.2",
+    "cross-spawn": "^7.0.6",
     "pg": "^8.23.1",
     "zod": "^4.6.7"
   },
@@ -22,6 +23,7 @@
     "@electric-sql/pglite": "^0.5.12",
     "@electric-sql/pglite-socket": "^0.2.15",
     "@modelcontextprotocol/server-filesystem": "^2.0.1",
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^26.6.5",
     "@types/pg": "^8.23.1",
     "typescript": "^7.0.2"