korus-inbox

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    const below = await next(e)
    const { count } = await waiting($)
    if (count === 0 || e.props.hasSurvey) return below
    const { Box, Button } = $.ui.resolve(e)
    const band = (
      <Button
        key="korus-inbox:open"
        label={`inbox ${count}`}
        hotkey="i"
        onPress={() => {
          void openInbox($).catch(() => $.ui.toast('Owner inbox did not open.'))
        }}
      />
    )
    // The engine draws nothing of its own here, so an engine element means
    // no other hook drew a band.
    if (below.type === 'engine') return band
    return (
      <Box flexDirection="column">
        {band}
        {below}
      </Box>
    )
  })

  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
    const { Box, Button, Text } = $.ui.resolve(e)
    const now = await $.clock.now()
    const mine = await read($, own)
    const theirs = await read($, remote)
    const note = await read($, folderNote)
    const opened = new Set(await read($, expanded))
    const myLabel = await shownName($)
    const list = waitingOf(mine, theirs)
    const done = mine.filter(isDone)

    // Rows the card draws itself, each cut at the edge and never wrapped, so
    // a row starts only where these rows say it does.
    const drawRows = (prefix: string, lines: readonly string[]) =>
      lines.map((line, index) => (
        <Text key={`${prefix}:${index}`} wrap="truncate-end">
          {line}
        </Text>
      ))

    const copyButton = (key: string, text: string | undefined) =>
      text !== undefined && text !== '' ? (
        <Button
          key={key}
          label="Copy"
          onPress={async press => {
            const copied = await $.ui.copy({ text, surface: press.surface })
            $.ui.toast(copied.isCopied ? 'Copied.' : `Not copied: ${copied.reason}`)
          }}
        />
      ) : null

    // The lines every card shares, in order: Do this, Needs you for, Why, For
    // you, From, Folder. The headline is drawn by the caller.
    const commonLines = (card: Card, from: string, where: string, folderText: string | undefined, keyBase: string) => {
      const needs = needsOf(card)
      const why = whyLineOf(card)
      return (
        <Box key={`${keyBase}:common`} flexDirection="column">
          <Text color="cyan" wrap="wrap">{`Do this: ${doThisOf(card, where)}`}</Text>
          <Text dimColor wrap="wrap">{`Needs you for: ${needs.needs} | confidence: ${needs.confidence}`}</Text>
          {why !== undefined && why !== '' && <Text wrap="wrap">{`Why: ${why}`}</Text>}
          {card.kind === 'refused' && card.ask !== undefined && <Text wrap="wrap">{`For you: ${card.ask}`}</Text>}
          {card.kind === 'question' && <Text wrap="wrap">{questionText(card.questions)}</Text>}
          <Text dimColor wrap="wrap">{`From: ${from}`}</Text>
          {folderText !== undefined && <Text dimColor wrap="wrap">{`Folder: ${folderText}`}</Text>}
        </Box>
      )
    }

    const detailsLines = (card: Card, keyBase: string) => (
      <Box key={`${keyBase}:details`} flexDirection="column">
        {card.command !== undefined && <Text dimColor>Full command:</Text>}
        {card.command !== undefined && <Text wrap="wrap">{clean(card.command, MAX_COMMAND)}</Text>}
        {card.kind === 'refused' && <Text dimColor>Full refusal:</Text>}
        {card.kind === 'refused' && <Text wrap="wrap">{card.detail ?? card.refusal ?? ''}</Text>}
        <Text dimColor wrap="wrap">{`Review: ${needsOf(card).review}`}</Text>
      </Box>
    )

    const partNote = (card: Card, canRun: boolean) => {
      if (card.kind !== 'refused' || card.command === undefined) return null
      const part = card.part?.part
      if (part === undefined) {
        return <Text dimColor wrap="wrap">Copy takes the whole command, not the blocked part alone.</Text>
      }
      if (part === card.command) return null
      return (
        <Text dimColor wrap="wrap">
          {canRun
            ? 'Copy and Run use only the blocked part above, not the whole line.'
            : 'Copy takes only the blocked part above, not the whole line.'}
        </Text>
      )
    }

    // Every Button key names its entry, never its row: a row that moves
    // between the draw and the press cannot carry a press to another entry.
    // Own keys are minted UUIDs; remote keys are checked to a safe alphabet.
    const ownCard = (entry: InboxEntry) => {
      const card = cardOf(entry)
      const where = entry.cwd !== undefined && entry.cwd !== '' ? entry.cwd : '(unknown)'
      const from = `${entry.agentId !== undefined ? 'a subagent of this session' : 'this session'}, ${age(now - entry.createdAt)} ago`
      const run = entry.run
      const isArmed = entry.armedAt !== undefined && now - entry.armedAt < ARM_MS
      const text = runText(entry, card.part)
      const textBlock = entry.kind === 'question' ? undefined : runBlock(entry, card.part)
      // A pane too narrow for a whole row would cut it short, so it offers
      // Copy only; the claim needs a drawn Run now, so it cannot run there.
      const block =
        entry.kind !== 'question' && textBlock === undefined && e.props.bodyColumns < RUN_COLUMNS
          ? `Copy only here: the pane is ${e.props.bodyColumns} columns wide, and Run needs ${RUN_COLUMNS} so that no row is cut short.`
          : textBlock
      const canRun = entry.kind !== 'question' && block === undefined && text !== undefined && run?.status !== 'running'
      const tailHead = run?.status === 'failed' ? 'error: ' : 'out: '
      const isOpen = opened.has(`details:${entry.id}`)
      return (
        <Box key={`own:${entry.id}`} flexDirection="column" marginTop={1}>
          {entry.kind === 'refused' && canRun && text !== undefined ? (
            <Box flexDirection="column">{drawRows(`head:${entry.id}`, labelledRows('Blocked: ', text))}</Box>
          ) : (
            <Text bold wrap="wrap">
              {headOf(card)}
            </Text>
          )}
          {commonLines(card, from, entry.kind === 'question' ? `${myLabel} (this session)` : 'this session', entry.kind === 'question' ? undefined : where, `own:${entry.id}`)}
          {entry.kind === 'signal' && entry.command !== undefined && canRun && (
            <Box flexDirection="column">{drawRows(`cmd:${entry.id}`, labelledRows('Command: ', entry.command))}</Box>
          )}
          {entry.kind === 'signal' && entry.command === undefined && entry.withheld !== undefined && (
            <Text dimColor wrap="wrap">{`(${entry.withheld})`}</Text>
          )}
          {partNote(card, canRun)}
          {run !== undefined && (
            <Box flexDirection="column">
              <Text wrap="wrap">
                {run.status === 'running'
                  ? 'running:'
                  : run.status === 'done'
                    ? `ran, exit ${run.exitCode ?? '?'}:`
                    : 'could not run:'}
              </Text>
              {run.argv !== undefined ? (
                <Box flexDirection="column">
                  {drawRows(`rfolder:${entry.id}`, labelledRows('folder: ', where))}
                  {drawRows(`rargv:${entry.id}`, argvRows(run.argv))}
                </Box>
              ) : (
                <Text dimColor>argv: none, nothing ran</Text>
              )}
              {/* The command writes its own output, so every line of it is
                  marked and cut, and none can draw a row of the views. */}
              {run.tail !== undefined && run.tail !== '' && (
                <Box flexDirection="column">
                  {run.tail.split('\n').map((line, index) => (
                    <Text key={`tail:${entry.id}:${index}`} dimColor wrap="truncate-end">
                      {`${tailHead}${line}`}
                    </Text>
                  ))}
                </Box>
              )}
            </Box>
          )}
          {isArmed && canRun && (
            <Box flexDirection="column">
              <Text color="yellow" wrap="wrap">
                {entry.armedArgv !== undefined
                  ? 'Run now runs this:'
                  : `Run now runs nothing: ${entry.armedError ?? 'no shell was found'}`}
              </Text>
              {entry.armedArgv !== undefined && (
                <Box flexDirection="column">
                  {drawRows(`folder:${entry.id}`, labelledRows('folder: ', where))}
                  {drawRows(`argv:${entry.id}`, argvRows(entry.armedArgv))}
                </Box>
              )}
              <Text dimColor wrap="wrap">
                {`Run now ignores a press within ${ARM_GAP_MS} ms of the last press, so one double press cannot run it.`}
              </Text>
            </Box>