@cloudcli-ai/cloudcli 1.32.0 → 1.33.1

package/server/modules/providers/list/claude/claude-auth.provider.ts

@@ -16,6 +16,10 @@ type ClaudeCredentialsStatus = {
   error?: string;
 };
 
+const hasErrorCode = (error: unknown, code: string): boolean => (
+  error instanceof Error && 'code' in error && error.code === code
+);
+
 export class ClaudeProviderAuth implements IProviderAuth {
   /**
    * Checks whether the Claude Code CLI is available on this host.
@@ -77,6 +81,12 @@ export class ClaudeProviderAuth implements IProviderAuth {
    * Checks Claude credentials in the same priority order used by Claude Code.
    */
   private async checkCredentials(): Promise<ClaudeCredentialsStatus> {
+    const missingCredentialsError = 'Claude CLI is not authenticated. Run claude /login or configure ANTHROPIC_API_KEY.';
+
+    if (process.env.ANTHROPIC_AUTH_TOKEN?.trim()) {
+      return { authenticated: true, email: 'Auth Token', method: 'api_key' };
+    }
+
     if (process.env.ANTHROPIC_API_KEY?.trim()) {
       return { authenticated: true, email: 'API Key Auth', method: 'api_key' };
     }
@@ -110,15 +120,33 @@ export class ClaudeProviderAuth implements IProviderAuth {
 
         return {
           authenticated: false,
-          email,
-          method: 'credentials_file',
-          error: 'OAuth token has expired. Please re-authenticate with claude login',
+          email: null,
+          method: null,
+          error: 'Claude login has expired. Run claude /login again.',
         };
       }
 
-      return { authenticated: false, email: null, method: null };
-    } catch {
-      return { authenticated: false, email: null, method: null };
+      return {
+        authenticated: false,
+        email: null,
+        method: null,
+        error: missingCredentialsError,
+      };
+    } catch (error) {
+      let errorMessage = 'Unable to read Claude credentials. Run claude /login again.';
+
+      if (hasErrorCode(error, 'ENOENT')) {
+        errorMessage = missingCredentialsError;
+      } else if (error instanceof SyntaxError) {
+        errorMessage = 'Claude credentials are unreadable. Run claude /login again.';
+      }
+
+      return {
+        authenticated: false,
+        email: null,
+        method: null,
+        error: errorMessage,
+      };
     }
   }
 }

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

@@ -0,0 +1,196 @@
+import { readFile } from 'node:fs/promises';
+
+import { sessionsDb } from '@/modules/database/index.js';
+import type { IProviderModels } from '@/shared/interfaces.js';
+import type {
+  ProviderChangeActiveModelInput,
+  ProviderCurrentActiveModel,
+  ProviderModelsDefinition,
+  ProviderSessionActiveModelChange,
+} from '@/shared/types.js';
+import {
+  buildDefaultProviderCurrentActiveModel,
+  writeProviderSessionActiveModelChange,
+} from '@/shared/utils.js';
+
+export const CLAUDE_FALLBACK_MODELS: ProviderModelsDefinition = {
+  OPTIONS: [
+    {
+      value: 'default',
+      label: 'Default (recommended)',
+      description: 'Use the default model (currently Opus 4.8 (1M context)) · $5/$25 per Mtok',
+    },
+    {
+      value: "sonnet",
+      label: "Sonnet",
+      description: "Sonnet 4.6 · Best for everyday tasks · $3/$15 per Mtok",
+    },
+    {
+      value: 'sonnet[1m]',
+      label: 'Sonnet (1M context)',
+      description: 'Sonnet 4.6 for long sessions · $3/$15 per Mtok',
+    },
+    {
+      value: 'opus[1m]',
+      label: 'Opus 4.8 (1M context)',
+      description: 'Opus 4.8 with 1M context · Most capable for complex work · $5/$25 per Mtok',
+    },
+    {
+      value: 'haiku',
+      label: 'Haiku',
+      description: 'Haiku 4.5 · Fastest for quick answers · $1/$5 per Mtok',
+    },
+  ],
+  DEFAULT: 'default',
+};
+type ClaudeInitEvent = {
+  sessionId?: string;
+  session_id?: string;
+  type?: string;
+  subtype?: string;
+  model?: string;
+  message?: {
+    content?: unknown;
+    model?: string;
+  };
+};
+
+const ANSI_PATTERN = new RegExp(
+  '[\\u001B\\u009B][[\\]()#;?]*(?:'
+  + '(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]'
+  + '|(?:[\\dA-PR-TZcf-ntqry=><~]))',
+  'g',
+);
+
+const extractClaudeEventModel = (event: ClaudeInitEvent, sessionId: string): string | null => {
+  const eventSessionId = event.sessionId ?? event.session_id;
+  if (eventSessionId && eventSessionId !== sessionId) {
+    return null;
+  }
+
+  const contentModel = extractClaudeModelFromMessageContent(event.message?.content);
+  if (contentModel) {
+    return contentModel;
+  }
+
+  const directModel = event.model?.trim();
+  if (directModel) {
+    return directModel;
+  }
+
+  const messageModel = event.message?.model?.trim();
+  return messageModel || null;
+};
+
+const stripAnsi = (value: string): string => value.replace(ANSI_PATTERN, '');
+
+const extractTaggedContent = (content: string, tagName: string): string | null => {
+  const escapedTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = new RegExp(`<${escapedTagName}>([\\s\\S]*?)<\\/${escapedTagName}>`).exec(content);
+  return match ? match[1] : null;
+};
+
+const extractClaudeModelFromTextContent = (content: string): string | null => {
+  const localCommandStdout = extractTaggedContent(content, 'local-command-stdout');
+  if (localCommandStdout !== null) {
+    const cleanedStdout = stripAnsi(localCommandStdout).replace(/\s+/g, ' ').trim();
+    const changedModel = /(?:set|changed|switched)\s+model\s+to\s+(.+?)\.?$/i.exec(cleanedStdout);
+    if (changedModel?.[1]?.trim()) {
+      return changedModel[1].trim();
+    }
+  }
+
+  const modelTag = extractTaggedContent(content, 'model')?.trim();
+  return modelTag || null;
+};
+
+const extractClaudeModelFromMessageContent = (content: unknown): string | null => {
+  if (typeof content === 'string') {
+    return extractClaudeModelFromTextContent(content);
+  }
+
+  if (!Array.isArray(content)) {
+    return null;
+  }
+
+  for (const part of content) {
+    if (!part || typeof part !== 'object' || !('text' in part) || typeof part.text !== 'string') {
+      continue;
+    }
+
+    const model = extractClaudeModelFromTextContent(part.text);
+    if (model) {
+      return model;
+    }
+  }
+
+  return null;
+};
+
+const readClaudeSessionModelFromJsonl = async (
+  sessionId: string,
+  jsonlPath: string,
+): Promise<ProviderCurrentActiveModel | null> => {
+  const content = await readFile(jsonlPath, 'utf8');
+  const lines = content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const event = JSON.parse(lines[index]) as ClaudeInitEvent;
+      const model = extractClaudeEventModel(event, sessionId);
+      if (model) {
+        return { model };
+      }
+    } catch {
+      // Skip malformed JSONL lines that can happen during concurrent writes.
+    }
+  }
+
+  return null;
+};
+
+export class ClaudeProviderModels implements IProviderModels {
+  async getSupportedModels(): Promise<ProviderModelsDefinition> {
+    // claude creates a new jsonl file as a separate session for this request.
+    // As a result, it lists the workspace where this is invoked when it shouldn't.
+    //
+    // Disabled for now:
+    // const queryInstance = query({
+    //   prompt: 'Get supported models',
+    //   options: buildClaudeQueryOptions(),
+    // });
+    // const supportedModels = await queryInstance.supportedModels();
+    // queryInstance.close();
+    // return buildClaudeModelsDefinition(supportedModels);
+    return CLAUDE_FALLBACK_MODELS;
+  }
+
+  async getCurrentActiveModel(sessionId?: string): Promise<ProviderCurrentActiveModel> {
+    if (!sessionId?.trim()) {
+      return buildDefaultProviderCurrentActiveModel(await this.getSupportedModels());
+    }
+
+    try {
+      const jsonlPath = sessionsDb.getSessionById(sessionId)?.jsonl_path;
+      const activeModel = jsonlPath
+        ? await readClaudeSessionModelFromJsonl(sessionId, jsonlPath)
+        : null;
+      if (activeModel?.model) {
+        return activeModel;
+      }
+    } catch {
+      // Fall through to the provider default when the session-backed lookup fails.
+    }
+
+    return buildDefaultProviderCurrentActiveModel(await this.getSupportedModels());
+  }
+
+  async changeActiveModel(
+    input: ProviderChangeActiveModelInput,
+  ): Promise<ProviderSessionActiveModelChange> {
+    return writeProviderSessionActiveModelChange('claude', input);
+  }
+}

package/server/modules/providers/list/claude/claude.provider.ts

@@ -1,17 +1,20 @@
 import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
 import { ClaudeProviderAuth } from '@/modules/providers/list/claude/claude-auth.provider.js';
+import { ClaudeProviderModels } from '@/modules/providers/list/claude/claude-models.provider.js';
 import { ClaudeMcpProvider } from '@/modules/providers/list/claude/claude-mcp.provider.js';
 import { ClaudeSessionSynchronizer } from '@/modules/providers/list/claude/claude-session-synchronizer.provider.js';
 import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
 import { ClaudeSkillsProvider } from '@/modules/providers/list/claude/claude-skills.provider.js';
 import type {
   IProviderAuth,
+  IProviderModels,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 
 export class ClaudeProvider extends AbstractProvider {
+  readonly models: IProviderModels = new ClaudeProviderModels();
   readonly mcp = new ClaudeMcpProvider();
   readonly auth: IProviderAuth = new ClaudeProviderAuth();
   readonly skills: IProviderSkills = new ClaudeSkillsProvider();

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

@@ -0,0 +1,125 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+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 = {
+  OPTIONS: [
+    { value: 'gpt-5.5', label: 'gpt-5.5' },
+    { value: 'gpt-5.4', label: 'gpt-5.4' },
+    { value: 'gpt-5.4-mini', label: 'gpt-5.4-mini' },
+    { value: 'gpt-5.3-codex', label: 'gpt-5.3-codex' },
+    { value: 'gpt-5.2', label: 'gpt-5.2' },
+  ],
+  DEFAULT: 'gpt-5.4',
+};
+
+type CodexCachedModel = {
+  slug?: string;
+  display_name?: string;
+  description?: string;
+  priority?: number;
+  visibility?: string;
+  supported_in_api?: boolean;
+};
+
+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 => ({
+  value: model.slug as string,
+  label: readOptionalString(model.display_name) ?? (model.slug as string),
+  description: readOptionalString(model.description),
+});
+
+const buildCodexModelsDefinition = (models: CodexCachedModel[]): ProviderModelsDefinition => {
+  const sortedModels = [...models]
+    .filter((model) => model.visibility !== 'hidden' && 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,
+  };
+};
+
+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;
+    }
+  }
+
+  async getCurrentActiveModel(): Promise<ProviderCurrentActiveModel> {
+    try {
+      const raw = await readFile(CODEX_CONFIG_PATH, 'utf8');
+      const parsed = readObjectRecord(TOML.parse(raw));
+      const model = readOptionalString(parsed?.model);
+      if (!model) {
+        return buildDefaultProviderCurrentActiveModel(await this.getSupportedModels());
+      }
+
+      return {
+        model,
+      };
+    } catch {
+      return buildDefaultProviderCurrentActiveModel(await this.getSupportedModels());
+    }
+  }
+
+  async changeActiveModel(
+    input: ProviderChangeActiveModelInput,
+  ): Promise<ProviderSessionActiveModelChange> {
+    return writeProviderSessionActiveModelChange('codex', input);
+  }
+}

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

@@ -1,52 +1,12 @@
-import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
 import { SkillsProvider } from '@/modules/providers/shared/skills/skills.provider.js';
 import type { ProviderSkillSource } from '@/shared/types.js';
-
-const hasGitMarker = async (dirPath: string): Promise<boolean> => {
-  try {
-    const gitMarkerStats = await fs.stat(path.join(dirPath, '.git'));
-    return gitMarkerStats.isDirectory() || gitMarkerStats.isFile();
-  } catch {
-    return false;
-  }
-};
-
-const findTopmostGitRoot = async (startPath: string): Promise<string | null> => {
-  let currentPath = path.resolve(startPath);
-  let topmostGitRoot: string | null = null;
-
-  while (true) {
-    if (await hasGitMarker(currentPath)) {
-      topmostGitRoot = currentPath;
-    }
-
-    const parentPath = path.dirname(currentPath);
-    if (parentPath === currentPath) {
-      break;
-    }
-
-    currentPath = parentPath;
-  }
-
-  return topmostGitRoot;
-};
-
-const addUniqueSource = (
-  sources: ProviderSkillSource[],
-  seenRootDirs: Set<string>,
-  source: ProviderSkillSource,
-): void => {
-  const normalizedRootDir = path.resolve(source.rootDir);
-  if (seenRootDirs.has(normalizedRootDir)) {
-    return;
-  }
-
-  seenRootDirs.add(normalizedRootDir);
-  sources.push({ ...source, rootDir: normalizedRootDir });
-};
+import {
+  addUniqueProviderSkillSource,
+  findTopmostGitRoot,
+} from '@/shared/utils.js';
 
 export class CodexSkillsProvider extends SkillsProvider {
   constructor() {
@@ -58,7 +18,7 @@ export class CodexSkillsProvider extends SkillsProvider {
     const seenRootDirs = new Set<string>();
     const repoRoot = await findTopmostGitRoot(workspacePath);
 
-    addUniqueSource(sources, seenRootDirs, {
+    addUniqueProviderSkillSource(sources, seenRootDirs, {
       scope: 'repo',
       rootDir: path.join(workspacePath, '.agents', 'skills'),
       commandPrefix: '$',
@@ -67,29 +27,29 @@ export class CodexSkillsProvider extends SkillsProvider {
     if (repoRoot) {
       // Codex checks repository skills at the launch folder, one folder above it,
       // and the topmost git root; these can collapse to the same directory.
-      addUniqueSource(sources, seenRootDirs, {
+      addUniqueProviderSkillSource(sources, seenRootDirs, {
         scope: 'repo',
         rootDir: path.join(path.dirname(workspacePath), '.agents', 'skills'),
         commandPrefix: '$',
       });
-      addUniqueSource(sources, seenRootDirs, {
+      addUniqueProviderSkillSource(sources, seenRootDirs, {
         scope: 'repo',
         rootDir: path.join(repoRoot, '.agents', 'skills'),
         commandPrefix: '$',
       });
     }
 
-    addUniqueSource(sources, seenRootDirs, {
+    addUniqueProviderSkillSource(sources, seenRootDirs, {
       scope: 'user',
       rootDir: path.join(os.homedir(), '.agents', 'skills'),
       commandPrefix: '$',
     });
-    addUniqueSource(sources, seenRootDirs, {
+    addUniqueProviderSkillSource(sources, seenRootDirs, {
       scope: 'admin',
       rootDir: path.join('/etc', 'codex', 'skills'),
       commandPrefix: '$',
     });
-    addUniqueSource(sources, seenRootDirs, {
+    addUniqueProviderSkillSource(sources, seenRootDirs, {
       scope: 'system',
       rootDir: path.join(os.homedir(), '.codex', 'skills', '.system'),
       commandPrefix: '$',

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

@@ -1,17 +1,20 @@
 import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
 import { CodexProviderAuth } from '@/modules/providers/list/codex/codex-auth.provider.js';
+import { CodexProviderModels } from '@/modules/providers/list/codex/codex-models.provider.js';
 import { CodexMcpProvider } from '@/modules/providers/list/codex/codex-mcp.provider.js';
 import { CodexSessionSynchronizer } from '@/modules/providers/list/codex/codex-session-synchronizer.provider.js';
 import { CodexSessionsProvider } from '@/modules/providers/list/codex/codex-sessions.provider.js';
 import { CodexSkillsProvider } from '@/modules/providers/list/codex/codex-skills.provider.js';
 import type {
   IProviderAuth,
+  IProviderModels,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 
 export class CodexProvider extends AbstractProvider {
+  readonly models: IProviderModels = new CodexProviderModels();
   readonly mcp = new CodexMcpProvider();
   readonly auth: IProviderAuth = new CodexProviderAuth();
   readonly skills: IProviderSkills = new CodexSkillsProvider();