backstep 0.1.6 → 0.1.8

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

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

@@ -132,6 +132,8 @@ test('with nothing to undo the band still holds the key, and a press says there
 
   const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect((await ui.find({ type: 'Text', text: /nothing to undo yet/ }))).toBeTruthy()
+  // The mark: the front triangle in the terminal's own color, the one behind in the logo's pink.
+  expect((await ui.find({ type: 'Text', text: '◀', props: { color: '#ee7bb6' } }))).toBeTruthy()
   await ui.press({ key: 'undo' })
   expect(toasts[0]).toContain('Nothing to undo yet')
   await ui.unmount()

package/mod/hooks/register.tsx

@@ -13,6 +13,12 @@ const turns = atom({ plugin: 'backstep', key: 'turns' } as const, [] as Turn[])
 const rewind = atom({ plugin: 'backstep', key: 'rewind' } as const, null as Rewind | null)
 const note = atom({ plugin: 'backstep', key: 'note' } as const, null as string | null)
 const armed = atom({ plugin: 'backstep', key: 'armed' } as const, null as number | null)
+// 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[])
+// 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'
 // How long the "press again to undo" question waits before it lets go.
 const CONFIRM_MS = 5000
 
@@ -186,8 +192,9 @@ async function undoLastTurn($: EngineInterface) {
 
   if (done) {
     const list = items.filter((i) => i.ok).map((i) => `- ${i.label}`).join('\n')
+    const key = await keysLabel($)
     await update($, note, () =>
-      `[Backstep] The user pressed undo (${keysLabel()}) on your previous turn. These changes were reverted:\n${list}\n` +
+      `[Backstep] The user pressed undo (${key}) on your 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` : '') +
         `Treat them as not having happened, re-read files before editing them, and don't redo them unless asked.`,
     )
@@ -275,10 +282,8 @@ type ShellPlan = { kind: 'read' | 'write' | 'outbound'; reason?: string; id?: st
 
 // Set from the plugin's options each time the module registers.
 let cli = 'backstep'
-// The keys bound to undo, read as a session starts and when the person changes them.
-let undoKeys = ['ctrl+u']
 const keyLabel = (k: string) => (k.startsWith('cmd+') ? `⌘${k.slice(4).toUpperCase()}` : k)
-const keysLabel = () => undoKeys.map(keyLabel).join(' / ')
+const keysLabel = async ($: EngineInterface) => (await read($, keys)).map(keyLabel).join(' / ')
 
 function backstep(args: string[]): string[] {
   return cli === 'backstep' ? ['backstep', ...args] : ['node', '--disable-warning=ExperimentalWarning', cli, ...args]
@@ -441,10 +446,12 @@ async function changeKey($: EngineInterface, key: string): Promise<string> {
     r = { ok: false, detail: ran.stderr.trim() || 'it failed' }
   }
   if (!r.ok || !r.key) return `Couldn't change the undo key: ${r.detail ?? 'it failed'}`
-  undoKeys = r.keys?.length ? r.keys : [r.key]
-  $.ui.toast(`Backstep: undo is now ${keysLabel()}.`)
-  const was = r.previous && !undoKeys.includes(r.previous) ? ` (it was ${keyLabel(r.previous)})` : ''
-  return `Undo is now ${keysLabel()}${was}. It works right away.`
+  const now = r.keys?.length ? r.keys : [r.key]
+  await update($, keys, () => now)
+  const label = await keysLabel($)
+  $.ui.toast(`Backstep: undo is now ${label}.`)
+  const was = r.previous && !now.includes(r.previous) ? ` (it was ${keyLabel(r.previous)})` : ''
+  return `Undo is now ${label}${was}. It works right away.`
 }
 
 const CONNECT = 'mcp__backstep__connect'
@@ -499,15 +506,15 @@ export const register: Register = (on, options) => {
     await $.tool.register(CONNECT_TOOL)
     await $.tool.register(KEY_TOOL)
     const r = await next(e)
-    const bound = await $.process.run(backstep(['key', '--json'])).catch(() => null)
+    const boundOut = await $.process.run(backstep(['key', '--json'])).catch(() => null)
     try {
-      const keys = (JSON.parse(bound?.stdout || '{}') as { keys?: string[] }).keys
-      if (keys?.length) undoKeys = keys
+      const bound = (JSON.parse(boundOut?.stdout || '{}') as { keys?: string[] }).keys
+      if (bound?.length) await update($, keys, () => bound)
     } catch {
       // keep the default
     }
     // Said first thing, so nobody has to wonder whether it's running.
-    $.ui.log(`✓ Backstep connected · press ${keysLabel()} to undo Claude's last turn`)
+    $.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.
@@ -592,15 +599,17 @@ export const register: Register = (on, options) => {
     if (r?.phase === 'running') {
       return (
         <Box>
-          <Text color="success" bold>↺ Rewinding </Text>
-          <Text color="success">{bar(r.frame)}</Text>
+          <Text bold>◀</Text>
+          <Text color={PINK} bold>◀</Text>
+          <Text bold> Rewinding </Text>
+          <Text>{bar(r.frame)}</Text>
           <Text dimColor> undoing the last turn…</Text>
         </Box>
       )
     }
 
     if (r) {
-      const tone = r.phase === 'failed' ? 'error' : r.phase === 'empty' ? 'warning' : 'success'
+      const tone = r.phase === 'failed' ? 'error' : r.phase === 'empty' ? 'warning' : undefined
       const glyph = r.phase === 'failed' ? '✗' : r.phase === 'empty' ? '!' : '✓'
       const visible = r.items.slice(0, Math.min(r.shown, 6))
       const more = r.items.length - 6
@@ -612,7 +621,7 @@ export const register: Register = (on, options) => {
           {visible.map((i, n) => (
             <Text key={`i${n}`} color={i.ok ? undefined : 'error'} dimColor={i.ok}>
               {'  '}
-              {i.ok ? '↺ ' : '✗ '}
+              {i.ok ? '◀ ' : '✗ '}
               {i.label}
             </Text>
           ))}
@@ -622,13 +631,16 @@ export const register: Register = (on, options) => {
     }
 
     const target = (await read($, turns)).findLast(hasWork)
+    const label = (await read($, keys)).map(keyLabel).join(' / ')
     if (target && (await read($, armed)) !== null) {
       return (
         <Box>
-          <Text color="warning" bold>↺ Undo Claude's last turn? </Text>
+          <Text bold>◀</Text>
+          <Text color={PINK} bold>◀</Text>
+          <Text color="warning" bold> Undo Claude's last turn? </Text>
           <Text dimColor>{summary(target)}  </Text>
           <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
-            {`${keysLabel()} again to undo`}
+            {`${label} again to undo`}
           </Button>
           <Text dimColor>  ·  </Text>
           <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
@@ -643,10 +655,12 @@ export const register: Register = (on, options) => {
     // with nothing to undo, a press says so rather than doing nothing.
     return (
       <Box>
-        <Text color="success">↺ </Text>
+        <Text bold>◀</Text>
+        <Text color={PINK} bold>◀</Text>
+        <Text> </Text>
         <Text dimColor>{target ? `Last turn: ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
         <Button key="undo" action={UNDO_ACTION} plain dimColor onPress={() => void pressUndo($)}>
-          {`${keysLabel()} to undo`}
+          {`${label} to undo`}
         </Button>
       </Box>
     )

package/mod/types/index.d.ts

@@ -26,6 +26,7 @@ export type Rewind = {
 declare module 'claude-code' {
   interface PluginState {
     // armed: when the undo key was first pressed; a second press within a few seconds undoes.
-    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null }
+    // 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[] }
   }
 }

package/package.json

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