@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/modules/providers/list/codex/codex-models.provider.ts

@@ -6,24 +6,69 @@ import TOML from '@iarna/toml';
 
 import type { IProviderModels } from '@/shared/interfaces.js';
 import type {
-  ProviderChangeActiveModelInput,
   ProviderCurrentActiveModel,
-  ProviderModelOption,
   ProviderModelsDefinition,
-  ProviderSessionActiveModelChange,
 } from '@/shared/types.js';
 import {
   buildDefaultProviderCurrentActiveModel,
   readObjectRecord,
   readOptionalString,
-  writeProviderSessionActiveModelChange,
 } from '@/shared/utils.js';
 
-export const CODEX_FALLBACK_MODELS: ProviderModelsDefinition = {
+/** Curated Codex catalog shipped as immutable CloudCLI defaults. */
+export const CODEX_PREDEFINED_MODELS: ProviderModelsDefinition = {
   OPTIONS: [
+    {
+      value: 'gpt-5.6-sol',
+      label: 'GPT-5.6 Sol',
+      description: 'Latest frontier agentic coding model.',
+      effort: {
+        default: 'low',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+          { value: 'ultra' },
+        ],
+      },
+    },
+    {
+      value: 'gpt-5.6-terra',
+      label: 'GPT-5.6 Terra',
+      description: 'Balanced agentic coding model for everyday work.',
+      effort: {
+        default: 'medium',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+          { value: 'ultra' },
+        ],
+      },
+    },
+    {
+      value: 'gpt-5.6-luna',
+      label: 'GPT-5.6 Luna',
+      description: 'Fast and affordable agentic coding model.',
+      effort: {
+        default: 'medium',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+        ],
+      },
+    },
     {
       value: 'gpt-5.5',
-      label: 'gpt-5.5',
+      label: 'GPT-5.5',
+      description: 'Frontier model for complex coding, research, and real-world work.',
       effort: {
         default: 'medium',
         values: [{ value: 'low' }, { value: 'medium' }, { value: 'high' }, { value: 'xhigh' }],
@@ -31,7 +76,8 @@ export const CODEX_FALLBACK_MODELS: ProviderModelsDefinition = {
     },
     {
       value: 'gpt-5.4',
-      label: 'gpt-5.4',
+      label: 'GPT-5.4',
+      description: 'Strong model for everyday coding.',
       effort: {
         default: 'medium',
         values: [{ value: 'low' }, { value: 'medium' }, { value: 'high' }, { value: 'xhigh' }],
@@ -39,113 +85,23 @@ export const CODEX_FALLBACK_MODELS: ProviderModelsDefinition = {
     },
     {
       value: 'gpt-5.4-mini',
-      label: 'gpt-5.4-mini',
+      label: 'GPT-5.4 Mini',
+      description: 'Small, fast, and cost-efficient model for simpler coding tasks.',
       effort: {
         default: 'medium',
         values: [{ value: 'low' }, { value: 'medium' }, { value: 'high' }, { value: 'xhigh' }],
       },
     },
   ],
-  DEFAULT: 'gpt-5.4',
-};
-
-type CodexCachedModel = {
-  slug?: string;
-  display_name?: string;
-  description?: string;
-  priority?: number;
-  visibility?: string;
-  supported_in_api?: boolean;
-  default_reasoning_level?: string;
-  supported_reasoning_levels?: Array<{
-    effort?: string;
-    description?: string;
-  }>;
+  DEFAULT: 'gpt-5.6-sol',
 };
 
-const CODEX_MODELS_CACHE_PATH = path.join(os.homedir(), '.codex', 'models_cache.json');
 const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
 
-const isCodexCachedModel = (value: unknown): value is CodexCachedModel => {
-  const record = readObjectRecord(value);
-  return Boolean(record && readOptionalString(record.slug));
-};
-
-const readCodexPriority = (value: unknown): number => (
-  typeof value === 'number' && Number.isFinite(value) ? value : Number.MAX_SAFE_INTEGER
-);
-
-const mapCodexModel = (model: CodexCachedModel): ProviderModelOption => {
-  const effortValues = Array.isArray(model.supported_reasoning_levels)
-    ? model.supported_reasoning_levels
-      .map((level) => {
-        const value = readOptionalString(level?.effort);
-        if (!value) {
-          return null;
-        }
-
-        return {
-          value,
-          description: readOptionalString(level?.description),
-        };
-      })
-      .filter((level): level is NonNullable<typeof level> => Boolean(level))
-    : [];
-
-  return {
-    value: model.slug as string,
-    label: readOptionalString(model.display_name) ?? (model.slug as string),
-    description: readOptionalString(model.description),
-    effort: effortValues.length > 0
-      ? {
-          default: readOptionalString(model.default_reasoning_level) ?? undefined,
-          values: effortValues,
-        }
-      : undefined,
-  };
-};
-
-const buildCodexModelsDefinition = (models: CodexCachedModel[]): ProviderModelsDefinition => {
-  const sortedModels = [...models]
-    .filter((model) => model.visibility === 'list' && model.supported_in_api !== false)
-    .sort((left, right) => readCodexPriority(left.priority) - readCodexPriority(right.priority));
-
-  const options: ProviderModelOption[] = [];
-  const seenValues = new Set<string>();
-
-  for (const model of sortedModels) {
-    const mappedModel = mapCodexModel(model);
-    if (seenValues.has(mappedModel.value)) {
-      continue;
-    }
-
-    seenValues.add(mappedModel.value);
-    options.push(mappedModel);
-  }
-
-  if (options.length === 0) {
-    return CODEX_FALLBACK_MODELS;
-  }
-
-  return {
-    OPTIONS: options,
-    DEFAULT: options[0]?.value ?? CODEX_FALLBACK_MODELS.DEFAULT,
-  };
-};
-
+/** Provider registry model adapter for Codex predefined models and active config. */
 export class CodexProviderModels implements IProviderModels {
   async getSupportedModels(): Promise<ProviderModelsDefinition> {
-    try {
-      const raw = await readFile(CODEX_MODELS_CACHE_PATH, 'utf8');
-      const parsed = readObjectRecord(JSON.parse(raw));
-      const models = Array.isArray(parsed?.models)
-        ? parsed.models.filter(isCodexCachedModel)
-        : [];
-
-      return buildCodexModelsDefinition(models);
-    } catch {
-      return CODEX_FALLBACK_MODELS;
-    }
+    return CODEX_PREDEFINED_MODELS;
   }
 
   async getCurrentActiveModel(): Promise<ProviderCurrentActiveModel> {
@@ -164,10 +120,4 @@ export class CodexProviderModels implements IProviderModels {
       return buildDefaultProviderCurrentActiveModel(await this.getSupportedModels());
     }
   }
-
-  async changeActiveModel(
-    input: ProviderChangeActiveModelInput,
-  ): Promise<ProviderSessionActiveModelChange> {
-    return writeProviderSessionActiveModelChange('codex', input);
-  }
 }

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

@@ -3,11 +3,11 @@
  * =============================
  *
  * 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.
+ * chat sessions. It mirrors the Claude runtime adapter for consistency.
  *
  * ## Usage
  *
- * - queryCodex(command, options, ws) - Execute a prompt with streaming via WebSocket
+ * - 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
@@ -15,12 +15,13 @@
 
 import { Codex } from '@openai/codex-sdk';
 
-import { buildCodexInputItems, normalizeImageDescriptors } from './shared/image-attachments.js';
-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 { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';
+import {
+  appendFilesInputTag,
+  buildCodexInputItems,
+  normalizeImageDescriptors
+} from '@/shared/image-attachments.js';
+import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
+import { createCompleteMessage, createNormalizedMessage } from '@/shared/utils.js';
 
 const activeCodexSessions = new Map();
 
@@ -222,7 +223,7 @@ 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) {
+export async function queryCodex(command, options = {}, ws, context) {
   const {
     sessionId,
     sessionSummary,
@@ -231,18 +232,19 @@ export async function queryCodex(command, options = {}, ws) {
     model,
     effort,
     images,
+    files,
     permissionMode = 'default'
   } = options;
 
-  const resolvedModel = await providerModelsService.resolveResumeModel(
-    'codex',
-    sessionId,
-    model,
-  );
+  // Callers pass the stable app session id; the SDK resumes threads with the
+  // provider-native id recorded on the session row.
+  const providerSessionId = context.resolveProviderSessionId(sessionId);
+
+  const resolvedModel = await context.resolveResumeModel(sessionId, model);
 
   const workingDirectory = cwd || projectPath || process.cwd();
   const { sandboxMode, approvalPolicy } = mapPermissionModeToCodexOptions(permissionMode);
-  const catalog = (await providerModelsService.getProviderModels('codex')).models;
+  const catalog = await context.getProviderModels();
   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)
@@ -251,10 +253,15 @@ export async function queryCodex(command, options = {}, ws) {
 
   let codex;
   let thread;
-  let capturedSessionId = sessionId;
+  // 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;
   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).
+  const sessionKey = () => sessionId || capturedSessionId || null;
 
   try {
     codex = new Codex();
@@ -268,8 +275,8 @@ export async function queryCodex(command, options = {}, ws) {
       modelReasoningEffort: resolvedEffort,
     };
 
-    if (sessionId) {
-      thread = codex.resumeThread(sessionId, threadOptions);
+    if (providerSessionId) {
+      thread = codex.resumeThread(providerSessionId, threadOptions);
     } else {
       thread = codex.startThread(threadOptions);
     }
@@ -287,15 +294,16 @@ export async function queryCodex(command, options = {}, ws) {
       });
     };
 
-    if (capturedSessionId) {
-      registerSession(capturedSessionId);
+    if (sessionKey()) {
+      registerSession(sessionKey());
     }
 
     // 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(command, images, workingDirectory)
-      : command;
+      ? buildCodexInputItems(promptWithFiles, images, workingDirectory)
+      : promptWithFiles;
     const streamedTurn = await thread.runStreamed(turnInput, {
       signal: abortController.signal
     });
@@ -306,13 +314,13 @@ export async function queryCodex(command, options = {}, ws) {
         const discoveredSessionId = event.thread_id || event.id || null;
         if (discoveredSessionId && !capturedSessionId) {
           capturedSessionId = discoveredSessionId;
-          registerSession(capturedSessionId);
+          registerSession(sessionKey());
 
           if (ws.setSessionId && typeof ws.setSessionId === 'function') {
             ws.setSessionId(capturedSessionId);
           }
 
-          if (!sessionId && !sessionCreatedSent) {
+          if (!providerSessionId && !sessionCreatedSent) {
             sessionCreatedSent = true;
             sendMessage(ws, createNormalizedMessage({ kind: 'session_created', newSessionId: capturedSessionId, sessionId: capturedSessionId, provider: 'codex' }));
           }
@@ -323,8 +331,8 @@ export async function queryCodex(command, options = {}, ws) {
       if (abortController.signal.aborted) {
         break;
       }
-      if (capturedSessionId) {
-        const session = activeCodexSessions.get(capturedSessionId);
+      if (sessionKey()) {
+        const session = activeCodexSessions.get(sessionKey());
         if (session?.status === 'aborted') {
           break;
         }
@@ -337,17 +345,18 @@ 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, capturedSessionId || sessionId || null);
+      const normalizedMsgs = context.normalizeMessage(transformed, capturedSessionId || sessionId || null);
       for (const msg of normalizedMsgs) {
         sendMessage(ws, msg);
       }
 
       if (event.type === 'turn.failed' && !terminalFailure) {
         terminalFailure = event.error || new Error('Turn failed');
+        // Notifications are app-facing, so they carry the app session id.
         notifyRunFailed({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: capturedSessionId || sessionId || null,
+          sessionId: sessionId || capturedSessionId || null,
           sessionName: sessionSummary,
           error: terminalFailure
         });
@@ -364,7 +373,7 @@ export async function queryCodex(command, options = {}, ws) {
 
     // Send the terminal completion event — skipped for aborted runs, whose
     // terminal `complete` (aborted: true) was already sent by abort-session.
-    const runSession = capturedSessionId ? activeCodexSessions.get(capturedSessionId) : null;
+    const runSession = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
     const runAborted = runSession?.status === 'aborted' || abortController.signal.aborted;
     if (!runAborted) {
       sendMessage(ws, createCompleteMessage({
@@ -377,7 +386,7 @@ export async function queryCodex(command, options = {}, ws) {
         notifyRunStopped({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: capturedSessionId || sessionId || null,
+          sessionId: sessionId || capturedSessionId || null,
           sessionName: sessionSummary,
           stopReason: 'completed'
         });
@@ -385,7 +394,7 @@ export async function queryCodex(command, options = {}, ws) {
     }
 
   } catch (error) {
-    const session = capturedSessionId ? activeCodexSessions.get(capturedSessionId) : null;
+    const session = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
     const wasAborted =
       session?.status === 'aborted' ||
       error?.name === 'AbortError' ||
@@ -395,7 +404,7 @@ export async function queryCodex(command, options = {}, ws) {
       console.error('[Codex] Error:', error);
 
       // Check if Codex SDK is available for a clearer error message
-      const installed = await providerAuthService.isProviderInstalled('codex');
+      const installed = await context.isProviderInstalled();
       const errorContent = !installed
         ? 'Codex CLI is not configured. Please set up authentication first.'
         : error.message;
@@ -410,7 +419,7 @@ export async function queryCodex(command, options = {}, ws) {
         notifyRunFailed({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: capturedSessionId || sessionId || null,
+          sessionId: sessionId || capturedSessionId || null,
           sessionName: sessionSummary,
           error
         });
@@ -419,8 +428,8 @@ export async function queryCodex(command, options = {}, ws) {
 
   } finally {
     // Update session status
-    if (capturedSessionId) {
-      const session = activeCodexSessions.get(capturedSessionId);
+    if (sessionKey()) {
+      const session = activeCodexSessions.get(sessionKey());
       if (session) {
         session.status = session.status === 'aborted' ? 'aborted' : 'completed';
       }
@@ -480,6 +489,11 @@ export function getActiveCodexSessions() {
   return sessions;
 }
 
+export const codexRuntime = {
+  run: queryCodex,
+  abort: abortCodexSession,
+};
+
 /**
  * Helper to send message via WebSocket or writer
  * @param {WebSocket|object} ws - WebSocket or response writer
@@ -500,7 +514,7 @@ function sendMessage(ws, data) {
 }
 
 // Clean up old completed sessions periodically
-setInterval(() => {
+const completedSessionCleanupTimer = setInterval(() => {
   const now = Date.now();
   const maxAge = 30 * 60 * 1000; // 30 minutes
 
@@ -513,3 +527,7 @@ setInterval(() => {
     }
   }
 }, 5 * 60 * 1000); // Every 5 minutes
+
+// Runtime cleanup should not keep focused tests or one-off scripts alive after
+// their provider work has completed.
+completedSessionCleanupTimer.unref?.();

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

@@ -134,23 +134,7 @@ export class CodexSessionSynchronizer implements IProviderSessionSynchronizer {
       };
     }
 
-    // Sessions started by sending a message from cloudcli carry a distinct
-    // app-allocated session_id mapped to the provider id. For these we title the
-    // conversation from the first user message the user typed, instead of the
-    // generic "Untitled Codex Session" placeholder. Sessions discovered purely
-    // by indexing (session_id === provider_session_id) keep the existing
-    // thread_name/last-agent-message setup below.
-    const isAppCreated =
-      existingSession != null &&
-      existingSession.provider_session_id != null &&
-      existingSession.session_id !== existingSession.provider_session_id;
-
-    let sessionName = isAppCreated
-      ? await this.extractFirstUserMessageFromStart(filePath)
-      : undefined;
-    if (!sessionName) {
-      sessionName = nameMap.get(parsed.sessionId);
-    }
+    let sessionName = nameMap.get(parsed.sessionId);
     if (!sessionName) {
       sessionName = await this.extractLastAgentMessageFromEnd(filePath);
     }
@@ -180,49 +164,6 @@ export class CodexSessionSynchronizer implements IProviderSessionSynchronizer {
     return typeof source === 'object' && source !== null && 'subagent' in source;
   }
 
-  /**
-   * Returns the first user message text in a Codex transcript, used to title
-   * app-created sessions from the prompt the user sent from cloudcli.
-   *
-   * Reads the `event_msg`/`user_message` payload rather than the raw
-   * `response_item` user turn so injected `<environment_context>` boilerplate is
-   * never mistaken for the user's prompt.
-   */
-  private async extractFirstUserMessageFromStart(filePath: string): Promise<string | undefined> {
-    try {
-      const content = await readFile(filePath, 'utf8');
-      const lines = content.split(/\r?\n/);
-
-      for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (!line) {
-          continue;
-        }
-
-        let parsed: unknown;
-        try {
-          parsed = JSON.parse(line);
-        } catch {
-          continue;
-        }
-
-        const data = parsed as Record<string, unknown>;
-        const eventType = typeof data.type === 'string' ? data.type : undefined;
-        const payload = data.payload as Record<string, unknown> | undefined;
-        const payloadType = typeof payload?.type === 'string' ? payload.type : undefined;
-        const message = typeof payload?.message === 'string' ? payload.message : undefined;
-
-        if (eventType === 'event_msg' && payloadType === 'user_message' && message?.trim()) {
-          return message;
-        }
-      }
-    } catch {
-      // Ignore missing/unreadable files so sync can continue.
-    }
-
-    return undefined;
-  }
-
   private async extractLastAgentMessageFromEnd(filePath: string): Promise<string | undefined> {
     try {
       const content = await readFile(filePath, 'utf8');