save-point

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    const below = await next(e)
    const text = e.props.hasSurvey ? undefined : bandText((await read($, saved))[0], await $.clock.now())
    if (text === undefined) return below

    const { Box, Button, Text } = $.ui.resolve(e)
    return (
      <Box flexDirection="column">
        {below}
        <Box>
          <Text dimColor>{text} </Text>
          <Button key="open" plain hotkey="3" label="save-point" onPress={() => $.ui.open({ id: PANE, title: 'save-point' })} />
        </Box>
      </Box>
    )
  })

  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
    const { Box, Button, Text } = $.ui.resolve(e)
    const now = await $.clock.now()
    const isPresenting = isPresentation(await $.env.get('GROUND_RULES_PRESENTATION'))
    const records: Saved[] = []
    for (const key of (await $.store.keys()).filter(name => name.startsWith('sp:'))) {
      const record = await $.store.get(key)
      if (isSaved(record)) records.push(record)
    }
    const listed = records.sort((a, b) => b.at - a.at).slice(0, KEPT_LISTED)

    const restore = (record: Saved) => async (): Promise<void> => {
      const io = makeIo($)
      const repo: Repo = { root: record.root, gitDir: record.gitDir }
      const target = record.sha ?? record.stashes?.[0]
      if (target === undefined || !(await exists(io, repo, target))) {
        $.ui.toast('save-point: that snapshot no longer exists (git gc removed it).')
        return
      }

      const paths = record.sha === undefined ? [] : await filesToRestore(io, repo, record.sha)
      if (record.sha !== undefined && paths.length === 0) {
        $.ui.toast('save-point: nothing to restore, the files already match the snapshot.')
        return
      }

      const answer = await $.ui.ask(restoreQuestion(record, paths, isPresenting), ['Keep', 'Restore'])
      if (answer !== 'Restore') return

      // Take the current state first, so a restore can be undone the same way.
      const fresh = await takeSnapshot(io, repo, 'before restore', await sessionTag($))
      if (fresh.ok) {
        const { snapshot } = fresh
        const entry: Pending = {
          kind: 'before restore',
          root: repo.root,
          gitDir: repo.gitDir,
          sha: snapshot.sha,
          before: snapshot.paths,
          skipped: snapshot.skipped.length,
          at: await $.clock.now(),
        }
        await file($, entry, snapshot.paths.length)
      }

      const isDone =
        record.sha === undefined
          ? await applyStashes(io, repo, record.stashes ?? [])
          : await restoreFiles(io, repo, record.sha, paths)
      $.ui.toast(isDone ? 'save-point: restored.' : 'save-point: the restore stopped partway. Run git status.')
    }

    return (
      <Box flexDirection="column">
        {listed.length === 0 && <Text dimColor>Nothing has been saved yet.</Text>}
        {listed.map(record => (
          <Box key={`row-${record.key}`}>
            <Text>{snapshotLine(record, now, isPresenting)} </Text>
            <Button key={`restore-${record.key}`} label="Restore" onPress={restore(record)} />
          </Box>
        ))}
        <Text dimColor>A snapshot is a git object with no ref. git gc removes it after about 14 days.</Text>
      </Box>
    )
  })