Merge main into brandon/upgrade-opentui-2025-10-28

Author: brandonkachen

cli/src/chat.tsx

@@ -2,17 +2,11 @@ import os from 'os'
 import path from 'path'
 
 import { useRenderer, useTerminalDimensions } from '@opentui/react'
-import React, {
-  type ReactNode,
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react'
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import stringWidth from 'string-width'
 import { useShallow } from 'zustand/react/shallow'
 
+import { routeUserPrompt } from './commands/router'
 import { AgentModeToggle } from './components/agent-mode-toggle'
 import { LoginModal } from './components/login-modal'
 import {
@@ -49,92 +43,32 @@ import {
 } from './utils/local-agent-registry'
 import { logger } from './utils/logger'
 import { buildMessageTree } from './utils/message-tree-utils'
+import { openFileAtPath } from './utils/open-file'
 import { handleSlashCommands } from './utils/slash-commands'
 import {
+  chatThemes,
   createMarkdownPalette,
   resolveThemeColor,
-  type ChatTheme,
 } from './utils/theme-system'
 import { env } from '@codebuff/common/env'
 import { clientEnvVars } from '@codebuff/common/env-schema'
 import { formatValidationError } from './utils/validation-error-formatting'
 import { getCodebuffClient } from './utils/codebuff-client'
-import { openFileAtPath } from './utils/open-file'
 
 import type { SendMessageTimerEvent } from './hooks/use-send-message'
+import type {
+  ChatMessage,
+  ContentBlock,
+  ChatVariant,
+  AgentMessage,
+} from './types/chat'
+import type { SendMessageFn } from './types/contracts/send-message'
 import type { User } from './utils/auth'
-import type { AgentMode } from './utils/constants'
-import type { ToolName } from '@codebuff/sdk'
 import type { ScrollBoxRenderable } from '@opentui/core'
 
-type ChatVariant = 'ai' | 'user' | 'agent' | 'error'
-
 const MAX_VIRTUALIZED_TOP_LEVEL = 60
 const VIRTUAL_OVERSCAN = 12
 
-type AgentMessage = {
-  agentName: string
-  agentType: string
-  responseCount: number
-  subAgentCount?: number
-}
-
-export type ContentBlock =
-  | {
-      type: 'text'
-      content: string
-      color?: string
-      marginTop?: number
-      marginBottom?: number
-      status?: 'running' | 'complete'
-    }
-  | {
-      type: 'html'
-      marginTop?: number
-      marginBottom?: number
-      render: (context: { textColor: string; theme: ChatTheme }) => ReactNode
-    }
-  | {
-      type: 'tool'
-      toolCallId: string
-      toolName: ToolName
-      input: any
-      output?: string
-      outputRaw?: unknown
-      agentId?: string
-    }
-  | {
-      type: 'agent'
-      agentId: string
-      agentName: string
-      agentType: string
-      content: string
-      status: 'running' | 'complete'
-      blocks?: ContentBlock[]
-      initialPrompt?: string
-    }
-  | {
-      type: 'agent-list'
-      id: string
-      agents: Array<{ id: string; displayName: string }>
-      agentsDir: string
-    }
-
-export type ChatMessage = {
-  id: string
-  variant: ChatVariant
-  content: string
-  blocks?: ContentBlock[]
-  timestamp: string
-  parentId?: string
-  agent?: AgentMessage
-  isCompletion?: boolean
-  credits?: number
-  completionTime?: string
-  isComplete?: boolean
-  metadata?: Record<string, any>
-}
-
 export const App = ({
   initialPrompt,
   agentId,
@@ -927,10 +861,7 @@ export const App = ({
     setInputValue,
   )
 
-  const sendMessageRef =
-    useRef<
-      (content: string, params: { agentMode: AgentMode }) => Promise<void>
-    >()
+  const sendMessageRef = useRef<SendMessageFn>()
 
   const {
     queuedMessages,
@@ -945,7 +876,7 @@ export const App = ({
     setIsStreaming,
   } = useMessageQueue(
     (content: string) =>
-      sendMessageRef.current?.(content, { agentMode }) ?? Promise.resolve(),
+      sendMessageRef.current?.({ content, agentMode }) ?? Promise.resolve(),
     isChainInProgressRef,
     activeAgentStreamsRef,
   )
@@ -1009,7 +940,7 @@ export const App = ({
       const timeout = setTimeout(() => {
         logger.info({ prompt: initialPrompt }, 'Auto-submitting initial prompt')
         if (sendMessageRef.current) {
-          sendMessageRef.current(initialPrompt, { agentMode })
+          sendMessageRef.current({ content: initialPrompt, agentMode })
         }
       }, 100)
 
@@ -1027,28 +958,29 @@ export const App = ({
   )
 
   const handleSubmit = useCallback(
-    () => handleSlashCommands({
-      abortControllerRef,
-      agentMode,
-      inputRef,
-      inputValue,
-      isChainInProgressRef,
-      isStreaming,
-      logoutMutation,
-      streamMessageIdRef,
-      addToQueue,
-      handleCtrlC,
-      saveToHistory,
-      scrollToLatest,
-      sendMessage,
-      setCanProcessQueue,
-      setInputFocused,
-      setInputValue,
-      setIsAuthenticated,
-      setMessages,
-      setUser,
-      stopStreaming,
-    }),
+    () =>
+      routeUserPrompt({
+        abortControllerRef,
+        agentMode,
+        inputRef,
+        inputValue,
+        isChainInProgressRef,
+        isStreaming,
+        logoutMutation,
+        streamMessageIdRef,
+        addToQueue,
+        handleCtrlC,
+        saveToHistory,
+        scrollToLatest,
+        sendMessage,
+        setCanProcessQueue,
+        setInputFocused,
+        setInputValue,
+        setIsAuthenticated,
+        setMessages,
+        setUser,
+        stopStreaming,
+      }),
     [
       agentMode,
       inputValue,

cli/src/commands/init.ts

@@ -0,0 +1,48 @@
+import { existsSync, writeFileSync } from 'fs'
+import path from 'path'
+
+import {
+  codebuffConfigFile,
+  INITIAL_CODEBUFF_CONFIG,
+} from '@codebuff/common/json-config/constants'
+
+import { getProjectRoot } from '../project-files'
+
+import type { PostUserMessageFn } from '../types/contracts/send-message'
+
+export function handleInitializationFlowLocally(): {
+  postUserMessage: PostUserMessageFn
+} {
+  const projectRoot = getProjectRoot()
+  const configPath = path.join(projectRoot, codebuffConfigFile)
+
+  if (existsSync(configPath)) {
+    const postUserMessage: PostUserMessageFn = (prev) => [
+      ...prev,
+
+      {
+        id: `sys-${Date.now()}`,
+        variant: 'ai' as const,
+        content: `📋 ${codebuffConfigFile} already exists.`,
+        timestamp: new Date().toISOString(),
+      },
+    ]
+    return {
+      postUserMessage,
+    }
+  }
+
+  // Create the config file
+  writeFileSync(configPath, JSON.stringify(INITIAL_CODEBUFF_CONFIG, null, 2))
+
+  const postUserMessage: PostUserMessageFn = (prev) => [
+    ...prev,
+    {
+      id: `sys-${Date.now()}`,
+      variant: 'ai' as const,
+      content: `✅ Created \`${codebuffConfigFile}\``,
+      timestamp: new Date().toISOString(),
+    },
+  ]
+  return { postUserMessage }
+}

cli/src/commands/router.ts

@@ -0,0 +1,133 @@
+import { handleInitializationFlowLocally } from './init'
+
+import type { MultilineInputHandle } from '../components/multiline-input'
+import type { ChatMessage } from '../types/chat'
+import type { SendMessageFn } from '../types/contracts/send-message'
+import type { User } from '../utils/auth'
+import type { AgentMode } from '../utils/constants'
+import type { UseMutationResult } from '@tanstack/react-query'
+
+export function routeUserPrompt(params: {
+  abortControllerRef: React.MutableRefObject<AbortController | null>
+  agentMode: AgentMode
+  inputRef: React.MutableRefObject<MultilineInputHandle | null>
+  inputValue: string
+  isChainInProgressRef: React.MutableRefObject<boolean>
+  isStreaming: boolean
+  logoutMutation: UseMutationResult<boolean, Error, void, unknown>
+  streamMessageIdRef: React.MutableRefObject<string | null>
+  addToQueue: (message: string) => void
+  handleCtrlC: () => true
+  saveToHistory: (message: string) => void
+  scrollToLatest: () => void
+  sendMessage: SendMessageFn
+  setCanProcessQueue: (value: React.SetStateAction<boolean>) => void
+  setInputFocused: (focused: boolean) => void
+  setInputValue: (value: string | ((prev: string) => string)) => void
+  setIsAuthenticated: (value: React.SetStateAction<boolean | null>) => void
+  setMessages: (
+    value: ChatMessage[] | ((prev: ChatMessage[]) => ChatMessage[]),
+  ) => void
+  setUser: (value: React.SetStateAction<User | null>) => void
+  stopStreaming: () => void
+}) {
+  const {
+    abortControllerRef,
+    agentMode,
+    inputRef,
+    inputValue,
+    isChainInProgressRef,
+    isStreaming,
+    logoutMutation,
+    streamMessageIdRef,
+    addToQueue,
+    handleCtrlC,
+    saveToHistory,
+    scrollToLatest,
+    sendMessage,
+    setCanProcessQueue,
+    setInputFocused,
+    setInputValue,
+    setIsAuthenticated,
+    setMessages,
+    setUser,
+    stopStreaming,
+  } = params
+
+  const trimmed = inputValue.trim()
+  if (!trimmed) return
+
+  let postUserMessage: Parameters<SendMessageFn>[0]['postUserMessage'] =
+    undefined
+
+  const normalized = trimmed.startsWith('/') ? trimmed.slice(1) : trimmed
+  const cmd = normalized.split(/\s+/)[0].toLowerCase()
+  if (cmd === 'login' || cmd === 'signin') {
+    const msg = {
+      id: `sys-${Date.now()}`,
+      variant: 'ai' as const,
+      content: "You're already in the app. Use /logout to switch accounts.",
+      timestamp: new Date().toISOString(),
+    }
+    setMessages((prev) => [...prev, msg])
+    setInputValue('')
+    return
+  }
+  if (cmd === 'logout' || cmd === 'signout') {
+    abortControllerRef.current?.abort()
+    stopStreaming()
+    setCanProcessQueue(false)
+
+    logoutMutation.mutate(undefined, {
+      onSettled: () => {
+        const msg = {
+          id: `sys-${Date.now()}`,
+          variant: 'ai' as const,
+          content: 'Logged out.',
+          timestamp: new Date().toISOString(),
+        }
+        setMessages((prev) => [...prev, msg])
+        setInputValue('')
+        setTimeout(() => {
+          setUser(null)
+          setIsAuthenticated(false)
+        }, 300)
+      },
+    })
+    return
+  }
+
+  if (cmd === 'exit' || cmd === 'quit') {
+    abortControllerRef.current?.abort()
+    stopStreaming()
+    setCanProcessQueue(false)
+    setInputValue('')
+    handleCtrlC()
+    return
+  }
+
+  saveToHistory(trimmed)
+  setInputValue('')
+
+  if (cmd === 'init') {
+    ;({ postUserMessage } = handleInitializationFlowLocally())
+    // do not return, continue on to send to agent-runtime
+  }
+
+  if (
+    isStreaming ||
+    streamMessageIdRef.current ||
+    isChainInProgressRef.current
+  ) {
+    addToQueue(trimmed)
+    setInputFocused(true)
+    inputRef.current?.focus()
+    return
+  }
+
+  sendMessage({ content: trimmed, agentMode, postUserMessage })
+
+  setTimeout(() => {
+    scrollToLatest()
+  }, 0)
+}

cli/src/components/login-modal.tsx

@@ -31,6 +31,7 @@ import { useLoginStore } from '../state/login-store'
 import { copyTextToClipboard } from '../utils/clipboard'
 import { logger } from '../utils/logger'
 
+import type { ChatTheme } from '../types/theme-system'
 import type { User } from '../utils/auth'
 
 interface LoginModalProps {