@axhub/genie 0.1.8 → 0.2.0

package/server/openai-codex.js

@@ -15,9 +15,18 @@
 
 import { Codex } from '@openai/codex-sdk';
 import { parseCodexTurnUsage } from './utils/codexTokenUsage.js';
+import { getCodexPathOverride } 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
@@ -233,10 +242,11 @@ export async function queryCodex(command, options = {}, ws) {
     projectPath,
     model,
     permissionMode = 'default',
-    modelReasoningEffort
+    modelReasoningEffort,
+    images
   } = options;
 
-  const workingDirectory = cwd || projectPath || process.cwd();
+  const workingDirectory = resolveWorkingDirectory({ cwd, projectPath });
   const { sandboxMode, approvalPolicy } = mapPermissionModeToCodexOptions(permissionMode);
 
   let codex;
@@ -244,6 +254,75 @@ 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;
+  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()
@@ -283,7 +362,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 = {
@@ -304,6 +385,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);
@@ -313,22 +395,45 @@ 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();
+
+    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) {
@@ -341,6 +446,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;
       }
 
@@ -423,6 +560,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;
@@ -441,18 +582,28 @@ 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();
+    await cleanupMaterializedImages(tempImagePaths, tempImageDir);
     // Update session status
     if (currentSessionId) {
       const session = activeCodexSessions.get(currentSessionId);
       if (session) {
-        session.status = 'completed';
+        session.status = terminalStatus;
       }
     }
   }
@@ -471,6 +622,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

package/server/opencode-cli.js

@@ -6,6 +6,7 @@ import fetch from 'node-fetch';
 import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
+import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
 
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 
@@ -295,7 +296,7 @@ async function requestJson(baseUrl, path, { method = 'GET', headers = {}, body,
 
 export async function listOpencodeModels(options = {}) {
   const { cwd, projectPath } = options;
-  const workingDir = cwd || projectPath || process.cwd();
+  const workingDir = resolveWorkingDirectory({ cwd, projectPath });
   let server = null;
 
   try {
@@ -536,7 +537,7 @@ export async function queryOpencode(command, options = {}, ws) {
     permissionMode = 'default'
   } = options;
 
-  const workingDir = cwd || projectPath || process.cwd();
+  const workingDir = resolveWorkingDirectory({ cwd, projectPath });
   const abortController = new AbortController();
   let server = null;
   let resolvedSessionId = sessionId || null;