backstep 0.1.10 → 0.1.13

package/mod/hooks/register.tsx

@@ -57,16 +57,66 @@ type Outcome = {
   detail: string
   run?: { server: string; tool: string; args: Record<string, unknown> }
   pushed?: { root: string; pushes: Pushed[] }
+  github?: GhMade[]
 }
 const PUSH = /\bgit\b[^;&|]*\bpush\b/
+// A gh command that makes something on GitHub: noted once it runs, so undo can offer to take it away.
+const GH_CREATE = /\bgh\s+(repo|issue|pr|release)\s+create\b/
+type GhMade = { kind: 'repo' | 'issue' | 'pr' | 'release'; repo: string; number?: number; tag?: string; url: string }
+const describeGh = (g: GhMade) =>
+  g.kind === 'repo' ? `the GitHub repository ${g.repo}` : g.kind === 'release' ? `the release ${g.tag} in ${g.repo}` : `${g.kind === 'pr' ? 'pull request' : 'issue'} #${g.number} in ${g.repo}`
+
+// Runs a Backstep command that answers with { ok, detail }, however it fails.
+async function jsonRun($: EngineInterface, args: string[], timeoutMs: number, stdin?: string): Promise<{ ok: boolean; detail: string; needs?: string }> {
+  const ran = await $.process
+    .run(backstep(args), { timeoutMs, ...(stdin !== undefined ? { stdin } : {}) })
+    .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
+  try {
+    return JSON.parse(ran.stdout) as { ok: boolean; detail: string; needs?: string }
+  } catch {
+    return { ok: false, detail: (ran.stderr || 'it failed').trim().split('\n').at(-1) ?? 'it failed' }
+  }
+}
+
+const ghUndo = ($: EngineInterface, g: GhMade) => jsonRun($, ['gh-undo'], 120_000, JSON.stringify(g))
+
+// Asks, for each thing Claude made on GitHub in the undone turns, whether to take it away there too.
+// Returns the repositories deleted, whose pushes then need no undo of their own.
+async function offerGithubUndo($: EngineInterface, outcomes: Outcome[]): Promise<Set<string>> {
+  const gone = new Set<string>()
+  for (const g of outcomes.flatMap((o) => (o.ok && o.github ? o.github : []))) {
+    const yes = g.kind === 'repo' ? 'Delete it' : g.kind === 'issue' || g.kind === 'pr' ? 'Close it' : 'Delete it'
+    const answer = await $.ui
+      .ask(`Claude created ${describeGh(g)}. ${yes === 'Close it' ? 'Close' : 'Delete'} it on GitHub too?`, { header: 'Backstep', options: [yes, 'Leave it'] })
+      .catch(() => null)
+    if (answer !== yes) {
+      $.ui.log(`${MARK_TEXT} Not undone on GitHub: ${describeGh(g)} stays (you chose to leave it).`)
+      continue
+    }
+    let r = await ghUndo($, g)
+    // gh's sign-in needs one more permission: get it on GitHub's own page, then try again.
+    if (!r.ok && r.needs) {
+      $.ui.toast("GitHub needs your OK first. Backstep opened GitHub in your browser and copied the code: paste it there and press Authorize.", { timeoutMs: 15_000 })
+      $.ui.log(`${MARK_TEXT} GitHub needs your OK first: Backstep opened the approval page and copied the code to your clipboard. Paste it and press Authorize.`)
+      const granted = await jsonRun($, ['gh-auth', r.needs], 600_000)
+      r = granted.ok ? await ghUndo($, g) : { ok: false, detail: `GitHub didn't give the OK (${granted.detail}), so ${describeGh(g)} is still there` }
+    }
+    if (r.ok && g.kind === 'repo') gone.add(g.repo)
+    $.ui.log(r.ok ? `${MARK_TEXT} On GitHub: ${r.detail}.` : `${MARK_TEXT} Not undone on GitHub: ${r.detail}`)
+    $.ui.toast(r.ok ? `Backstep ${r.detail}.` : `Backstep ${r.detail}`)
+  }
+  return gone
+}
 
 const PUSH_ASK = { yes: 'Push the undo', no: 'Leave it as it is' }
 
 // Undo rewound the code here; this asks before taking it back on GitHub too,
 // as a new commit that undoes Claude's (never a force push).
-async function offerPushUndo($: EngineInterface, outcomes: Outcome[]) {
+async function offerPushUndo($: EngineInterface, outcomes: Outcome[], repoGone = false) {
   for (const o of outcomes) {
     if (!o.ok || !o.pushed) continue
+    // The repository it went to is deleted: nothing left there to undo.
+    if (repoGone) continue
     for (const p of o.pushed.pushes) {
       const what =
         p.before === null
@@ -184,11 +234,12 @@ async function undoLastTurn($: EngineInterface, count = 1) {
         .map((line) => ({ label: line.replace(/^(restored|removed) (.*)$/, (_, verb: string, p: string) => `${short(p)} ${verb}`), ok: true })),
     )
   const stopped = outcomes.filter((o) => !o.ok).map((o) => ({ label: `${o.tool}: ${o.detail.split('\n')[0] ?? 'failed'}`, ok: false }))
-  // A push is offered back on GitHub below, so it isn't listed as lost.
+  // A push, or something made on GitHub, is offered back below, so it isn't listed as lost.
   const offered = outcomes.some((o) => o.ok && o.pushed)
+  const offeredGh = outcomes.some((o) => o.ok && o.github?.length)
   const kept = taken
     .flatMap((t) => t.lostItems ?? [])
-    .filter((l) => !(offered && /pushes to a remote/.test(l)))
+    .filter((l) => !(offered && /pushes to a remote/.test(l)) && !(offeredGh && /changes GitHub/.test(l)))
     .map((label) => ({ label, ok: false }))
   const items: RewindItem[] = [...undone, ...stopped, ...kept]
   const done = undone.length
@@ -228,17 +279,15 @@ async function undoLastTurn($: EngineInterface, count = 1) {
     )
   }
 
-  // Asked once the band shows what came back.
-  void offerPushUndo($, outcomes)
+  // Asked once the band shows what came back: GitHub things first, then pushes.
+  void offerGithubUndo($, outcomes).then((gone) => offerPushUndo($, outcomes, gone.size > 0))
 
-  // Reveal the restored items one by one, then fold the band away.
+  // Reveal the items one by one. The list stays until the person's next
+  // message (it's in the conversation too), so nothing is missed.
   const reveal = $.clock.every(90, () => {
     void update($, rewind, (r) => (r && r.shown < r.items.length ? { ...r, shown: r.shown + 1 } : r))
   })
-  $.clock.after(failed || lost ? 12_000 : 4200, () => {
-    reveal.cancel()
-    void update($, rewind, () => null)
-  })
+  $.clock.after(90 * (items.length + 2), () => reveal.cancel())
 }
 
 type Next = (e: Record<string, unknown>) => Promise<{ deny?: string; isError?: true; result?: unknown; text?: string }>
@@ -332,11 +381,12 @@ const brief = (command: string) => {
 // Something in a turn that can't be undone, named, so undo can list it.
 const lostOne = (x: Turn, what: string): Turn => ({ ...x, lost: (x.lost ?? 0) + 1, lostItems: [...(x.lostItems ?? []), what].slice(-20) })
 
-// A turn named by what the person asked: ("commit and push it").
-const named = (t: Turn) => {
+// A turn named by what the person asked: "commit and push it", cut to `max`.
+const quoted = (t: Turn, max = 40) => {
   const p = (t.prompt ?? '').replace(/\s+/g, ' ').trim()
-  return p ? ` ("${p.length > 40 ? `${p.slice(0, 39)}…` : p}")` : ''
+  return p ? ` "${p.length > max ? `${p.slice(0, max - 1)}…` : p}"` : ''
 }
+const named = (t: Turn) => (t.prompt ? ` (${quoted(t).trim()})` : '')
 
 // Each part only saves to git (add, commit, push and friends), or only moves around.
 const GIT_SAVE = /^(git\s+(add|commit|push|status|log|diff|show|branch|remote|fetch|rev-parse|config)\b|cd\s|echo\s|true$)/
@@ -394,7 +444,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($, c.dir ?? cwd)
+      if (c.state === 'ask') await askDatabase($, c.dir ?? cwd, c.service)
       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 {
@@ -422,36 +472,45 @@ const ASK = {
 // 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)
+// How each database is named in the question, and what the answer connects.
+const DB_NAME: Record<string, string> = { supabase: 'Supabase', postgres: 'a Postgres database', firebase: 'Firebase' }
+
+// Asked when Claude Code opens a project that uses a database (Supabase, other
+// Postgres, Firebase), 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 askDatabase($: EngineInterface, cwd: string, service = 'supabase') {
+  const key = `${service}:${cwd}`
+  if (asked.has(key)) return
+  asked.add(key)
+  const name = DB_NAME[service] ?? service
   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?", {
+    .ask(`This project uses ${name}, but Backstep isn't connected to it, so Claude's changes to it can't be undone. Connect it?`, {
       header: 'Backstep',
       options: [ASK.connect, ASK.later, ASK.never],
     })
     .catch(() => null)
   if (answer === ASK.never) {
-    await $.process.run(backstep(['connect', 'supabase', '--dir', cwd, '--dismiss'])).catch(() => null)
+    await $.process.run(backstep(['connect', service, '--dir', cwd, '--dismiss'])).catch(() => null)
     return
   }
   if (answer !== ASK.connect) return
-  const ran = await $.process.run(backstep(['connect', 'supabase', '--dir', cwd, '--json']), { timeoutMs: 120_000 }).catch(() => null)
-  let s: Connected | undefined
+  const ran = await $.process.run(backstep(['connect', service, '--dir', cwd, '--json']), { timeoutMs: 120_000 }).catch(() => null)
+  let all: Connected[] = []
   try {
-    s = (JSON.parse(ran?.stdout || '[]') as Connected[])[0]
+    all = JSON.parse(ran?.stdout || '[]') as Connected[]
   } catch {
-    s = undefined
+    all = []
   }
-  if (s?.state === 'connected' || s?.state === 'covered') {
-    $.ui.toast(`Backstep ${s.detail}. Claude's changes to its database can now be undone.`)
+  const s = all.find((c) => c.state === 'connected' || c.state === 'covered') ?? all.find((c) => c.state === 'needs')
+  if (s && (s.state === 'connected' || s.state === 'covered')) {
+    $.ui.toast(`Backstep ${s.detail}.`)
+    $.ui.log(`${MARK_TEXT} Backstep ${s.detail}.`)
     return
   }
-  // Nothing in the project to connect with: a sign-in is needed, and Claude walks the person through it.
-  $.ui.toast('Backstep needs a Supabase sign-in for this. Ask Claude to "connect Backstep to Supabase" and it will walk you through it.')
+  // What's still needed, said where it stays.
+  const need = s?.detail ?? `ask Claude to "connect Backstep to ${service}"`
+  $.ui.log(`${MARK_TEXT} Not connected to ${name} yet: ${need}`)
+  $.ui.toast(service === 'supabase' ? 'Backstep needs a Supabase sign-in for this. Ask Claude to "connect Backstep to Supabase" and it will walk you through it.' : `Backstep isn't connected to ${name} yet: ${need}`)
 }
 
 const UPDATE = { yes: 'Update', later: 'Not now', skip: 'Skip this version' }
@@ -596,6 +655,9 @@ export const register: Register = (on, options) => {
   on('prompt.submit', async ($, e, next) => {
     if (e.command || e.isMeta || (e.origin.kind !== 'composer' && e.origin.kind !== 'bridge')) return next(e)
     const startedAt = await $.clock.now()
+    // The last undo's list has been seen: the band goes back to the undo line.
+    const shown = await read($, rewind)
+    if (shown && shown.phase !== 'running') await update($, rewind, () => null)
     await update($, turns, (l) => [...(l ?? []), newTurn(startedAt, e.text)].slice(-KEEP_TURNS))
     const pending = await read($, note)
     if (!pending) return next(e)
@@ -636,8 +698,8 @@ export const register: Register = (on, options) => {
       // 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)
+        const { ask, service } = JSON.parse(checked?.stdout || '{}') as { ask?: string | null; service?: string | null }
+        if (ask) await askDatabase($, ask, service ?? 'supabase')
       } catch {
         // can't tell: run it as before
       }
@@ -665,9 +727,9 @@ export const register: Register = (on, options) => {
         )
       }
       // A push: once it's run, note what it sent, so undo can offer to take it back there.
-      if (plan?.id && PUSH.test(command)) {
+      if (plan?.id && (PUSH.test(command) || GH_CREATE.test(command))) {
         const r = await next(e)
-        await $.process.run(backstep(['shell-end', plan.id])).catch(() => null)
+        await $.process.run(backstep(['shell-end', plan.id]), { stdin: r.text ?? '' }).catch(() => null)
         return r
       }
     } else if (tool.startsWith('mcp__')) {
@@ -727,40 +789,53 @@ export const register: Register = (on, options) => {
     const { target, before } = await undoTargets($)
     const label = (await read($, keys)).map(keyLabel).join(' / ')
     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 = (
+        <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
+          cancel
+        </Button>
+      )
       // The last turn only committed and pushed: the work it saved is what the person most likely wants back.
       if (before) {
         return (
+          <Box flexDirection="column">
+            <Box>
+              <Text bold>◀</Text>
+              <Text color={PINK} bold>◀</Text>
+              <Text color="warning" bold>{' That turn only saved and pushed to git.'}</Text>
+            </Box>
+            <Text dimColor>{`   Undo it and the turn before it${quoted(before, 50)}?`}</Text>
+            <Box>
+              <Text>{'   '}</Text>
+              <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
+                {`${label} again to undo both`}
+              </Button>
+              <Text dimColor>{'  ·  '}</Text>
+              <Button key="just" plain dimColor onPress={() => void update($, armed, () => null).then(() => undoLastTurn($, 1))}>
+                just the push
+              </Button>
+              <Text dimColor>{'  ·  '}</Text>
+              {cancel}
+            </Box>
+          </Box>
+        )
+      }
+      return (
+        <Box flexDirection="column">
           <Box>
             <Text bold>◀</Text>
             <Text color={PINK} bold>◀</Text>
-            <Text color="warning" bold> That turn only saved and pushed to git. </Text>
+            <Text color="warning" bold>{" Undo Claude's last turn?"}</Text>
+          </Box>
+          <Text dimColor>{`   ${quoted(target, 50).trim() || 'That turn'} · ${summary(target)}`}</Text>
+          <Box>
+            <Text>{'   '}</Text>
             <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
-              {`${label} again to undo it and the turn before${named(before)}`}
-            </Button>
-            <Text dimColor>  ·  </Text>
-            <Button key="just" plain dimColor onPress={() => void update($, armed, () => null).then(() => undoLastTurn($, 1))}>
-              just the push
-            </Button>
-            <Text dimColor>  ·  </Text>
-            <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
-              cancel
+              {`${label} again to undo`}
             </Button>
+            <Text dimColor>{'  ·  '}</Text>
+            {cancel}
           </Box>
-        )
-      }
-      return (
-        <Box>
-          <Text bold>◀</Text>
-          <Text color={PINK} bold>◀</Text>
-          <Text color="warning" bold>{` Undo Claude's last turn${named(target)}? `}</Text>
-          <Text dimColor>{summary(target)}  </Text>
-          <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
-            {`${label} again to undo`}
-          </Button>
-          <Text dimColor>  ·  </Text>
-          <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
-            cancel
-          </Button>
         </Box>
       )
     }
@@ -773,7 +848,7 @@ export const register: Register = (on, options) => {
         <Text bold>◀</Text>
         <Text color={PINK} bold>◀</Text>
         <Text> </Text>
-        <Text dimColor>{target ? `Last turn${named(target)}: ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
+        <Text dimColor>{target ? `Last turn:${quoted(target, 28)} · ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
         <Button key="undo" action={UNDO_ACTION} plain dimColor onPress={() => void pressUndo($)}>
           {`${label} to undo`}
         </Button>

package/package.json

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