@cloudcli-ai/cloudcli 1.31.5 → 1.33.0

package/server/modules/providers/provider.routes.ts

@@ -2,9 +2,17 @@ import express, { type Request, type Response } from 'express';
 
 import { providerAuthService } from '@/modules/providers/services/provider-auth.service.js';
 import { providerMcpService } from '@/modules/providers/services/mcp.service.js';
+import { providerModelsService } from '@/modules/providers/services/provider-models.service.js';
+import { providerSkillsService } from '@/modules/providers/services/skills.service.js';
 import { sessionConversationsSearchService } from '@/modules/providers/services/session-conversations-search.service.js';
 import { sessionsService } from '@/modules/providers/services/sessions.service.js';
-import type { LLMProvider, McpScope, McpTransport, UpsertProviderMcpServerInput } from '@/shared/types.js';
+import type {
+  LLMProvider,
+  McpScope,
+  McpTransport,
+  ProviderChangeActiveModelInput,
+  UpsertProviderMcpServerInput,
+} from '@/shared/types.js';
 import { AppError, asyncHandler, createApiSuccessResponse } from '@/shared/utils.js';
 
 const router = express.Router();
@@ -172,7 +180,13 @@ const parseMcpUpsertPayload = (payload: unknown): UpsertProviderMcpServerInput =
 
 const parseProvider = (value: unknown): LLMProvider => {
   const normalized = normalizeProviderParam(value);
-  if (normalized === 'claude' || normalized === 'codex' || normalized === 'cursor' || normalized === 'gemini') {
+  if (
+    normalized === 'claude'
+    || normalized === 'codex'
+    || normalized === 'cursor'
+    || normalized === 'gemini'
+    || normalized === 'opencode'
+  ) {
     return normalized;
   }
 
@@ -238,6 +252,29 @@ const parseSessionSearchLimit = (value: unknown): number => {
   return Math.max(1, Math.min(parsed, 100));
 };
 
+const parseChangeActiveModelPayload = (payload: unknown): ProviderChangeActiveModelInput => {
+  if (!payload || typeof payload !== 'object') {
+    throw new AppError('Request body must be an object.', {
+      code: 'INVALID_REQUEST_BODY',
+      statusCode: 400,
+    });
+  }
+
+  const body = payload as Record<string, unknown>;
+  const model = readOptionalQueryString(body.model);
+  if (!model) {
+    throw new AppError('model is required.', {
+      code: 'MODEL_REQUIRED',
+      statusCode: 400,
+    });
+  }
+
+  return {
+    sessionId: '',
+    model,
+  };
+};
+
 router.get(
   '/:provider/auth/status',
   asyncHandler(async (req: Request, res: Response) => {
@@ -247,6 +284,41 @@ router.get(
   }),
 );
 
+router.get(
+  '/:provider/models',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = parseProvider(req.params.provider);
+    const bypassCache = parseOptionalBooleanQuery(req.query.bypassCache, 'bypassCache') ?? false;
+    const result = await providerModelsService.getProviderModels(provider, { bypassCache });
+    res.json(createApiSuccessResponse({ provider, models: result.models, cache: result.cache }));
+  }),
+);
+
+router.post(
+  '/:provider/sessions/:sessionId/active-model',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = parseProvider(req.params.provider);
+    const sessionId = parseSessionId(req.params.sessionId);
+    const payload = parseChangeActiveModelPayload(req.body);
+    const result = await providerModelsService.changeActiveModel(provider, {
+      ...payload,
+      sessionId,
+    });
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
+// ----------------- Skills routes -----------------
+router.get(
+  '/:provider/skills',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = parseProvider(req.params.provider);
+    const workspacePath = readOptionalQueryString(req.query.workspacePath);
+    const skills = await providerSkillsService.listProviderSkills(provider, { workspacePath });
+    res.json(createApiSuccessResponse({ provider, skills }));
+  }),
+);
+
 // ----------------- MCP routes -----------------
 router.get(
   '/:provider/mcp/servers',
@@ -311,12 +383,33 @@ router.post(
 );
 
 // ----------------- Session routes -----------------
+router.get(
+  '/sessions/archived',
+  asyncHandler(async (_req: Request, res: Response) => {
+    const sessions = sessionsService.listArchivedSessions();
+    res.json(createApiSuccessResponse({ sessions }));
+  }),
+);
+
 router.delete(
   '/sessions/:sessionId',
   asyncHandler(async (req: Request, res: Response) => {
     const sessionId = parseSessionId(req.params.sessionId);
-    const deletedFromDisk = parseOptionalBooleanQuery(req.query.deletedFromDisk, 'deletedFromDisk') ?? false;
-    const result = await sessionsService.deleteSessionById(sessionId, deletedFromDisk);
+    const force = parseOptionalBooleanQuery(req.query.force, 'force') ?? false;
+    const deletedFromDisk = parseOptionalBooleanQuery(req.query.deletedFromDisk, 'deletedFromDisk') ?? force;
+    const result = await sessionsService.deleteOrArchiveSessionById(sessionId, {
+      force,
+      deletedFromDisk,
+    });
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
+router.post(
+  '/sessions/:sessionId/restore',
+  asyncHandler(async (req: Request, res: Response) => {
+    const sessionId = parseSessionId(req.params.sessionId);
+    const result = sessionsService.restoreSessionById(sessionId);
     res.json(createApiSuccessResponse(result));
   }),
 );

package/server/modules/providers/services/mcp.service.ts

@@ -1,18 +1,7 @@
-import os from 'node:os';
-
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import type { LLMProvider, McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
 import { AppError } from '@/shared/utils.js';
 
-/** Cursor MCP is not supported on Windows hosts (no Cursor CLI integration). */
-function includeProviderInGlobalMcp(providerId: LLMProvider): boolean {
-  if (providerId === 'cursor' && os.platform() === 'win32') {
-    return false;
-  }
-
-  return true;
-}
-
 
 export const providerMcpService = {
   /**
@@ -75,7 +64,7 @@ export const providerMcpService = {
 
     const scope = input.scope ?? 'project';
     const results: Array<{ provider: LLMProvider; created: boolean; error?: string }> = [];
-    const providers = providerRegistry.listProviders().filter((p) => includeProviderInGlobalMcp(p.id));
+    const providers = providerRegistry.listProviders();
     for (const provider of providers) {
       try {
         await provider.mcp.upsertServer({ ...input, scope });

package/server/modules/providers/services/provider-models.service.ts

@@ -0,0 +1,325 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import type { IProvider } from '@/shared/interfaces.js';
+import type {
+  LLMProvider,
+  ProviderChangeActiveModelInput,
+  ProviderCurrentActiveModel,
+  ProviderModelsCacheInfo,
+  ProviderModelsDefinition,
+  ProviderModelsResult,
+  ProviderSessionActiveModelChange,
+} from '@/shared/types.js';
+import { readProviderSessionActiveModelChange } from '@/shared/utils.js';
+
+export const PROVIDER_MODELS_CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000;
+const PROVIDER_MODELS_CACHE_VERSION = 1;
+
+type ProviderModelsServiceDependencies = {
+  resolveProvider?: (provider: LLMProvider) => Pick<IProvider, 'models'>;
+  cachePath?: string;
+  activeModelChangesPath?: string;
+  now?: () => number;
+};
+
+type ProviderModelsOptions = {
+  bypassCache?: boolean;
+};
+
+type ProviderModelsCacheEntry = {
+  updatedAt: number;
+  expiresAt: number;
+  models: ProviderModelsDefinition;
+};
+
+type ProviderModelsCacheFile = {
+  version: number;
+  entries: Record<string, ProviderModelsCacheEntry>;
+};
+
+const getProviderModelsCachePath = (): string => path.join(
+  os.homedir(),
+  '.cloudcli',
+  'provider-models-cache.json',
+);
+
+const toProviderModelsCacheInfo = (
+  entry: ProviderModelsCacheEntry,
+  source: ProviderModelsCacheInfo['source'],
+): ProviderModelsCacheInfo => ({
+  updatedAt: new Date(entry.updatedAt).toISOString(),
+  expiresAt: new Date(entry.expiresAt).toISOString(),
+  source,
+});
+
+const isProviderModelOption = (
+  value: unknown,
+): value is ProviderModelsDefinition['OPTIONS'][number] => (
+  Boolean(value)
+  && typeof value === 'object'
+  && typeof (value as ProviderModelsDefinition['OPTIONS'][number]).value === 'string'
+  && typeof (value as ProviderModelsDefinition['OPTIONS'][number]).label === 'string'
+  && (
+    typeof (value as ProviderModelsDefinition['OPTIONS'][number]).description === 'undefined'
+    || typeof (value as ProviderModelsDefinition['OPTIONS'][number]).description === 'string'
+  )
+);
+
+const isProviderModelsDefinition = (value: unknown): value is ProviderModelsDefinition => (
+  Boolean(value)
+  && typeof value === 'object'
+  && Array.isArray((value as ProviderModelsDefinition).OPTIONS)
+  && (value as ProviderModelsDefinition).OPTIONS.every(isProviderModelOption)
+  && typeof (value as ProviderModelsDefinition).DEFAULT === 'string'
+);
+
+const isProviderModelsCacheEntry = (value: unknown): value is ProviderModelsCacheEntry => (
+  Boolean(value)
+  && typeof value === 'object'
+  && typeof (value as ProviderModelsCacheEntry).updatedAt === 'number'
+  && typeof (value as ProviderModelsCacheEntry).expiresAt === 'number'
+  && isProviderModelsDefinition((value as ProviderModelsCacheEntry).models)
+);
+
+const readProviderModelsCacheFile = async (
+  cachePath: string,
+): Promise<ProviderModelsCacheFile | null> => {
+  try {
+    const raw = await readFile(cachePath, 'utf8');
+    const parsed = JSON.parse(raw) as Partial<ProviderModelsCacheFile>;
+    if (parsed.version !== PROVIDER_MODELS_CACHE_VERSION || !parsed.entries || typeof parsed.entries !== 'object') {
+      return null;
+    }
+
+    const entries = Object.fromEntries(
+      Object.entries(parsed.entries).filter((entry): entry is [string, ProviderModelsCacheEntry] =>
+        isProviderModelsCacheEntry(entry[1]),
+      ),
+    );
+
+    return {
+      version: PROVIDER_MODELS_CACHE_VERSION,
+      entries,
+    };
+  } catch {
+    return null;
+  }
+};
+
+const writeProviderModelsCacheFile = async (
+  cachePath: string,
+  entries: Map<LLMProvider, ProviderModelsCacheEntry>,
+  now: number,
+): Promise<void> => {
+  const serializableEntries = Object.fromEntries(
+    [...entries.entries()].filter(([, entry]) => entry.expiresAt > now),
+  );
+  const payload: ProviderModelsCacheFile = {
+    version: PROVIDER_MODELS_CACHE_VERSION,
+    entries: serializableEntries,
+  };
+
+  await mkdir(path.dirname(cachePath), { recursive: true });
+  await writeFile(cachePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+};
+
+/**
+ * Provider model lookup service.
+ *
+ * Routes and other service callers use this layer instead of resolving provider
+ * classes directly so the provider-registry dependency stays centralized in one
+ * place.
+ */
+export const createProviderModelsService = (dependencies: ProviderModelsServiceDependencies = {}) => {
+  const resolveProvider = dependencies.resolveProvider ?? providerRegistry.resolveProvider;
+  const cachePath = dependencies.cachePath ?? getProviderModelsCachePath();
+  const activeModelChangesPath = dependencies.activeModelChangesPath;
+  const now = dependencies.now ?? (() => Date.now());
+  const memoryCache = new Map<LLMProvider, ProviderModelsCacheEntry>();
+  const pendingRequests = new Map<LLMProvider, Promise<ProviderModelsResult>>();
+  let persistedCacheLoaded = false;
+  let persistedCacheLoadPromise: Promise<void> | null = null;
+
+  const pruneExpiredMemoryEntry = (
+    provider: LLMProvider,
+    currentTime: number,
+    source: ProviderModelsCacheInfo['source'],
+  ): ProviderModelsResult | null => {
+    const cachedEntry = memoryCache.get(provider);
+    if (!cachedEntry) {
+      return null;
+    }
+
+    if (cachedEntry.expiresAt > currentTime) {
+      return {
+        models: cachedEntry.models,
+        cache: toProviderModelsCacheInfo(cachedEntry, source),
+      };
+    }
+
+    memoryCache.delete(provider);
+    return null;
+  };
+
+  const loadPersistedCache = async (): Promise<void> => {
+    if (persistedCacheLoaded) {
+      return;
+    }
+
+    if (!persistedCacheLoadPromise) {
+      persistedCacheLoadPromise = (async () => {
+        const cacheFile = await readProviderModelsCacheFile(cachePath);
+        const currentTime = now();
+
+        for (const [provider, entry] of Object.entries(cacheFile?.entries ?? {})) {
+          if (entry.expiresAt > currentTime) {
+            memoryCache.set(provider as LLMProvider, entry);
+          }
+        }
+
+        persistedCacheLoaded = true;
+      })().finally(() => {
+        persistedCacheLoadPromise = null;
+      });
+    }
+
+    await persistedCacheLoadPromise;
+  };
+
+  const persistCache = async (): Promise<void> => {
+    try {
+      await writeProviderModelsCacheFile(cachePath, memoryCache, now());
+    } catch (error) {
+      console.warn('Unable to persist provider models cache:', error);
+    }
+  };
+
+  const setCacheEntry = async (
+    provider: LLMProvider,
+    models: ProviderModelsDefinition,
+  ): Promise<ProviderModelsCacheEntry> => {
+    const currentTime = now();
+    const entry: ProviderModelsCacheEntry = {
+      updatedAt: currentTime,
+      expiresAt: currentTime + PROVIDER_MODELS_CACHE_TTL_MS,
+      models,
+    };
+
+    memoryCache.set(provider, entry);
+    await persistCache();
+    return entry;
+  };
+
+  const loadAndCacheModels = (
+    provider: LLMProvider,
+  ): Promise<ProviderModelsResult> => {
+    const request = resolveProvider(provider).models.getSupportedModels()
+      .then(async (models) => {
+        const entry = await setCacheEntry(provider, models);
+        return {
+          models,
+          cache: toProviderModelsCacheInfo(entry, 'fresh'),
+        };
+      })
+      .finally(() => {
+        pendingRequests.delete(provider);
+      });
+
+    pendingRequests.set(provider, request);
+    return request;
+  };
+
+  const getProviderModels = async (
+    provider: LLMProvider,
+    options: ProviderModelsOptions = {},
+  ): Promise<ProviderModelsResult> => {
+    if (options.bypassCache) {
+      const pendingRequest = pendingRequests.get(provider);
+      if (pendingRequest) {
+        return pendingRequest;
+      }
+
+      return loadAndCacheModels(provider);
+    }
+
+    const cachedModels = pruneExpiredMemoryEntry(provider, now(), 'memory');
+    if (cachedModels) {
+      return cachedModels;
+    }
+
+    const pendingRequest = pendingRequests.get(provider);
+    if (pendingRequest) {
+      return pendingRequest;
+    }
+
+    await loadPersistedCache();
+
+    const persistedModels = pruneExpiredMemoryEntry(provider, now(), 'disk');
+    if (persistedModels) {
+      return persistedModels;
+    }
+
+    const postLoadPendingRequest = pendingRequests.get(provider);
+    if (postLoadPendingRequest) {
+      return postLoadPendingRequest;
+    }
+
+    return loadAndCacheModels(provider);
+  };
+
+  const getCurrentActiveModel = async (
+    provider: LLMProvider,
+    sessionId?: string,
+  ): Promise<ProviderCurrentActiveModel> => resolveProvider(provider).models.getCurrentActiveModel(sessionId);
+
+  const changeActiveModel = async (
+    provider: LLMProvider,
+    input: ProviderChangeActiveModelInput,
+  ): Promise<ProviderSessionActiveModelChange> => resolveProvider(provider).models.changeActiveModel(input);
+
+  const getChangedActiveModel = async (
+    provider: LLMProvider,
+    sessionId: string,
+  ): Promise<ProviderSessionActiveModelChange> => readProviderSessionActiveModelChange(provider, sessionId, {
+    filePath: activeModelChangesPath,
+  });
+
+  const resolveResumeModel = async (
+    provider: LLMProvider,
+    sessionId: string | undefined,
+    requestedModel?: string | null,
+  ): Promise<string | undefined> => {
+    const normalizedRequestedModel = typeof requestedModel === 'string' ? requestedModel.trim() : '';
+    if (!sessionId?.trim()) {
+      return normalizedRequestedModel || undefined;
+    }
+
+    const changedModel = await getChangedActiveModel(provider, sessionId);
+    if (changedModel.supported && changedModel.changed && changedModel.model?.trim()) {
+      return changedModel.model.trim();
+    }
+
+    return normalizedRequestedModel || undefined;
+  };
+
+  const clearCache = (): void => {
+    memoryCache.clear();
+    pendingRequests.clear();
+    persistedCacheLoaded = false;
+    persistedCacheLoadPromise = null;
+  };
+
+  return {
+    getProviderModels,
+    getCurrentActiveModel,
+    getChangedActiveModel,
+    changeActiveModel,
+    resolveResumeModel,
+    clearCache,
+  };
+};
+
+export const providerModelsService = createProviderModelsService();

package/server/modules/providers/services/session-conversations-search.service.ts

@@ -89,13 +89,8 @@ const RIPGREP_CHUNK_CONCURRENCY = 6;
 const UNKNOWN_PROJECT_KEY = '__unknown_project__';
 
 const INTERNAL_CONTENT_PREFIXES = [
-  '<command-name>',
-  '<command-message>',
-  '<command-args>',
-  '<local-command-stdout>',
   '<system-reminder>',
   'Caveat:',
-  'This session is being continued from a previous',
   'Invalid API key',
   '[Request interrupted',
 ] as const;
@@ -302,6 +297,135 @@ function extractClaudeText(content: unknown): string {
     .join(' ');
 }
 
+function 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;
+}
+
+type ClaudeLocalCommandPayload = {
+  commandName: string;
+  commandMessage: string;
+  commandArgs: string;
+};
+
+function parseClaudeLocalCommandPayload(content: string): ClaudeLocalCommandPayload | null {
+  const commandName = extractTaggedContent(content, 'command-name');
+  const commandMessage = extractTaggedContent(content, 'command-message');
+  const commandArgs = extractTaggedContent(content, 'command-args');
+
+  if (commandName === null && commandMessage === null && commandArgs === null) {
+    return null;
+  }
+
+  return {
+    commandName: commandName ?? '',
+    commandMessage: commandMessage ?? '',
+    commandArgs: commandArgs ?? '',
+  };
+}
+
+function buildClaudeLocalCommandDisplayText(payload: ClaudeLocalCommandPayload): string {
+  const commandName = payload.commandName.trim();
+  const commandMessage = payload.commandMessage.trim();
+  const commandArgs = payload.commandArgs.trim();
+  const baseCommand = commandName || commandMessage;
+
+  if (!baseCommand) {
+    return '';
+  }
+
+  return commandArgs ? `${baseCommand} ${commandArgs}` : baseCommand;
+}
+
+function stripAnsiFormatting(text: string): string {
+  return text.replace(/\u001B\[[0-9;?]*[ -/]*[@-~]/g, '');
+}
+
+type ClaudeSearchableMessage = {
+  text: string;
+  role: 'user' | 'assistant';
+};
+
+/**
+ * Claude mixes visible chat, compact summaries, and local command wrappers into
+ * the same transcript stream. Search should operate on the user-visible meaning
+ * of those rows rather than the raw wrapper syntax.
+ */
+function extractClaudeSearchableMessage(entry: AnyRecord): ClaudeSearchableMessage | null {
+  if (!entry.message?.content || entry.isApiErrorMessage) {
+    return null;
+  }
+
+  const rawRole = entry.message.role;
+  if (rawRole !== 'user' && rawRole !== 'assistant') {
+    return null;
+  }
+
+  if (typeof entry.message.content === 'string') {
+    const content = String(entry.message.content);
+
+    if (entry.isCompactSummary === true && content.trim()) {
+      return {
+        text: content,
+        role: 'assistant',
+      };
+    }
+
+    const localCommand = parseClaudeLocalCommandPayload(content);
+    if (localCommand) {
+      const displayText = buildClaudeLocalCommandDisplayText(localCommand);
+      return displayText
+        ? {
+            text: displayText,
+            role: 'user',
+          }
+        : null;
+    }
+
+    const localCommandStdout = extractTaggedContent(content, 'local-command-stdout');
+    if (localCommandStdout !== null) {
+      const stdoutText = stripAnsiFormatting(localCommandStdout).trim();
+      return stdoutText
+        ? {
+            text: stdoutText,
+            role: 'assistant',
+          }
+        : null;
+    }
+
+    if (!content || isInternalContent(content)) {
+      return null;
+    }
+
+    return {
+      text: content,
+      role: rawRole,
+    };
+  }
+
+  const text = extractClaudeText(entry.message.content);
+  if (!text) {
+    return null;
+  }
+
+  if (entry.isCompactSummary === true) {
+    return {
+      text,
+      role: 'assistant',
+    };
+  }
+
+  if (isInternalContent(text)) {
+    return null;
+  }
+
+  return {
+    text,
+    role: rawRole,
+  };
+}
+
 function extractCodexText(content: unknown): string {
   if (typeof content === 'string') {
     return content;
@@ -348,6 +472,7 @@ function extractGeminiText(content: unknown): string {
 
 function normalizeSearchableSessions(rows: SessionRepositoryRow[]): SearchableSessionRow[] {
   const normalizedRows: SearchableSessionRow[] = [];
+  const projectArchiveStateByPath = new Map<string, boolean>();
 
   for (const row of rows) {
     const provider = row.provider as SearchableProvider;
@@ -365,6 +490,27 @@ function normalizeSearchableSessions(rows: SessionRepositoryRow[]): SearchableSe
       continue;
     }
 
+    /**
+     * Active session rows can still belong to an archived project because
+     * project archiving intentionally preserves the underlying session data.
+     * Global conversation search should follow the visible workspace model,
+     * which means excluding any session whose owning project is archived.
+     *
+     * Cache the archive lookup per normalized project path so one search pass
+     * does not re-query the same project row for every session in that folder.
+     */
+    const normalizedProjectPath = typeof row.project_path === 'string' ? row.project_path.trim() : '';
+    if (normalizedProjectPath) {
+      if (!projectArchiveStateByPath.has(normalizedProjectPath)) {
+        const projectRow = projectsDb.getProjectPath(normalizedProjectPath);
+        projectArchiveStateByPath.set(normalizedProjectPath, Boolean(projectRow?.isArchived));
+      }
+
+      if (projectArchiveStateByPath.get(normalizedProjectPath) === true) {
+        continue;
+      }
+    }
+
     normalizedRows.push({
       ...row,
       provider,
@@ -733,18 +879,21 @@ async function parseClaudeSessionMatches(
           }
         }
 
-        if (!entry.message?.content || entry.isApiErrorMessage) {
+        const searchableMessage = extractClaudeSearchableMessage(entry);
+        if (!searchableMessage) {
           continue;
         }
 
-        const role = entry.message.role;
-        if (role !== 'user' && role !== 'assistant') {
-          continue;
-        }
+        const { text, role } = searchableMessage;
 
-        const text = extractClaudeText(entry.message.content);
-        if (!text || isInternalContent(text)) {
-          continue;
+        /**
+         * Claude compact summaries are the most faithful session-summary source
+         * after a `/compact` because they describe the post-compaction state that
+         * the resumed session actually continues from. Prefer them over generic
+         * fallback user text when present.
+         */
+        if (entry.isCompactSummary === true) {
+          state.resolvedSummary = text;
         }
 
         if (role === 'user') {