better-codex 0.2.0 → 0.2.2

package/apps/backend/src/core/jsonrpc.ts

@@ -59,10 +59,12 @@ export class JsonRpcConnection extends EventEmitter {
     })
 
     stdout.on('end', () => {
+      this.rejectAllPending(new Error('connection closed'))
       this.emit('close')
     })
 
     stdout.on('error', (error) => {
+      this.rejectAllPending(error)
       this.emit('error', error)
     })
 
@@ -161,6 +163,17 @@ export class JsonRpcConnection extends EventEmitter {
   private writeMessage(message: JsonRpcRequest | JsonRpcResponse | JsonRpcNotification): void {
     this.stdin.write(`${JSON.stringify(message)}\n`)
   }
+
+  private rejectAllPending(error: Error): void {
+    if (!this.pending.size) {
+      return
+    }
+    const message = error.message || 'connection closed'
+    for (const [, pending] of this.pending) {
+      pending.reject({ message })
+    }
+    this.pending.clear()
+  }
 }
 
 export type JsonRpcEventsMap = JsonRpcEvents

package/apps/backend/src/server.ts

@@ -371,6 +371,25 @@ const app = new Elysia()
       }),
     }
   )
+  .delete(
+    '/threads/active/:threadId',
+    ({ params, query }) => {
+      const profileId = typeof query.profileId === 'string' ? query.profileId : undefined
+      if (!profileId) {
+        return { ok: false, error: 'profileId is required' }
+      }
+      threadActivity.markCompleted(profileId, params.threadId)
+      return { ok: true }
+    },
+    {
+      params: t.Object({
+        threadId: t.String(),
+      }),
+      query: t.Object({
+        profileId: t.String(),
+      }),
+    }
+  )
   .post(
     '/threads/reindex',
     async ({ body }) => {

package/apps/web/src/components/layout/session-view.tsx

@@ -1,9 +1,9 @@
-import { useEffect, useRef, useState } from 'react'
+import { useEffect, useRef, useState, useMemo } from 'react'
 import { useAppStore } from '../../store'
 import { type SelectOption } from '../ui'
 import { VirtualizedMessageList } from './virtualized-message-list'
 import { hubClient } from '../../services/hub-client'
-import type { ApprovalPolicy, Attachment, FileMention, MessageKind, ReasoningEffort, ReasoningSummary } from '../../types'
+import type { ApprovalPolicy, Attachment, FileMention, MessageKind, ReasoningEffort, ReasoningSummary, SandboxMode, SandboxPolicy } from '../../types'
 import { INIT_PROMPT } from '../../utils/init-prompt'
 import { filterSlashCommands, findSlashCommand, getSlashQuery, parseSlashInput, type SlashCommandDefinition } from '../../utils/slash-commands'
 import { approvalPolicyDescription, approvalPolicyLabel, normalizeApprovalPolicy } from '../../utils/approval-policy'
@@ -15,6 +15,23 @@ import { SessionAuthBanner } from '../session-view/session-auth-banner'
 import { SessionComposer } from '../session-view/session-composer'
 import { SessionDialogs } from '../session-view/session-dialogs'
 import { SessionEmpty } from '../session-view/session-empty'
+import { RateLimitBanner, isRateLimitError } from '../session-view/rate-limit-banner'
+
+const ALWAYS_ALLOW_SANDBOX_MODE: SandboxMode = 'workspace-write'
+const ALWAYS_ALLOW_SANDBOX_POLICY: SandboxPolicy = { type: 'workspaceWrite' }
+
+const resolveSandboxPolicy = (mode?: SandboxMode | null): SandboxPolicy | null => {
+  switch (mode) {
+    case 'danger-full-access':
+      return { type: 'dangerFullAccess' }
+    case 'read-only':
+      return { type: 'readOnly' }
+    case 'workspace-write':
+      return { type: 'workspaceWrite' }
+    default:
+      return null
+  }
+}
 
 export function SessionView() {
   const [inputValue, setInputValue] = useState('')
@@ -37,6 +54,8 @@ export function SessionView() {
   const [pendingCwd, setPendingCwd] = useState('')
   const [pendingApproval, setPendingApproval] = useState<ApprovalPolicy>('on-request')
   const [showApiKeyPrompt, setShowApiKeyPrompt] = useState(false)
+  const [showAccountSwitchDialog, setShowAccountSwitchDialog] = useState(false)
+  const [rateLimitBannerDismissed, setRateLimitBannerDismissed] = useState(false)
   // Attachments and file mentions state
   const [attachments, setAttachments] = useState<Attachment[]>([])
   const [fileMentions, setFileMentions] = useState<FileMention[]>([])
@@ -73,14 +92,17 @@ export function SessionView() {
     threadEfforts,
     threadApprovals,
     threadWebSearch,
+    threadSandboxes,
     threadTurnIds,
     threadTurnStartedAt,
     threadLastTurnDuration,
     threadTokenUsage,
+    threadPendingAccountSwitch,
     setThreadModel,
     setThreadEffort,
     setThreadApproval,
     setThreadWebSearch,
+    setThreadSandbox,
     threadSummaries,
     setThreadSummary,
     threadCwds,
@@ -93,6 +115,8 @@ export function SessionView() {
     connectionStatus,
     setMessagesForThread,
     setAccountLoginId,
+    setThreadPendingAccountSwitch,
+    setBackendToUiThreadId,
   } = useAppStore()
 
   const selectedThread = threads.find((thread) => thread.id === selectedThreadId)
@@ -115,10 +139,14 @@ export function SessionView() {
   const selectedEffort = selectedThreadId ? threadEfforts[selectedThreadId] : undefined
   const effectiveEffort = selectedEffort ?? defaultEffort ?? null
   const selectedApproval = selectedThreadId ? threadApprovals[selectedThreadId] : undefined
+  const selectedSandbox = selectedThreadId ? threadSandboxes[selectedThreadId] : undefined
   const selectedSummary = selectedThreadId ? threadSummaries[selectedThreadId] : undefined
   const selectedCwd = selectedThreadId ? threadCwds[selectedThreadId] : undefined
   const selectedUsage = selectedThreadId ? threadTokenUsage[selectedThreadId] : undefined
   const webSearchEnabled = selectedThreadId ? threadWebSearch[selectedThreadId] ?? false : false
+  const selectedWebSearch = webSearchEnabled
+  // Get the effective backend thread ID (may differ from UI thread ID after account switch)
+  const effectiveBackendThreadId = selectedThread?.backendThreadId ?? selectedThreadId
   const isAccountReady = account?.status === 'online'
   const isAuthPending = account?.status === 'degraded'
   const canInteract = connectionStatus === 'connected' && !isArchived && isAccountReady
@@ -143,6 +171,34 @@ export function SessionView() {
   const mentionQuery = getMentionQuery(inputValue)
   const mentionMenuOpen = mentionQuery !== null && !slashMenuOpen
   const mentionMatches = mentionMenuOpen ? fileSearchResults : []
+
+  // Rate limit detection - check recent messages for rate limit errors
+  const rateLimitError = useMemo(() => {
+    if (!threadMessages.length) return null
+    // Check the last 5 messages for rate limit errors
+    const recentMessages = threadMessages.slice(-5)
+    for (const msg of recentMessages) {
+      if (msg.role === 'assistant' && msg.title === 'Error' && isRateLimitError(msg.content)) {
+        return msg.content
+      }
+    }
+    return null
+  }, [threadMessages])
+
+  // Get accounts available for switching (online accounts other than current)
+  const switchableAccounts = useMemo(() => {
+    return accounts.filter(
+      (a) => a.id !== threadAccountId && a.status === 'online'
+    )
+  }, [accounts, threadAccountId])
+
+  // Show rate limit banner when error detected and not dismissed
+  const showRateLimitBanner = !!rateLimitError && !rateLimitBannerDismissed && switchableAccounts.length > 0
+
+  // Reset banner dismissed state when thread changes
+  useEffect(() => {
+    setRateLimitBannerDismissed(false)
+  }, [selectedThreadId])
   
   const modelOptions = models.map((model): SelectOption => ({
     value: model.id,
@@ -175,6 +231,18 @@ export function SessionView() {
       description: approvalPolicyDescription(value),
     })
   )
+  const sandboxOptions: SelectOption[] = [
+    {
+      value: '',
+      label: 'Sandboxed',
+      description: 'Use configured sandbox settings',
+    },
+    {
+      value: 'danger-full-access',
+      label: 'Dangerously allow full access',
+      description: 'No filesystem sandbox (trusted only)',
+    },
+  ]
   const resumeCandidates = threadAccountId
     ? threads.filter((thread) => thread.accountId === threadAccountId)
     : []
@@ -402,6 +470,7 @@ export function SessionView() {
         summary: selectedSummary ?? null,
         cwd: selectedCwd ?? null,
         approvalPolicy: selectedApproval ?? null,
+        sandbox: selectedSandbox ?? null,
         createdAt: Date.now(),
       })
       setInputValue('')
@@ -426,6 +495,79 @@ export function SessionView() {
     try {
       updateThread(selectedThreadId, { status: 'active' })
       
+      // Check if this thread has a pending account switch
+      // If so, we need to start a new thread on the new account
+      const pendingSwitch = threadPendingAccountSwitch[selectedThreadId]
+      let actualThreadId = selectedThreadId
+      
+      if (pendingSwitch) {
+        // Start a new thread on the new account
+        const newAccountId = selectedThread.accountId
+        const accountModels = modelsByAccount[newAccountId] || []
+        const defaultThreadModel = accountModels.find((model) => model.isDefault) ?? accountModels[0]
+        const startParams: {
+          model?: string
+          approvalPolicy?: ApprovalPolicy
+          sandbox?: SandboxMode
+          config?: Record<string, unknown>
+        } = {}
+        if (defaultThreadModel?.id) {
+          startParams.model = defaultThreadModel.id
+        }
+        if (selectedApproval) {
+          startParams.approvalPolicy = selectedApproval
+        }
+        if (selectedSandbox) {
+          startParams.sandbox = selectedSandbox
+        } else if (selectedApproval === 'never') {
+          startParams.sandbox = ALWAYS_ALLOW_SANDBOX_MODE
+        }
+        if (selectedWebSearch) {
+          startParams.config = { 'features.web_search_request': true }
+        }
+        
+        const result = (await hubClient.request(newAccountId, 'thread/start', startParams)) as {
+          thread?: {
+            id: string
+            preview?: string
+            modelProvider?: string
+            createdAt?: number
+          }
+          reasoningEffort?: ReasoningEffort | null
+          approvalPolicy?: ApprovalPolicy | null
+        }
+        
+        if (!result.thread) {
+          throw new Error('Failed to start new thread on switched account')
+        }
+        
+        // Use the new backend thread ID for this turn
+        actualThreadId = result.thread.id
+        
+        // Map the backend thread ID to the UI thread ID so events get routed correctly
+        setBackendToUiThreadId(actualThreadId, selectedThreadId)
+        
+        // Update the local thread to use the new backend thread ID
+        // We keep the same local thread but update its properties
+        updateThread(selectedThreadId, { 
+          backendThreadId: actualThreadId,
+          status: 'active',
+        })
+        
+        // Clear the pending switch flag
+        setThreadPendingAccountSwitch(selectedThreadId, null)
+        
+        // Add a system message noting the new thread was created
+        addMessage(selectedThreadId, {
+          id: `sys-new-thread-${Date.now()}`,
+          role: 'assistant',
+          content: `New conversation started on this account. Previous context from ${pendingSwitch.previousAccountId} is shown for reference but not available to the model.`,
+          kind: 'tool',
+          title: 'New Conversation',
+          timestamp: new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }),
+        })
+      }
+      
       // Build input array with text, images, and file references
       const input: Array<{ type: string; text?: string; url?: string; path?: string }> = []
       
@@ -443,7 +585,8 @@ export function SessionView() {
           input.push({ type: 'image', url: attachment.url })
         }
       }
-      
+      const sandboxPolicyOverride = resolveSandboxPolicy(selectedSandbox)
+
       const params: {
         threadId: string
         input: Array<{ type: string; text?: string; url?: string; path?: string }>
@@ -452,8 +595,9 @@ export function SessionView() {
         summary?: ReasoningSummary
         cwd?: string
         approvalPolicy?: ApprovalPolicy
+        sandboxPolicy?: SandboxPolicy
       } = {
-        threadId: selectedThreadId,
+        threadId: actualThreadId,
         input,
       }
       if (effectiveModel) {
@@ -465,6 +609,11 @@ export function SessionView() {
       if (selectedApproval) {
         params.approvalPolicy = selectedApproval
       }
+      if (sandboxPolicyOverride) {
+        params.sandboxPolicy = sandboxPolicyOverride
+      } else if (selectedApproval === 'never') {
+        params.sandboxPolicy = ALWAYS_ALLOW_SANDBOX_POLICY
+      }
       if (selectedSummary) {
         params.summary = selectedSummary
       }
@@ -487,13 +636,23 @@ export function SessionView() {
   const startNewThread = async (accountId: string, approvalOverride?: ApprovalPolicy | null, webSearch?: boolean) => {
     const accountModels = modelsByAccount[accountId] || []
     const defaultThreadModel = accountModels.find((model) => model.isDefault) ?? accountModels[0]
-    const params: { model?: string; approvalPolicy?: ApprovalPolicy; config?: Record<string, unknown> } = {}
+    const params: {
+      model?: string
+      approvalPolicy?: ApprovalPolicy
+      sandbox?: SandboxMode
+      config?: Record<string, unknown>
+    } = {}
     if (defaultThreadModel?.id) {
       params.model = defaultThreadModel.id
     }
     if (approvalOverride) {
       params.approvalPolicy = approvalOverride
     }
+    if (selectedSandbox) {
+      params.sandbox = selectedSandbox
+    } else if (approvalOverride === 'never') {
+      params.sandbox = ALWAYS_ALLOW_SANDBOX_MODE
+    }
     if (webSearch) {
       params.config = { 'features.web_search_request': true }
     }
@@ -542,6 +701,9 @@ export function SessionView() {
     if (effort) {
       setThreadEffort(threadId, effort)
     }
+    if (selectedSandbox) {
+      setThreadSandbox(threadId, selectedSandbox)
+    }
     if (selectedSummary) {
       setThreadSummary(threadId, selectedSummary)
     }
@@ -607,6 +769,7 @@ export function SessionView() {
       `Reasoning summary: ${selectedSummary ?? 'default'}`,
       `Working directory: ${selectedCwd || 'default'}`,
       `Approvals: ${selectedApproval ?? 'default'}`,
+      `Sandbox: ${selectedSandbox ?? 'default'}`,
       `Connection: ${connectionStatus}`,
     ]
     if (usageLine) {
@@ -656,14 +819,14 @@ export function SessionView() {
   }
 
   const runReviewCommand = async (instructions?: string) => {
-    if (!selectedThreadId || !account) {
+    if (!selectedThreadId || !account || !effectiveBackendThreadId) {
       return
     }
     const target = instructions
       ? { type: 'custom', instructions }
       : { type: 'uncommittedChanges' }
     await hubClient.request(account.id, 'review/start', {
-      threadId: selectedThreadId,
+      threadId: effectiveBackendThreadId,
       target,
       delivery: 'inline',
     })
@@ -792,6 +955,36 @@ export function SessionView() {
           setShowApprovalsDialog(true)
           return
         }
+        case 'switch': {
+          // If an account name is provided, try to switch directly
+          if (rest) {
+            const targetAccount = accounts.find(
+              (a) => a.name.toLowerCase() === rest.toLowerCase() ||
+                     a.id === rest
+            )
+            if (targetAccount && targetAccount.status === 'online' && targetAccount.id !== threadAccountId) {
+              handleSwitchThreadAccount(targetAccount.id)
+              return
+            }
+            if (targetAccount && targetAccount.id === threadAccountId) {
+              addSystemMessage('tool', '/switch', `Already using account: ${targetAccount.name}`)
+              return
+            }
+            if (targetAccount && targetAccount.status !== 'online') {
+              addSystemMessage('tool', '/switch', `Account "${targetAccount.name}" is not authenticated.`)
+              return
+            }
+            addSystemMessage('tool', '/switch', `Account "${rest}" not found.`)
+            return
+          }
+          // Show dialog if no account specified
+          if (switchableAccounts.length === 0) {
+            addSystemMessage('tool', '/switch', 'No other authenticated accounts available to switch to.')
+            return
+          }
+          setShowAccountSwitchDialog(true)
+          return
+        }
         case 'review': {
           await runReviewCommand(rest || undefined)
           return
@@ -966,12 +1159,12 @@ export function SessionView() {
   }
 
   const handleArchive = async () => {
-    if (!selectedThreadId || !selectedThread || !canInteract) {
+    if (!selectedThreadId || !selectedThread || !canInteract || !effectiveBackendThreadId) {
       return
     }
     try {
       await hubClient.request(selectedThread.accountId, 'thread/archive', {
-        threadId: selectedThreadId,
+        threadId: effectiveBackendThreadId,
       })
       updateThread(selectedThreadId, { status: 'archived' })
       clearQueuedMessages(selectedThreadId)
@@ -1123,7 +1316,7 @@ export function SessionView() {
   }
 
   const handleInterruptTurn = async () => {
-    if (!account || !selectedThreadId) {
+    if (!account || !selectedThreadId || !effectiveBackendThreadId) {
       return
     }
     const turnId = threadTurnIds[selectedThreadId]
@@ -1132,7 +1325,7 @@ export function SessionView() {
     }
     try {
       await hubClient.request(account.id, 'turn/interrupt', {
-        threadId: selectedThreadId,
+        threadId: effectiveBackendThreadId,
         turnId,
       })
     } catch {
@@ -1213,6 +1406,76 @@ export function SessionView() {
     }
   }
 
+  const handleSwitchThreadAccount = async (newAccountId: string) => {
+    if (!selectedThreadId || !selectedThread) {
+      return
+    }
+    
+    const newAccount = accounts.find((a) => a.id === newAccountId)
+    if (!newAccount || newAccount.status !== 'online') {
+      setAlertDialog({
+        open: true,
+        title: 'Account Unavailable',
+        message: 'Selected account is not authenticated. Please sign in first.',
+        variant: 'warning',
+      })
+      return
+    }
+
+    const previousAccountId = selectedThread.accountId
+    const previousAccount = accounts.find((a) => a.id === previousAccountId)
+
+    // If a task is running on the current account, interrupt it first
+    if (isTaskRunning && previousAccount) {
+      const turnId = threadTurnIds[selectedThreadId]
+      if (turnId) {
+        try {
+          await hubClient.request(previousAccount.id, 'turn/interrupt', {
+            threadId: effectiveBackendThreadId,
+            turnId,
+          })
+          // Wait a moment for the interrupt to process
+          await new Promise((resolve) => setTimeout(resolve, 200))
+        } catch {
+          // Continue with switch even if interrupt fails
+          console.warn('Failed to interrupt turn before account switch')
+        }
+      }
+      // Reset thread status
+      updateThread(selectedThreadId, { status: 'idle' })
+    }
+
+    // Mark this thread as having a pending account switch
+    // The next message sent will start a fresh conversation on the new account
+    setThreadPendingAccountSwitch(selectedThreadId, {
+      originalThreadId: selectedThreadId,
+      previousAccountId,
+    })
+
+    // Update thread's accountId
+    updateThread(selectedThreadId, { accountId: newAccountId })
+
+    // Reset model selection to the new account's default model
+    const newAccountModels = modelsByAccount[newAccountId] || []
+    const newDefaultModel = newAccountModels.find((m) => m.isDefault) ?? newAccountModels[0]
+    if (newDefaultModel) {
+      setThreadModel(selectedThreadId, newDefaultModel.id)
+      if (newDefaultModel.defaultReasoningEffort) {
+        setThreadEffort(selectedThreadId, newDefaultModel.defaultReasoningEffort)
+      }
+    }
+
+    // Add a system message to indicate the switch
+    addMessage(selectedThreadId, {
+      id: `sys-switch-${Date.now()}`,
+      role: 'assistant',
+      content: `Switched to account: ${newAccount.name}. Your next message will start a new conversation using this account.`,
+      kind: 'tool',
+      title: 'Account Switch',
+      timestamp: new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }),
+    })
+  }
+
   if (!selectedThread) {
     return <SessionEmpty onNewSession={handleEmptyNewSession} />
   }
@@ -1221,11 +1484,14 @@ export function SessionView() {
     <main className="flex-1 flex flex-col h-full bg-bg-primary overflow-hidden">
       <SessionHeader
         title={selectedThread.title}
+        accountId={selectedThread.accountId}
         accountName={account?.name}
+        accounts={accounts}
         model={selectedThread.model}
         status={selectedThread.status}
         canInteract={canInteract}
         onArchive={handleArchive}
+        onSwitchAccount={handleSwitchThreadAccount}
       />
       <SessionAuthBanner
         visible={!isAccountReady}
@@ -1235,6 +1501,14 @@ export function SessionView() {
         onCancel={account?.id && accountLoginIds[account.id] ? handleCancelAuth : undefined}
         onRefresh={account ? () => void refreshAccountStatus(account.id) : undefined}
       />
+      <RateLimitBanner
+        visible={showRateLimitBanner}
+        currentAccount={account}
+        availableAccounts={switchableAccounts}
+        errorMessage={rateLimitError ?? undefined}
+        onSwitchAccount={handleSwitchThreadAccount}
+        onDismiss={() => setRateLimitBannerDismissed(true)}
+      />
       <VirtualizedMessageList
         messages={threadMessages}
         approvals={pendingApprovals}
@@ -1298,6 +1572,17 @@ export function SessionView() {
         }}
         showModelSelect={models.length > 0}
         showEffortSelect={effortOptions.length > 0}
+        sandboxOptions={sandboxOptions}
+        effectiveSandbox={selectedSandbox ?? ''}
+        onSandboxChange={(value) => {
+          if (!selectedThreadId) return
+          if (!value) {
+            setThreadSandbox(selectedThreadId, null)
+            return
+          }
+          setThreadSandbox(selectedThreadId, value as SandboxMode)
+        }}
+        showSandboxSelect
         queuedCount={queuedCount}
         webSearchEnabled={webSearchEnabled}
         onWebSearchToggle={() => {
@@ -1347,6 +1632,11 @@ export function SessionView() {
         onCloseResumeDialog={() => setShowResumeDialog(false)}
         resumeCandidates={resumeCandidates}
         onResumeThread={handleResumeThread}
+        showAccountSwitchDialog={showAccountSwitchDialog}
+        onCloseAccountSwitchDialog={() => setShowAccountSwitchDialog(false)}
+        currentAccount={account}
+        switchableAccounts={switchableAccounts}
+        onSwitchAccount={handleSwitchThreadAccount}
         showFeedbackDialog={showFeedbackDialog}
         onCloseFeedbackDialog={() => setShowFeedbackDialog(false)}
         feedbackCategory={feedbackCategory}