backstep 0.1.25 → 0.1.27

package/README.md

@@ -67,6 +67,8 @@ With Claude Code: `claude mcp add files -- backstep wrap --name files -- <the se
 
 The undo key is ctrl+u (not ctrl+z: Claude Code suspends itself on ctrl+z in a terminal before anything else sees the key, so it can't be used). The first press asks "Undo Claude's last turn?" above the prompt and a second press within 5 seconds undoes, so a stray press does nothing. Change the key whenever you like: ask Claude ("change my Backstep undo key to ctrl+q"), or run `backstep key ctrl+q`. The line above the prompt is always there, even with nothing to undo, because the key only reaches Backstep while it's on screen; otherwise a press would do nothing.
 
+In the Claude Code desktop app, keys don't reach Backstep, so the line above the message box has an **Undo last turn** button to click instead (it asks once, then undoes). Typing `/backstep-undo` works everywhere and undoes straight away.
+
 Backstep checks npm for a newer version as each Claude Code session starts and asks before updating (Update, Not now, or Skip this version; `backstep update` does it by hand, `BACKSTEP_UPDATE_CHECK=0` turns the check off).
 
 Other commands: `backstep ui`, `backstep log`, `backstep undo <action-id>`, `backstep undo --run <run-id>`, `backstep connect [supabase|firebase]` (connects what the project uses, the same as asking Claude), `backstep disconnect supabase <ref>`.
@@ -119,7 +121,7 @@ Everything is journaled to `~/.backstep/journal.db` (SQLite, mode 0600; override
 
 ## Telemetry
 
-`backstep setup` sends one anonymous `install` event, Claude Code with the Backstep mod sends one `active` event a day, and `backstep uninstall` sends one `uninstall` event. Each carries a random id made on your machine (`~/.backstep/install-id`), the Backstep version, your OS and CPU type, and the Node major version. Nothing else: no paths, commands, server names, IP-based location, or anything from the journal. The code is `src/telemetry.ts`.
+`backstep setup` sends one anonymous `install` event the first time on a computer (and an `update` event each time after, as updates run setup again), Claude Code with the Backstep mod sends one `active` event a day, and `backstep uninstall` sends one `uninstall` event. Each carries a random id made on your machine (`~/.backstep/install-id`), the Backstep version, your OS and CPU type, and the Node major version. Nothing else: no paths, commands, server names, IP-based location, or anything from the journal. The code is `src/telemetry.ts`.
 
 Turn it off with `BACKSTEP_TELEMETRY=0`, or the standard `DO_NOT_TRACK=1`.
 

package/dist/account.js

@@ -0,0 +1,217 @@
+// Accounts and plans. Undo always runs on this computer. What Backstep allows
+// is set by a small file on getbackstep.com (backstep.json):
+//
+//   minVersion     versions older than this must update before ctrl+u works
+//   requireSignIn  whether ctrl+u needs a signed-in account (off for now)
+//   message        a line shown with either
+//
+// Signed in, this computer keeps a plan note: the account, its plan and the
+// features that plan includes, signed by Backstep's server so it can't be
+// edited here. It lasts a week and is renewed as sessions start.
+//
+// Fail open: if getbackstep.com can't be reached, Backstep keeps working on
+// what it last heard (or as if nothing were required, if it never heard).
+import { createHash, createPublicKey, randomBytes, verify } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homeDir } from "./store.js";
+import { version } from "./telemetry.js";
+import { newer } from "./update.js";
+const SITE = () => (process.env.BACKSTEP_SITE ?? "https://getbackstep.com").replace(/\/$/, "");
+// The server's public key: it can only check notes, never make them, so it's safe to ship.
+const PUBLIC_KEY = () => process.env.BACKSTEP_PUBLIC_KEY ?? "MCowBQYDK2VwAyEAUIhhw5NeNtGFT6o6AWn5TnjsnmjQ97OF6U4kdl4x0DA=";
+const DAY_MS = 24 * 60 * 60 * 1000;
+// A note past its date still counts for this long, so a week offline never turns undo off.
+const GRACE_MS = 7 * DAY_MS;
+// What was last heard from the site counts this long when it can't be reached.
+const REMOTE_KEEP_MS = 30 * DAY_MS;
+const NOTHING_REQUIRED = { minVersion: "0.0.0", requireSignIn: false, message: null };
+const remoteFile = () => join(homeDir(), "remote.json");
+const accountFile = () => join(homeDir(), "account.json");
+function readJson(f) {
+    try {
+        return existsSync(f) ? JSON.parse(readFileSync(f, "utf8")) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(f, v) {
+    mkdirSync(homeDir(), { recursive: true });
+    writeFileSync(f, JSON.stringify(v, null, 2) + "\n", { mode: 0o600 });
+}
+function asRemote(j) {
+    if (!j || typeof j !== "object")
+        return null;
+    const o = j;
+    return {
+        minVersion: typeof o.minVersion === "string" ? o.minVersion : "0.0.0",
+        requireSignIn: o.requireSignIn === true,
+        message: typeof o.message === "string" && o.message.trim() ? o.message.trim() : null,
+    };
+}
+// What the site said last, without asking it again.
+export function cachedRemote(now = Date.now()) {
+    const c = readJson(remoteFile());
+    return c && now - c.at < REMOTE_KEEP_MS ? (asRemote(c.remote) ?? NOTHING_REQUIRED) : NOTHING_REQUIRED;
+}
+// Asks the site, never waiting more than a few seconds.
+export async function fetchRemote() {
+    try {
+        const r = await fetch(`${SITE()}/backstep.json`, { signal: AbortSignal.timeout(4000), headers: { "cache-control": "no-cache" } });
+        if (r.ok) {
+            const remote = asRemote(await r.json());
+            if (remote) {
+                writeJson(remoteFile(), { at: Date.now(), remote });
+                return remote;
+            }
+        }
+        // No file there at all: nothing is required.
+        if (r.status === 404) {
+            writeJson(remoteFile(), { at: Date.now(), remote: NOTHING_REQUIRED });
+            return NOTHING_REQUIRED;
+        }
+    }
+    catch {
+        // offline or the site is down: what it said last
+    }
+    return cachedRemote();
+}
+const b64url = (b) => b.toString("base64url");
+// A plan note is `payload.signature`, each base64url; the signature covers the payload text.
+export function checkNote(raw) {
+    if (!raw || typeof raw !== "string")
+        return null;
+    const [payload, sig] = raw.split(".");
+    if (!payload || !sig)
+        return null;
+    try {
+        const key = createPublicKey({ key: Buffer.from(PUBLIC_KEY(), "base64"), format: "der", type: "spki" });
+        if (!verify(null, Buffer.from(payload), key, Buffer.from(sig, "base64url")))
+            return null;
+        const n = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+        return typeof n.exp === "number" && Array.isArray(n.features) && typeof n.plan === "string" ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+const saved = () => readJson(accountFile()) ?? {};
+// The plan note on this computer, if it's genuine and not long past its date.
+export function currentNote(now = Date.now()) {
+    const n = checkNote(saved().note);
+    return n && n.exp + GRACE_MS > now ? n : null;
+}
+async function post(path, body) {
+    const r = await fetch(`${SITE()}${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(8000),
+    });
+    let json = {};
+    try {
+        json = (await r.json());
+    }
+    catch {
+        // no body
+    }
+    return { status: r.status, json };
+}
+// Renews the plan note. An account signed out or turned off on the server loses it here.
+export async function refreshNote() {
+    const s = saved();
+    if (!s.device)
+        return "none";
+    try {
+        const r = await post("/api/note", { device: s.device });
+        if (r.status === 200 && checkNote(r.json.note)) {
+            writeJson(accountFile(), { ...s, note: r.json.note });
+            return "renewed";
+        }
+        if (r.status === 401 || r.status === 403) {
+            rmSync(accountFile(), { force: true });
+            return "revoked";
+        }
+    }
+    catch {
+        // offline
+    }
+    return "offline";
+}
+function judge(remote, feature, note) {
+    const current = version();
+    const say = remote.message ? ` ${remote.message}` : "";
+    if (newer(remote.minVersion, current)) {
+        return { ok: false, reason: "update", minVersion: remote.minVersion, current, detail: `Backstep ${current} is no longer supported: update to ${remote.minVersion} or newer.${say}` };
+    }
+    if (!remote.requireSignIn)
+        return { ok: true, signedIn: note !== null, plan: note?.plan ?? null, email: note?.email ?? null, required: false };
+    if (!note)
+        return { ok: false, reason: "signin", detail: `Backstep needs you to sign in. Run: npx backstep login${say}` };
+    if (feature && !note.features.includes(feature) && !note.features.includes("*")) {
+        return { ok: false, reason: "plan", detail: `${feature} isn't on your ${note.plan} plan. See plans at getbackstep.com${say}` };
+    }
+    return { ok: true, signedIn: true, plan: note.plan, email: note.email, required: true };
+}
+// Whether ctrl+u (or one feature) may run, from what's already on this computer. Never waits on the network.
+export function accessNow(feature) {
+    return judge(cachedRemote(), feature, currentNote());
+}
+// The same, asking the site first and renewing a note that's close to its date. Run as sessions start.
+export async function accessOnline(feature) {
+    const remote = await fetchRemote();
+    const n = checkNote(saved().note);
+    if (saved().device && (!n || n.exp - Date.now() < 2 * DAY_MS))
+        await refreshNote();
+    return judge(remote, feature, currentNote());
+}
+// Throws with a line a person can act on when the feature isn't allowed. For the CLI's undo commands.
+export function requireAccess(feature) {
+    const a = accessNow(feature);
+    if (!a.ok)
+        throw new Error(a.detail);
+}
+// The words a person checks on the sign-in page: the same on both sides, never the secret itself.
+export const matchCode = (code) => {
+    const h = createHash("sha256").update(code).digest("hex").slice(0, 8).toUpperCase();
+    return `${h.slice(0, 4)}-${h.slice(4)}`;
+};
+const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+// Signs this computer in: opens getbackstep.com/login with a one-time code and
+// waits (up to ten minutes) for the person to finish there.
+export async function login(open, say, waitMs = 10 * 60 * 1000, everyMs = 2000) {
+    const code = b64url(randomBytes(18));
+    const device = b64url(randomBytes(32));
+    const url = `${SITE()}/login.html?code=${code}`;
+    say(`Opening ${SITE().replace(/^https?:\/\//, "")} to sign in. If it doesn't open, go to:\n  ${url}`);
+    say(`The page should show the code ${matchCode(code)}. Only continue if it does.`);
+    open(url);
+    const until = Date.now() + waitMs;
+    while (Date.now() < until) {
+        await pause(everyMs);
+        let r;
+        try {
+            r = await post("/api/login/claim", { code, device });
+        }
+        catch {
+            continue; // a dropped request: ask again
+        }
+        if (r.status === 202)
+            continue;
+        const note = checkNote(r.json.note);
+        if (r.status === 200 && note) {
+            writeJson(accountFile(), { note: r.json.note, device });
+            return { ok: true, detail: `signed in as ${note.email} (${note.plan} plan)` };
+        }
+        return { ok: false, detail: typeof r.json.error === "string" ? r.json.error : `the sign-in didn't go through (${r.status})` };
+    }
+    return { ok: false, detail: "the sign-in wasn't finished in time. Run backstep login to try again" };
+}
+export async function logout() {
+    const s = saved();
+    if (s.device)
+        await post("/api/logout", { device: s.device }).catch(() => null);
+    rmSync(accountFile(), { force: true });
+    return s.note ? "Signed out on this computer." : "This computer wasn't signed in.";
+}

package/dist/cli.js

@@ -8,7 +8,8 @@ import { pruneDatabaseCopies, undoAction, undoRun, undoSince } from "./undo.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";
+import { ghMade, grantScope, openPage, undoGh } from "./github.js";
+import { accessNow, accessOnline, currentNote, login, logout, requireAccess } from "./account.js";
 import { undoVercel, vercelBefore, vercelMade } from "./vercel.js";
 import { snapshotDb } from "./adapters/dbsnap.js";
 import { dbDirs, firebaseProject, postgresUrls, projectDatabases, projectUses, restKeys, supabaseDirs, unconnected } from "./connect.js";
@@ -97,6 +98,9 @@ const HELP = `backstep: undo for everything your agents touch
                                connection string you give), Firebase by adding its MCP server.
                                In Claude Code you can just ask: "connect Backstep to my Supabase"
   backstep key [<key>]         show the key that undoes Claude's last turn, or change it (e.g. backstep key ctrl+u)
+  backstep login               sign in to your Backstep account (opens getbackstep.com)
+  backstep logout              sign out on this computer
+  backstep account             show who's signed in and on which plan
   backstep update               install the newest version (Claude Code offers this as a session starts)
   backstep status [--json]     what Backstep can and can't undo for each service Claude Code reaches,
                                and what to connect next
@@ -300,6 +304,34 @@ async function main() {
         }
         return;
     }
+    if (cmd === "login") {
+        const out = await login(openPage, (line) => console.log(line));
+        console.log(out.ok ? `Backstep: ${out.detail}.` : `Backstep couldn't sign you in: ${out.detail}.`);
+        if (!out.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (cmd === "logout") {
+        console.log(await logout());
+        return;
+    }
+    if (cmd === "account") {
+        const n = currentNote();
+        const a = await accessOnline();
+        const fresh = currentNote() ?? n;
+        console.log(fresh ? `Signed in as ${fresh.email} (${fresh.plan} plan).` : "Not signed in. Run: backstep login");
+        if (!a.ok)
+            console.log(a.detail);
+        else if (!a.required)
+            console.log("Signing in isn't needed to use Backstep right now.");
+        return;
+    }
+    // Run by the Claude Code mod as a session starts: may ctrl+u run? Asks getbackstep.com (fail open).
+    if (cmd === "access") {
+        const { values } = parseArgs({ args: rest, options: { feature: { type: "string" }, offline: { type: "boolean", default: false } } });
+        console.log(JSON.stringify(values.offline ? accessNow(values.feature) : await accessOnline(values.feature)));
+        return;
+    }
     // Run by the Claude Code mod as a session starts: is there a newer Backstep?
     if (cmd === "update-check") {
         console.log(JSON.stringify(await checkUpdate()));
@@ -536,6 +568,7 @@ async function main() {
     }
     // Takes back something Claude changed on Vercel (the change, as undo reported it, on stdin). The mod runs this after asking.
     if (cmd === "vercel-undo") {
+        requireAccess("vercel");
         const out = undoVercel(JSON.parse(readFileSync(0, "utf8")));
         console.log(JSON.stringify(out));
         if (!out.ok)
@@ -543,6 +576,7 @@ async function main() {
         return;
     }
     if (cmd === "gh-undo") {
+        requireAccess("github");
         const out = undoGh(JSON.parse(readFileSync(0, "utf8")));
         console.log(JSON.stringify(out));
         if (!out.ok)
@@ -551,6 +585,7 @@ async function main() {
     }
     // Puts an undo of code Claude pushed on the remote, as a new commit. The push, as undo reported it, comes on stdin.
     if (cmd === "revert-push") {
+        requireAccess("github");
         const { values } = parseArgs({ args: rest, options: { root: { type: "string" } } });
         if (!values.root)
             throw new Error("usage: backstep revert-push --root <repo>  (the push as JSON on stdin)");
@@ -609,6 +644,7 @@ async function main() {
         return;
     }
     if (cmd === "undo") {
+        requireAccess("undo");
         const { values, positionals } = parseArgs({
             args: rest,
             allowPositionals: true,

package/dist/github.js

@@ -73,7 +73,7 @@ function copy(text) {
             return true;
     return false;
 }
-function openPage(url) {
+export function openPage(url) {
     const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
     spawnSync(cmd, args, { stdio: "ignore" });
 }

package/dist/telemetry.js

@@ -1,4 +1,4 @@
-// An anonymous count of installs and of installs still in use, so we know how
+// An anonymous count of installs, updates and installs still in use, so we know how
 // many people use Backstep. Each event carries a random id made on this
 // machine, the Backstep version, the OS and the Node version. Never paths,
 // commands, server names or anything from the journal.
@@ -62,7 +62,10 @@ async function send(event) {
         // Offline, blocked, or slow: skip it.
     }
 }
-export const sendInstall = () => send("install");
+// Setup runs on a first install and again on every update. Only the first, on a
+// computer that has never sent anything (no install-id yet), counts as an
+// install; every later setup is an update, so installs stay new installs.
+export const sendInstall = () => send(existsSync(join(homeDir(), "install-id")) ? "update" : "install");
 export const sendUninstall = () => send("uninstall");
 // At most once a day, as Claude Code starts with Backstep's mod.
 export async function sendActive() {

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

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

@@ -261,6 +261,7 @@ test('servers added since setup are wrapped as a session starts', { options: { c
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'wrap-servers', '--project', '/repo', '--json'],
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'status', '--quick', '--json', '--dir', '/repo'],
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'ping'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'access'],
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'update-check'],
   ])
   expect(toasts.find((t) => t.includes('linear is now behind Backstep'))).toBeTruthy()
@@ -1021,3 +1022,157 @@ test('a production deploy Claude made on Vercel is offered back after undo, and
   expect(logs.find((l) => l.includes('Backstep undid'))).not.toContain('changes Vercel')
   await ui.unmount()
 })
+
+function gated(on: On, access: Record<string, unknown>, answer: string) {
+  const runs: string[][] = []
+  const toasts: string[] = []
+  const logs: string[] = []
+  const asked: string[] = []
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const stdout = e.argv.includes('access')
+      ? JSON.stringify(access)
+      : e.argv.includes('update-check')
+        ? JSON.stringify({ current: '0.1.25', latest: '0.1.40', available: true })
+        : e.argv.includes('update') && e.argv.includes('--json')
+          ? JSON.stringify({ ok: true, detail: 'updated to 0.1.40' })
+          : e.argv.includes('status')
+            ? JSON.stringify({ items: [], suggest: [] })
+            : e.argv.includes('snap')
+              ? JSON.stringify({ id: 'a1', undoable: true })
+              : '[]'
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('ui.status', () => ({ value: undefined }))
+  on('tool.register', (_, e) => ({ value: { tool: `mcp__backstep__${e.name}` } }))
+  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]: answer } } }
+  })
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+  return { runs, toasts, logs, asked }
+}
+
+const TOO_OLD = { ok: false, reason: 'update', current: '0.1.25', minVersion: '0.1.30', detail: 'Backstep 0.1.25 is no longer supported: update to 0.1.30 or newer.' }
+
+test('a version getbackstep.com says is too old must update: ctrl+u stays off until it does', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, toasts, asked } = gated(on, TOO_OLD, 'Not now')
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await clock.settle()
+  expect(asked).toEqual(['This version of Backstep (0.1.25) is no longer supported, so ctrl+u is off until it updates. Update to 0.1.40 now?'])
+  // The ordinary "a new version is out" question isn't asked on top.
+  expect(asked.length).toBe(1)
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/a.ts', old_string: 'a', new_string: 'b' } as never)
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  await ui.press({ key: 'undo' })
+  await clock.settle()
+  expect(runs.some((r) => r.includes('undo'))).toBe(false)
+  expect(toasts.at(-1)).toContain('no longer supported')
+  await ui.unmount()
+})
+
+test('Update now installs the newest version and turns ctrl+u back on', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, logs } = gated(on, TOO_OLD, 'Update now')
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await clock.settle()
+  expect(runs.some((r) => r.slice(3).join(' ') === 'update --version 0.1.40 --json')).toBe(true)
+  expect(logs.find((l) => l.includes('Backstep is updated to 0.1.40 (you had 0.1.25)'))).toBeTruthy()
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/a.ts', old_string: 'a', new_string: 'b' } as never)
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  await clock.settle()
+  expect(runs.some((r) => r.includes('undo'))).toBe(true)
+  await ui.unmount()
+})
+
+test('when signing in is required and nobody is, ctrl+u says how to sign in instead of undoing', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, toasts, asked } = gated(on, { ok: false, reason: 'signin', detail: 'Backstep needs you to sign in. Run: npx backstep login' }, 'Not now')
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await clock.settle()
+  expect(toasts.find((t) => t.includes('npx backstep login'))).toBeTruthy()
+  // Not a version problem: the ordinary update offer still comes.
+  expect(asked).toEqual(['Backstep 0.1.40 is out (you have 0.1.25). Update now?'])
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/a.ts', old_string: 'a', new_string: 'b' } as never)
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  await clock.settle()
+  expect(runs.some((r) => r.includes('undo'))).toBe(false)
+  expect(toasts.at(-1)).toContain('npx backstep login')
+  await ui.unmount()
+})
+
+test('in the desktop app the band says Undo (a click), since ctrl+u never reaches it there', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  engine(on, { exitCode: 0, stdout: '[]' })
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/a.ts', old_string: 'a', new_string: 'b' })
+
+  const desk = await $.ui.mount({ ...BAND, surface: 'desktop' })
+  expect((await desk.find({ type: 'Button', key: 'undo' }))?.text).toBe('◀ Undo last turn')
+  expect(JSON.stringify(await desk.find({ type: 'Box', text: /Undo last turn/ }))).not.toContain('ctrl')
+  await desk.press({ key: 'undo' })
+  expect(await desk.find({ type: 'Text', text: /Undo Claude's last turn\?/ })).toBeTruthy()
+  expect((await desk.find({ type: 'Button', key: 'undo' }))?.text).toBe('Yes, undo it')
+  expect((await desk.find({ type: 'Button', key: 'cancel' }))?.text).toBe('Cancel')
+  await desk.unmount()
+
+  const term = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await term.find({ type: 'Button', key: 'undo' }))?.text).toContain('again to undo')
+  await term.unmount()
+})
+
+test('/backstep-undo undoes the last turn straight away, and says when there is nothing to undo', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs } = engine(on, { exitCode: 0, stdout: JSON.stringify([{ id: 'c1', tool: 'Edit', ok: true, detail: 'restored /repo/src/a.ts' }]) })
+
+  expect(JSON.stringify(await $.command.run({ command: 'backstep-undo' } as never))).toContain('Nothing to undo yet')
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/a.ts', old_string: 'a', new_string: 'b' })
+  const ran = $.command.run({ command: 'backstep-undo' } as never)
+  await clock.advance(1000)
+  const r = await ran
+  expect(runs.some((a) => a[3] === 'undo')).toBe(true)
+  expect(JSON.stringify(r)).toContain('Rewound 1 change from the last turn.')
+})
+
+test('in the desktop app, the update is offered the same way and says not to close Claude Code', { options: { cli: CLI } }, async ($, on) => {
+  const { asked, logs, statuses } = updates(on, 'Update')
+  await $.session.start({ cwd: '/repo', surface: 'desktop', hasPerson: true } as never)
+  await settle()
+  expect(asked).toEqual(['Backstep 0.2.0 is out (you have 0.1.2). Update now?'])
+  const said = logs.join('\n')
+  expect(said).toContain('type /backstep-undo')
+  expect(said).toContain("Don't close Claude Code until it says it's done")
+  expect(statuses[0]).toContain("don't close Claude Code")
+  expect(said).not.toContain('terminal')
+})

package/mod/hooks/register.tsx

@@ -18,6 +18,8 @@ const armed = atom({ plugin: 'backstep', key: 'armed' } as const, null as number
 const keys = atom({ plugin: 'backstep', key: 'keys' } as const, ['ctrl+u'] as string[])
 // The one-time code GitHub's approval page wants, on the band while GitHub waits.
 const githubCode = atom({ plugin: 'backstep', key: 'githubCode' } as const, null as GithubCode | null)
+// Why ctrl+u can't run here, when getbackstep.com says so (a version too old, or no sign-in when one is needed).
+const blocked = atom({ plugin: 'backstep', key: 'blocked' } as const, null as string | null)
 // Backstep's mark, as on the logo: the front rewind triangle in the terminal's
 // own black or white, the one behind it in the logo's pink.
 const PINK = '#ee7bb6'
@@ -254,6 +256,13 @@ function relPath(path: string, cwd: string): string {
 
 async function pressUndo($: EngineInterface) {
   if (await read($, rewind)) return
+  // Too old a version, or signing in is required and nobody is: say what to do instead.
+  const off = await read($, blocked)
+  if (off) {
+    $.ui.toast(off, { timeoutMs: 10_000 })
+    $.ui.log(`${MARK_TEXT} ${off}`)
+    return
+  }
   const target = (await read($, turns)).findLast(hasWork)
   if (!target) {
     $.ui.toast('Nothing to undo yet: Claude hasn\'t changed anything Backstep can take back.')
@@ -272,6 +281,18 @@ async function pressUndo($: EngineInterface) {
   })
 }
 
+// /backstep-undo: the command is the confirmation, so it undoes straight away.
+async function undoByCommand($: EngineInterface): Promise<string> {
+  if (await read($, rewind)) return 'Backstep is already undoing a turn.'
+  const off = await read($, blocked)
+  if (off) return `${MARK_TEXT} ${off}`
+  if (!(await read($, turns)).some(hasWork)) return "Nothing to undo yet: Claude hasn't changed anything Backstep can take back."
+  await update($, armed, () => null)
+  const { before } = await undoTargets($)
+  await undoLastTurn($, before ? 2 : 1)
+  return (await read($, rewind))?.message ?? 'Done.'
+}
+
 // Undoes the last `count` turns that changed something, newest first.
 async function undoLastTurn($: EngineInterface, count = 1) {
   if (await read($, rewind)) return
@@ -387,7 +408,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
 
   if (done) {
     const list = items.filter((i) => i.ok).map((i) => `- ${i.label}`).join('\n')
-    const key = await keysLabel($)
+    const key = surface === 'terminal' ? await keysLabel($) : 'the Undo button or /backstep-undo'
     await update($, note, () =>
       `[Backstep] The user pressed undo (${key}) on your ${taken.length > 1 ? `last ${taken.length} turns` : 'previous turn'}. These changes were reverted:\n${list}\n` +
         (lost ? `${plural(lost, 'action')} from that turn couldn't be undone (they reached outside this machine with no way back, or the project was too big to snapshot).\n` : '') +
@@ -643,6 +664,49 @@ async function askDatabase($: EngineInterface, cwd: string, service = 'supabase'
 
 const UPDATE = { yes: 'Update', later: 'Not now', skip: 'Skip this version' }
 
+type Access = { ok: boolean; reason?: 'update' | 'signin' | 'plan'; detail?: string; current?: string; minVersion?: string }
+
+// As a session starts: may ctrl+u run here? getbackstep.com can say a version
+// is too old or that signing in is needed (both off unless it says so; if it
+// can't be reached, Backstep works as before). Returns whether this version
+// had to update, so the ordinary update offer isn't asked as well.
+async function checkAccess($: EngineInterface): Promise<boolean> {
+  const ran = await $.process.run(backstep(['access']), { timeoutMs: 20_000 }).catch(() => null)
+  let a: Access = { ok: true }
+  try {
+    a = JSON.parse(ran?.stdout || '{"ok":true}') as Access
+  } catch {
+    return false
+  }
+  // Only a clear no turns ctrl+u off: anything else (an older CLI, odd output) leaves it on.
+  if (!a || typeof a !== 'object' || a.ok !== false || !a.detail) {
+    await update($, blocked, () => null)
+    return false
+  }
+  await update($, blocked, () => a.detail ?? null)
+  $.ui.log(`${MARK_TEXT} ${a.detail}`)
+  if (a.reason !== 'update') {
+    $.ui.toast(a.detail ?? 'Backstep is turned off here.', { timeoutMs: 15_000 })
+    return false
+  }
+  // Too old to keep running: asked to update, and ctrl+u waits until it has.
+  const checked = await $.process.run(backstep(['update-check']), { timeoutMs: 15_000 }).catch(() => null)
+  let latest = a.minVersion ?? ''
+  try {
+    latest = (JSON.parse(checked?.stdout || '{}') as { latest?: string | null }).latest ?? latest
+  } catch {
+    // the minimum, then
+  }
+  const answer = await $.ui
+    .ask(`This version of Backstep (${a.current}) is no longer supported, so ${surface === 'terminal' ? await keysLabel($) : 'undo'} is off until it updates. Update to ${latest} now?`, {
+      header: 'Backstep',
+      options: ['Update now', 'Not now'],
+    })
+    .catch(() => null)
+  if (answer === 'Update now' && latest && (await installUpdate($, a.current, latest, true))) await update($, blocked, () => null)
+  return true
+}
+
 // A newer Backstep on npm: asked as a session starts, installed only on a yes.
 async function offerUpdate($: EngineInterface) {
   const ran = await $.process.run(backstep(['update-check']), { timeoutMs: 15_000 }).catch(() => null)
@@ -661,11 +725,18 @@ async function offerUpdate($: EngineInterface) {
     return
   }
   if (answer !== UPDATE.yes) return
+  await installUpdate($, u.current, u.latest)
+}
+
+// Installs a version, saying not to close the terminal while it runs and which version it ended on.
+async function installUpdate($: EngineInterface, current: string | undefined, latest: string, forced = false): Promise<boolean> {
+  const u = { current, latest }
   // Said where it stays (the conversation) and where it's seen while it runs (the status line).
   const from = u.current ? ` from ${u.current}` : ''
-  $.ui.log(`${MARK_TEXT} Updating Backstep${from} to ${u.latest}… Don't close this terminal until it says it's done (about a minute).`)
-  $.ui.toast(`Updating Backstep to ${u.latest}. Don't close this terminal until it's done.`, { timeoutMs: 15_000 })
-  $.ui.status(`◀◀ Updating Backstep to ${u.latest}… don't close this terminal`)
+  const win = surface === 'terminal' ? 'this terminal' : 'Claude Code'
+  $.ui.log(`${MARK_TEXT} Updating Backstep${from} to ${u.latest}… Don't close ${win} until it says it's done (about a minute).`)
+  $.ui.toast(`Updating Backstep to ${u.latest}. Don't close ${win} until it's done.`, { timeoutMs: 15_000 })
+  $.ui.status(`◀◀ Updating Backstep to ${u.latest}… don't close ${win}`)
   const done = await $.process
     .run(backstep(['update', '--version', u.latest, '--json']), { timeoutMs: 600_000 })
     .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
@@ -677,12 +748,14 @@ async function offerUpdate($: EngineInterface) {
   }
   $.ui.status(undefined)
   if (r.ok) {
-    $.ui.log(`${MARK_TEXT} Backstep is updated to ${u.latest}${u.current ? ` (you had ${u.current})` : ''}. It's safe to close the terminal now. Restart Claude Code to start using ${u.latest}.`)
+    $.ui.log(`${MARK_TEXT} Backstep is updated to ${u.latest}${u.current ? ` (you had ${u.current})` : ''}. It's safe to close ${win} now. Restart Claude Code to start using ${u.latest}.`)
     $.ui.toast(`Backstep is updated to ${u.latest}. Restart Claude Code to use it.`)
+    return true
   } else {
-    $.ui.log(`${MARK_TEXT} Backstep couldn't update to ${u.latest}: ${r.detail}. You're still on ${u.current ?? 'the version you had'}, which keeps working. To try again, run: npx backstep@latest setup`)
+    $.ui.log(`${MARK_TEXT} Backstep couldn't update to ${u.latest}: ${r.detail}. You're still on ${u.current ?? 'the version you had'}${forced ? '' : ', which keeps working'}. To try again, run: npx backstep@latest setup`)
     $.ui.toast(`Backstep couldn't update: ${r.detail}. Try: npx backstep@latest setup`)
   }
+  return false
 }
 
 const KEY = 'mcp__backstep__undo_key'
@@ -806,15 +879,21 @@ async function uninstallBackstep($: EngineInterface): Promise<string> {
   return `Backstep is removed. Restart Claude Code to finish.\n${lines}`
 }
 
+// Where this session is drawn: the terminal, or an app (the desktop app, VS Code) where there's no terminal to mention.
+let surface = 'terminal'
+
 export const register: Register = (on, options) => {
   cli = String(options.cli ?? 'backstep')
 
   on('session.start', async ($, e, next) => {
+    surface = e.surface ?? 'terminal'
     await $.tool.register(CONNECT_TOOL)
     await $.tool.register(KEY_TOOL)
     await $.tool.register(UNINSTALL_TOOL)
     // A command that can't be added never holds up the session: asking Claude still uninstalls.
     await $.command.register({ name: 'uninstall-backstep', description: 'Remove Backstep and everything it set up from this computer' }).catch(() => null)
+    // Undo by command too: the desktop app has no way for ctrl+u to reach Backstep yet.
+    await $.command.register({ name: 'backstep-undo', description: "Undo Claude's last turn with Backstep" }).catch(() => null)
     const r = await next(e)
     const boundOut = await $.process.run(backstep(['key', '--json'])).catch(() => null)
     try {
@@ -824,11 +903,17 @@ export const register: Register = (on, options) => {
       // keep the default
     }
     // Said first thing, so nobody has to wonder whether it's running.
-    $.ui.log(`✓ Backstep connected · press ${await keysLabel($)} to undo Claude's last turn`)
+    $.ui.log(
+      e.surface === 'terminal'
+        ? `✓ Backstep connected · press ${await keysLabel($)} to undo Claude's last turn`
+        : "✓ Backstep connected · click Undo last turn above the message box, or type /backstep-undo, to undo Claude's last turn",
+    )
     // In the background: a session never waits on either.
     void wrapNewServers($, e.cwd)
-    // One question at a time: Supabase first, then any update.
-    void checkCoverage($, e.cwd).then(() => offerUpdate($))
+    // One question at a time: Supabase first, then whether this version may run, then any update.
+    void checkCoverage($, e.cwd)
+      .then(() => checkAccess($))
+      .then((forced) => (forced ? undefined : offerUpdate($)))
     void $.process.run(backstep(['ping'])).catch(() => null)
     return r
   })
@@ -855,6 +940,7 @@ export const register: Register = (on, options) => {
   on('tool.call', { tool: UNINSTALL }, async ($) => ({ result: await uninstallBackstep($) }))
 
   on('command.run', { command: 'uninstall-backstep' }, async ($) => ({ text: await uninstallBackstep($) }))
+  on('command.run', { command: 'backstep-undo' }, async ($) => ({ text: await undoByCommand($) }))
 
   on('tool.call', async ($, e, next) => {
     const tool = String(e.tool)
@@ -1004,6 +1090,57 @@ export const register: Register = (on, options) => {
 
     const { target, before } = await undoTargets($)
     const label = (await read($, keys)).map(keyLabel).join(' / ')
+
+    // The desktop app (and any app that isn't the terminal): ctrl+u never reaches
+    // Backstep there, so it's real buttons to click and no key is mentioned.
+    const appBand = async (target: Turn | undefined, before: Turn | undefined) => {
+      const cancel = (
+        <Button key="cancel" variant="secondary" onPress={() => void update($, armed, () => null)}>
+          Cancel
+        </Button>
+      )
+      if (target && (await read($, armed)) !== null) {
+        return (
+          <Box flexDirection="column">
+            <Box>
+              {mark()}
+              <Text color="warning" bold>{before ? 'That turn only saved and pushed to git.' : "Undo Claude's last turn?"}</Text>
+            </Box>
+            <Text dimColor>{before ? `   Undo it and the turn before it${quoted(before, 50)}?` : `   ${quoted(target, 50).trim() || 'That turn'} · ${summary(target)}`}</Text>
+            <Box marginTop={1}>
+              <Text>{'   '}</Text>
+              <Button key="undo" variant="primary" onPress={() => void pressUndo($)}>
+                {before ? 'Yes, undo both' : 'Yes, undo it'}
+              </Button>
+              <Text>{'  '}</Text>
+              {before ? (
+                <Button key="just" variant="secondary" onPress={() => void update($, armed, () => null).then(() => undoLastTurn($, 1))}>
+                  Just the push
+                </Button>
+              ) : null}
+              {before ? <Text>{'  '}</Text> : null}
+              {cancel}
+            </Box>
+          </Box>
+        )
+      }
+      return (
+        <Box>
+          {mark()}
+          <Box flexShrink={1} minWidth={0}>
+            <Text dimColor wrap="truncate-end">{target ? `Last turn:${quoted(target, 28)} · ${summary(target)}` : 'Backstep is running · nothing to undo yet'}</Text>
+          </Box>
+          <Box flexShrink={0} marginLeft={2}>
+            <Button key="undo" variant="primary" onPress={() => void pressUndo($)}>
+              ◀ Undo last turn
+            </Button>
+          </Box>
+        </Box>
+      )
+    }
+    // Only the terminal hands ctrl+u to the button; anywhere else (the desktop app) it's a click.
+    const keyed = e.surface === 'terminal'
+    if (!keyed) return appBand(target, before)
     if (target && (await read($, armed)) !== null) {
       // Laid out a line at a time, so nothing gets squeezed into columns on a narrow terminal.
       const cancel = (

package/mod/types/index.d.ts

@@ -37,6 +37,7 @@ declare module 'claude-code' {
     // armed: when the undo key was first pressed; a second press within a few seconds undoes.
     // keys: the keys bound to undo, kept here so the band redraws when they change.
     // githubCode: the code GitHub's approval page wants, shown on the band until GitHub answers.
-    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[]; githubCode: GithubCode | null }
+    // blocked: why ctrl+u can't run, when getbackstep.com says this version is too old or a sign-in is needed.
+    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[]; githubCode: GithubCode | null; blocked: string | null }
   }
 }

package/package.json

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