@axhub/genie 0.1.7 → 0.1.9

package/server/openai-codex.js

@@ -15,9 +15,16 @@
 
 import { Codex } from '@openai/codex-sdk';
 import { parseCodexTurnUsage } from './utils/codexTokenUsage.js';
+import { getCodexPathOverride } from './utils/codexPath.js';
 
 // Track active sessions
 const activeCodexSessions = new Map();
+const CODEX_STREAM_START_TIMEOUT_MS = parseInt(process.env.CODEX_STREAM_START_TIMEOUT_MS, 10) || 20000;
+const CODEX_MEANINGFUL_EVENT_TIMEOUT_MS = parseInt(process.env.CODEX_MEANINGFUL_EVENT_TIMEOUT_MS, 10) || 60000;
+
+function isCodexPlaceholderSessionId(sessionId) {
+  return typeof sessionId === 'string' && /^codex-\d+$/.test(sessionId.trim());
+}
 
 /**
  * Transform Codex SDK event to WebSocket message format
@@ -214,7 +221,8 @@ function mapPermissionModeToCodexOptions(permissionMode) {
     default:
       return {
         sandboxMode: 'workspace-write',
-        approvalPolicy: 'untrusted'
+        // Keep default mode writable and non-blocking for coding workflows.
+        approvalPolicy: 'never'
       };
   }
 }
@@ -243,6 +251,73 @@ export async function queryCodex(command, options = {}, ws) {
   let currentSessionId = sessionId;
   let resolvedSessionIdFromEvent = null;
   const streamedTextByItemId = new Map();
+  const streamAbortController = new AbortController();
+  let hasStreamEvent = false;
+  let startupTimeoutId = null;
+  let meaningfulEventTimeoutId = null;
+  let timeoutErrorMessage = null;
+  let terminalStatus = 'completed';
+  let shouldSendCompletionEvent = true;
+
+  const clearStartupTimeout = () => {
+    if (startupTimeoutId) {
+      clearTimeout(startupTimeoutId);
+      startupTimeoutId = null;
+    }
+  };
+
+  const clearMeaningfulEventTimeout = () => {
+    if (meaningfulEventTimeoutId) {
+      clearTimeout(meaningfulEventTimeoutId);
+      meaningfulEventTimeoutId = null;
+    }
+  };
+
+  const armStartupTimeout = () => {
+    clearStartupTimeout();
+
+    if (!Number.isFinite(CODEX_STREAM_START_TIMEOUT_MS) || CODEX_STREAM_START_TIMEOUT_MS <= 0) {
+      return;
+    }
+
+    startupTimeoutId = setTimeout(() => {
+      if (hasStreamEvent) {
+        return;
+      }
+
+      timeoutErrorMessage =
+        `Codex did not produce any stream events within ${Math.round(CODEX_STREAM_START_TIMEOUT_MS / 1000)} seconds. ` +
+        'This usually means the Codex client or upstream service is unavailable.';
+      streamAbortController.abort();
+    }, CODEX_STREAM_START_TIMEOUT_MS);
+  };
+
+  const armMeaningfulEventTimeout = () => {
+    clearMeaningfulEventTimeout();
+
+    if (!Number.isFinite(CODEX_MEANINGFUL_EVENT_TIMEOUT_MS) || CODEX_MEANINGFUL_EVENT_TIMEOUT_MS <= 0) {
+      return;
+    }
+
+    meaningfulEventTimeoutId = setTimeout(() => {
+      timeoutErrorMessage =
+        `Codex stopped emitting progress events for ${Math.round(CODEX_MEANINGFUL_EVENT_TIMEOUT_MS / 1000)} seconds. ` +
+        'The upstream Codex service may be unavailable or stalled.';
+      streamAbortController.abort();
+    }, CODEX_MEANINGFUL_EVENT_TIMEOUT_MS);
+  };
+
+  const markStreamEventObserved = (options = {}) => {
+    const { keepProgressWatch = true } = options;
+    hasStreamEvent = true;
+    clearStartupTimeout();
+
+    if (keepProgressWatch) {
+      armMeaningfulEventTimeout();
+    } else {
+      clearMeaningfulEventTimeout();
+    }
+  };
 
   const syncResolvedSessionId = (broadcastUpdate = false) => {
     const resolvedThreadId = typeof thread?.id === 'string' && thread.id.trim()
@@ -282,7 +357,9 @@ export async function queryCodex(command, options = {}, ws) {
 
   try {
     // Initialize Codex SDK
-    codex = new Codex();
+    codex = new Codex({
+      codexPathOverride: getCodexPathOverride()
+    });
 
     // Thread options with sandbox and approval settings
     const threadOptions = {
@@ -303,6 +380,7 @@ export async function queryCodex(command, options = {}, ws) {
 
     // Get the thread ID
     currentSessionId = thread.id || sessionId || `codex-${Date.now()}`;
+    const shouldBroadcastInitialSessionId = !isCodexPlaceholderSessionId(currentSessionId);
 
     if (ws?.setSessionId && typeof ws.setSessionId === 'function') {
       ws.setSessionId(currentSessionId);
@@ -312,22 +390,32 @@ export async function queryCodex(command, options = {}, ws) {
     activeCodexSessions.set(currentSessionId, {
       thread,
       codex,
+      abortController: streamAbortController,
       status: 'running',
       startedAt: new Date().toISOString()
     });
 
     // Send session created event
-    sendMessage(ws, {
-      type: 'session-created',
-      sessionId: currentSessionId,
-      provider: 'codex'
-    });
+    if (shouldBroadcastInitialSessionId) {
+      sendMessage(ws, {
+        type: 'session-created',
+        sessionId: currentSessionId,
+        provider: 'codex'
+      });
+    }
 
     // Execute with streaming
-    const streamedTurn = await thread.runStreamed(command);
+    armStartupTimeout();
+
+    const streamedTurn = await thread.runStreamed(command, {
+      signal: streamAbortController.signal
+    });
     syncResolvedSessionId(true);
 
     for await (const event of streamedTurn.events) {
+      const isTerminalEvent = event?.type === 'turn.completed' || event?.type === 'turn.failed';
+      markStreamEventObserved({ keepProgressWatch: !isTerminalEvent });
+
       if (event?.type === 'thread.started') {
         const eventThreadId = getThreadIdFromEvent(event);
         if (eventThreadId) {
@@ -340,6 +428,38 @@ export async function queryCodex(command, options = {}, ws) {
       // Check if session was aborted
       const session = activeCodexSessions.get(currentSessionId);
       if (!session || session.status === 'aborted') {
+        terminalStatus = 'aborted';
+        shouldSendCompletionEvent = false;
+        break;
+      }
+
+      if (event.type === 'error') {
+        const errorMessage = typeof event.message === 'string' ? event.message.trim() : '';
+        if (errorMessage) {
+          sendMessage(ws, {
+            type: 'codex-response',
+            data: {
+              type: 'provider_notice',
+              message: errorMessage
+            },
+            sessionId: currentSessionId
+          });
+        }
+        continue;
+      }
+
+      if (event.type === 'turn.failed') {
+        terminalStatus = 'errored';
+        shouldSendCompletionEvent = false;
+        clearStartupTimeout();
+        clearMeaningfulEventTimeout();
+
+        const transformed = transformCodexEvent(event);
+        sendMessage(ws, {
+          type: 'codex-response',
+          data: transformed,
+          sessionId: currentSessionId
+        });
         break;
       }
 
@@ -422,6 +542,10 @@ export async function queryCodex(command, options = {}, ws) {
     syncResolvedSessionId(true);
 
     // Send completion event
+    if (!shouldSendCompletionEvent) {
+      return;
+    }
+
     const finalSessionId = (typeof thread?.id === 'string' && thread.id.trim())
       ? thread.id.trim()
       : currentSessionId;
@@ -440,18 +564,27 @@ export async function queryCodex(command, options = {}, ws) {
   } catch (error) {
     console.error('[Codex] Error:', error);
 
+    const trackedSession = currentSessionId ? activeCodexSessions.get(currentSessionId) : null;
+    if (trackedSession?.status === 'aborted') {
+      terminalStatus = 'aborted';
+      return;
+    }
+
+    terminalStatus = 'errored';
     sendMessage(ws, {
       type: 'codex-error',
-      error: error.message,
+      error: timeoutErrorMessage || error.message,
       sessionId: currentSessionId
     });
 
   } finally {
+    clearStartupTimeout();
+    clearMeaningfulEventTimeout();
     // Update session status
     if (currentSessionId) {
       const session = activeCodexSessions.get(currentSessionId);
       if (session) {
-        session.status = 'completed';
+        session.status = terminalStatus;
       }
     }
   }
@@ -470,6 +603,9 @@ export function abortCodexSession(sessionId) {
   }
 
   session.status = 'aborted';
+  if (session.abortController && !session.abortController.signal.aborted) {
+    session.abortController.abort();
+  }
 
   // The SDK doesn't have a direct abort method, but marking status
   // will cause the streaming loop to exit