@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/modules/providers/list/codex/{codex-runtime.provider.js → codex-runtime.provider.ts}

@@ -8,29 +8,48 @@
  * ## Usage
  *
  * - codexRuntime.run(command, options, writer, context) - Execute a streamed prompt
- * - abortCodexSession(sessionId) - Cancel an active session
- * - isCodexSessionActive(sessionId) - Check if a session is running
- * - getActiveCodexSessions() - List all active sessions
+ * - codexRuntime.abort(sessionId) - Cancel an active session
  */
 
 import { Codex } from '@openai/codex-sdk';
+import type { ModelReasoningEffort, Thread, ThreadOptions } from '@openai/codex-sdk';
 
 import {
   appendFilesInputTag,
   buildCodexInputItems,
-  normalizeImageDescriptors
-} from '@/shared/image-attachments.js';
+  normalizeImageDescriptors,
+  createCompleteMessage,
+  createNormalizedMessage,
+} from '@/shared/index.js';
 import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
-import { createCompleteMessage, createNormalizedMessage } from '@/shared/utils.js';
+import type { AnyRecord, ProviderRuntimeContext, ProviderRuntimeWriter } from '@/shared/index.js';
+
+type ActiveCodexSession = {
+  thread: Thread;
+  codex: Codex;
+  status: 'running' | 'aborted' | 'completed';
+  abortController: AbortController;
+  startedAt: string;
+};
+
+const activeCodexSessions = new Map<string, ActiveCodexSession>();
+
+// Codex CLI requires non-whitespace stdin even when --image arguments are
+// present, so attachment-only turns need a small text instruction.
+const CODEX_IMAGE_ONLY_PROMPT = 'Please analyze the attached image(s).';
 
-const activeCodexSessions = new Map();
+/**
+ * Item types whose in-flight updates are worth showing. These are the ones a
+ * user waits on — a shell command's output, an MCP call, and the running plan.
+ */
+const PROGRESSIVE_CODEX_ITEM_TYPES = new Set(['command_execution', 'mcp_tool_call', 'todo_list']);
 
-function readUsageNumber(value) {
+function readUsageNumber(value: unknown) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : 0;
 }
 
-function extractCodexTokenBudget(event) {
+function extractCodexTokenBudget(event: AnyRecord) {
   const info = event?.info || event?.payload?.info || event?.usage?.info;
   const usage = info?.total_token_usage || event?.usage?.total_token_usage || event?.usage;
   if (!usage || typeof usage !== 'object') {
@@ -58,7 +77,7 @@ function extractCodexTokenBudget(event) {
  * @param {object} event - SDK event
  * @returns {object} - Transformed event for WebSocket
  */
-function transformCodexEvent(event) {
+function transformCodexEvent(event: AnyRecord): AnyRecord {
   // Map SDK event types to a consistent format
   switch (event.type) {
     case 'item.started':
@@ -69,12 +88,16 @@ function transformCodexEvent(event) {
         return { type: event.type, item: null };
       }
 
-      // Transform based on item type
+      // `itemId` is the SDK's stable per-item id. Carrying it through means an
+      // in-progress row and its later completion normalize to the same message
+      // id, so the client updates one transcript entry instead of appending a
+      // new one for every progress tick.
       switch (item.type) {
         case 'agent_message':
           return {
             type: 'item',
             itemType: 'agent_message',
+            itemId: item.id,
             message: {
               role: 'assistant',
               content: item.text
@@ -85,6 +108,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'reasoning',
+            itemId: item.id,
             message: {
               role: 'assistant',
               content: item.text,
@@ -96,6 +120,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'command_execution',
+            itemId: item.id,
             command: item.command,
             output: item.aggregated_output,
             exitCode: item.exit_code,
@@ -106,6 +131,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'file_change',
+            itemId: item.id,
             changes: item.changes,
             status: item.status
           };
@@ -114,6 +140,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'mcp_tool_call',
+            itemId: item.id,
             server: item.server,
             tool: item.tool,
             arguments: item.arguments,
@@ -126,6 +153,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'web_search',
+            itemId: item.id,
             query: item.query
           };
 
@@ -133,6 +161,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'todo_list',
+            itemId: item.id,
             items: item.items
           };
 
@@ -140,6 +169,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'error',
+            itemId: item.id,
             message: {
               role: 'error',
               content: item.message
@@ -150,6 +180,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: item.type,
+            itemId: item.id,
             item: item
           };
       }
@@ -196,7 +227,7 @@ function transformCodexEvent(event) {
  * @param {string} permissionMode - 'default', 'acceptEdits', or 'bypassPermissions'
  * @returns {object} - { sandboxMode, approvalPolicy }
  */
-function mapPermissionModeToCodexOptions(permissionMode) {
+function mapPermissionModeToCodexOptions(permissionMode: string): Pick<ThreadOptions, 'sandboxMode' | 'approvalPolicy'> {
   switch (permissionMode) {
     case 'acceptEdits':
       return {
@@ -212,7 +243,9 @@ function mapPermissionModeToCodexOptions(permissionMode) {
     default:
       return {
         sandboxMode: 'workspace-write',
-        approvalPolicy: 'untrusted'
+        // Current Codex CLI versions reject the retired `untrusted` policy.
+        // Keep sandboxing enabled; exec cannot grant interactive approval requests.
+        approvalPolicy: 'on-request'
       };
   }
 }
@@ -223,7 +256,12 @@ function mapPermissionModeToCodexOptions(permissionMode) {
  * @param {object} options - Options including cwd, sessionId, model, permissionMode
  * @param {WebSocket|object} ws - WebSocket connection or response writer
  */
-export async function queryCodex(command, options = {}, ws, context) {
+async function queryCodex(
+  command: string,
+  options: AnyRecord = {},
+  ws: ProviderRuntimeWriter,
+  context: ProviderRuntimeContext,
+) {
   const {
     sessionId,
     sessionSummary,
@@ -248,16 +286,22 @@ export async function queryCodex(command, options = {}, ws, context) {
   const selectedModel = catalog.OPTIONS.find((option) => option.value === resolvedModel) || null;
   const allowedEfforts = selectedModel?.effort?.values?.map((value) => value.value) || [];
   const resolvedEffort = typeof effort === 'string' && effort !== 'default' && allowedEfforts.includes(effort)
-    ? effort
+    ? effort as ModelReasoningEffort
     : undefined;
 
-  let codex;
-  let thread;
+  let codex: Codex;
+  let thread: Thread;
   // Provider-native thread id (starts as the resume id, or is captured from
   // the stream for brand-new sessions).
   let capturedSessionId = providerSessionId;
   let sessionCreatedSent = false;
-  let terminalFailure = null;
+  let terminalFailure: { message: string } | null = null;
+  // Codex surfaces API failures as streamed error items/turn.failed events, and
+  // then the SDK also throws "Codex Exec exited with code N: <stderr>" once the
+  // process dies. Showing both means the rendered error is followed by a raw
+  // stderr dump of unrelated CLI log lines, so the thrown wrapper is dropped
+  // when the stream already reported the failure.
+  let errorSurfaced = false;
   const abortController = new AbortController();
   // Session-map key: the app session id when the caller supplied one, else
   // the provider-native thread id once captured (legacy/direct API callers).
@@ -266,7 +310,7 @@ export async function queryCodex(command, options = {}, ws, context) {
   try {
     codex = new Codex();
 
-    const threadOptions = {
+    const threadOptions: ThreadOptions = {
       workingDirectory,
       skipGitRepoCheck: true,
       sandboxMode,
@@ -281,7 +325,7 @@ export async function queryCodex(command, options = {}, ws, context) {
       thread = codex.startThread(threadOptions);
     }
 
-    const registerSession = (id) => {
+    const registerSession = (id: string | null) => {
       if (!id) {
         return;
       }
@@ -301,8 +345,12 @@ export async function queryCodex(command, options = {}, ws, context) {
     // Execute with streaming. Turns with image attachments send structured
     // input items so Codex reads the images from their local asset paths.
     const promptWithFiles = appendFilesInputTag(command, files);
-    const turnInput = normalizeImageDescriptors(images).length > 0
-      ? buildCodexInputItems(promptWithFiles, images, workingDirectory)
+    const normalizedImages = normalizeImageDescriptors(images);
+    const promptWithImageFallback = !promptWithFiles.trim() && normalizedImages.length > 0
+      ? CODEX_IMAGE_ONLY_PROMPT
+      : promptWithFiles;
+    const turnInput = normalizedImages.length > 0
+      ? buildCodexInputItems(promptWithImageFallback, normalizedImages, workingDirectory)
       : promptWithFiles;
     const streamedTurn = await thread.runStreamed(turnInput, {
       signal: abortController.signal
@@ -311,7 +359,7 @@ export async function queryCodex(command, options = {}, ws, context) {
     for await (const event of streamedTurn.events) {
       // Capture thread/session id lazily from the stream (Codex emits this asynchronously).
       if (event.type === 'thread.started') {
-        const discoveredSessionId = event.thread_id || event.id || null;
+        const discoveredSessionId = event.thread_id || null;
         if (discoveredSessionId && !capturedSessionId) {
           capturedSessionId = discoveredSessionId;
           registerSession(sessionKey());
@@ -332,17 +380,29 @@ export async function queryCodex(command, options = {}, ws, context) {
         break;
       }
       if (sessionKey()) {
-        const session = activeCodexSessions.get(sessionKey());
+        const session = activeCodexSessions.get(sessionKey() || '');
         if (session?.status === 'aborted') {
           break;
         }
       }
 
-      if (event.type === 'item.started' || event.type === 'item.updated') {
+      // Progress events used to be dropped, so a long shell command or a
+      // growing plan showed nothing until it finished. They are forwarded now;
+      // every item carries a stable id, so the client replaces the row it
+      // already has rather than stacking a new one per tick. Text items are
+      // still skipped mid-flight because assistant prose arrives through the
+      // separate streaming path.
+      if (
+        (event.type === 'item.started' || event.type === 'item.updated')
+        && !PROGRESSIVE_CODEX_ITEM_TYPES.has(event.item?.type)
+      ) {
         continue;
       }
 
       const transformed = transformCodexEvent(event);
+      if (transformed.type === 'error' || transformed.itemType === 'error') {
+        errorSurfaced = true;
+      }
 
       // Normalize the transformed event into NormalizedMessage(s) via adapter
       const normalizedMsgs = context.normalizeMessage(transformed, capturedSessionId || sessionId || null);
@@ -352,6 +412,7 @@ export async function queryCodex(command, options = {}, ws, context) {
 
       if (event.type === 'turn.failed' && !terminalFailure) {
         terminalFailure = event.error || new Error('Turn failed');
+        errorSurfaced = true;
         // Notifications are app-facing, so they carry the app session id.
         notifyRunFailed({
           userId: ws?.userId || null,
@@ -373,7 +434,7 @@ export async function queryCodex(command, options = {}, ws, context) {
 
     // Send the terminal completion event — skipped for aborted runs, whose
     // terminal `complete` (aborted: true) was already sent by abort-session.
-    const runSession = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
+    const runSession = activeCodexSessions.get(sessionKey() || '');
     const runAborted = runSession?.status === 'aborted' || abortController.signal.aborted;
     if (!runAborted) {
       sendMessage(ws, createCompleteMessage({
@@ -394,22 +455,25 @@ export async function queryCodex(command, options = {}, ws, context) {
     }
 
   } catch (error) {
-    const session = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
+    const session = activeCodexSessions.get(sessionKey() || '');
+    const runError = error instanceof Error ? error : new Error(String(error));
     const wasAborted =
       session?.status === 'aborted' ||
-      error?.name === 'AbortError' ||
-      String(error?.message || '').toLowerCase().includes('aborted');
+      runError.name === 'AbortError' ||
+      runError.message.toLowerCase().includes('aborted');
 
     if (!wasAborted) {
       console.error('[Codex] Error:', error);
 
-      // Check if Codex SDK is available for a clearer error message
-      const installed = await context.isProviderInstalled();
-      const errorContent = !installed
-        ? 'Codex CLI is not configured. Please set up authentication first.'
-        : error.message;
+      if (!errorSurfaced) {
+        // Check if Codex SDK is available for a clearer error message
+        const installed = await context.isProviderInstalled();
+        const errorContent = !installed
+          ? 'Codex CLI is not configured. Please set up authentication first.'
+          : runError.message;
 
-      sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+        sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+      }
       sendMessage(ws, createCompleteMessage({
         provider: 'codex',
         sessionId: capturedSessionId || sessionId || null,
@@ -429,7 +493,7 @@ export async function queryCodex(command, options = {}, ws, context) {
   } finally {
     // Update session status
     if (sessionKey()) {
-      const session = activeCodexSessions.get(sessionKey());
+      const session = activeCodexSessions.get(sessionKey() || '');
       if (session) {
         session.status = session.status === 'aborted' ? 'aborted' : 'completed';
       }
@@ -442,7 +506,7 @@ export async function queryCodex(command, options = {}, ws, context) {
  * @param {string} sessionId - Session ID to abort
  * @returns {boolean} - Whether abort was successful
  */
-export function abortCodexSession(sessionId) {
+function abortCodexSession(sessionId: string) {
   const session = activeCodexSessions.get(sessionId);
 
   if (!session) {
@@ -459,36 +523,7 @@ export function abortCodexSession(sessionId) {
   return true;
 }
 
-/**
- * Check if a session is active
- * @param {string} sessionId - Session ID to check
- * @returns {boolean} - Whether session is active
- */
-export function isCodexSessionActive(sessionId) {
-  const session = activeCodexSessions.get(sessionId);
-  return session?.status === 'running';
-}
-
-/**
- * Get all active sessions
- * @returns {Array} - Array of active session info
- */
-export function getActiveCodexSessions() {
-  const sessions = [];
-
-  for (const [id, session] of activeCodexSessions.entries()) {
-    if (session.status === 'running') {
-      sessions.push({
-        id,
-        status: session.status,
-        startedAt: session.startedAt
-      });
-    }
-  }
-
-  return sessions;
-}
-
+/** Used by the providers module's CodexProvider to run and abort SDK turns. */
 export const codexRuntime = {
   run: queryCodex,
   abort: abortCodexSession,
@@ -499,10 +534,10 @@ export const codexRuntime = {
  * @param {WebSocket|object} ws - WebSocket or response writer
  * @param {object} data - Data to send
  */
-function sendMessage(ws, data) {
+function sendMessage(ws: ProviderRuntimeWriter, data: unknown) {
   try {
-    if (ws.isSSEStreamWriter || ws.isWebSocketWriter) {
-      // Writer handles stringification (SSEStreamWriter or WebSocketWriter)
+    if (ws.isWebSocketWriter) {
+      // The gateway writer handles stringification
       ws.send(data);
     } else if (typeof ws.send === 'function') {
       // Raw WebSocket - stringify here

package/server/modules/providers/list/codex/codex-session-synchronizer.provider.ts

@@ -122,6 +122,15 @@ export class CodexSessionSynchronizer implements IProviderSessionSynchronizer {
       return null;
     }
 
+    // A thread a session was edited off is left on disk on purpose, but it is
+    // nobody's conversation any more. Re-indexing it would add a sidebar entry
+    // for the version the user edited away from — and for a session that was
+    // itself discovered from disk, whose app id is its original thread id, it
+    // would hand the row back to that thread.
+    if (sessionsDb.isProviderSessionSuperseded(parsed.sessionId, this.provider)) {
+      return null;
+    }
+
     // App-created sessions are keyed by an app id, so disk-discovered provider
     // ids must be resolved through the provider-id mapping first.
     const existingSession = sessionsDb.getSessionByProviderSessionId(parsed.sessionId)