@promus/cli 0.24.17

package/src/ui/state.ts

@@ -0,0 +1,198 @@
+import type {
+  PermissionDecision,
+  PermissionMode,
+  PermissionRequest,
+  SlashCommand,
+} from '@promus/core'
+import { type JobEvent, isJobTerminalKind } from '@promus/plugin-comms'
+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 "promus 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 (`~/.promus/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
+  /** Native gas-token symbol for the agent's network ('ETH' / '0G'). */
+  currency?: string
+}
+
+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)
+
+  // 0G Compute ledger balance, in 0G. 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 0G. Pays gas for chain writes (agent.message
+  // inbox.send, sync's updateSlots anchor). Typically starves before the
+  // compute ledger in long sessions (~0.001 0G/send at 4 gwei).
+  const [eoaBalance, setEoaBalance] = createSignal<number | null>(null)
+  // v0.22.0: 0G Sandbox billing reserve, in 0G. 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)
+
+  // Phase 8: in-flight escrow jobs the agent is a party to (buyer or
+  // provider). Incremented on JobCreated, decremented once per terminal
+  // event per jobId. The contract emits both JobForceClosed AND JobSettled
+  // when force-closing a Done job (force-close routes through _settle), so
+  // we de-dup by jobId here to keep the counter honest.
+  const [activeJobCount, setActiveJobCount] = createSignal(0)
+  const terminatedJobs = new Set<string>()
+  const bumpActiveJobs = (e: JobEvent) => {
+    if (e.kind === 'created') {
+      setActiveJobCount(c => c + 1)
+      return
+    }
+    if (!isJobTerminalKind(e.kind)) return
+    const id = e.jobId.toString()
+    if (terminatedJobs.has(id)) return
+    terminatedJobs.add(id)
+    setActiveJobCount(c => Math.max(0, c - 1))
+  }
+
+  // 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,
+    bumpActiveJobs,
+    pushRow,
+    onStatusChange,
+    identityLabel: opts.identityLabel,
+    isLocalGateway: opts.isLocalGateway ?? false,
+    currency: opts.currency ?? 'ETH',
+  }
+}
+
+export type ChatState = ReturnType<typeof createChatState>

package/src/util/bootstrap-mode.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'bun:test'
+import { resolveBootstrapMode } from './bootstrap-mode'
+
+describe('resolveBootstrapMode', () => {
+  it('defaults to npm when no env is set', () => {
+    expect(resolveBootstrapMode({})).toBe('npm')
+  })
+
+  it('respects explicit PROMUS_BOOTSTRAP_MODE=git', () => {
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'git' })).toBe('git')
+  })
+
+  it('respects explicit PROMUS_BOOTSTRAP_MODE=npm', () => {
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'npm' })).toBe('npm')
+  })
+
+  it("auto-implies git when PROMUS_BOOTSTRAP_REF is set without explicit mode (preserves 'deploy main' workflow)", () => {
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_REF: 'main' })).toBe('git')
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_REF: 'abc1234' })).toBe('git')
+  })
+
+  it('lets explicit MODE win over REF (e.g. NPM=v0.21.20 alongside REF=ignored)', () => {
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'npm', PROMUS_BOOTSTRAP_REF: 'main' })).toBe(
+      'npm',
+    )
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'git', PROMUS_BOOTSTRAP_REF: 'main' })).toBe(
+      'git',
+    )
+  })
+
+  it('falls through to npm on garbage PROMUS_BOOTSTRAP_MODE (typos, uppercase, etc.)', () => {
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'GIT' })).toBe('npm')
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'Npm' })).toBe('npm')
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_MODE: 'docker' })).toBe('npm')
+  })
+
+  it('treats empty-string PROMUS_BOOTSTRAP_REF as unset (does not flip to git)', () => {
+    expect(resolveBootstrapMode({ PROMUS_BOOTSTRAP_REF: '' })).toBe('npm')
+  })
+})

package/src/util/bootstrap-mode.ts

@@ -0,0 +1,25 @@
+import type { BootstrapMode } from '@promus/gateway'
+
+/**
+ * Resolve the sandbox bootstrap mode from operator env.
+ *
+ * Default is `'npm'` since v0.21.20 (~10x faster cold start: `bun add -g
+ * promus@<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. `PROMUS_BOOTSTRAP_MODE=git|npm` — explicit operator override, wins.
+ *   2. `PROMUS_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.PROMUS_BOOTSTRAP_MODE === 'git') return 'git'
+  if (env.PROMUS_BOOTSTRAP_MODE === 'npm') return 'npm'
+  if (env.PROMUS_BOOTSTRAP_REF) return 'git'
+  return 'npm'
+}

package/src/util/bootstrap-progress-box.test.ts

@@ -0,0 +1,190 @@
+import { describe, expect, test } from 'bun:test'
+import { Writable } from 'node:stream'
+import {
+  BootstrapProgressBox,
+  __testing,
+  mapBootstrapMarkerToStage,
+} from './bootstrap-progress-box'
+
+class CapturingStream extends Writable {
+  chunks: string[] = []
+  isTTY: boolean
+  constructor(isTTY: boolean) {
+    super()
+    this.isTTY = isTTY
+  }
+  override _write(chunk: Buffer | string, _enc: string, cb: () => void): void {
+    this.chunks.push(chunk.toString())
+    cb()
+  }
+  combined(): string {
+    return this.chunks.join('')
+  }
+}
+
+describe('mapBootstrapMarkerToStage', () => {
+  test('maps every gateway bootstrap.ts marker', () => {
+    expect(mapBootstrapMarkerToStage('updating package index')).toBe('apt-update')
+    expect(
+      mapBootstrapMarkerToStage('installing system deps (build-essential, curl, git, xvfb)'),
+    ).toBe('system-deps')
+    expect(mapBootstrapMarkerToStage('installing bun runtime')).toBe('bun-install')
+    expect(mapBootstrapMarkerToStage('installing promus (0.24.7)')).toBe('promus-install')
+    expect(mapBootstrapMarkerToStage('installing promus (git main)')).toBe('promus-install')
+    expect(mapBootstrapMarkerToStage('installing chrome for browser tools')).toBe('browser-deps')
+    expect(mapBootstrapMarkerToStage('starting harness daemon')).toBe('harness-spawn')
+    expect(mapBootstrapMarkerToStage('harness ready')).toBe('harness-spawn')
+  })
+
+  test('returns null for unknown markers', () => {
+    expect(mapBootstrapMarkerToStage('something else entirely')).toBeNull()
+    expect(mapBootstrapMarkerToStage('')).toBeNull()
+  })
+})
+
+describe('BootstrapProgressBox TTY mode', () => {
+  test('start renders the initial frame with all stages pending', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    const combined = out.combined()
+    expect(combined).toContain('bootstrap progress')
+    expect(combined).toContain('launchScript uploaded to Daytona')
+    expect(combined).toContain('apt update')
+    expect(combined).toContain('/healthz Ready')
+    expect(combined).toContain('╰')
+  })
+
+  test('markStage running uses spinner glyph; done uses checkmark', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('launch-upload', 'running')
+    const afterRunning = out.combined()
+    const runningGlyph = __testing.SPINNER_FRAMES.find(g => afterRunning.includes(g))
+    expect(runningGlyph).toBeDefined()
+
+    box.markStage('launch-upload', 'done')
+    expect(out.combined()).toContain('✓')
+  })
+
+  test('markStage running auto-completes prior pending stages (handles skipped bun-install)', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('apt-update', 'running')
+    box.markStage('system-deps', 'running')
+    // Skip bun-install — bun already installed
+    box.markStage('promus-install', 'running')
+    const checkmarks = (out.combined().match(/✓/g) ?? []).length
+    // Stages auto-completed: launch-upload (skipped), apt-update, system-deps, bun-install (skipped)
+    expect(checkmarks).toBeGreaterThanOrEqual(4)
+  })
+
+  test('stop finalizes any running stage as done and appends a newline', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('healthz-ready', 'running')
+    box.stop()
+    const combined = out.combined()
+    const checkmarks = (combined.match(/✓/g) ?? []).length
+    expect(checkmarks).toBeGreaterThanOrEqual(1)
+    expect(combined.endsWith('\n')).toBe(true)
+  })
+
+  test('fail marks running stage as failed (✗) and leaves later pending stages alone', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('promus-install', 'running')
+    box.fail()
+    expect(out.combined()).toContain('✗')
+  })
+
+  test('uses ANSI cursor-up + clear-to-end between renders', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('apt-update', 'running')
+    const combined = out.combined()
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: validates emitted ANSI escapes
+    expect(combined).toMatch(/\x1b\[\d+A/)
+    expect(combined).toContain('\x1b[0J')
+  })
+
+  test('honors custom label override', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({
+      out,
+      labels: { 'promus-install': 'promus 0.24.7 installed' },
+    })
+    box.start()
+    expect(out.combined()).toContain('promus 0.24.7 installed')
+  })
+
+  test('row layout pads to constant width regardless of label length', () => {
+    const out = new CapturingStream(true)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    const lines = out
+      .combined()
+      .split('\n')
+      .filter(l => l.startsWith('│'))
+    const widths = lines.map(l => stripAnsi(l).length)
+    const unique = new Set(widths)
+    expect(unique.size).toBe(1)
+  })
+})
+
+describe('BootstrapProgressBox non-TTY fallback', () => {
+  test('emits per-transition lines without ANSI', () => {
+    const out = new CapturingStream(false)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('apt-update', 'running')
+    box.markStage('apt-update', 'done')
+    const combined = out.combined()
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: asserts absence of ANSI escapes
+    expect(combined).not.toMatch(/\x1b\[/)
+    expect(combined).toContain('[..]')
+    expect(combined).toContain('[ok]')
+    expect(combined).toContain('apt update')
+  })
+
+  test('does not re-print the same status twice in non-TTY mode', () => {
+    const out = new CapturingStream(false)
+    const box = new BootstrapProgressBox({ out })
+    box.start()
+    box.markStage('apt-update', 'done')
+    box.tick()
+    box.tick()
+    const okLines = (out.combined().match(/\[ok\] /g) ?? []).length
+    expect(okLines).toBe(1)
+  })
+})
+
+describe('formatTime', () => {
+  test('00:00 for zero', () => {
+    expect(__testing.formatTime(0)).toBe('00:00')
+  })
+  test('zero pads single-digit seconds and minutes', () => {
+    expect(__testing.formatTime(7)).toBe('00:07')
+    expect(__testing.formatTime(65)).toBe('01:05')
+    expect(__testing.formatTime(601)).toBe('10:01')
+  })
+})
+
+describe('truncate', () => {
+  test('returns as-is when within limit', () => {
+    expect(__testing.truncate('hello', 10)).toBe('hello')
+  })
+  test('truncates with ellipsis when over limit', () => {
+    expect(__testing.truncate('a very long label that overflows', 12)).toBe('a very long…')
+  })
+})
+
+function stripAnsi(s: string): string {
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping ANSI escapes
+  return s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+}