backstep 0.1.8 → 0.1.9

package/README.md

@@ -9,6 +9,7 @@ Undo for everything your agents touch. Backstep sits between your agent (Claude
 - **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+u 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.
+- **Supabase through its web API** (curl to `/rest/v1`, seed and app scripts using supabase-js): Backstep finds Supabase projects in the folder Claude Code opened or a level or two below, and the first time Claude is about to change one that isn't connected, it asks before the command runs. Connect uses the project's own `SUPABASE_URL` and service role key from its `.env`, no password: every table's rows are saved on this machine before each such command (smallest first, up to the size budget), and ctrl+u removes rows added since and writes back the old ones. Table changes need the database itself connected (password or access token).
 - **Code Claude pushed:** ctrl+u 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/rest.js

@@ -0,0 +1,170 @@
+// Supabase undo through its own web API (PostgREST), for a project Backstep
+// reaches with the keys in its .env rather than a database password. Before a
+// command that could change it (a curl to /rest/v1, a seed script, an app
+// script using supabase-js), every table's rows are read and kept on this
+// machine, smallest tables first up to a budget. Undo deletes rows added
+// since and writes the old rows back. Rows only: the web API can't drop or
+// rebuild tables, so table changes need the database itself connected.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { snapshotDir } from "../store.js";
+const PAGE = 1000;
+const budget = () => Number(process.env.BACKSTEP_DB_SNAPSHOT_MB ?? 250) * 1024 * 1024;
+async function call(url, key, path, init = {}) {
+    const r = await fetch(`${url.replace(/\/$/, "")}/rest/v1/${path}`, {
+        ...init,
+        headers: { apikey: key, authorization: `Bearer ${key}`, "content-type": "application/json", ...init.headers },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!r.ok)
+        throw new Error(`Supabase said ${r.status}: ${(await r.text()).slice(0, 200)}`);
+    return r;
+}
+// The tables the API can write, and each one's primary key, from its OpenAPI description.
+async function describe(url, key) {
+    const spec = (await (await call(url, key, "", { headers: { accept: "application/openapi+json" } })).json());
+    const out = [];
+    for (const [name, def] of Object.entries(spec.definitions ?? {})) {
+        if (!spec.paths?.[`/${name}`]?.post)
+            continue; // a view or a read-only table
+        const pk = Object.entries(def.properties ?? {})
+            .filter(([, p]) => /<pk\/>|primary key/i.test(p.description ?? ""))
+            .map(([col]) => col);
+        out.push({ name, pk });
+    }
+    return out;
+}
+async function count(url, key, table) {
+    const r = await call(url, key, `${encodeURIComponent(table)}?select=*`, { method: "HEAD", headers: { prefer: "count=exact", range: "0-0", "range-unit": "items" } });
+    return Number(r.headers.get("content-range")?.split("/")[1] ?? 0) || 0;
+}
+async function rows(url, key, table) {
+    const out = [];
+    for (let from = 0;; from += PAGE) {
+        const r = await call(url, key, `${encodeURIComponent(table)}?select=*`, { headers: { range: `${from}-${from + PAGE - 1}`, "range-unit": "items" } });
+        const page = (await r.json());
+        out.push(...page);
+        if (page.length < PAGE)
+            return out;
+    }
+}
+export async function snapshotRest(actionId, url, key) {
+    const tables = await describe(url, key);
+    const sized = await Promise.all(tables.map(async (t) => ({ ...t, n: await count(url, key, t.name) })));
+    const dir = join(snapshotDir(actionId), "rest");
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    let spent = 0;
+    const out = [];
+    // Smallest first: the most tables for the budget.
+    for (const t of sized.sort((a, b) => a.n - b.n)) {
+        if (t.pk.length === 0) {
+            out.push({ name: t.name, pk: [], file: null, skipped: "it has no primary key" });
+            continue;
+        }
+        const data = JSON.stringify(await rows(url, key, t.name));
+        if (spent + data.length > budget()) {
+            out.push({ name: t.name, pk: t.pk, file: null, skipped: "it was too big to copy" });
+            continue;
+        }
+        spent += data.length;
+        const file = join(dir, `${out.length}.json`);
+        writeFileSync(file, data, { mode: 0o600 });
+        out.push({ name: t.name, pk: t.pk, file });
+    }
+    return { adapter: "rest", url, tables: out };
+}
+const keyOf = (pk, r) => JSON.stringify(pk.map((c) => r[c]));
+const same = (a, b) => JSON.stringify(Object.entries(a).sort()) === JSON.stringify(Object.entries(b).sort());
+// PostgREST's filter syntax for one row's key.
+function match(pk, r) {
+    return pk.map((c) => `${encodeURIComponent(c)}=eq.${encodeURIComponent(String(r[c]))}`).join("&");
+}
+export async function undoRest(u, key) {
+    const log = [];
+    const plans = [];
+    const live = new Set((await describe(u.url, key)).map((t) => t.name));
+    for (const t of u.tables) {
+        if (!t.file) {
+            if (t.skipped === "it was too big to copy")
+                log.push(`couldn't put back the rows of ${t.name}: ${t.skipped}`);
+            continue;
+        }
+        if (!live.has(t.name)) {
+            log.push(`couldn't put back ${t.name}: the table is gone, and bringing back a table needs the database connected`);
+            continue;
+        }
+        const was = JSON.parse(readFileSync(t.file, "utf8"));
+        const now = await rows(u.url, key, t.name);
+        const before = new Map(was.map((r) => [keyOf(t.pk, r), r]));
+        const after = new Map(now.map((r) => [keyOf(t.pk, r), r]));
+        const del = now.filter((r) => !before.has(keyOf(t.pk, r)));
+        const put = was.filter((r) => {
+            const cur = after.get(keyOf(t.pk, r));
+            return !cur || !same(cur, r);
+        });
+        if (del.length || put.length)
+            plans.push({ t, del, put });
+    }
+    // Foreign keys decide the order, which the API doesn't say: deletes and
+    // writes that fail are tried again after the others, until nothing moves.
+    const deleted = new Map();
+    for (let left = plans.flatMap((p) => p.del.map((r) => ({ p, r }))), pass = 0; left.length && pass < 6; pass++) {
+        const failed = [];
+        for (const { p, r } of left) {
+            try {
+                await call(u.url, key, `${encodeURIComponent(p.t.name)}?${match(p.t.pk, r)}`, { method: "DELETE" });
+                deleted.set(p.t.name, (deleted.get(p.t.name) ?? 0) + 1);
+            }
+            catch {
+                failed.push({ p, r });
+            }
+        }
+        if (failed.length === left.length)
+            throw new Error(`couldn't delete the rows added to ${failed[0].p.t.name}`);
+        left = failed;
+    }
+    const restored = new Map();
+    for (let left = plans.filter((p) => p.put.length), pass = 0; left.length && pass < 6; pass++) {
+        const failed = [];
+        for (const p of left) {
+            try {
+                await upsert(u.url, key, p.t, p.put);
+                restored.set(p.t.name, p.put.length);
+            }
+            catch {
+                failed.push(p);
+            }
+        }
+        if (failed.length === left.length)
+            throw new Error(`couldn't write back the rows of ${failed[0].t.name}`);
+        left = failed;
+    }
+    for (const p of plans) {
+        const parts = [restored.get(p.t.name) ? `put back ${restored.get(p.t.name)} rows` : "", deleted.get(p.t.name) ? `removed ${deleted.get(p.t.name)} new rows` : ""].filter(Boolean);
+        if (parts.length)
+            log.unshift(`${p.t.name}: ${parts.join(", ")}`);
+    }
+    return log.length ? log.join("\n") : "nothing had changed in Supabase";
+}
+// Writes rows back over whatever has their key. Columns the database fills in
+// itself (generated ones) are dropped and tried again when it refuses them.
+async function upsert(url, key, t, put) {
+    let body = put;
+    for (let i = 0; i < 5; i++) {
+        try {
+            await call(url, key, `${encodeURIComponent(t.name)}?on_conflict=${t.pk.map(encodeURIComponent).join(",")}`, {
+                method: "POST",
+                headers: { prefer: "resolution=merge-duplicates,return=minimal" },
+                body: JSON.stringify(body),
+            });
+            return;
+        }
+        catch (err) {
+            const col = String(err).match(/column "([^"]+)" can only be updated to DEFAULT|cannot insert a non-DEFAULT value into column "([^"]+)"/);
+            const name = col?.[1] ?? col?.[2];
+            if (!name)
+                throw err;
+            body = body.map(({ [name]: _, ...rest }) => rest);
+        }
+    }
+}

package/dist/check.js

@@ -3,7 +3,7 @@
 // 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 { configServers, projectUses } from "./connect.js";
+import { configServers, projectConnected, projectUses, supabaseDirs } from "./connect.js";
 import { supabaseProjects } from "./supabase.js";
 import { watchRules } from "./watch.js";
 import { dim, pink, white, width, wrap } from "./look.js";
@@ -60,12 +60,13 @@ function classify(s, supabaseConnected, ruled) {
 // which starts every server: for a check as a session starts.
 export function check(dir, opts = {}) {
     const found = (opts.quick ? null : listed(dir)) ?? configServers(dir);
-    const connected = supabaseProjects().length > 0;
+    // A database connection, or the project's own API keys.
+    const connected = supabaseProjects().length > 0 || supabaseDirs(dir).some(projectConnected);
     const ruled = new Set(watchRules().map((r) => r.server ?? "").filter(Boolean));
     const items = found.map((s) => classify(s, connected, ruled));
     const uses = projectUses(dir);
     const suggest = [];
-    const supabaseHere = items.some((i) => SUPABASE.test(i.name)) || uses.supabase;
+    const supabaseHere = items.some((i) => SUPABASE.test(i.name)) || uses.supabase || supabaseDirs(dir).length > 0;
     if (!connected && supabaseHere) {
         suggest.push({ title: "Connect Supabase", why: "so Claude's database changes can be undone", how: 'Ask Claude: "connect Backstep to Supabase"' });
     }

package/dist/cli.js

@@ -9,16 +9,23 @@ 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";
+import { projectConnected, projectDatabases, restKeys, supabaseDirs } from "./connect.js";
+import { snapshotRest } from "./adapters/rest.js";
 const PUSH = /\bgit\b[^;&|]*\bpush\b/;
-import { classifyShell, supabaseTarget, touchesDatabase } from "./shell.js";
+import { classifyShell, commandDir, supabaseTarget, touchesDatabase, touchesSupabase } from "./shell.js";
 import { watchEnd, watchStart } from "./watch.js";
 import { sendActive } from "./telemetry.js";
 import { readFileSync, rmSync } from "node:fs";
 import { loadRules } from "./rules.js";
 import { setup } from "./setup.js";
 import { autoWrap, printChanges, unwrapServers, wrapServers } from "./servers.js";
-import { disconnectSupabase, dismissSupabase } from "./supabase.js";
+import { disconnectSupabase, dismissSupabase, restKey, supabaseDismissed } 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.
+function reachedProjects(command, cwd) {
+    const dirs = supabaseDirs(commandDir(command, cwd));
+    return touchesDatabase(command) || touchesSupabase(command, dirs.length > 0) ? dirs : [];
+}
 import { connect } from "./connect.js";
 import { check, printCheck } from "./check.js";
 import { logo } from "./look.js";
@@ -343,11 +350,15 @@ async function main() {
         // A push also notes where the remote branches stood, so undo can take it back there too.
         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.
+        // A migration, reset, seed, raw SQL, or anything reaching Supabase's API: the
+        // connected databases it could change are noted too, or their rows through
+        // the API where only the project's keys connect it.
         const dbs = [];
+        const rests = [];
         const missed = [];
-        if (touchesDatabase(command)) {
-            for (const url of await projectDatabases(cwd, supabaseTarget(command))) {
+        for (const d of reachedProjects(command, cwd)) {
+            const urls = await projectDatabases(d, supabaseTarget(command));
+            for (const url of urls) {
                 try {
                     dbs.push(await snapshotDb(a.id, url));
                 }
@@ -355,12 +366,23 @@ async function main() {
                     missed.push(err instanceof Error ? err.message : String(err));
                 }
             }
+            const rest = restKeys(d);
+            if (!urls.length && rest && restKey(rest.url)) {
+                try {
+                    rests.push(await snapshotRest(a.id, rest.url, restKey(rest.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;
+        const extra = { ...(dbs.length ? { dbs } : {}), ...(rests.length ? { rests } : {}) };
+        const undo = tree ? { ...tree, ...extra } : dbs.length || rests.length ? { adapter: "dbs", dbs, rests } : null;
         if (undo)
             store.updateAction(a.id, { undo: JSON.stringify(undo) });
         // 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;
+        const saved = dbs.length + rests.length;
+        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 });
         if (!undo && kind !== "outbound")
@@ -369,7 +391,17 @@ async function main() {
             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 }));
+        console.log(JSON.stringify({ kind, reason: 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
+    // isn't connected to? Then the mod asks first, so the project can be saved before it changes.
+    if (cmd === "db-check") {
+        const sep = rest.indexOf("--");
+        const { values } = parseArgs({ args: sep === -1 ? rest : rest.slice(0, sep), options: { cwd: { type: "string" } } });
+        const command = sep === -1 ? "" : rest.slice(sep + 1).join(" ");
+        const ask = reachedProjects(command, values.cwd ?? process.cwd()).find((d) => !projectConnected(d) && !supabaseDismissed(d));
+        console.log(JSON.stringify({ ask: ask ?? null }));
         return;
     }
     // After a shell command that pushed: notes what it sent (run by the Claude Code mod).

package/dist/connect.js

@@ -8,11 +8,11 @@
 //    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 { existsSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, 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, supabaseDb, supabaseDismissed, supabaseProjects, supabaseToken, supabaseUrl, } from "./supabase.js";
+import { connectSupabase, hasSavedToken, LOCAL, mintSupabase, projectRef, saveSupabaseToken, supabaseDb, restKey, saveRest, 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"];
@@ -75,6 +75,41 @@ export function projectUses(dir) {
         firebase: existsSync(join(dir, "firebase.json")) || existsSync(join(dir, ".firebaserc")) || d.some((x) => x === "firebase" || x === "firebase-admin"),
     };
 }
+// Folders a session in `dir` works in that use Supabase: the folder itself, or
+// its projects a level or two down (Claude Code opened in a parent folder).
+export function supabaseDirs(dir) {
+    if (projectUses(dir).supabase)
+        return [dir];
+    const out = [];
+    const walk = (d, depth) => {
+        if (depth === 0)
+            return;
+        let names = [];
+        try {
+            names = readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory() && !/^(\.|node_modules$|dist$|build$|out$|coverage$)/.test(e.name)).map((e) => e.name);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const child = join(d, n);
+            if (projectUses(child).supabase)
+                out.push(child);
+            else
+                walk(child, depth - 1);
+        }
+    };
+    walk(dir, 2);
+    return out;
+}
+// The project's API URL and service key, from its .env files: enough to read
+// and write its rows through Supabase's own API, with no database password.
+export function restKeys(dir) {
+    const vars = envVars(dir);
+    const url = vars.find(([k, v]) => /SUPABASE_URL$/.test(k) && /^https?:\/\//.test(v))?.[1];
+    const key = vars.find(([k, v]) => /SERVICE_ROLE|SERVICE_KEY|SECRET_KEY/.test(k) && (/SUPABASE/.test(k) || v.startsWith("sb_secret_")) && v.length > 20)?.[1];
+    return url && key ? { url: url.replace(/\/$/, ""), key } : null;
+}
 // Connection strings worth trying, best first: the ones that say they're
 // direct, then any other Postgres URL in the project's env files.
 function candidates(dir) {
@@ -94,7 +129,7 @@ const TOKENS = "https://supabase.com/dashboard/account/tokens";
 const WHERE = "Supabase → your project → Connect (top of the page) → Direct connection (or Session pooler) → copy the URI and put the database password in place of [YOUR-PASSWORD]";
 // The hosted project a folder belongs to: `supabase link` notes it, and the
 // app's own settings name it in its API URL.
-function linkedRef(dir) {
+export function linkedRef(dir) {
     const linked = read(join(dir, "supabase", ".temp", "project-ref")).trim();
     if (/^[a-z0-9]{20}$/.test(linked))
         return linked;
@@ -136,8 +171,11 @@ async function signedIn(dir, token, ref, isNew) {
     }
     return isNew ? { service: "supabase", state: "connected", detail: "signed in to Supabase, so each project connects itself as Claude uses it" } : null;
 }
-// Whether the project this folder uses already has its database connected.
-function projectConnected(dir) {
+// Whether the project this folder uses is connected: its database, or its API through the project's keys.
+export function projectConnected(dir) {
+    const rest = restKeys(dir);
+    if (rest && restKey(rest.url))
+        return true;
     const ref = linkedRef(dir);
     return ref ? supabaseProjects().includes(ref) : supabaseProjects().length > 0;
 }
@@ -145,12 +183,16 @@ async function supabase(dir, given, ref, interactive = false, auto = false) {
     const label = (r) => (r === LOCAL ? "the local database" : `project ${r}`);
     // On its own, Backstep only notices: connecting is the person's call.
     if (auto) {
-        if (!projectUses(dir).supabase || supabaseDismissed(dir))
-            return { service: "supabase", state: "unused", detail: "nothing to ask" };
-        if (projectConnected(dir))
-            return { service: "supabase", state: "covered", detail: "already connected" };
-        return { service: "supabase", state: "ask", detail: "this project uses Supabase, but Backstep isn't connected to it" };
+        const dirs = supabaseDirs(dir);
+        const unconnected = dirs.find((d) => !supabaseDismissed(d) && !projectConnected(d));
+        if (unconnected)
+            return { service: "supabase", state: "ask", detail: "this project uses Supabase, but Backstep isn't connected to it", dir: unconnected };
+        // Connected, or the person said not to ask.
+        return dirs.some(projectConnected) ? { service: "supabase", state: "covered", detail: "already connected" } : { service: "supabase", state: "unused", detail: "nothing to ask" };
     }
+    // Opened in a parent folder: connect the Supabase project inside it.
+    if (!projectUses(dir).supabase)
+        dir = supabaseDirs(dir)[0] ?? dir;
     // An access token (sbp_…) rather than a connection string: one sign-in for every project.
     if (given?.startsWith("sbp_")) {
         try {
@@ -200,6 +242,24 @@ async function supabase(dir, given, ref, interactive = false, auto = false) {
     }
     if (had.length)
         return { service: "supabase", state: "covered", detail: `already connected: ${had.map(label).join(", ")}` };
+    // No database to reach, but the project's own API keys: rows can be undone through them.
+    const rest = restKeys(dir);
+    if (rest) {
+        try {
+            const r = await fetch(`${rest.url}/rest/v1/`, { headers: { apikey: rest.key, authorization: `Bearer ${rest.key}` }, signal: AbortSignal.timeout(15_000) });
+            if (!r.ok)
+                throw new Error(`Supabase said ${r.status}`);
+            saveRest(rest.url, rest.key);
+            return {
+                service: "supabase",
+                state: "connected",
+                detail: "connected with the project's own Supabase keys: rows Claude adds, changes or deletes can be undone (undoing changes to tables themselves needs the database password or an access token)",
+            };
+        }
+        catch (err) {
+            errors.push(`the project's Supabase keys didn't work: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     const used = /supabase/i.test(servers(dir).join("\n")) || projectUses(dir).supabase;
     if (!used && errors.length === 0)
         return { service: "supabase", state: "unused", detail: "this project doesn't use Supabase" };

package/dist/shell.js

@@ -125,3 +125,19 @@ export function supabaseTarget(command) {
         return "local";
     return /--linked\b|--db-url\b|\bdb\s+push\b/.test(command) ? "hosted" : "local";
 }
+// Commands that reach a Supabase project some other way: its web API (curl to
+// /rest/v1, its URL or keys from .env), or a script or package script that
+// might use supabase-js, judged together with whether the project uses Supabase.
+const SUPABASE_API = /supabase\.co\b|\/rest\/v1\b|SUPABASE_[A-Z_]*(URL|KEY)|(localhost|127\.0\.0\.1):54321\b/;
+const SCRIPT = /(^|[\s;&|(])((node|tsx|ts-node|bun|deno|python3?)\s+(run\s+)?[^\s;&|]+\.(m?[jt]s|cjs|py)\b|(npm|pnpm|yarn|bun)\s+(run\s+)?(seed|db|migrate|reset)[\w:-]*)/;
+export function touchesSupabase(command, projectUsesSupabase) {
+    return SUPABASE_API.test(command) || (projectUsesSupabase && SCRIPT.test(command));
+}
+// The folder a command works in: where its leading `cd` goes, else where it runs.
+export function commandDir(command, cwd) {
+    const m = command.match(/^\s*cd\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*(&&|;|$)/);
+    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}`;
+}

package/dist/supabase.js

@@ -159,6 +159,12 @@ async function api(token, method, path, body) {
     return (await r.json());
 }
 export const hasSavedToken = () => Boolean(load().token);
+export function saveRest(url, key) {
+    const c = load();
+    c.rest = { ...c.rest, [url.replace(/\/$/, "")]: key };
+    save(c);
+}
+export const restKey = (url) => load().rest?.[url.replace(/\/$/, "")] ?? null;
 export function dismissSupabase(dir) {
     const c = load();
     c.dismissed = [...new Set([...(c.dismissed ?? []), dir])];

package/dist/undo.js

@@ -5,7 +5,8 @@ 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";
+import { dbKey, freshUrl, restKey } from "./supabase.js";
+import { undoRest } from "./adapters/rest.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.
@@ -38,10 +39,11 @@ function resources(store, a) {
         return new Set(u.entries.map((e) => `fs:${e.path}`));
     // 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)}`);
+    const apis = (rests = []) => rests.map((r) => `pgdb:${r.url}`);
     if (u.adapter === "tree")
-        return new Set([`fs:${u.root}`, ...whole(u.dbs)]);
+        return new Set([`fs:${u.root}`, ...whole(u.dbs), ...apis(u.rests)]);
     if (u.adapter === "dbs")
-        return new Set(whole(u.dbs));
+        return new Set([...whole(u.dbs), ...apis(u.rests)]);
     // An opposite tool call doesn't rewind shared state, so it never conflicts.
     if (u.adapter === "inverse" || u.adapter === "engine")
         return new Set();
@@ -134,6 +136,12 @@ async function undoOne(store, a, opts = {}) {
             const lines = [];
             for (const d of u.dbs ?? [])
                 lines.push(await undoDb(await freshUrl(d.url), d));
+            for (const r of u.rests ?? []) {
+                const key = restKey(r.url);
+                if (!key)
+                    throw new Error(`Backstep isn't connected to ${r.url} any more`);
+                lines.push(await undoRest(r, key));
+            }
             if (u.adapter === "tree")
                 lines.unshift(undoTree(u, a.id));
             detail = lines.filter((l) => !/^nothing had changed/.test(l)).join("\n") || lines[0];

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

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

@@ -43,6 +43,7 @@ test('an edit is snapshotted and the band offers to undo the turn', { options: {
 
   expect(runs).toEqual([
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'snap', '--session', 's1', '--tool', 'Edit', '--cwd', '/repo', '--', '/repo/src/a.ts'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'db-check', '--cwd', '/repo', '--', 'ls'],
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'shell', '--session', 's1', '--cwd', '/repo', '--', 'ls'],
   ])
 
@@ -566,3 +567,42 @@ test('with two keys bound the band names both', { options: { cli: CLI } }, async
   expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u / ctrl+q to undo')
   await ui.unmount()
 })
+
+test('about to change a Supabase project that is not connected, Backstep asks first, then saves it', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const runs: string[][] = []
+  const asked: string[] = []
+  on('session.cwd', () => ({ value: '/work' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const stdout = e.argv.includes('db-check')
+      ? JSON.stringify({ ask: '/work/taskflow' })
+      : e.argv.includes('connect')
+        ? JSON.stringify([{ service: 'supabase', state: 'connected', detail: "connected with the project's own Supabase keys" }])
+        : e.argv.includes('shell')
+          ? JSON.stringify({ kind: 'write', id: 'r1', undoable: true, db: 1 })
+          : '[]'
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  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]: 'Connect' } } }
+  })
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+
+  await $.prompt.submit({ text: 'seed it', wait: false, origin: { kind: 'composer' } })
+  const command = 'cd taskflow && curl -X POST "$NEXT_PUBLIC_SUPABASE_URL/rest/v1/tasks"'
+  await $.tool.call({ tool: 'Bash', command })
+  expect(asked).toHaveLength(1)
+  const order = runs.map((r) => r[3])
+  expect(order).toEqual(['db-check', 'connect', 'shell'])
+  expect(runs[1].slice(3)).toEqual(['connect', 'supabase', '--dir', '/work/taskflow', '--json'])
+
+  // Asked once a session per project, whatever the answer.
+  await $.tool.call({ tool: 'Bash', command })
+  expect(asked).toHaveLength(1)
+})

package/mod/hooks/register.tsx

@@ -332,7 +332,7 @@ async function checkCoverage($: EngineInterface, cwd: string) {
   const found = await $.process.run(backstep(['connect', '--dir', cwd, '--json', '--auto']), { timeoutMs: 120_000 }).catch(() => null)
   try {
     for (const c of JSON.parse(found?.stdout || '[]') as Connected[]) {
-      if (c.service === 'supabase' && c.state === 'ask') await askSupabase($, cwd)
+      if (c.service === 'supabase' && c.state === 'ask') await askSupabase($, c.dir ?? cwd)
       if (c.state === 'added') $.ui.toast('Backstep added Firebase for this project, so Claude can reach it and its changes can be undone. Restart Claude Code to use it.')
     }
   } catch {
@@ -357,9 +357,15 @@ const ASK = {
   never: "Don't ask for this project",
 }
 
-// Asked when Claude Code opens a project that uses Supabase and Backstep isn't
-// connected to it; the answer is the only thing that connects it.
+// Projects asked about this session: "Not now" means not again until the next one.
+const asked = new Set<string>()
+
+// Asked when Claude Code opens a project that uses Supabase, or Claude is about
+// to change one, and Backstep isn't connected to it; the answer is the only
+// thing that connects it.
 async function askSupabase($: EngineInterface, cwd: string) {
+  if (asked.has(cwd)) return
+  asked.add(cwd)
   const answer = await $.ui
     .ask("This project uses Supabase, but Backstep isn't connected to it, so Claude's changes to its database can't be undone. Connect it?", {
       header: 'Backstep',
@@ -478,7 +484,7 @@ const CONNECT_TOOL = {
   },
 }
 
-type Connected = { service: string; state: string; detail: string }
+type Connected = { service: string; state: string; detail: string; dir?: string }
 
 async function connectServices($: EngineInterface, input: { service?: string; connection_string?: string; project_ref?: string }) {
   const cwd = await $.session.cwd()
@@ -562,6 +568,15 @@ export const register: Register = (on, options) => {
       const t = await current($)
       const cwd = await $.session.cwd()
       const sid = await $.session.id()
+      // About to change a Supabase project Backstep isn't connected to: ask now,
+      // so it can be saved before the command runs.
+      const checked = await $.process.run(backstep(['db-check', '--cwd', cwd, '--', command])).catch(() => null)
+      try {
+        const ask = (JSON.parse(checked?.stdout || '{}') as { ask?: string | null }).ask
+        if (ask) await askSupabase($, ask)
+      } catch {
+        // can't tell: run it as before
+      }
       // Never blocks the command: if Backstep can't be reached it just won't be undoable.
       const ran = await $.process
         // A database command copies the database first, which takes longer on a big one.

package/package.json

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