@cloudcli-ai/cloudcli 1.31.5 → 1.33.0

package/server/openai-codex.js

@@ -17,11 +17,40 @@ import { Codex } from '@openai/codex-sdk';
 import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
 import { sessionsService } from './modules/providers/services/sessions.service.js';
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
+import { providerModelsService } from './modules/providers/services/provider-models.service.js';
 import { createNormalizedMessage } from './shared/utils.js';
 
 // Track active sessions
 const activeCodexSessions = new Map();
 
+function readUsageNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function extractCodexTokenBudget(event) {
+  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') {
+    return null;
+  }
+
+  const inputTokens = readUsageNumber(usage.input_tokens);
+  const outputTokens = readUsageNumber(usage.output_tokens);
+  const used = readUsageNumber(usage.total_tokens) || inputTokens + outputTokens;
+
+  return {
+    used,
+    total: readUsageNumber(info?.model_context_window || event?.usage?.model_context_window) || 200000,
+    inputTokens,
+    outputTokens,
+    breakdown: {
+      input: inputTokens,
+      output: outputTokens,
+    },
+  };
+}
+
 /**
  * Transform Codex SDK event to WebSocket message format
  * @param {object} event - SDK event
@@ -143,7 +172,7 @@ function transformCodexEvent(event) {
     case 'thread.started':
       return {
         type: 'thread_started',
-        threadId: event.id
+        threadId: event.thread_id || event.id
       };
 
     case 'error':
@@ -202,12 +231,19 @@ export async function queryCodex(command, options = {}, ws) {
     permissionMode = 'default'
   } = options;
 
+  const resolvedModel = await providerModelsService.resolveResumeModel(
+    'codex',
+    sessionId,
+    model,
+  );
+
   const workingDirectory = cwd || projectPath || process.cwd();
   const { sandboxMode, approvalPolicy } = mapPermissionModeToCodexOptions(permissionMode);
 
   let codex;
   let thread;
-  let currentSessionId = sessionId;
+  let capturedSessionId = sessionId;
+  let sessionCreatedSent = false;
   let terminalFailure = null;
   const abortController = new AbortController();
 
@@ -221,7 +257,7 @@ export async function queryCodex(command, options = {}, ws) {
       skipGitRepoCheck: true,
       sandboxMode,
       approvalPolicy,
-      model
+      model: resolvedModel
     };
 
     // Start or resume thread
@@ -231,20 +267,23 @@ export async function queryCodex(command, options = {}, ws) {
       thread = codex.startThread(threadOptions);
     }
 
-    // Get the thread ID
-    currentSessionId = thread.id || sessionId || `codex-${Date.now()}`;
-
-    // Track the session
-    activeCodexSessions.set(currentSessionId, {
-      thread,
-      codex,
-      status: 'running',
-      abortController,
-      startedAt: new Date().toISOString()
-    });
+    const registerSession = (id) => {
+      if (!id) {
+        return;
+      }
+      activeCodexSessions.set(id, {
+        thread,
+        codex,
+        status: 'running',
+        abortController,
+        startedAt: new Date().toISOString()
+      });
+    };
 
-    // Send session created event
-    sendMessage(ws, createNormalizedMessage({ kind: 'session_created', newSessionId: currentSessionId, sessionId: currentSessionId, provider: 'codex' }));
+    // Existing sessions can be tracked immediately; new sessions are tracked after thread.started.
+    if (capturedSessionId) {
+      registerSession(capturedSessionId);
+    }
 
     // Execute with streaming
     const streamedTurn = await thread.runStreamed(command, {
@@ -252,11 +291,34 @@ export async function queryCodex(command, options = {}, ws) {
     });
 
     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;
+        if (discoveredSessionId && !capturedSessionId) {
+          capturedSessionId = discoveredSessionId;
+          registerSession(capturedSessionId);
+
+          if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+            ws.setSessionId(capturedSessionId);
+          }
+
+          if (!sessionId && !sessionCreatedSent) {
+            sessionCreatedSent = true;
+            sendMessage(ws, createNormalizedMessage({ kind: 'session_created', newSessionId: capturedSessionId, sessionId: capturedSessionId, provider: 'codex' }));
+          }
+        }
+      }
+
       // Check if session was aborted
-      const session = activeCodexSessions.get(currentSessionId);
-      if (!session || session.status === 'aborted') {
+      if (abortController.signal.aborted) {
         break;
       }
+      if (capturedSessionId) {
+        const session = activeCodexSessions.get(capturedSessionId);
+        if (session?.status === 'aborted') {
+          break;
+        }
+      }
 
       if (event.type === 'item.started' || event.type === 'item.updated') {
         continue;
@@ -265,7 +327,7 @@ export async function queryCodex(command, options = {}, ws) {
       const transformed = transformCodexEvent(event);
 
       // Normalize the transformed event into NormalizedMessage(s) via adapter
-      const normalizedMsgs = sessionsService.normalizeMessage('codex', transformed, currentSessionId);
+      const normalizedMsgs = sessionsService.normalizeMessage('codex', transformed, capturedSessionId || sessionId || null);
       for (const msg of normalizedMsgs) {
         sendMessage(ws, msg);
       }
@@ -275,33 +337,40 @@ export async function queryCodex(command, options = {}, ws) {
         notifyRunFailed({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: currentSessionId,
+          sessionId: capturedSessionId || sessionId || null,
           sessionName: sessionSummary,
           error: terminalFailure
         });
       }
 
       // Extract and send token usage if available (normalized to match Claude format)
-      if (event.type === 'turn.completed' && event.usage) {
-        const totalTokens = (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0);
-        sendMessage(ws, createNormalizedMessage({ kind: 'status', text: 'token_budget', tokenBudget: { used: totalTokens, total: 200000 }, sessionId: currentSessionId, provider: 'codex' }));
+      if (event.type === 'turn.completed') {
+        const tokenBudget = extractCodexTokenBudget(event);
+        if (tokenBudget) {
+          sendMessage(ws, createNormalizedMessage({ kind: 'status', text: 'token_budget', tokenBudget, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+        }
       }
     }
 
     // Send completion event
     if (!terminalFailure) {
-      sendMessage(ws, createNormalizedMessage({ kind: 'complete', actualSessionId: thread.id, sessionId: currentSessionId, provider: 'codex' }));
+      sendMessage(ws, createNormalizedMessage({
+        kind: 'complete',
+        actualSessionId: capturedSessionId || thread.id || sessionId || null,
+        sessionId: capturedSessionId || sessionId || null,
+        provider: 'codex'
+      }));
       notifyRunStopped({
         userId: ws?.userId || null,
         provider: 'codex',
-        sessionId: currentSessionId,
+        sessionId: capturedSessionId || sessionId || null,
         sessionName: sessionSummary,
         stopReason: 'completed'
       });
     }
 
   } catch (error) {
-    const session = currentSessionId ? activeCodexSessions.get(currentSessionId) : null;
+    const session = capturedSessionId ? activeCodexSessions.get(capturedSessionId) : null;
     const wasAborted =
       session?.status === 'aborted' ||
       error?.name === 'AbortError' ||
@@ -316,12 +385,12 @@ export async function queryCodex(command, options = {}, ws) {
         ? 'Codex CLI is not configured. Please set up authentication first.'
         : error.message;
 
-      sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: currentSessionId, provider: 'codex' }));
+      sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
       if (!terminalFailure) {
         notifyRunFailed({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: currentSessionId,
+          sessionId: capturedSessionId || sessionId || null,
           sessionName: sessionSummary,
           error
         });
@@ -330,8 +399,8 @@ export async function queryCodex(command, options = {}, ws) {
 
   } finally {
     // Update session status
-    if (currentSessionId) {
-      const session = activeCodexSessions.get(currentSessionId);
+    if (capturedSessionId) {
+      const session = activeCodexSessions.get(capturedSessionId);
       if (session) {
         session.status = session.status === 'aborted' ? 'aborted' : 'completed';
       }

package/server/opencode-cli.js

@@ -0,0 +1,336 @@
+import { spawn } from 'child_process';
+import fsSync from 'node:fs';
+
+import crossSpawn from 'cross-spawn';
+import Database from 'better-sqlite3';
+
+import { sessionsService } from './modules/providers/services/sessions.service.js';
+import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
+import { providerModelsService } from './modules/providers/services/provider-models.service.js';
+import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
+import { createNormalizedMessage, getOpenCodeDatabasePath } from './shared/utils.js';
+
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+const activeOpenCodeProcesses = new Map();
+
+function readOpenCodeSessionId(event) {
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  return event.sessionID || event.sessionId || null;
+}
+
+function readOpenCodeTokenUsage(sessionId) {
+  const dbPath = getOpenCodeDatabasePath();
+  if (!sessionId || !fsSync.existsSync(dbPath)) {
+    return null;
+  }
+
+  let db = null;
+  try {
+    db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    const columns = db.prepare('PRAGMA table_info(session)').all();
+    const columnNames = new Set(columns.map((column) => column.name));
+    const requiredColumns = ['tokens_input', 'tokens_output', 'tokens_reasoning', 'tokens_cache_read', 'tokens_cache_write'];
+    if (!requiredColumns.every((column) => columnNames.has(column))) {
+      return null;
+    }
+
+    const row = db.prepare(`
+      SELECT
+        tokens_input AS inputTokens,
+        tokens_output AS outputTokens,
+        tokens_reasoning AS reasoningTokens,
+        tokens_cache_read AS cacheReadTokens,
+        tokens_cache_write AS cacheWriteTokens
+      FROM session
+      WHERE id = ?
+    `).get(sessionId);
+
+    if (!row) {
+      return null;
+    }
+
+    const inputTokens = Number(row.inputTokens || 0) + Number(row.cacheReadTokens || 0);
+    const outputTokens = Number(row.outputTokens || 0);
+    const used = Number(row.inputTokens || 0)
+      + outputTokens
+      + Number(row.reasoningTokens || 0)
+      + Number(row.cacheReadTokens || 0)
+      + Number(row.cacheWriteTokens || 0);
+    if (used <= 0) {
+      return null;
+    }
+
+    return {
+      used,
+      inputTokens,
+      outputTokens,
+      breakdown: {
+        input: inputTokens,
+        output: outputTokens,
+      },
+    };
+  } catch {
+    return null;
+  } finally {
+    if (db) {
+      db.close();
+    }
+  }
+}
+
+async function spawnOpenCode(command, options = {}, ws) {
+  return new Promise((resolve, reject) => {
+    const { sessionId, projectPath, cwd, model, sessionSummary } = options;
+    const workingDir = cwd || projectPath || process.cwd();
+    const processKey = sessionId || Date.now().toString();
+    let capturedSessionId = sessionId || null;
+    let sessionCreatedSent = false;
+    let stdoutLineBuffer = '';
+    let terminalNotificationSent = false;
+    let opencodeProcess = null;
+
+    const notifyTerminalState = ({ code = null, error = null } = {}) => {
+      if (terminalNotificationSent) {
+        return;
+      }
+
+      terminalNotificationSent = true;
+      const finalSessionId = capturedSessionId || sessionId || processKey;
+      if (code === 0 && !error) {
+        notifyRunStopped({
+          userId: ws?.userId || null,
+          provider: 'opencode',
+          sessionId: finalSessionId,
+          sessionName: sessionSummary,
+          stopReason: 'completed',
+        });
+        return;
+      }
+
+      notifyRunFailed({
+        userId: ws?.userId || null,
+        provider: 'opencode',
+        sessionId: finalSessionId,
+        sessionName: sessionSummary,
+        error: error || `OpenCode CLI exited with code ${code}`,
+      });
+    };
+
+    const registerSession = (nextSessionId) => {
+      if (!nextSessionId || capturedSessionId === nextSessionId) {
+        return;
+      }
+
+      capturedSessionId = nextSessionId;
+      if (processKey !== capturedSessionId && opencodeProcess) {
+        activeOpenCodeProcesses.delete(processKey);
+        activeOpenCodeProcesses.set(capturedSessionId, opencodeProcess);
+      }
+      if (opencodeProcess) {
+        opencodeProcess.sessionId = capturedSessionId;
+      }
+
+      if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+        ws.setSessionId(capturedSessionId);
+      }
+
+      if (!sessionId && !sessionCreatedSent) {
+        sessionCreatedSent = true;
+        ws.send(createNormalizedMessage({
+          kind: 'session_created',
+          newSessionId: capturedSessionId,
+          sessionId: capturedSessionId,
+          provider: 'opencode',
+        }));
+      }
+    };
+
+    const processOpenCodeOutputLine = (line) => {
+      if (!line || !line.trim()) {
+        return;
+      }
+
+      let response;
+      try {
+        response = JSON.parse(line);
+      } catch {
+        ws.send(createNormalizedMessage({
+          kind: 'stream_delta',
+          content: line,
+          sessionId: capturedSessionId || sessionId || null,
+          provider: 'opencode',
+        }));
+        return;
+      }
+
+      try {
+        registerSession(readOpenCodeSessionId(response));
+        const normalized = sessionsService.normalizeMessage(
+          'opencode',
+          response,
+          capturedSessionId || sessionId || null,
+        );
+        for (const msg of normalized) {
+          ws.send(msg);
+        }
+      } catch (error) {
+        const errorContent = error instanceof Error ? error.message : String(error);
+        console.error('[OpenCode] Failed to process JSON output:', errorContent);
+        ws.send(createNormalizedMessage({
+          kind: 'error',
+          content: errorContent,
+          sessionId: capturedSessionId || sessionId || null,
+          provider: 'opencode',
+        }));
+      }
+    };
+
+    void providerModelsService.resolveResumeModel('opencode', sessionId, model).then((resolvedModel) => {
+      const args = ['run', '--format', 'json'];
+      if (sessionId) {
+        args.push('--session', sessionId);
+      }
+      if (resolvedModel) {
+        args.push('--model', resolvedModel);
+      }
+      if (command && command.trim()) {
+        args.push(command.trim());
+      }
+
+      opencodeProcess = spawnFunction('opencode', args, {
+        cwd: workingDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env },
+      });
+
+      activeOpenCodeProcesses.set(processKey, opencodeProcess);
+      opencodeProcess.sessionId = processKey;
+      opencodeProcess.stdin.end();
+
+      opencodeProcess.stdout.on('data', (data) => {
+        stdoutLineBuffer += data.toString();
+        const completeLines = stdoutLineBuffer.split(/\r?\n/);
+        stdoutLineBuffer = completeLines.pop() || '';
+
+        completeLines.forEach((line) => {
+          processOpenCodeOutputLine(line.trim());
+        });
+      });
+
+      opencodeProcess.stderr.on('data', (data) => {
+        const stderrText = data.toString();
+        if (!stderrText.trim()) {
+          return;
+        }
+
+        ws.send(createNormalizedMessage({
+          kind: 'error',
+          content: stderrText,
+          sessionId: capturedSessionId || sessionId || null,
+          provider: 'opencode',
+        }));
+      });
+
+      opencodeProcess.on('close', async (code) => {
+        const finalSessionId = capturedSessionId || sessionId || processKey;
+        activeOpenCodeProcesses.delete(finalSessionId);
+        activeOpenCodeProcesses.delete(processKey);
+
+        if (stdoutLineBuffer.trim()) {
+          processOpenCodeOutputLine(stdoutLineBuffer.trim());
+          stdoutLineBuffer = '';
+        }
+
+        const tokenBudget = readOpenCodeTokenUsage(finalSessionId);
+        if (tokenBudget) {
+          ws.send(createNormalizedMessage({
+            kind: 'status',
+            text: 'token_budget',
+            tokenBudget,
+            sessionId: finalSessionId,
+            provider: 'opencode',
+          }));
+        }
+
+        ws.send(createNormalizedMessage({
+          kind: 'complete',
+          exitCode: code,
+          isNewSession: !sessionId && !!command,
+          sessionId: finalSessionId,
+          provider: 'opencode',
+        }));
+
+        if (code === 0) {
+          notifyTerminalState({ code });
+          resolve();
+          return;
+        }
+
+        if (code === 127 || code === null) {
+          const installed = await providerAuthService.isProviderInstalled('opencode');
+          if (!installed) {
+            ws.send(createNormalizedMessage({
+              kind: 'error',
+              content: 'OpenCode CLI is not installed. Install it from https://opencode.ai/docs/',
+              sessionId: finalSessionId,
+              provider: 'opencode',
+            }));
+          }
+        }
+
+        notifyTerminalState({ code });
+        reject(new Error(code === null ? 'OpenCode CLI process was terminated' : `OpenCode CLI exited with code ${code}`));
+      });
+
+      opencodeProcess.on('error', async (error) => {
+        const finalSessionId = capturedSessionId || sessionId || processKey;
+        activeOpenCodeProcesses.delete(finalSessionId);
+        activeOpenCodeProcesses.delete(processKey);
+
+        const installed = await providerAuthService.isProviderInstalled('opencode');
+        const errorContent = !installed
+          ? 'OpenCode CLI is not installed. Install it from https://opencode.ai/docs/'
+          : error.message;
+
+        ws.send(createNormalizedMessage({
+          kind: 'error',
+          content: errorContent,
+          sessionId: finalSessionId,
+          provider: 'opencode',
+        }));
+        notifyTerminalState({ error });
+        reject(error);
+      });
+    }).catch(reject);
+  });
+}
+
+function abortOpenCodeSession(sessionId) {
+  const process = activeOpenCodeProcesses.get(sessionId);
+  if (!process) {
+    return false;
+  }
+
+  process.kill('SIGTERM');
+  activeOpenCodeProcesses.delete(sessionId);
+  return true;
+}
+
+function isOpenCodeSessionActive(sessionId) {
+  return activeOpenCodeProcesses.has(sessionId);
+}
+
+function getActiveOpenCodeSessions() {
+  return Array.from(activeOpenCodeProcesses.keys());
+}
+
+export {
+  spawnOpenCode,
+  abortOpenCodeSession,
+  isOpenCodeSessionActive,
+  getActiveOpenCodeSessions,
+};

package/server/opencode-cli.test.js

@@ -0,0 +1,95 @@
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { spawnOpenCode } from './opencode-cli.js';
+
+const findEnvKey = (name) =>
+  Object.keys(process.env).find((key) => key.toLowerCase() === name.toLowerCase()) || name;
+
+async function createFakeOpenCodeExecutable(binDir) {
+  const scriptPath = path.join(binDir, 'opencode.js');
+  await writeFile(scriptPath, `
+const events = [
+  { type: 'text', sessionID: 'open-live-1', text: 'assistant response' },
+  { type: 'step_finish', sessionID: 'open-live-1' },
+];
+
+for (const event of events) {
+  console.log(JSON.stringify(event));
+}
+`, 'utf8');
+
+  if (process.platform === 'win32') {
+    const commandPath = path.join(binDir, 'opencode.cmd');
+    await writeFile(commandPath, '@echo off\r\nnode "%~dp0opencode.js" %*\r\n', 'utf8');
+    return;
+  }
+
+  const commandPath = path.join(binDir, 'opencode');
+  await writeFile(commandPath, '#!/bin/sh\nnode "$(dirname "$0")/opencode.js" "$@"\n', 'utf8');
+  await chmod(commandPath, 0o755);
+}
+
+test('spawnOpenCode emits session_created before normalized live messages for new sessions', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'opencode-cli-live-'));
+  const pathKey = findEnvKey('PATH');
+  const pathExtKey = findEnvKey('PATHEXT');
+  const previousPath = process.env[pathKey];
+  const previousPathExt = process.env[pathExtKey];
+  const messages = [];
+  const writer = {
+    userId: null,
+    sessionId: null,
+    send(message) {
+      messages.push(message);
+    },
+    setSessionId(sessionId) {
+      this.sessionId = sessionId;
+    },
+  };
+
+  try {
+    await createFakeOpenCodeExecutable(tempRoot);
+    process.env[pathKey] = `${tempRoot}${path.delimiter}${previousPath || ''}`;
+    if (process.platform === 'win32') {
+      process.env[pathExtKey] = previousPathExt?.toUpperCase().includes('.CMD')
+        ? previousPathExt
+        : `.COM;.EXE;.BAT;.CMD${previousPathExt ? `;${previousPathExt}` : ''}`;
+    }
+
+    await spawnOpenCode('Hi', { cwd: tempRoot }, writer);
+
+    const sessionCreatedIndex = messages.findIndex((message) => message.kind === 'session_created');
+    const assistantDeltaIndex = messages.findIndex((message) =>
+      message.kind === 'stream_delta' && message.content === 'assistant response',
+    );
+    const streamEnd = messages.find((message) => message.kind === 'stream_end');
+    const complete = messages.find((message) => message.kind === 'complete');
+
+    assert.notEqual(sessionCreatedIndex, -1);
+    assert.notEqual(assistantDeltaIndex, -1);
+    assert.ok(sessionCreatedIndex < assistantDeltaIndex);
+    assert.equal(messages[sessionCreatedIndex].newSessionId, 'open-live-1');
+    assert.equal(writer.sessionId, 'open-live-1');
+    assert.equal(streamEnd?.sessionId, 'open-live-1');
+    assert.equal(complete?.sessionId, 'open-live-1');
+    assert.equal(messages.some((message) => message.kind === 'error'), false);
+  } finally {
+    if (previousPath === undefined) {
+      delete process.env[pathKey];
+    } else {
+      process.env[pathKey] = previousPath;
+    }
+
+    if (previousPathExt === undefined) {
+      delete process.env[pathExtKey];
+    } else {
+      process.env[pathExtKey] = previousPathExt;
+    }
+
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});