nebula-treasury 0.1.0

package/src/ui/approval-summary.ts

@@ -0,0 +1,32 @@
+import type { PermissionRequest } from 'nebula-ai-core'
+import { shortAddr } from '../util/format'
+
+/**
+ * Body line for the approval modal. Friendly text for value-moving onchain
+ * kinds; falls back to command/path for shell.run / fs.write / code.execute.
+ *
+ * Why the `'→'` sniff in chain.send: chain.wrap and chain.unwrap reuse
+ * `chain.send` as their permission kind but encode the operation in `token`
+ * (`MNT→WMNT` / `WMNT→MNT`) and have no recipient to display.
+ */
+export function summarizeApprovalSubject(req: PermissionRequest): string {
+  const amt = req.amount ?? ''
+  const tok = req.token ?? ''
+  switch (req.kind) {
+    case 'chain.send': {
+      if (tok.includes('→')) return `${amt} ${tok}`.trim()
+      const tokenLabel = tok || 'MNT'
+      return `send ${amt} ${tokenLabel} to ${shortAddr(req.recipient)}`
+    }
+    case 'chain.swap':
+      if (!amt && !tok) return 'swap'
+      return `swap ${amt} ${tok}`.trim()
+    case 'chain.write': {
+      const valuePart = amt ? ` (value: ${amt})` : ''
+      const onPart = req.recipient ? ` on ${shortAddr(req.recipient)}` : ''
+      return `${req.command ?? '?'}${valuePart}${onPart}`
+    }
+    default:
+      return req.command ?? req.path ?? '(unspecified)'
+  }
+}

package/src/ui/markdown-parse.ts

@@ -0,0 +1,219 @@
+/**
+ * Lightweight markdown parser for the assistant chat rows. Pure logic only,
+ * no JSX, so tests can import without dragging in the JSX runtime (CI's bun
+ * defaults to react-jsx and fails to resolve `react/jsx-dev-runtime` when
+ * a .tsx file is imported by a test).
+ *
+ * Subset the brain actually emits: `**bold**`, `*italic*`, `` `code` ``,
+ * `# headings`, `- bullet lists`, `1. numbered lists`, fenced code blocks,
+ * GFM tables (`| col | col |` + `|---|---|` separator).
+ */
+
+export interface MdSegment {
+  text: string
+  fg?: string
+  bold?: boolean
+  italic?: boolean
+}
+
+export const MD_COLORS = {
+  text: '#e5e7eb',
+  code: '#fda4af',
+  heading: '#fbbf24',
+  bullet: '#94a3b8',
+  codeBlock: '#f9a8d4',
+  tableBorder: '#6b7280',
+  tableHeader: '#fbbf24',
+}
+
+/**
+ * Parse a single line's inline markup (`**bold**`, `*italic*`, `` `code` ``)
+ * into a flat list of segments. Caller handles the line-level structure.
+ */
+function parseInline(line: string, baseFg: string = MD_COLORS.text): MdSegment[] {
+  const out: MdSegment[] = []
+  let i = 0
+  let plain = ''
+  const flushPlain = () => {
+    if (plain) {
+      out.push({ text: plain, fg: baseFg })
+      plain = ''
+    }
+  }
+  while (i < line.length) {
+    if (line[i] === '`') {
+      const end = line.indexOf('`', i + 1)
+      if (end > i) {
+        flushPlain()
+        out.push({ text: line.slice(i + 1, end), fg: MD_COLORS.code })
+        i = end + 1
+        continue
+      }
+    }
+    if (line[i] === '*' && line[i + 1] === '*') {
+      const end = line.indexOf('**', i + 2)
+      if (end > i + 2) {
+        flushPlain()
+        out.push({ text: line.slice(i + 2, end), fg: baseFg, bold: true })
+        i = end + 2
+        continue
+      }
+    }
+    if (line[i] === '*' && line[i + 1] !== '*' && line[i + 1] !== ' ') {
+      const end = line.indexOf('*', i + 1)
+      if (end > i + 1 && line[end - 1] !== ' ' && line[end + 1] !== '*') {
+        flushPlain()
+        out.push({ text: line.slice(i + 1, end), fg: baseFg, italic: true })
+        i = end + 1
+        continue
+      }
+    }
+    plain += line[i]
+    i++
+  }
+  flushPlain()
+  return out
+}
+
+// GFM table separator row: `|---|---|` (optionally with alignment colons).
+// Allows single-column tables (`|---|`), multi-column (`|---|---|`), and
+// missing leading/trailing pipes (`---|---`).
+const TABLE_SEPARATOR_RE = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/
+
+function parseTableRow(line: string): string[] {
+  const trimmed = line.trim().replace(/^\|/, '').replace(/\|$/, '')
+  return trimmed.split('|').map(c => c.trim())
+}
+
+/**
+ * Detect a GFM table starting at `lines[startIdx]`. Returns the parsed rows
+ * (header included as row 0) plus the index AFTER the last data row, or null
+ * if no table block matches.
+ */
+function detectTable(lines: string[], startIdx: number): { rows: string[][]; end: number } | null {
+  const header = lines[startIdx]
+  if (header === undefined) return null
+  if (!/^\s*\|.+\|?\s*$/.test(header)) return null
+  const sep = lines[startIdx + 1]
+  if (!sep || !TABLE_SEPARATOR_RE.test(sep)) return null
+
+  const rows: string[][] = [parseTableRow(header)]
+  let i = startIdx + 2
+  while (i < lines.length) {
+    const ln = lines[i]
+    if (ln === undefined || !/^\s*\|.+\|?\s*$/.test(ln)) break
+    rows.push(parseTableRow(ln))
+    i++
+  }
+  return { rows, end: i }
+}
+
+/**
+ * Render a parsed table as flat segments. Uses box-drawing characters for the
+ * separator under the header row; columns are padded to the widest cell. First
+ * row is rendered bold + heading color so it stands out.
+ */
+function renderTable(rows: string[][], out: MdSegment[], pushNewline: () => void): void {
+  if (rows.length === 0) return
+  const colCount = Math.max(...rows.map(r => r.length))
+  const widths = new Array(colCount).fill(0) as number[]
+  for (const row of rows) {
+    for (let c = 0; c < row.length; c++) {
+      widths[c] = Math.max(widths[c]!, row[c]!.length)
+    }
+  }
+  for (let r = 0; r < rows.length; r++) {
+    pushNewline()
+    const row = rows[r]!
+    const cells: string[] = []
+    for (let c = 0; c < colCount; c++) {
+      const cell = (row[c] ?? '').padEnd(widths[c]!, ' ')
+      cells.push(cell)
+    }
+    const lineText = `│ ${cells.join(' │ ')} │`
+    out.push({
+      text: lineText,
+      fg: r === 0 ? MD_COLORS.tableHeader : MD_COLORS.text,
+      bold: r === 0,
+    })
+    if (r === 0) {
+      pushNewline()
+      const sep = `├${widths.map(w => '─'.repeat(w + 2)).join('┼')}┤`
+      out.push({ text: sep, fg: MD_COLORS.tableBorder })
+    }
+  }
+}
+
+/**
+ * Parse the full text into a flat list of segments separated by newlines.
+ * Block-level structure is encoded as styled prefixes in the segments
+ * (heading -> bold colored line; bullet -> "• " + content; table -> aligned
+ * cells with box-drawing separator).
+ */
+export function parseMarkdown(text: string): MdSegment[] {
+  if (!text) return []
+  const out: MdSegment[] = []
+  const lines = text.split('\n')
+  let inFence = false
+  let firstLine = true
+
+  const pushNewline = () => {
+    if (!firstLine) out.push({ text: '\n', fg: MD_COLORS.text })
+    firstLine = false
+  }
+
+  let i = 0
+  while (i < lines.length) {
+    const rawLine = lines[i]!
+    if (rawLine.trim().startsWith('```')) {
+      inFence = !inFence
+      i++
+      continue
+    }
+    if (inFence) {
+      pushNewline()
+      out.push({ text: rawLine, fg: MD_COLORS.codeBlock })
+      i++
+      continue
+    }
+    const headingMatch = rawLine.match(/^(#{1,6})\s+(.*)$/)
+    if (headingMatch) {
+      pushNewline()
+      const inner = parseInline(headingMatch[2]!, MD_COLORS.heading)
+      for (const seg of inner) {
+        out.push({ ...seg, fg: seg.fg ?? MD_COLORS.heading, bold: true })
+      }
+      i++
+      continue
+    }
+    const table = detectTable(lines, i)
+    if (table) {
+      renderTable(table.rows, out, pushNewline)
+      i = table.end
+      continue
+    }
+    const bulletMatch = rawLine.match(/^(\s*)([-*])\s+(.*)$/)
+    if (bulletMatch) {
+      pushNewline()
+      out.push({ text: `${bulletMatch[1]}• `, fg: MD_COLORS.bullet })
+      out.push(...parseInline(bulletMatch[3]!))
+      i++
+      continue
+    }
+    const numberedMatch = rawLine.match(/^(\s*)(\d+)\.\s+(.*)$/)
+    if (numberedMatch) {
+      pushNewline()
+      out.push({
+        text: `${numberedMatch[1]}${numberedMatch[2]}. `,
+        fg: MD_COLORS.bullet,
+      })
+      out.push(...parseInline(numberedMatch[3]!))
+      i++
+      continue
+    }
+    pushNewline()
+    out.push(...parseInline(rawLine))
+    i++
+  }
+  return out
+}

package/src/ui/markdown.tsx

@@ -0,0 +1,37 @@
+import { For } from 'solid-js'
+import { parseMarkdown } from './markdown-parse'
+
+export {
+  parseMarkdown,
+  MD_COLORS,
+  type MdSegment,
+} from './markdown-parse'
+
+/**
+ * Render parsed markdown segments as opentui spans inside an existing
+ * `<text>` block. Caller owns the wrapping `<text>` (so wrapMode + flexGrow
+ * stay configurable).
+ *
+ * Why custom rather than opentui's built-in `<markdown>`: nebula already
+ * renders assistant text inside a row that has a fixed-width prefix
+ * gutter; switching to `<markdown>` would break the indent and gutter
+ * alignment because it owns its own layout. A custom renderer that emits
+ * spans keeps the existing AssistantTextRow flow intact.
+ */
+export function MarkdownSegments(props: { text: string }) {
+  const segments = () => parseMarkdown(props.text)
+  return (
+    <For each={segments()}>
+      {seg => {
+        // opentui's SpanProps type omits fg/bold/italic but the runtime
+        // accepts them. Cast through an object spread to bypass the check.
+        const styles = {
+          ...(seg.fg ? { fg: seg.fg } : {}),
+          ...(seg.bold ? { bold: true } : {}),
+          ...(seg.italic ? { italic: true } : {}),
+        } as Record<string, unknown>
+        return <span {...styles}>{seg.text}</span>
+      }}
+    </For>
+  )
+}

package/src/ui/state.ts

@@ -0,0 +1,181 @@
+import type {
+  PermissionDecision,
+  PermissionMode,
+  PermissionRequest,
+  SlashCommand,
+} from 'nebula-ai-core'
+import { createSignal } from 'solid-js'
+
+export type TurnRole =
+  | 'user'
+  | 'assistant'
+  | 'system'
+  | 'tool-call'
+  | 'tool-result'
+  | 'inbox'
+  | 'market'
+  | 'inbox-tg'
+  | 'telegram-assistant'
+
+export interface TurnRow {
+  id: string
+  role: TurnRole
+  text: string
+  // tool-call rows: tool name + formatted args (rendered as `name(args)`)
+  toolName?: string
+  args?: string
+  // tool-result rows: failure flag drives icon + color
+  failed?: boolean
+  // v0.21.2: drives the ↪ prefix so operators see the SAME logical fetch was
+  // escalated, not a fresh brain decision.
+  autoEscalated?: boolean
+  // True only for the first row in an "nebula block" (assistant + tool-call rows
+  // that share the same speaker turn). Computed once at push time so the For
+  // loop renderer doesn't re-walk neighbors on every state mutation.
+  firstOfBlock?: boolean
+}
+
+export interface PendingApproval {
+  request: PermissionRequest
+  resolve: (decision: PermissionDecision) => void
+}
+
+interface CreateChatStateOpts {
+  initialSystem: string
+  identityLabel: string
+  approvalsMode: PermissionMode
+  // v0.24.4: true when the TUI talks to a local gateway daemon over a unix
+  // socket (`~/.nebula/agents/<id>/gateway.sock`) instead of a remote Daytona
+  // sandbox endpoint. Drives statusbar copy (drops the "sandbox X" prefix on
+  // the system line) and hides the sandbox-billing balance segment (which is
+  // meaningless for local deploys — there is no billing reserve to surface).
+  // Defaults to false so existing call sites that don't pass it (i.e. nothing
+  // today, since both call sites set it explicitly) keep sandbox semantics.
+  isLocalGateway?: boolean
+}
+
+export function createChatState(opts: CreateChatStateOpts) {
+  const [rows, setRows] = createSignal<TurnRow[]>([
+    { id: 'sys-0', role: 'system', text: opts.initialSystem },
+  ])
+  const [input, setInput] = createSignal('')
+  const [status, setStatus] = createSignal<'idle' | 'thinking' | 'error'>('idle')
+  const [usage, setUsage] = createSignal<{ total?: number; cached?: number } | null>(null)
+  const [pendingApproval, setPendingApproval] = createSignal<PendingApproval | null>(null)
+  const [approvalsMode, setApprovalsMode] = createSignal<PermissionMode>(opts.approvalsMode)
+
+  // Mantle Compute ledger balance, in Mantle. Refreshed at chat init and after each
+  // per-turn auto-sync. null = not yet fetched / fetch failed.
+  const [balance, setBalance] = createSignal<number | null>(null)
+  // Agent EOA balance, in Mantle. Pays gas for chain writes (agent.message
+  // inbox.send, sync's updateSlots anchor). Typically starves before the
+  // compute ledger in long sessions (~0.001 Mantle/send at 4 gwei).
+  const [eoaBalance, setEoaBalance] = createSignal<number | null>(null)
+  // v0.22.0: Mantle Sandbox billing reserve, in Mantle. Sandbox-deployed agents only —
+  // local-mode TUI stays null and the statusline `<Show>` hides the segment.
+  // Auto-topup refills this when it dips below the configured threshold; the
+  // statusline mirror lets operators see the same balance without leaving TUI.
+  const [sandboxBalance, setSandboxBalance] = createSignal<number | null>(null)
+  // ms epoch when current turn started (status flipped to 'thinking'). The
+  // spinner row reads this and renders elapsed seconds. Cleared on idle.
+  const [turnStartedAt, setTurnStartedAt] = createSignal<number | null>(null)
+
+  // In-flight escrow job count surfaced in the statusbar. The marketplace
+  // wiring that populated this lived in the (removed) comms plugin; the signal
+  // is retained so the statusbar segment and the sandbox 'market' rows keep
+  // their type contract.
+  const [activeJobCount, setActiveJobCount] = createSignal(0)
+  void setActiveJobCount
+
+  // Per-turn AbortController. Set when handleSubmit kicks off brain.infer;
+  // cleared (set to null) after the turn ends or is aborted. The keyboard
+  // handler reads it to wire Esc → abort.
+  const [activeAbort, setActiveAbort] = createSignal<AbortController | null>(null)
+
+  // v0.20.0: slash-command autocomplete popup state. `slashMatches` is the
+  // filtered list of commands matching the current input prefix; populated
+  // when input starts with `/`, cleared otherwise. `slashIndex` tracks the
+  // selected row inside `slashMatches`. Both reset to defaults on submit.
+  const [slashMatches, setSlashMatches] = createSignal<SlashCommand[]>([])
+  const [slashIndex, setSlashIndex] = createSignal(0)
+
+  // Status-change subscribers. Phase 12 telegram-dispatch hooks here so it
+  // can drain its queue when the brain returns to idle from a stdin turn.
+  type StatusListener = (next: 'idle' | 'thinking' | 'error') => void
+  const statusListeners = new Set<StatusListener>()
+  const onStatusChange = (cb: StatusListener): (() => void) => {
+    statusListeners.add(cb)
+    return () => statusListeners.delete(cb)
+  }
+
+  // Wrap status setter so the turn-start timestamp tracks status changes
+  // automatically. Every code path that flips to 'thinking' starts the
+  // clock; every flip to idle/error stops it. Removes the burden from
+  // call sites.
+  const setStatusTracked: typeof setStatus = next => {
+    const prev = status()
+    const result = setStatus(next)
+    const after = status()
+    if (prev !== 'thinking' && after === 'thinking') setTurnStartedAt(Date.now())
+    else if (prev === 'thinking' && after !== 'thinking') setTurnStartedAt(null)
+    if (prev !== after) {
+      for (const cb of statusListeners) {
+        try {
+          cb(after)
+        } catch {
+          // listener errors must not break status updates
+        }
+      }
+    }
+    return result
+  }
+
+  let idCounter = 1
+  const nextId = () => `row-${idCounter++}`
+
+  const pushRow = (row: Omit<TurnRow, 'id' | 'firstOfBlock'>) => {
+    setRows(prev => {
+      const last = prev[prev.length - 1] ?? null
+      const isAssistantBlock = row.role === 'assistant' || row.role === 'tool-call'
+      const continuesBlock =
+        last?.role === 'assistant' || last?.role === 'tool-call' || last?.role === 'tool-result'
+      const firstOfBlock = isAssistantBlock && !continuesBlock
+      return [...prev, { ...row, id: nextId(), firstOfBlock }]
+    })
+  }
+
+  return {
+    rows,
+    input,
+    status,
+    usage,
+    pendingApproval,
+    approvalsMode,
+    balance,
+    eoaBalance,
+    sandboxBalance,
+    turnStartedAt,
+    activeAbort,
+    activeJobCount,
+    slashMatches,
+    slashIndex,
+    setInput,
+    setStatus: setStatusTracked,
+    setUsage,
+    setPendingApproval,
+    setApprovalsMode,
+    setBalance,
+    setEoaBalance,
+    setSandboxBalance,
+    setTurnStartedAt,
+    setActiveAbort,
+    setSlashMatches,
+    setSlashIndex,
+    pushRow,
+    onStatusChange,
+    identityLabel: opts.identityLabel,
+    isLocalGateway: opts.isLocalGateway ?? false,
+  }
+}
+
+export type ChatState = ReturnType<typeof createChatState>

package/src/util/bootstrap-mode.ts

@@ -0,0 +1,25 @@
+import type { BootstrapMode } from 'nebula-ai-gateway'
+
+/**
+ * Resolve the sandbox bootstrap mode from operator env.
+ *
+ * Default is `'npm'` since v0.21.20 (~10x faster cold start: `bun add -g
+ * nebula-ai-cli@<ver>` finishes in ~30-60s vs ~5-8min for `git clone +
+ * bun install`). The npm path was shipped in v0.21.15 and lived as opt-in
+ * for several releases before this flip.
+ *
+ * Resolution order:
+ *   1. `NEBULA_BOOTSTRAP_MODE=git|npm` — explicit operator override, wins.
+ *   2. `NEBULA_BOOTSTRAP_REF` set without explicit mode → 'git'. The REF env
+ *      is a git-mode concept (branch tip / commit SHA); auto-implying git
+ *      preserves the existing "deploy main", "deploy <sha>" dev workflows.
+ *   3. Otherwise → 'npm'.
+ *
+ * Callers pass `opts.mode` directly to bypass this resolver entirely.
+ */
+export function resolveBootstrapMode(env: NodeJS.ProcessEnv = process.env): BootstrapMode {
+  if (env.NEBULA_BOOTSTRAP_MODE === 'git') return 'git'
+  if (env.NEBULA_BOOTSTRAP_MODE === 'npm') return 'npm'
+  if (env.NEBULA_BOOTSTRAP_REF) return 'git'
+  return 'npm'
+}