@axhub/genie 0.2.6 → 0.2.8

package/server/_legacy-providers/openai-codex.js

@@ -0,0 +1,705 @@
+/**
+ * OpenAI Codex SDK Integration
+ * =============================
+ *
+ * This module provides integration with the OpenAI Codex SDK for non-interactive
+ * chat sessions. It mirrors the pattern used in claude-sdk.js for consistency.
+ *
+ * ## Usage
+ *
+ * - queryCodex(command, options, ws) - Execute a prompt with streaming via WebSocket
+ * - abortCodexSession(sessionId) - Cancel an active session
+ * - isCodexSessionActive(sessionId) - Check if a session is running
+ * - getActiveCodexSessions() - List all active sessions
+ */
+
+import { Codex } from '@openai/codex-sdk';
+import { parseCodexTurnUsage } from './utils/codexTokenUsage.js';
+import { getCodexPathOverride, getCodexProcessEnv } from './utils/codexPath.js';
+import { cleanupMaterializedImages, materializeImagesToTempFiles } from './utils/agentImages.js';
+import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.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
+ * @param {object} event - SDK event
+ * @returns {object} - Transformed event for WebSocket
+ */
+function transformCodexEvent(event) {
+  // Map SDK event types to a consistent format
+  switch (event.type) {
+    case 'item.started':
+    case 'item.updated':
+    case 'item.completed':
+      const item = event.item;
+      if (!item) {
+        return { type: event.type, item: null };
+      }
+
+      // Transform based on item type
+      switch (item.type) {
+        case 'agent_message':
+          return {
+            type: 'item',
+            itemType: 'agent_message',
+            message: {
+              role: 'assistant',
+              content: item.text
+            }
+          };
+
+        case 'reasoning':
+          return {
+            type: 'item',
+            itemType: 'reasoning',
+            message: {
+              role: 'assistant',
+              content: item.text,
+              isReasoning: true
+            }
+          };
+
+        case 'command_execution':
+          return {
+            type: 'item',
+            itemType: 'command_execution',
+            command: item.command,
+            output: item.aggregated_output,
+            exitCode: item.exit_code,
+            status: item.status
+          };
+
+        case 'file_change':
+          return {
+            type: 'item',
+            itemType: 'file_change',
+            changes: item.changes,
+            status: item.status
+          };
+
+        case 'mcp_tool_call':
+          return {
+            type: 'item',
+            itemType: 'mcp_tool_call',
+            server: item.server,
+            tool: item.tool,
+            arguments: item.arguments,
+            result: item.result,
+            error: item.error,
+            status: item.status
+          };
+
+        case 'web_search':
+          return {
+            type: 'item',
+            itemType: 'web_search',
+            query: item.query
+          };
+
+        case 'todo_list':
+          return {
+            type: 'item',
+            itemType: 'todo_list',
+            items: item.items
+          };
+
+        case 'error':
+          return {
+            type: 'item',
+            itemType: 'error',
+            message: {
+              role: 'error',
+              content: item.message
+            }
+          };
+
+        default:
+          return {
+            type: 'item',
+            itemType: item.type,
+            item: item
+          };
+      }
+
+    case 'turn.started':
+      return {
+        type: 'turn_started'
+      };
+
+    case 'turn.completed':
+      return {
+        type: 'turn_complete',
+        usage: event.usage
+      };
+
+    case 'turn.failed':
+      return {
+        type: 'turn_failed',
+        error: event.error
+      };
+
+    case 'thread.started':
+      return {
+        type: 'thread_started',
+        threadId: event.thread_id || event.id
+      };
+
+    case 'error':
+      return {
+        type: 'error',
+        message: event.message
+      };
+
+    default:
+      return {
+        type: event.type,
+        data: event
+      };
+  }
+}
+
+/**
+ * Extract thread id from thread.started events (SDK uses thread_id)
+ * @param {object} event
+ * @returns {string|null}
+ */
+function getThreadIdFromEvent(event) {
+  const threadId = event?.thread_id || event?.id;
+  return typeof threadId === 'string' && threadId.trim() ? threadId.trim() : null;
+}
+
+/**
+ * Extract text-bearing item info from Codex item events.
+ * Only agent_message and reasoning currently stream textual deltas.
+ * @param {object} item
+ * @returns {{itemId: string, itemType: string, text: string, isReasoning: boolean}|null}
+ */
+function getTextItemInfo(item) {
+  if (!item || (item.type !== 'agent_message' && item.type !== 'reasoning')) {
+    return null;
+  }
+
+  const itemId = typeof item.id === 'string' && item.id.trim()
+    ? item.id.trim()
+    : null;
+  if (!itemId) {
+    return null;
+  }
+
+  return {
+    itemId,
+    itemType: item.type,
+    text: typeof item.text === 'string' ? item.text : '',
+    isReasoning: item.type === 'reasoning'
+  };
+}
+
+/**
+ * Map permission mode to Codex SDK options
+ * @param {string} permissionMode - 'default', 'acceptEdits', or 'bypassPermissions'
+ * @returns {object} - { sandboxMode, approvalPolicy }
+ */
+function mapPermissionModeToCodexOptions(permissionMode) {
+  switch (permissionMode) {
+    case 'acceptEdits':
+      return {
+        sandboxMode: 'workspace-write',
+        approvalPolicy: 'never'
+      };
+    case 'bypassPermissions':
+      return {
+        sandboxMode: 'danger-full-access',
+        approvalPolicy: 'never'
+      };
+    case 'default':
+    default:
+      return {
+        sandboxMode: 'workspace-write',
+        // Keep default mode writable and non-blocking for coding workflows.
+        approvalPolicy: 'never'
+      };
+  }
+}
+
+/**
+ * Execute a Codex query with streaming
+ * @param {string} command - The prompt to send
+ * @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) {
+  const {
+    sessionId,
+    cwd,
+    projectPath,
+    model,
+    permissionMode = 'default',
+    modelReasoningEffort,
+    images
+  } = options;
+
+  const workingDirectory = resolveWorkingDirectory({ cwd, projectPath });
+  const { sandboxMode, approvalPolicy } = mapPermissionModeToCodexOptions(permissionMode);
+
+  let codex;
+  let thread;
+  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;
+  let tempImagePaths = [];
+  let tempImageDir = null;
+
+  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()
+      ? thread.id.trim()
+      : (typeof resolvedSessionIdFromEvent === 'string' && resolvedSessionIdFromEvent.trim()
+        ? resolvedSessionIdFromEvent.trim()
+        : null);
+
+    if (!resolvedThreadId || resolvedThreadId === currentSessionId) {
+      return false;
+    }
+
+    const previousSessionId = currentSessionId;
+    const trackedSession = previousSessionId ? activeCodexSessions.get(previousSessionId) : null;
+
+    if (trackedSession && previousSessionId !== resolvedThreadId) {
+      activeCodexSessions.delete(previousSessionId);
+      activeCodexSessions.set(resolvedThreadId, trackedSession);
+    }
+
+    currentSessionId = resolvedThreadId;
+
+    if (ws?.setSessionId && typeof ws.setSessionId === 'function') {
+      ws.setSessionId(currentSessionId);
+    }
+
+    if (broadcastUpdate) {
+      sendMessage(ws, {
+        type: 'session-created',
+        sessionId: currentSessionId,
+        provider: 'codex'
+      });
+    }
+
+    return true;
+  };
+
+  try {
+    // Initialize Codex SDK
+    codex = new Codex({
+      codexPathOverride: getCodexPathOverride(),
+      env: getCodexProcessEnv()
+    });
+
+    // Thread options with sandbox and approval settings
+    const threadOptions = {
+      workingDirectory,
+      skipGitRepoCheck: true,
+      sandboxMode,
+      approvalPolicy,
+      model,
+      ...(modelReasoningEffort ? { modelReasoningEffort } : {})
+    };
+
+    // Start or resume thread
+    if (sessionId) {
+      thread = codex.resumeThread(sessionId, threadOptions);
+    } else {
+      thread = codex.startThread(threadOptions);
+    }
+
+    // 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);
+    }
+
+    // Track the session
+    activeCodexSessions.set(currentSessionId, {
+      thread,
+      codex,
+      abortController: streamAbortController,
+      status: 'running',
+      startedAt: new Date().toISOString()
+    });
+
+    // Send session created event
+    if (shouldBroadcastInitialSessionId) {
+      sendMessage(ws, {
+        type: 'session-created',
+        sessionId: currentSessionId,
+        provider: 'codex'
+      });
+    }
+
+    // Execute with streaming
+    armStartupTimeout();
+
+    if (Array.isArray(images) && images.length > 0) {
+      const materializedImages = await materializeImagesToTempFiles(images, workingDirectory, 'codex-images');
+      tempImagePaths = materializedImages.tempImagePaths;
+      tempImageDir = materializedImages.tempDir;
+    }
+
+    const runInput = tempImagePaths.length > 0
+      ? [
+          { type: 'text', text: command },
+          ...tempImagePaths.map((imagePath) => ({ type: 'local_image', path: imagePath }))
+        ]
+      : command;
+
+    const streamedTurn = await thread.runStreamed(runInput, {
+      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) {
+          resolvedSessionIdFromEvent = eventThreadId;
+        }
+      }
+
+      syncResolvedSessionId(true);
+
+      // 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;
+      }
+
+      const isItemEvent = event.type === 'item.started' || event.type === 'item.updated' || event.type === 'item.completed';
+      if (isItemEvent) {
+        const textItemInfo = getTextItemInfo(event.item);
+
+        if (textItemInfo) {
+          const previousText = streamedTextByItemId.get(textItemInfo.itemId) || '';
+          const nextText = textItemInfo.text || '';
+
+          let delta = '';
+          if (nextText.startsWith(previousText)) {
+            delta = nextText.slice(previousText.length);
+          } else if (nextText !== previousText) {
+            // Fallback when text is rewritten rather than appended
+            delta = nextText;
+          }
+
+          streamedTextByItemId.set(textItemInfo.itemId, nextText);
+
+          if (delta) {
+            sendMessage(ws, {
+              type: 'codex-response',
+              data: {
+                type: 'item_delta',
+                itemType: textItemInfo.itemType,
+                itemId: textItemInfo.itemId,
+                isReasoning: textItemInfo.isReasoning,
+                delta
+              },
+              sessionId: currentSessionId
+            });
+          }
+
+          if (event.type === 'item.completed') {
+            sendMessage(ws, {
+              type: 'codex-response',
+              data: {
+                type: 'item_done',
+                itemType: textItemInfo.itemType,
+                itemId: textItemInfo.itemId,
+                isReasoning: textItemInfo.isReasoning,
+                content: nextText
+              },
+              sessionId: currentSessionId
+            });
+            streamedTextByItemId.delete(textItemInfo.itemId);
+          }
+
+          continue;
+        }
+
+        // Non-text items can be noisy during started/updated phases.
+        // Keep existing behavior: emit them when completed.
+        if (event.type !== 'item.completed') {
+          continue;
+        }
+      }
+
+      const transformed = transformCodexEvent(event);
+
+      sendMessage(ws, {
+        type: 'codex-response',
+        data: transformed,
+        sessionId: currentSessionId
+      });
+
+      // Extract and send token usage if available (normalized to match Claude format)
+      if (event.type === 'turn.completed' && event.usage) {
+        const tokenBudget = parseCodexTurnUsage(event.usage);
+        sendMessage(ws, {
+          type: 'token-budget',
+          data: tokenBudget,
+          sessionId: currentSessionId
+        });
+      }
+    }
+
+    syncResolvedSessionId(true);
+
+    // Send completion event
+    if (!shouldSendCompletionEvent) {
+      return;
+    }
+
+    const finalSessionId = (typeof thread?.id === 'string' && thread.id.trim())
+      ? thread.id.trim()
+      : currentSessionId;
+
+    currentSessionId = finalSessionId;
+    if (ws?.setSessionId && typeof ws.setSessionId === 'function') {
+      ws.setSessionId(currentSessionId);
+    }
+
+    sendMessage(ws, {
+      type: 'codex-complete',
+      sessionId: currentSessionId,
+      actualSessionId: finalSessionId
+    });
+
+  } 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: timeoutErrorMessage || error.message,
+      sessionId: currentSessionId
+    });
+
+  } finally {
+    clearStartupTimeout();
+    clearMeaningfulEventTimeout();
+    await cleanupMaterializedImages(tempImagePaths, tempImageDir);
+    // Update session status
+    if (currentSessionId) {
+      const session = activeCodexSessions.get(currentSessionId);
+      if (session) {
+        session.status = terminalStatus;
+      }
+    }
+  }
+}
+
+/**
+ * Abort an active Codex session
+ * @param {string} sessionId - Session ID to abort
+ * @returns {boolean} - Whether abort was successful
+ */
+export function abortCodexSession(sessionId) {
+  const session = activeCodexSessions.get(sessionId);
+
+  if (!session) {
+    return false;
+  }
+
+  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
+
+  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;
+}
+
+/**
+ * Helper to send message via WebSocket or writer
+ * @param {WebSocket|object} ws - WebSocket or response writer
+ * @param {object} data - Data to send
+ */
+function sendMessage(ws, data) {
+  try {
+    const isStructuredWriter = !!(
+      ws?.isSSEStreamWriter ||
+      ws?.isWebSocketWriter ||
+      typeof ws?.setSessionId === 'function' ||
+      typeof ws?.getSessionId === 'function'
+    );
+
+    if (isStructuredWriter) {
+      // Internal writers expect plain objects and handle serialization themselves.
+      ws.send(data);
+    } else if (typeof ws.send === 'function') {
+      // Raw WebSocket clients expect a serialized payload.
+      ws.send(JSON.stringify(data));
+    }
+  } catch (error) {
+    console.error('[Codex] Error sending message:', error);
+  }
+}
+
+// Clean up old completed sessions periodically
+setInterval(() => {
+  const now = Date.now();
+  const maxAge = 30 * 60 * 1000; // 30 minutes
+
+  for (const [id, session] of activeCodexSessions.entries()) {
+    if (session.status !== 'running') {
+      const startedAt = new Date(session.startedAt).getTime();
+      if (now - startedAt > maxAge) {
+        activeCodexSessions.delete(id);
+      }
+    }
+  }
+}, 5 * 60 * 1000); // Every 5 minutes