backstep 0.1.10 → 0.1.14

package/mod/hooks/register.tsx

@@ -7,7 +7,7 @@
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, Register } from 'claude-code'
 
-import type { Rewind, RewindItem, Turn } from '../types'
+import type { GithubCode, Rewind, RewindItem, Turn } from '../types'
 
 const turns = atom({ plugin: 'backstep', key: 'turns' } as const, [] as Turn[])
 const rewind = atom({ plugin: 'backstep', key: 'rewind' } as const, null as Rewind | null)
@@ -16,6 +16,8 @@ const armed = atom({ plugin: 'backstep', key: 'armed' } as const, null as number
 // The keys bound to undo, read as a session starts and when the person changes
 // them. Kept in state, not a variable, so the band redraws with the new key.
 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)
 // 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'
@@ -57,16 +59,99 @@ 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))
+
+// Gets GitHub's OK for one more gh permission. The CLI prints the one-time code
+// on a line of its own as soon as GitHub gives it, so the band shows it while
+// GitHub waits; the answer is its last line.
+async function ghAuth($: EngineInterface, scope: string, what: string): Promise<{ ok: boolean; detail: string }> {
+  let out = ''
+  try {
+    const child = $.process.spawn({ argv: backstep(['gh-auth', scope]) })
+    for await (const { stream, text } of child) {
+      if (stream !== 'stdout') continue
+      out += text
+      const code = out.match(/"code":"([A-Z0-9]{4}-[A-Z0-9]{4})"/)?.[1]
+      if (code && !(await read($, githubCode))) {
+        await update($, githubCode, () => ({ code, what }))
+        $.ui.log(`${MARK_TEXT} One more step to ${what}: paste the code ${code} on the GitHub page that just opened, then press Authorize. (It's already copied, so ⌘V / Ctrl+V works.)`)
+      }
+    }
+  } catch (err) {
+    out += `\n${JSON.stringify({ ok: false, detail: err instanceof Error ? err.message : String(err) })}`
+  } finally {
+    await update($, githubCode, () => null)
+  }
+  try {
+    return JSON.parse(out.trim().split('\n').at(-1) ?? '') as { ok: boolean; detail: string }
+  } catch {
+    return { ok: false, detail: "GitHub didn't answer" }
+  }
+}
+
+// Adds a line to the band's list once something offered after the rewind is settled.
+async function addItem($: EngineInterface, item: RewindItem) {
+  await update($, rewind, (r) => (r ? { ...r, items: [...r.items, item], shown: r.shown + 1 } : r))
+}
+
+// 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('One more step: paste the code shown above the prompt on the GitHub page that just opened, then press Authorize.', { timeoutMs: 15_000 })
+      const granted = await ghAuth($, r.needs, `${yes === 'Close it' ? 'close' : 'delete'} ${describeGh(g)}`)
+      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)
+    await addItem($, r.ok ? { label: `on GitHub: ${r.detail}`, ok: true } : { label: `on GitHub: ${r.detail}`, ok: false })
+    $.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 +269,14 @@ 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)
+  // Deleting the repository takes whatever was pushed to it along.
+  const offeredRepo = outcomes.some((o) => o.ok && o.github?.some((g) => g.kind === 'repo'))
   const kept = taken
     .flatMap((t) => t.lostItems ?? [])
-    .filter((l) => !(offered && /pushes to a remote/.test(l)))
+    .filter((l) => !((offered || offeredRepo) && /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 +316,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 +418,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 +481,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 +509,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 +692,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 +735,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 +764,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__')) {
@@ -693,6 +792,24 @@ export const register: Register = (on, options) => {
       )
     }
 
+    const waiting = await read($, githubCode)
+    // GitHub is waiting on the person: the code, big and plain, says this is a step to take, not a failure.
+    const step = waiting ? (
+      <Box flexDirection="column" marginTop={r ? 1 : 0}>
+        <Box>
+          <Text bold>◀</Text>
+          <Text color={PINK} bold>◀</Text>
+          <Text color="warning" bold>{` One more step to ${waiting.what}:`}</Text>
+        </Box>
+        <Text>{'   Paste this code on the GitHub page that just opened, then press Authorize:'}</Text>
+        <Box>
+          <Text>{'   '}</Text>
+          <Text color={PINK} bold>{waiting.code}</Text>
+          <Text dimColor>{'  (already copied: ⌘V / Ctrl+V)'}</Text>
+        </Box>
+      </Box>
+    ) : null
+
     if (r) {
       const tone = r.phase === 'failed' ? 'error' : r.phase === 'empty' ? 'warning' : undefined
       const glyph = r.phase === 'failed' ? '✗' : r.phase === 'empty' ? '!' : '✓'
@@ -720,47 +837,63 @@ export const register: Register = (on, options) => {
               {i.label}
             </Text>
           ))}
+          {step}
         </Box>
       )
     }
 
+    if (step) return step
+
     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 +906,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/mod/types/index.d.ts

@@ -29,10 +29,14 @@ export type Rewind = {
   message: string
 }
 
+// GitHub waiting on the person's OK for one more permission: the one-time code to paste, and what it's for.
+export type GithubCode = { code: string; what: string }
+
 declare module 'claude-code' {
   interface PluginState {
     // 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.
-    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[] }
+    // 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 }
   }
 }

package/package.json

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