backstep 0.1.2 → 0.1.3

package/README.md

@@ -8,6 +8,7 @@ Undo for everything your agents touch. Backstep sits between your agent (Claude
 - **Supabase:** `execute_sql` and `apply_migration` snapshot the tables they change, over a connection to the project's database. Backstep never connects it on its own: when Claude Code opens a project that uses Supabase and isn't connected, it asks (Connect, Not now, or Don't ask for this project). Connect uses a connection string in the project's `.env` files, the local `supabase start` database, or a Supabase sign-in (`supabase login`, `SUPABASE_ACCESS_TOKEN`, or an access token you give Backstep once), with which the project gets a temporary database login that Backstep renews as it runs out. You can also ask Claude to "connect Backstep to Supabase" any time. Deleted rows, dropped tables and migrations, including the migration's history row, all come back. Works for the claude.ai Supabase connector and a local Supabase MCP server alike.
 - **Firebase:** before a change, Backstep reads what's there through the Firebase MCP server itself, and undoes through it too, so there's nothing to set up. Firestore documents updated, deleted or added; Realtime Database writes; Remote Config publishes (rolled back to the version before); and users enabled or disabled.
 - **claude.ai connectors and servers Claude Code signs in to:** Backstep can't sit in front of these, so the Claude Code mod watches their calls instead. Calls with an undo rule are undone through Claude Code's own connection.
+- **Database commands Claude runs** (`supabase db push`, `supabase migration up`, `supabase db reset`, `psql`, `prisma migrate`, `drizzle-kit push`, seed scripts…): in a project whose Supabase database is connected, the whole database is noted before the command runs, and ctrl+z puts it back in one transaction: rows, new tables dropped, dropped or altered tables rebuilt with their constraints, indexes, foreign keys, row level security policies, triggers and grants, sequence counters, and the migration history. Copies sit in a `backstep` schema in the same database; the newest 10 per database are kept. On a very big database it keeps every table's structure and the migration history, and rows smallest-table-first up to a budget (`BACKSTEP_DB_SNAPSHOT_MB`, default 250); undo names any table whose rows it couldn't bring back. Functions, views, types and extensions aren't restored.
 - **Code Claude pushed:** ctrl+z rewinds the commits locally, then asks whether to undo them on GitHub (or any remote) too. Yes pushes one new commit that undoes Claude's, made in a temporary worktree: no force push, no rewritten history, so it works on protected branches and for teammates who already pulled. Newer commits that clash, or a rewritten branch, stop it. A branch Claude created is deleted instead, if nobody has added to it. It uses the project's own git sign-in, so there's nothing to connect.
 - **Things that can't be undone** (sending email, payments, deploys, `ALTER TABLE`…) run as normal and are marked in the journal, so you know what an undo didn't cover.
 - **Anything else, by rule:** a rules file maps a tool to its opposite (`create_issue` → close the issue, `send_message` → retract it), filled in from the call and its result. See [Undo rules](#undo-rules).

package/dist/adapters/dbsnap.js

@@ -0,0 +1,265 @@
+// Database undo for shell commands (`supabase db push`, `supabase migration up`,
+// `psql`, `prisma migrate`, seed scripts…), which change a database Backstep
+// can't see into. Before the command runs, the whole database's own tables are
+// noted:
+//  - every table's structure: columns, constraints, indexes, foreign keys,
+//    row level security and its policies, triggers, grants, sequence counters;
+//  - every table's rows, copied into Backstep's own schema in the same
+//    database, smallest tables first, until a size budget is spent. A very big
+//    database keeps its structure, its migration history and as many tables'
+//    rows as fit; undo names the tables whose rows it couldn't bring back.
+// Undo, in one transaction: drops tables made since, rebuilds tables dropped
+// or reshaped, and puts back rows wherever they changed.
+import pg from "pg";
+import { q } from "./postgres.js";
+const SNAP_SCHEMA = "backstep";
+const budget = () => Number(process.env.BACKSTEP_DB_SNAPSHOT_MB ?? 250) * 1024 * 1024;
+// Supabase's and Postgres's own schemas: managed by them, not by the project's migrations.
+const SYSTEM = [
+    "information_schema", "auth", "storage", "realtime", "_realtime", "extensions", "graphql", "graphql_public", "pgsodium",
+    "pgsodium_masks", "vault", "net", "supabase_functions", "cron", "pgbouncer", "_analytics", "_supavisor", "pgtle", "topology",
+    "tiger", "tiger_data",
+];
+const MIGRATIONS = "supabase_migrations";
+async function withClient(url, fn) {
+    const client = new pg.Client({ connectionString: url, connectionTimeoutMillis: 10_000 });
+    await client.connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        await client.end();
+    }
+}
+async function tables(c) {
+    const r = await c.query(`SELECT c.oid::int AS oid, n.nspname AS schema, c.relname AS name, pg_total_relation_size(c.oid)::bigint AS bytes
+     FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE c.relkind = 'r' AND NOT c.relispartition
+       AND n.nspname NOT LIKE 'pg\\_%' AND n.nspname NOT LIKE 'backstep%' AND n.nspname <> ALL($1::text[])
+     ORDER BY n.nspname, c.relname`, [SYSTEM]);
+    return r.rows.map((x) => ({ oid: Number(x.oid), schema: x.schema, name: x.name, bytes: Number(x.bytes) }));
+}
+const full = (t) => `${q(t.schema)}.${q(t.name)}`;
+async function shapeOf(c, oid) {
+    const r = await c.query(`SELECT string_agg(attname || ' ' || format_type(atttypid, atttypmod), ', ' ORDER BY attnum) AS s
+     FROM pg_attribute WHERE attrelid = $1 AND attnum > 0 AND NOT attisdropped`, [oid]);
+    return r.rows[0].s ?? "";
+}
+async function describe(c, t) {
+    const name = full(t);
+    const cols = await c.query(`SELECT a.attname, format_type(a.atttypid, a.atttypmod) AS type, a.attnotnull, a.attidentity, a.attgenerated,
+            pg_get_expr(d.adbin, d.adrelid) AS def
+     FROM pg_attribute a LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+     WHERE a.attrelid = $1 AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum`, [t.oid]);
+    const seqs = await c.query(`SELECT s.oid::regclass::text AS name, a.attname
+     FROM pg_depend dep JOIN pg_class s ON s.oid = dep.objid AND s.relkind = 'S'
+     JOIN pg_attribute a ON a.attrelid = dep.refobjid AND a.attnum = dep.refobjsubid
+     WHERE dep.refobjid = $1 AND dep.deptype IN ('a', 'i')`, [t.oid]);
+    const seqValues = [];
+    const create = [];
+    // Serial columns' sequences go with their table; make them first so the defaults resolve.
+    const serial = seqs.rows.filter((s) => !cols.rows.find((col) => col.attname === s.attname)?.attidentity);
+    for (const s of serial)
+        create.push(`CREATE SEQUENCE IF NOT EXISTS ${s.name}`);
+    const defs = cols.rows.map((col) => {
+        let d = `${q(col.attname)} ${col.type}`;
+        if (col.attgenerated === "s")
+            d += ` GENERATED ALWAYS AS (${col.def}) STORED`;
+        else if (col.attidentity)
+            d += ` GENERATED ${col.attidentity === "a" ? "ALWAYS" : "BY DEFAULT"} AS IDENTITY`;
+        else if (col.def !== null)
+            d += ` DEFAULT ${col.def}`;
+        if (col.attnotnull)
+            d += " NOT NULL";
+        return d;
+    });
+    create.push(`CREATE TABLE ${name} (${defs.join(", ")})`);
+    for (const s of serial)
+        create.push(`ALTER SEQUENCE ${s.name} OWNED BY ${name}.${q(s.attname)}`);
+    for (const s of seqs.rows) {
+        const v = await c.query(`SELECT last_value::text AS v, is_called FROM ${s.name}`);
+        seqValues.push({ name: s.name, value: v.rows[0].v, called: v.rows[0].is_called });
+    }
+    const cons = await c.query(`SELECT conname, contype, pg_get_constraintdef(oid) AS def FROM pg_constraint
+     WHERE conrelid = $1 AND contype IN ('p', 'u', 'c', 'x', 'f') ORDER BY contype = 'p' DESC, conname`, [t.oid]);
+    const fks = [];
+    for (const k of cons.rows) {
+        const sql = `ALTER TABLE ${name} ADD CONSTRAINT ${q(k.conname)} ${k.def}`;
+        if (k.contype === "f")
+            fks.push({ name: k.conname, sql });
+        else
+            create.push(sql);
+    }
+    const idx = await c.query(`SELECT pg_get_indexdef(i.indexrelid) AS def FROM pg_index i
+     WHERE i.indrelid = $1 AND NOT EXISTS (SELECT 1 FROM pg_constraint k WHERE k.conindid = i.indexrelid)`, [t.oid]);
+    for (const i of idx.rows)
+        create.push(i.def);
+    const rls = await c.query(`SELECT relrowsecurity, relforcerowsecurity FROM pg_class WHERE oid = $1`, [t.oid]);
+    if (rls.rows[0].relrowsecurity)
+        create.push(`ALTER TABLE ${name} ENABLE ROW LEVEL SECURITY`);
+    if (rls.rows[0].relforcerowsecurity)
+        create.push(`ALTER TABLE ${name} FORCE ROW LEVEL SECURITY`);
+    const pols = await c.query(`SELECT policyname, permissive, cmd, roles::text[] AS roles, qual, with_check FROM pg_policies WHERE schemaname = $1 AND tablename = $2`, [t.schema, t.name]);
+    for (const p of pols.rows) {
+        const roles = p.roles.map((r) => (r === "public" ? "public" : q(r))).join(", ");
+        create.push(`CREATE POLICY ${q(p.policyname)} ON ${name} AS ${p.permissive} FOR ${p.cmd} TO ${roles}` +
+            (p.qual ? ` USING (${p.qual})` : "") +
+            (p.with_check ? ` WITH CHECK (${p.with_check})` : ""));
+    }
+    // Supabase's API reaches tables through grants to anon and authenticated.
+    const grants = await c.query(`SELECT CASE WHEN g.grantee = 0 THEN 'PUBLIC' ELSE quote_ident(pg_get_userbyid(g.grantee)) END AS who, g.privilege_type AS priv
+     FROM pg_class c, aclexplode(c.relacl) g WHERE c.oid = $1 AND g.grantee <> c.relowner`, [t.oid]);
+    for (const g of grants.rows)
+        create.push(`GRANT ${g.priv} ON ${name} TO ${g.who}`);
+    const trig = await c.query(`SELECT pg_get_triggerdef(oid) AS def FROM pg_trigger WHERE tgrelid = $1 AND NOT tgisinternal`, [t.oid]);
+    return { schema: t.schema, name: t.name, shape: await shapeOf(c, t.oid), create, triggers: trig.rows.map((x) => x.def), fks, seqs: seqValues };
+}
+// The same rows in any order give the same fingerprint.
+async function fingerprint(c, table) {
+    const r = await c.query(`SELECT md5(coalesce(string_agg(h, '' ORDER BY h), '')) AS s FROM (SELECT md5(t::text) AS h FROM ${table} t) x`);
+    return r.rows[0].s;
+}
+export async function snapshotDb(actionId, url) {
+    return withClient(url, async (c) => {
+        const all = await tables(c);
+        await c.query(`CREATE SCHEMA IF NOT EXISTS ${q(SNAP_SCHEMA)}`);
+        // The migration history first, then the smallest tables: the most tables for the budget.
+        const order = [...all].sort((a, b) => Number(b.schema === MIGRATIONS) - Number(a.schema === MIGRATIONS) || a.bytes - b.bytes);
+        let spent = 0;
+        const copied = new Map();
+        let k = 0;
+        for (const t of order) {
+            if (t.schema !== MIGRATIONS && spent + t.bytes > budget())
+                continue;
+            spent += t.bytes;
+            const copy = `${actionId}_db${k++}`;
+            await c.query(`CREATE TABLE ${q(SNAP_SCHEMA)}.${q(copy)} AS TABLE ${full(t)}`);
+            copied.set(t.oid, { copy, sum: await fingerprint(c, full(t)) });
+        }
+        const out = [];
+        for (const t of all)
+            out.push({ ...(await describe(c, t)), copy: copied.get(t.oid)?.copy ?? null, sum: copied.get(t.oid)?.sum ?? null });
+        return { adapter: "db", url, tables: out };
+    });
+}
+async function insertable(c, table) {
+    const r = await c.query(`SELECT string_agg(quote_ident(attname), ', ' ORDER BY attnum) AS cols FROM pg_attribute
+     WHERE attrelid = to_regclass($1) AND attnum > 0 AND NOT attisdropped AND attgenerated = ''`, [table]);
+    return r.rows[0].cols;
+}
+async function putRows(c, t) {
+    const cols = await insertable(c, full(t));
+    const r = await c.query(`INSERT INTO ${full(t)} (${cols}) OVERRIDING SYSTEM VALUE SELECT ${cols} FROM ${q(SNAP_SCHEMA)}.${q(t.copy)}`);
+    return r.rowCount ?? 0;
+}
+const label = (t) => (t.schema === "public" ? t.name : `${t.schema}.${t.name}`);
+export async function undoDb(url, u) {
+    return withClient(url, async (c) => {
+        const log = [];
+        await c.query("BEGIN");
+        try {
+            const now = new Map((await tables(c)).map((t) => [`${t.schema}.${t.name}`, t]));
+            const was = new Map(u.tables.map((t) => [`${t.schema}.${t.name}`, t]));
+            // Made since: gone again.
+            for (const [key, t] of now) {
+                if (was.has(key))
+                    continue;
+                await c.query(`DROP TABLE IF EXISTS ${full(t)} CASCADE`);
+                log.push(`removed new table ${label(t)}`);
+            }
+            // Dropped or reshaped since: rebuilt as it was, rows and all.
+            const rebuilt = [];
+            const changed = [];
+            for (const [key, t] of was) {
+                const cur = now.get(key);
+                if (cur && (await shapeOf(c, cur.oid)) === t.shape) {
+                    if (t.copy && (await fingerprint(c, full(t))) !== t.sum)
+                        changed.push(t);
+                    continue;
+                }
+                if (cur)
+                    await c.query(`DROP TABLE ${full(t)} CASCADE`);
+                for (const sql of t.create)
+                    await c.query(sql);
+                rebuilt.push(t);
+            }
+            for (const t of rebuilt) {
+                const rows = t.copy ? await putRows(c, t) : 0;
+                log.push(t.copy
+                    ? `restored table ${label(t)} (${rows} rows)`
+                    : `restored table ${label(t)}, but not its rows: it was too big to copy`);
+            }
+            // Rows changed in a table that's still there: put the old ones back. Tables
+            // whose rows point at these come along, so no foreign key is left dangling.
+            const set = new Map(changed.map((t) => [`${t.schema}.${t.name}`, t]));
+            for (let grew = true; grew;) {
+                grew = false;
+                const refs = await c.query(`SELECT DISTINCT cn.nspname || '.' || cl.relname AS child, pn.nspname || '.' || pl.relname AS parent
+           FROM pg_constraint k JOIN pg_class cl ON cl.oid = k.conrelid JOIN pg_namespace cn ON cn.oid = cl.relnamespace
+           JOIN pg_class pl ON pl.oid = k.confrelid JOIN pg_namespace pn ON pn.oid = pl.relnamespace WHERE k.contype = 'f'`);
+                for (const r of refs.rows) {
+                    if (!set.has(r.parent) || set.has(r.child) || r.child === r.parent)
+                        continue;
+                    const child = was.get(r.child);
+                    if (!child?.copy)
+                        throw new Error(`couldn't put back the rows of ${label(set.get(r.parent))}: ${r.child} points at them and was too big to copy`);
+                    set.set(r.child, child);
+                    grew = true;
+                }
+            }
+            if (set.size) {
+                const list = [...set.values()];
+                for (const t of list)
+                    await c.query(`ALTER TABLE ${full(t)} DISABLE TRIGGER USER`);
+                await c.query(`TRUNCATE ${list.map(full).join(", ")}`);
+                // Parents before the tables that point at them.
+                const left = new Set(set.keys());
+                const deps = await c.query(`SELECT cn.nspname || '.' || cl.relname AS child, pn.nspname || '.' || pl.relname AS parent
+           FROM pg_constraint k JOIN pg_class cl ON cl.oid = k.conrelid JOIN pg_namespace cn ON cn.oid = cl.relnamespace
+           JOIN pg_class pl ON pl.oid = k.confrelid JOIN pg_namespace pn ON pn.oid = pl.relnamespace WHERE k.contype = 'f'`);
+                while (left.size) {
+                    const ready = [...left].filter((k) => !deps.rows.some((d) => d.child === k && d.parent !== k && left.has(d.parent)));
+                    const batch = ready.length ? ready : [...left];
+                    for (const key of batch) {
+                        const t = set.get(key);
+                        log.push(`restored ${await putRows(c, t)} rows in ${label(t)}`);
+                        left.delete(key);
+                    }
+                }
+                for (const t of list)
+                    await c.query(`ALTER TABLE ${full(t)} ENABLE TRIGGER USER`);
+            }
+            // Triggers on rebuilt tables once their rows are in, then every foreign key a drop took with it.
+            for (const t of rebuilt)
+                for (const sql of t.triggers)
+                    await c.query(sql);
+            for (const t of u.tables) {
+                for (const fk of t.fks) {
+                    const has = await c.query(`SELECT 1 FROM pg_constraint WHERE conrelid = to_regclass($1) AND conname = $2`, [full(t), fk.name]);
+                    if (has.rowCount === 0)
+                        await c.query(fk.sql);
+                }
+            }
+            // Counters, so new rows don't collide with restored ones.
+            for (const t of [...rebuilt, ...set.values()]) {
+                for (const s of t.seqs)
+                    await c.query(`SELECT setval($1, $2::bigint, $3)`, [s.name, s.value, s.called]);
+            }
+            await c.query("COMMIT");
+        }
+        catch (err) {
+            await c.query("ROLLBACK");
+            throw err;
+        }
+        await dropCopies(c, u);
+        return log.length ? log.join("\n") : "nothing had changed in the database";
+    });
+}
+async function dropCopies(c, u) {
+    for (const t of u.tables)
+        if (t.copy)
+            await c.query(`DROP TABLE IF EXISTS ${q(SNAP_SCHEMA)}.${q(t.copy)}`);
+}
+export async function discardDb(u) {
+    await withClient(u.url, (c) => dropCopies(c, u)).catch(() => { });
+}

package/dist/cli.js

@@ -4,12 +4,14 @@ import { fileURLToPath } from "node:url";
 import { runProxy } from "./proxy.js";
 import { startUi } from "./ui/server.js";
 import { Store, snapshotDir } from "./store.js";
-import { undoAction, undoRun, undoSince } from "./undo.js";
+import { pruneDatabaseCopies, undoAction, undoRun, undoSince } from "./undo.js";
 import { snapshotPaths } from "./adapters/fs.js";
 import { notePushed, snapshotTree } from "./adapters/tree.js";
 import { revertPush } from "./push.js";
+import { snapshotDb } from "./adapters/dbsnap.js";
+import { projectDatabases } from "./connect.js";
 const PUSH = /\bgit\b[^;&|]*\bpush\b/;
-import { classifyShell } from "./shell.js";
+import { classifyShell, supabaseTarget, touchesDatabase } from "./shell.js";
 import { watchEnd, watchStart } from "./watch.js";
 import { sendActive } from "./telemetry.js";
 import { readFileSync, rmSync } from "node:fs";
@@ -317,12 +319,35 @@ async function main() {
         });
         // Outbound commands still get a snapshot: whatever they change locally can come back.
         // A push also notes where the remote branches stood, so undo can take it back there too.
-        const undo = snapshotTree(a.id, values.cwd ?? process.cwd(), { pushes: PUSH.test(command) });
+        const cwd = values.cwd ?? process.cwd();
+        const tree = snapshotTree(a.id, cwd, { pushes: PUSH.test(command) });
+        // A migration, reset, seed or raw SQL: the connected databases it could change are noted too.
+        const dbs = [];
+        const missed = [];
+        if (touchesDatabase(command)) {
+            for (const url of await projectDatabases(cwd, supabaseTarget(command))) {
+                try {
+                    dbs.push(await snapshotDb(a.id, url));
+                }
+                catch (err) {
+                    missed.push(err instanceof Error ? err.message : String(err));
+                }
+            }
+        }
+        const undo = tree ? { ...tree, ...(dbs.length ? { dbs } : {}) } : dbs.length ? { adapter: "dbs", dbs } : null;
         if (undo)
             store.updateAction(a.id, { undo: JSON.stringify(undo) });
-        else if (plan.kind !== "outbound")
+        // With its database saved, a command that reaches it is no longer lost to undo.
+        const kind = plan.kind === "outbound" && dbs.length && plan.reason === "changes a database directly" ? "write" : plan.kind;
+        if (kind !== plan.kind)
+            store.updateAction(a.id, { kind: "reversible", reason: null });
+        if (!undo && kind !== "outbound")
             store.updateAction(a.id, { kind: "write", reason: "project too large to snapshot" });
-        console.log(JSON.stringify({ kind: plan.kind, reason: plan.reason, id: a.id, undoable: undo !== null }));
+        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: dbs.length }));
         return;
     }
     // After a shell command that pushed: notes what it sent (run by the Claude Code mod).

package/dist/connect.js

@@ -12,7 +12,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { claudeConfigFile, wrapServers } from "./servers.js";
-import { connectSupabase, hasSavedToken, LOCAL, mintSupabase, projectRef, saveSupabaseToken, supabaseDismissed, supabaseProjects, supabaseToken } from "./supabase.js";
+import { connectSupabase, hasSavedToken, LOCAL, mintSupabase, projectRef, saveSupabaseToken, supabaseDb, supabaseDismissed, supabaseProjects, supabaseToken, supabaseUrl, } from "./supabase.js";
 const ENV_FILES = [".env", ".env.local", ".env.development", ".env.development.local"];
 const PG = /^postgres(ql)?:\/\//;
 const FIREBASE_SERVER = ["npx", "-y", "firebase-tools@latest", "mcp"];
@@ -105,6 +105,23 @@ function linkedRef(dir) {
     }
     return undefined;
 }
+// The connected databases a command in this folder could change: only ones the
+// person connected, so a database is never touched without their say.
+export async function projectDatabases(dir, target) {
+    const out = [];
+    const ref = linkedRef(dir);
+    if (target !== "local" && ref && supabaseProjects().includes(ref)) {
+        const url = await supabaseUrl(ref);
+        if (url)
+            out.push(url);
+    }
+    if (target !== "hosted" && projectUses(dir).supabase) {
+        const local = supabaseDb(LOCAL);
+        if (local)
+            out.push(local);
+    }
+    return out;
+}
 // Signed in to Supabase: this folder's project connects now, the rest as Claude uses them.
 async function signedIn(dir, token, ref, isNew) {
     const project = ref ?? linkedRef(dir);

package/dist/shell.js

@@ -110,3 +110,18 @@ export function classifyShell(command) {
         return { kind: "read" };
     return { kind: "write" };
 }
+// Commands that change a database through its own tools rather than Claude's:
+// migrations, resets, seeds and raw SQL.
+const DATABASE = /(^|[\s;&|(])(npx\s+|pnpm\s+(dlx\s+)?|bunx\s+|yarn\s+)?(supabase\s+(db|migration|seed)\b|psql\b|pg_restore\b|prisma\s+(migrate|db)\b|drizzle-kit\s+(push|migrate)\b|knex\s+(migrate|seed)|sequelize(-cli)?\s+db:|typeorm\s+(migration|schema)|node-pg-migrate\b|dbmate\b|goose\b|sqlx\s+(migrate|database)\b|alembic\b|(rails|rake)\s+db:|python3?\s+manage\.py\s+(migrate|flush|loaddata)\b)/;
+export function touchesDatabase(command) {
+    return DATABASE.test(command);
+}
+// Which of a project's databases a Supabase command aims at: `db push` and
+// --linked mean the hosted project, the rest default to the local one.
+export function supabaseTarget(command) {
+    if (!/\bsupabase\s+(db|migration|seed)\b/.test(command))
+        return "both";
+    if (/--local\b/.test(command))
+        return "local";
+    return /--linked\b|--db-url\b|\bdb\s+push\b/.test(command) ? "hosted" : "local";
+}

package/dist/store.js

@@ -114,6 +114,12 @@ export class Store {
         const r = this.db.prepare("UPDATE actions SET status = ? WHERE id = ? AND status = ?").run(to, id, from);
         return r.changes === 1;
     }
+    // Actions still holding a copy of a database, newest first.
+    databaseCopies() {
+        return this.db
+            .prepare(`SELECT * FROM actions WHERE undo LIKE '%"adapter":"db"%' AND status IN ('ok', 'error') ORDER BY created_at DESC`)
+            .all();
+    }
     getAction(id) {
         return this.db.prepare("SELECT * FROM actions WHERE id = ?").get(id);
     }

package/dist/undo.js

@@ -3,18 +3,45 @@ import { rmSync } from "node:fs";
 import { undoPaths } from "./adapters/fs.js";
 import { undoSql } from "./adapters/postgres.js";
 import { undoTree } from "./adapters/tree.js";
+import { discardDb, undoDb } from "./adapters/dbsnap.js";
 import { snapshotDir } from "./store.js";
 import { dbKey, freshUrl } from "./supabase.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.
+const KEEP_DB_COPIES = 10;
+export async function pruneDatabaseCopies(store) {
+    const seen = new Map();
+    for (const a of store.databaseCopies()) {
+        const u = JSON.parse(a.undo);
+        const keep = [];
+        for (const d of u.dbs ?? []) {
+            const k = dbKey(d.url);
+            const n = (seen.get(k) ?? 0) + 1;
+            seen.set(k, n);
+            if (n <= KEEP_DB_COPIES)
+                keep.push(d);
+            else
+                await discardDb({ ...d, url: await freshUrl(d.url) });
+        }
+        if (keep.length === (u.dbs ?? []).length)
+            continue;
+        const next = u.adapter === "dbs" ? (keep.length ? { ...u, dbs: keep } : null) : { ...u, dbs: keep.length ? keep : undefined };
+        store.updateAction(a.id, { undo: next ? JSON.stringify(next) : null, ...(next ? {} : { kind: "write", reason: "its database copy was cleared to save space" }) });
+    }
+}
 function resources(store, a) {
     const u = a.undo ? JSON.parse(a.undo) : null;
     if (!u)
         return new Set();
     if (u.adapter === "fs")
         return new Set(u.entries.map((e) => `fs:${e.path}`));
-    // A project snapshot rewinds every file under its folder.
+    // A project snapshot rewinds every file under its folder, and any whole database saved with it.
+    const whole = (dbs = []) => dbs.map((d) => `pgdb:${dbKey(d.url)}`);
     if (u.adapter === "tree")
-        return new Set([`fs:${u.root}`]);
+        return new Set([`fs:${u.root}`, ...whole(u.dbs)]);
+    if (u.adapter === "dbs")
+        return new Set(whole(u.dbs));
     // An opposite tool call doesn't rewind shared state, so it never conflicts.
     if (u.adapter === "inverse" || u.adapter === "engine")
         return new Set();
@@ -22,7 +49,7 @@ function resources(store, a) {
     const url = u.url ?? store.getRun(a.run_id)?.pg_url;
     const db = url ? dbKey(url) : a.run_id;
     const pgKey = (t) => `pg:${db}:${t.schema}.${t.name}`;
-    return new Set([...u.snapshots, ...u.trashed, ...u.created].map(pgKey));
+    return new Set([...u.snapshots, ...u.trashed, ...u.created].map(pgKey).concat(url ? [`pgdb:${dbKey(url)}`] : []));
 }
 // Same resource, or a file inside a folder that's rewound whole.
 function overlaps(a, b) {
@@ -102,8 +129,14 @@ async function undoOne(store, a, opts = {}) {
         if (u.adapter === "fs") {
             detail = undoPaths(u);
         }
-        else if (u.adapter === "tree") {
-            detail = undoTree(u, a.id);
+        else if (u.adapter === "tree" || u.adapter === "dbs") {
+            // The databases first: their undo is one transaction each, so a failure leaves everything as it was.
+            const lines = [];
+            for (const d of u.dbs ?? [])
+                lines.push(await undoDb(await freshUrl(d.url), d));
+            if (u.adapter === "tree")
+                lines.unshift(undoTree(u, a.id));
+            detail = lines.filter((l) => !/^nothing had changed/.test(l)).join("\n") || lines[0];
         }
         else {
             const url = u.url ?? store.getRun(a.run_id)?.pg_url;

package/mod/hooks/register.tsx

@@ -485,7 +485,8 @@ export const register: Register = (on, options) => {
       const sid = await $.session.id()
       // Never blocks the command: if Backstep can't be reached it just won't be undoable.
       const ran = await $.process
-        .run(backstep(['shell', '--session', sid, '--cwd', cwd, '--', command]), { timeoutMs: 60_000 })
+        // A database command copies the database first, which takes longer on a big one.
+        .run(backstep(['shell', '--session', sid, '--cwd', cwd, '--', command]), { timeoutMs: 180_000 })
         .catch(() => null)
       let plan: ShellPlan | null = null
       try {

package/package.json

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