backstep 0.1.25 → 0.1.26

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/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "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,110 @@ 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()
+})

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.')
@@ -643,6 +652,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 ${await keysLabel($)} 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,6 +713,12 @@ 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).`)
@@ -679,10 +737,12 @@ async function offerUpdate($: EngineInterface) {
   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.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'
@@ -827,8 +887,10 @@ export const register: Register = (on, options) => {
     $.ui.log(`✓ Backstep connected · press ${await keysLabel($)} 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
   })

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.26",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "homepage": "https://getbackstep.com",
   "scripts": {