better-codex 0.1.4 → 0.2.1

package/apps/web/src/hooks/use-hub-connection.ts

@@ -78,10 +78,16 @@ export const useHubConnection = () => {
     setAccountLoginId,
     upsertReviewSession,
     updateReviewSession,
+    resolveThreadId,
   } = useAppStore()
 
   const nowTimestamp = () => new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
 
+  const resolve = (backendThreadId: string | undefined): string | undefined => {
+    if (!backendThreadId) return undefined
+    return resolveThreadId(backendThreadId)
+  }
+
   const addSystemMessage = (threadId: string, title: string, content: string) => {
     addMessage(threadId, {
       id: `sys-${Date.now()}-${Math.random().toString(16).slice(2)}`,
@@ -238,7 +244,8 @@ export const useHubConnection = () => {
             }
 
             if (method === 'turn/started' && params && typeof params === 'object') {
-              const { threadId, turn } = params as { threadId?: string; turn?: { id?: string } }
+              const { threadId: rawThreadId, turn } = params as { threadId?: string; turn?: { id?: string } }
+              const threadId = resolve(rawThreadId)
               if (threadId) {
                 updateThread(threadId, { status: 'active' })
                 setThreadTurnStartedAt(threadId, Date.now())
@@ -249,7 +256,8 @@ export const useHubConnection = () => {
             }
 
             if (method === 'turn/completed' && params && typeof params === 'object') {
-              const { threadId, turn } = params as { threadId?: string; turn?: { id?: string; status?: string } }
+              const { threadId: rawThreadId, turn } = params as { threadId?: string; turn?: { id?: string; status?: string } }
+              const threadId = resolve(rawThreadId)
               // console.log('[HubConnection] turn/completed event for thread:', threadId)
               if (threadId) {
                 const startedAt = useAppStore.getState().threadTurnStartedAt[threadId]
@@ -271,27 +279,30 @@ export const useHubConnection = () => {
             }
 
             if (method === 'turn/diff/updated' && params && typeof params === 'object') {
-              const { threadId, turnId, diff } = params as { threadId?: string; turnId?: string; diff?: string }
+              const { threadId: rawThreadId, turnId, diff } = params as { threadId?: string; turnId?: string; diff?: string }
+              const threadId = resolve(rawThreadId)
               if (threadId && diff) {
                 const content = diff.length > 4000 ? `${diff.slice(0, 4000)}\n…` : diff
                 upsertMessage(threadId, {
                   id: `diff-${turnId ?? threadId}`,
                   role: 'assistant',
                   kind: 'file',
-                  title: 'Diff · updated',
+                  title: 'Diff',
                   content,
+                  meta: { diff },
                   timestamp: nowTimestamp(),
                 })
               }
             }
 
             if (method === 'turn/plan/updated' && params && typeof params === 'object') {
-              const { threadId, turnId, plan, explanation } = params as {
+              const { threadId: rawThreadId, turnId, plan, explanation } = params as {
                 threadId?: string
                 turnId?: string
                 plan?: Array<{ step?: string; status?: string }>
                 explanation?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && Array.isArray(plan)) {
                 const steps = plan
                   .map((entry) => `${entry.status ?? 'pending'} · ${entry.step ?? ''}`.trim())
@@ -310,7 +321,8 @@ export const useHubConnection = () => {
             }
 
             if (method === 'thread/tokenUsage/updated' && params && typeof params === 'object') {
-              const { threadId } = params as { threadId?: string }
+              const { threadId: rawThreadId } = params as { threadId?: string }
+              const threadId = resolve(rawThreadId)
               const usage = (params as { usage?: unknown }).usage ?? (params as { tokenUsage?: unknown }).tokenUsage
               if (threadId && usage) {
                 setThreadTokenUsage(threadId, usage)
@@ -318,73 +330,80 @@ export const useHubConnection = () => {
             }
 
             if (method === 'item/agentMessage/delta' && params && typeof params === 'object') {
-              const { threadId, itemId, delta } = params as {
+              const { threadId: rawThreadId, itemId, delta } = params as {
                 threadId?: string
                 itemId?: string
                 delta?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && itemId && delta) {
                 appendMessageDelta(threadId, itemId, delta)
               }
             }
 
             if (method === 'item/reasoning/summaryTextDelta' && params && typeof params === 'object') {
-              const { threadId, itemId, delta } = params as {
+              const { threadId: rawThreadId, itemId, delta } = params as {
                 threadId?: string
                 itemId?: string
                 delta?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && itemId && delta) {
                 appendMessageDelta(threadId, itemId, delta)
               }
             }
 
             if (method === 'item/reasoning/summaryPartAdded' && params && typeof params === 'object') {
-              const { threadId, itemId } = params as { threadId?: string; itemId?: string }
+              const { threadId: rawThreadId, itemId } = params as { threadId?: string; itemId?: string }
+              const threadId = resolve(rawThreadId)
               if (threadId && itemId) {
                 appendMessageDelta(threadId, itemId, '\n\n')
               }
             }
 
             if (method === 'item/reasoning/textDelta' && params && typeof params === 'object') {
-              const { threadId, itemId, delta } = params as {
+              const { threadId: rawThreadId, itemId, delta } = params as {
                 threadId?: string
                 itemId?: string
                 delta?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && itemId && delta) {
                 appendMessageDelta(threadId, itemId, delta)
               }
             }
 
             if (method === 'item/commandExecution/outputDelta' && params && typeof params === 'object') {
-              const { threadId, itemId, delta } = params as {
+              const { threadId: rawThreadId, itemId, delta } = params as {
                 threadId?: string
                 itemId?: string
                 delta?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && itemId && delta) {
                 appendMessageDelta(threadId, itemId, delta)
               }
             }
 
             if (method === 'item/fileChange/outputDelta' && params && typeof params === 'object') {
-              const { threadId, itemId, delta } = params as {
+              const { threadId: rawThreadId, itemId, delta } = params as {
                 threadId?: string
                 itemId?: string
                 delta?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && itemId && delta) {
                 appendMessageDelta(threadId, itemId, delta)
               }
             }
 
             if (method === 'item/started' && params && typeof params === 'object') {
-              const { item, threadId, turnId } = params as {
+              const { item, threadId: rawThreadId, turnId } = params as {
                 item?: ItemPayload & { review?: string }
                 threadId?: string
                 turnId?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && item?.type === 'agentMessage' && item.id) {
                 ensureAssistantMessage(threadId, item.id)
                 return
@@ -410,11 +429,12 @@ export const useHubConnection = () => {
             }
 
             if (method === 'item/completed' && params && typeof params === 'object') {
-              const { item, threadId, turnId } = params as {
+              const { item, threadId: rawThreadId, turnId } = params as {
                 item?: ItemPayload & { review?: string }
                 threadId?: string
                 turnId?: string
               }
+              const threadId = resolve(rawThreadId)
               if (threadId && item?.type === 'exitedReviewMode') {
                 const sessionId = turnId ?? item.id
                 if (sessionId) {
@@ -435,7 +455,8 @@ export const useHubConnection = () => {
             }
 
             if (method === 'error' && params && typeof params === 'object') {
-              const { threadId, error } = params as { threadId?: string; error?: { message?: string } }
+              const { threadId: rawThreadId, error } = params as { threadId?: string; error?: { message?: string } }
+              const threadId = resolve(rawThreadId)
               if (threadId) {
                 const message = error?.message ?? 'Unknown error.'
                 addSystemMessage(threadId, 'Error', message)
@@ -466,11 +487,12 @@ export const useHubConnection = () => {
                 parsedCmd?: string
                 command?: string[]
               }
+              const resolvedThreadId = resolve(parsed.threadId) ?? ''
               addApproval({
                 id: parsed.itemId ?? String(id),
                 requestId: id,
                 profileId,
-                threadId: parsed.threadId ?? '',
+                threadId: resolvedThreadId,
                 type: 'command',
                 payload: parsed.parsedCmd ?? parsed.command?.join(' ') ?? 'Command approval required',
                 status: 'pending',
@@ -483,11 +505,12 @@ export const useHubConnection = () => {
                 threadId?: string
                 reason?: string
               }
+              const resolvedThreadId = resolve(parsed.threadId) ?? ''
               addApproval({
                 id: parsed.itemId ?? String(id),
                 requestId: id,
                 profileId,
-                threadId: parsed.threadId ?? '',
+                threadId: resolvedThreadId,
                 type: 'file',
                 payload: parsed.reason ?? 'File changes requested',
                 status: 'pending',
@@ -537,8 +560,25 @@ export const useHubConnection = () => {
           })
           if (threads) {
             setThreadsForAccount(profile.id, toThreads(profile.id, threads))
-            if (profile.id === profiles[0]?.id && threads.data?.length) {
-              setSelectedThreadId(threads.data[0].id)
+          }
+          if (threads?.data?.length) {
+            try {
+              const activeThreads = await hubClient.listActiveThreads({ profileId: profile.id })
+              const knownThreadIds = new Set(threads.data.map((thread) => thread.id))
+              for (const entry of activeThreads) {
+                if (!knownThreadIds.has(entry.threadId)) {
+                  continue
+                }
+                updateThread(entry.threadId, { status: 'active' })
+                if (entry.turnId) {
+                  setThreadTurnId(entry.threadId, entry.turnId)
+                }
+                if (Number.isFinite(entry.startedAt)) {
+                  setThreadTurnStartedAt(entry.threadId, entry.startedAt)
+                }
+              }
+            } catch (error) {
+              console.error(error)
             }
           }
 

package/apps/web/src/hooks/use-thread-history.ts

@@ -24,6 +24,7 @@ type ThreadData = {
 type TurnData = {
   id: string
   items?: ThreadItem[]
+  status?: string
 }
 
 type ThreadItem = {
@@ -109,6 +110,72 @@ const buildMessagesFromTurns = (turns: TurnData[] = []): Message[] => {
   return messages
 }
 
+const mergeMessages = (base: Message[], incoming: Message[]): Message[] => {
+  if (incoming.length === 0) {
+    return base
+  }
+  if (base.length === 0) {
+    return incoming
+  }
+  const merged = [...base]
+  const indexById = new Map(base.map((msg, index) => [msg.id, index]))
+  const userContentIndex = new Map<string, number[]>()
+
+  const contentKey = (message: Message) => message.content.trim()
+  const isUserChat = (message: Message) => message.role === 'user' && message.kind === 'chat'
+
+  base.forEach((message, index) => {
+    if (!isUserChat(message) || message.timestamp) {
+      return
+    }
+    const key = contentKey(message)
+    if (!key) {
+      return
+    }
+    const existing = userContentIndex.get(key)
+    if (existing) {
+      existing.push(index)
+    } else {
+      userContentIndex.set(key, [index])
+    }
+  })
+
+  for (const message of incoming) {
+    const existingIndex = indexById.get(message.id)
+    if (existingIndex === undefined) {
+      if (isUserChat(message)) {
+        const key = contentKey(message)
+        const candidates = key ? userContentIndex.get(key) : undefined
+        const targetIndex = candidates?.shift()
+        if (targetIndex !== undefined) {
+          const target = merged[targetIndex]
+          merged[targetIndex] = {
+            ...target,
+            ...message,
+            id: target.id,
+            timestamp: message.timestamp || target.timestamp,
+          }
+          if (candidates && candidates.length === 0) {
+            userContentIndex.delete(key)
+          }
+          continue
+        }
+      }
+      merged.push(message)
+    } else {
+      merged[existingIndex] = { ...merged[existingIndex], ...message }
+    }
+  }
+  return merged
+}
+
+const isTurnInProgress = (status?: string) => {
+  if (!status) {
+    return false
+  }
+  return status === 'inProgress' || status === 'in_progress' || status === 'inprogress'
+}
+
 export const useThreadHistory = () => {
   const {
     threads,
@@ -121,9 +188,11 @@ export const useThreadHistory = () => {
     setThreadEffort,
     setThreadApproval,
     setThreadCwd,
+    setThreadTurnId,
   } = useAppStore()
 
   const inFlight = useRef<Set<string>>(new Set())
+  const loaded = useRef<Set<string>>(new Set())
 
   useEffect(() => {
     if (!selectedThreadId || connectionStatus !== 'connected') {
@@ -135,8 +204,7 @@ export const useThreadHistory = () => {
       return
     }
 
-    const existing = messages[selectedThreadId]
-    if (existing !== undefined) {
+    if (loaded.current.has(selectedThreadId)) {
       return
     }
 
@@ -162,14 +230,32 @@ export const useThreadHistory = () => {
           return
         }
 
-        const loadedMessages = buildMessagesFromTurns(resumeThread.turns)
-        setMessagesForThread(selectedThreadId, loadedMessages)
+        const turns = resumeThread.turns ?? []
+        const loadedMessages = buildMessagesFromTurns(turns)
+        const currentMessages = useAppStore.getState().messages[selectedThreadId] ?? []
+        const mergedMessages = mergeMessages(loadedMessages, currentMessages)
+        setMessagesForThread(selectedThreadId, mergedMessages)
+
+        let activeTurn: TurnData | null = null
+        for (let index = turns.length - 1; index >= 0; index -= 1) {
+          if (isTurnInProgress(turns[index]?.status)) {
+            activeTurn = turns[index]
+            break
+          }
+        }
+        setThreadTurnId(selectedThreadId, activeTurn?.id ?? null)
+        const nextStatus = thread.status === 'archived'
+          ? 'archived'
+          : activeTurn
+            ? 'active'
+            : 'idle'
 
         updateThread(selectedThreadId, {
           title: resumeThread.preview?.trim() || thread.title,
           preview: resumeThread.preview?.trim() || thread.preview,
           model: resumeThread.modelProvider ?? thread.model,
-          messageCount: loadedMessages.length,
+          messageCount: mergedMessages.length,
+          status: nextStatus,
         })
         if (result.model) {
           setThreadModel(selectedThreadId, result.model)
@@ -184,6 +270,7 @@ export const useThreadHistory = () => {
         if (result.cwd) {
           setThreadCwd(selectedThreadId, result.cwd)
         }
+        loaded.current.add(selectedThreadId)
       } catch (error) {
         console.error(error)
       } finally {
@@ -206,5 +293,7 @@ export const useThreadHistory = () => {
     setThreadApproval,
     threads,
     updateThread,
+    setThreadTurnId,
+    setThreadCwd,
   ])
 }

package/apps/web/src/services/hub-client.ts

@@ -12,6 +12,32 @@ export type PromptSummary = {
   description?: string
 }
 
+export type McpServerConfig = {
+  name: string
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  env_vars?: string[]
+  cwd?: string
+  url?: string
+  bearer_token_env_var?: string
+  http_headers?: Record<string, string>
+  env_http_headers?: Record<string, string>
+  enabled?: boolean
+  startup_timeout_sec?: number
+  startup_timeout_ms?: number
+  tool_timeout_sec?: number
+  enabled_tools?: string[]
+  disabled_tools?: string[]
+}
+
+export type ProfileConfigSnapshot = {
+  path: string
+  codexHome: string
+  content: string
+  mcpServers: McpServerConfig[]
+}
+
 export type ThreadSearchResult = {
   threadId: string
   profileId: string
@@ -27,6 +53,13 @@ export type ThreadSearchResult = {
   lastSeenAt: number | null
 }
 
+export type ActiveThread = {
+  threadId: string
+  profileId: string
+  turnId: string | null
+  startedAt: number
+}
+
 export type ReviewSessionResult = {
   id: string
   threadId: string
@@ -234,6 +267,40 @@ class HubClient {
     return data.content ?? ''
   }
 
+  async getProfileConfig(profileId: string): Promise<ProfileConfigSnapshot> {
+    const response = await fetch(`${HUB_URL}/profiles/${profileId}/config`)
+    if (!response.ok) {
+      throw new Error('Failed to load config')
+    }
+    return (await response.json()) as ProfileConfigSnapshot
+  }
+
+  async saveProfileConfig(profileId: string, content: string): Promise<ProfileConfigSnapshot> {
+    const response = await fetch(`${HUB_URL}/profiles/${profileId}/config`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ content }),
+    })
+    if (!response.ok) {
+      throw new Error('Failed to save config')
+    }
+    const data = (await response.json()) as { content?: string } & ProfileConfigSnapshot
+    return data
+  }
+
+  async saveMcpServers(profileId: string, servers: McpServerConfig[]): Promise<ProfileConfigSnapshot> {
+    const response = await fetch(`${HUB_URL}/profiles/${profileId}/mcp-servers`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ servers }),
+    })
+    if (!response.ok) {
+      throw new Error('Failed to save MCP servers')
+    }
+    const data = (await response.json()) as ProfileConfigSnapshot
+    return data
+  }
+
   async searchThreads(params: {
     query?: string
     profileId?: string
@@ -261,6 +328,17 @@ class HubClient {
     return data.threads ?? []
   }
 
+  async listActiveThreads(params?: { profileId?: string }): Promise<ActiveThread[]> {
+    const url = new URL('/threads/active', HUB_URL)
+    if (params?.profileId) url.searchParams.set('profileId', params.profileId)
+    const response = await fetch(url.toString())
+    if (!response.ok) {
+      throw new Error('Failed to load active threads')
+    }
+    const data = (await response.json()) as { threads?: ActiveThread[] }
+    return data.threads ?? []
+  }
+
   async listReviews(params?: { profileId?: string; limit?: number; offset?: number }): Promise<ReviewSessionResult[]> {
     const url = new URL('/reviews', HUB_URL)
     if (params?.profileId) url.searchParams.set('profileId', params.profileId)
@@ -274,7 +352,7 @@ class HubClient {
     return data.sessions ?? []
   }
 
-  async request(profileId: string, method: string, params?: unknown): Promise<unknown> {
+  private async sendRequest(profileId: string, method: string, params?: unknown): Promise<unknown> {
     if (!this.ws) {
       console.error('[HubClient] WebSocket not connected')
       throw new Error('WebSocket not connected')
@@ -306,6 +384,18 @@ class HubClient {
     })
   }
 
+  async request(profileId: string, method: string, params?: unknown): Promise<unknown> {
+    try {
+      return await this.sendRequest(profileId, method, params)
+    } catch (error) {
+      if (this.isProfileNotRunning(error)) {
+        await this.startProfile(profileId)
+        return await this.sendRequest(profileId, method, params)
+      }
+      throw error
+    }
+  }
+
   respond(profileId: string, id: number, result?: unknown, error?: { code?: number; message: string }) {
     if (!this.ws) {
       return
@@ -354,6 +444,13 @@ class HubClient {
 
     this.listeners.forEach((listener) => listener(payload as WsEvent))
   }
+
+  private isProfileNotRunning(error: unknown): boolean {
+    if (!error || typeof error !== 'object') {
+      return false
+    }
+    return error instanceof Error && error.message.includes('profile app-server not running')
+  }
 }
 
 export const hubClient = new HubClient()

package/apps/web/src/store/index.ts

@@ -20,6 +20,8 @@ interface AppState {
   threadTurnStartedAt: Record<string, number>
   threadLastTurnDuration: Record<string, number>
   threadTokenUsage: Record<string, unknown>
+  threadPendingAccountSwitch: Record<string, { originalThreadId: string; previousAccountId: string }>
+  backendToUiThreadId: Record<string, string>
   
   messages: Record<string, Message[]>
   queuedMessages: Record<string, QueuedMessage[]>
@@ -59,6 +61,9 @@ interface AppState {
   setThreadTurnStartedAt: (threadId: string, startedAt: number | null) => void
   setThreadLastTurnDuration: (threadId: string, duration: number | null) => void
   setThreadTokenUsage: (threadId: string, usage: unknown) => void
+  setThreadPendingAccountSwitch: (threadId: string, pending: { originalThreadId: string; previousAccountId: string } | null) => void
+  setBackendToUiThreadId: (backendThreadId: string, uiThreadId: string | null) => void
+  resolveThreadId: (threadId: string) => string
   
   addMessage: (threadId: string, message: Message) => void
   appendAgentDelta: (threadId: string, messageId: string, delta: string) => void
@@ -87,7 +92,7 @@ interface AppState {
   closeMobileDrawers: () => void
 }
 
-export const useAppStore = create<AppState>((set) => ({
+export const useAppStore = create<AppState>((set, get) => ({
   accounts: [],
   selectedAccountId: null,
   connectionStatus: 'idle',
@@ -105,6 +110,8 @@ export const useAppStore = create<AppState>((set) => ({
   threadTurnStartedAt: {},
   threadLastTurnDuration: {},
   threadTokenUsage: {},
+  threadPendingAccountSwitch: {},
+  backendToUiThreadId: {},
   messages: {},
   queuedMessages: {},
   approvals: [],
@@ -325,6 +332,34 @@ export const useAppStore = create<AppState>((set) => ({
       [threadId]: usage,
     },
   })),
+  setThreadPendingAccountSwitch: (threadId, pending) => set((state) => {
+    if (pending === null) {
+      const { [threadId]: _, ...rest } = state.threadPendingAccountSwitch
+      return { threadPendingAccountSwitch: rest }
+    }
+    return {
+      threadPendingAccountSwitch: {
+        ...state.threadPendingAccountSwitch,
+        [threadId]: pending,
+      },
+    }
+  }),
+  setBackendToUiThreadId: (backendThreadId, uiThreadId) => set((state) => {
+    if (uiThreadId === null) {
+      const { [backendThreadId]: _, ...rest } = state.backendToUiThreadId
+      return { backendToUiThreadId: rest }
+    }
+    return {
+      backendToUiThreadId: {
+        ...state.backendToUiThreadId,
+        [backendThreadId]: uiThreadId,
+      },
+    }
+  }),
+  resolveThreadId: (threadId: string): string => {
+    const state = get()
+    return state.backendToUiThreadId[threadId] ?? threadId
+  },
 
   addMessage: (threadId, message) => set((state) => ({
     messages: {

package/apps/web/src/types/index.ts

@@ -8,6 +8,29 @@ export type ReasoningSummary = 'auto' | 'concise' | 'detailed' | 'none'
 export type ApprovalPolicy = 'untrusted' | 'on-failure' | 'on-request' | 'never'
 export type ReviewStatus = 'pending' | 'running' | 'completed' | 'failed'
 
+export type CommandAction =
+  | { type: 'read'; command: string; name: string; path: string }
+  | { type: 'listFiles'; command: string; path?: string | null }
+  | { type: 'search'; command: string; query?: string | null; path?: string | null }
+  | { type: 'unknown'; command: string }
+
+export type FileChangeKind = 'add' | 'delete' | 'update'
+
+export interface FileChangeMeta {
+  path: string
+  kind: FileChangeKind
+  diff?: string
+  movePath?: string | null
+}
+
+export interface MessageMeta {
+  commandActions?: CommandAction[]
+  command?: string
+  status?: string
+  fileChanges?: FileChangeMeta[]
+  diff?: string
+}
+
 export interface Attachment {
   id: string
   type: 'image' | 'file'
@@ -60,6 +83,7 @@ export interface Thread {
   createdAt: string
   status: ThreadStatus
   messageCount: number
+  backendThreadId?: string
 }
 
 export interface Message {
@@ -69,6 +93,7 @@ export interface Message {
   kind?: MessageKind
   title?: string
   timestamp: string
+  meta?: MessageMeta
 }
 
 export interface QueuedMessage {