@cloudcli-ai/cloudcli 1.31.5 → 1.32.0

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

@@ -15,7 +15,24 @@ type GeminiCredentialsStatus = {
   error?: string;
 };
 
+type GeminiAuthType =
+  | 'oauth-personal'
+  | 'gemini-api-key'
+  | 'vertex-ai'
+  | 'compute-default-credentials'
+  | 'gateway'
+  | 'cloud-shell'
+  | null;
+
 export class GeminiProviderAuth implements IProviderAuth {
+  /**
+   * Gemini CLI can override its home root via GEMINI_CLI_HOME.
+   * Use the same resolution so status checks match runtime behavior.
+   */
+  private getGeminiCliHome(): string {
+    return process.env.GEMINI_CLI_HOME?.trim() || os.homedir();
+  }
+
   /**
    * Checks whether the Gemini CLI is available on this host.
    */
@@ -58,6 +75,88 @@ export class GeminiProviderAuth implements IProviderAuth {
     };
   }
 
+  /**
+   * Parses dotenv-style key/value pairs.
+   */
+  private parseEnvFile(content: string): Record<string, string> {
+    const parsed: Record<string, string> = {};
+
+    for (const rawLine of content.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith('#')) {
+        continue;
+      }
+
+      const normalizedLine = line.startsWith('export ')
+        ? line.slice('export '.length).trim()
+        : line;
+      const separatorIndex = normalizedLine.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+
+      const key = normalizedLine.slice(0, separatorIndex).trim();
+      if (!key) {
+        continue;
+      }
+
+      let value = normalizedLine.slice(separatorIndex + 1).trim();
+      const quoted = (value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''));
+      if (quoted) {
+        value = value.slice(1, -1);
+      } else {
+        value = value.replace(/\s+#.*$/, '').trim();
+      }
+
+      parsed[key] = value;
+    }
+
+    return parsed;
+  }
+
+  /**
+   * Loads user-level auth env in Gemini's "first file found" order.
+   */
+  private async loadUserLevelAuthEnv(): Promise<Record<string, string>> {
+    const geminiCliHome = this.getGeminiCliHome();
+    const envCandidates = [
+      path.join(geminiCliHome, '.gemini', '.env'),
+      path.join(geminiCliHome, '.env'),
+    ];
+
+    for (const envPath of envCandidates) {
+      try {
+        const content = await readFile(envPath, 'utf8');
+        return this.parseEnvFile(content);
+      } catch {
+        // Continue to the next fallback.
+      }
+    }
+
+    return {};
+  }
+
+  /**
+   * Reads Gemini's selected auth type from settings.json when available.
+   */
+  private async readSelectedAuthType(): Promise<GeminiAuthType> {
+    try {
+      const settingsPath = path.join(this.getGeminiCliHome(), '.gemini', 'settings.json');
+      const content = await readFile(settingsPath, 'utf8');
+      const settings = readObjectRecord(JSON.parse(content));
+      const security = readObjectRecord(settings?.security);
+      const auth = readObjectRecord(security?.auth);
+      const selectedType = readOptionalString(auth?.selectedType);
+      if (!selectedType) {
+        return null;
+      }
+
+      return selectedType as GeminiAuthType;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Checks Gemini credentials from API key env vars or local OAuth credential files.
    */
@@ -66,8 +165,46 @@ export class GeminiProviderAuth implements IProviderAuth {
       return { authenticated: true, email: 'API Key Auth', method: 'api_key' };
     }
 
+    const userEnv = await this.loadUserLevelAuthEnv();
+    if (readOptionalString(userEnv.GEMINI_API_KEY)) {
+      return { authenticated: true, email: 'API Key Auth', method: 'api_key' };
+    }
+
+    const selectedType = await this.readSelectedAuthType();
+    if (selectedType === 'vertex-ai') {
+      const hasGoogleApiKey = Boolean(
+        process.env.GOOGLE_API_KEY?.trim()
+        || readOptionalString(userEnv.GOOGLE_API_KEY)
+      );
+      const hasProject = Boolean(
+        process.env.GOOGLE_CLOUD_PROJECT?.trim()
+        || process.env.GOOGLE_CLOUD_PROJECT_ID?.trim()
+        || readOptionalString(userEnv.GOOGLE_CLOUD_PROJECT)
+        || readOptionalString(userEnv.GOOGLE_CLOUD_PROJECT_ID)
+      );
+      const hasLocation = Boolean(
+        process.env.GOOGLE_CLOUD_LOCATION?.trim()
+        || readOptionalString(userEnv.GOOGLE_CLOUD_LOCATION)
+      );
+      const hasServiceAccount = Boolean(
+        process.env.GOOGLE_APPLICATION_CREDENTIALS?.trim()
+        || readOptionalString(userEnv.GOOGLE_APPLICATION_CREDENTIALS)
+      );
+
+      if (hasGoogleApiKey || hasServiceAccount || (hasProject && hasLocation)) {
+        return { authenticated: true, email: 'Vertex AI Auth', method: 'vertex_ai' };
+      }
+
+      return {
+        authenticated: false,
+        email: null,
+        method: 'vertex_ai',
+        error: 'Gemini is set to Vertex AI, but required env vars are missing',
+      };
+    }
+
     try {
-      const credsPath = path.join(os.homedir(), '.gemini', 'oauth_creds.json');
+      const credsPath = path.join(this.getGeminiCliHome(), '.gemini', 'oauth_creds.json');
       const content = await readFile(credsPath, 'utf8');
       const creds = readObjectRecord(JSON.parse(content)) ?? {};
       const accessToken = readOptionalString(creds.access_token);
@@ -106,6 +243,25 @@ export class GeminiProviderAuth implements IProviderAuth {
         method: 'credentials_file',
       };
     } catch {
+      if (selectedType === 'gemini-api-key') {
+        return {
+          authenticated: false,
+          email: null,
+          method: 'api_key',
+          error: 'Gemini is set to "Use Gemini API key", but GEMINI_API_KEY is unavailable',
+        };
+      }
+
+      if (selectedType === 'oauth-personal') {
+        return {
+          authenticated: false,
+          email: null,
+          method: 'credentials_file',
+          error: 'Gemini is set to Google sign-in, but no cached OAuth credentials were found',
+        };
+      }
+
+      // If no explicit auth type was selected, surface the generic "not configured" error.
       return {
         authenticated: false,
         email: null,
@@ -140,7 +296,7 @@ export class GeminiProviderAuth implements IProviderAuth {
    */
   private async getActiveAccountEmail(): Promise<string | null> {
     try {
-      const accPath = path.join(os.homedir(), '.gemini', 'google_accounts.json');
+      const accPath = path.join(this.getGeminiCliHome(), '.gemini', 'google_accounts.json');
       const accContent = await readFile(accPath, 'utf8');
       const accounts = readObjectRecord(JSON.parse(accContent));
       return readOptionalString(accounts?.active) ?? null;

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

@@ -39,33 +39,37 @@ export class GeminiSessionSynchronizer implements IProviderSessionSynchronizer {
   async synchronize(since?: Date): Promise<number> {
     const projectHashLookup = this.buildProjectHashLookup();
 
-    const legacySessionFiles = await findFilesRecursivelyCreatedAfter(
-      path.join(this.geminiHome, 'sessions'),
-      '.json',
-      since ?? null
-    );
-    const legacyTempFiles = await findFilesRecursivelyCreatedAfter(
-      path.join(this.geminiHome, 'tmp'),
-      '.json',
-      since ?? null
-    );
-    const jsonlSessionFiles = await findFilesRecursivelyCreatedAfter(
-      path.join(this.geminiHome, 'sessions'),
-      '.jsonl',
-      since ?? null
-    );
+    // const legacySessionFiles = await findFilesRecursivelyCreatedAfter(
+    //   path.join(this.geminiHome, 'sessions'),
+    //   '.json',
+    //   since ?? null
+    // );
+    // Gemini creates overlapping artifacts across `sessions/` and `tmp/`.
+    // We currently index only `tmp/*/chats/*.jsonl` because those files are the
+    // live transcript source and avoid duplicate session rows from mirrored files.
+    // const legacyTempFiles = await findFilesRecursivelyCreatedAfter(
+    //   path.join(this.geminiHome, 'tmp'),
+    //   '.json',
+    //   since ?? null
+    // );
+    // const jsonlSessionFiles = await findFilesRecursivelyCreatedAfter(
+    //   path.join(this.geminiHome, 'sessions'),
+    //   '.jsonl',
+    //   since ?? null
+    // );
     const jsonlTempFiles = await findFilesRecursivelyCreatedAfter(
       path.join(this.geminiHome, 'tmp'),
       '.jsonl',
       since ?? null
     );
 
-    // Process legacy JSON first, then JSONL. If both exist for a session id,
-    // the JSONL artifact becomes the canonical jsonl_path via upsert.
+    // Current strategy: index only temp chat JSONL artifacts.
     const files = [
-      ...legacySessionFiles,
-      ...legacyTempFiles,
-      ...jsonlSessionFiles,
+      // ...legacySessionFiles,
+      // Intentionally disabled to avoid duplicate indexing from mirrored
+      // `sessions/*.json` and `sessions/*.jsonl` artifacts.
+      // ...legacyTempFiles,
+      // ...jsonlSessionFiles,
       ...jsonlTempFiles,
     ];
 

package/server/modules/providers/list/gemini/gemini-sessions.provider.ts

@@ -528,10 +528,16 @@ export class GeminiSessionsProvider implements IProviderSessions {
     const messages = pageLimit === null
       ? normalized.slice(start)
       : normalized.slice(start, start + pageLimit);
+    let total = 0;
+    for (const msg of normalized) {
+      if (msg.kind !== 'tool_result') {
+        total += 1;
+      }
+    }
 
     return {
       messages,
-      total: normalized.length,
+      total,
       hasMore: pageLimit === null ? false : start + pageLimit < normalized.length,
       offset: start,
       limit: pageLimit,

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

@@ -0,0 +1,36 @@
+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';
+
+export class GeminiSkillsProvider extends SkillsProvider {
+  constructor() {
+    super('gemini');
+  }
+
+  protected async getSkillSources(workspacePath: string): Promise<ProviderSkillSource[]> {
+    return [
+      {
+        scope: 'user',
+        rootDir: path.join(os.homedir(), '.gemini', 'skills'),
+        commandPrefix: '/',
+      },
+      {
+        scope: 'user',
+        rootDir: path.join(os.homedir(), '.agents', 'skills'),
+        commandPrefix: '/',
+      },
+      {
+        scope: 'project',
+        rootDir: path.join(workspacePath, '.gemini', 'skills'),
+        commandPrefix: '/',
+      },
+      {
+        scope: 'project',
+        rootDir: path.join(workspacePath, '.agents', 'skills'),
+        commandPrefix: '/',
+      },
+    ];
+  }
+}

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

@@ -3,11 +3,18 @@ import { GeminiProviderAuth } from '@/modules/providers/list/gemini/gemini-auth.
 import { GeminiMcpProvider } from '@/modules/providers/list/gemini/gemini-mcp.provider.js';
 import { GeminiSessionSynchronizer } from '@/modules/providers/list/gemini/gemini-session-synchronizer.provider.js';
 import { GeminiSessionsProvider } from '@/modules/providers/list/gemini/gemini-sessions.provider.js';
-import type { IProviderAuth, IProviderSessionSynchronizer, IProviderSessions } from '@/shared/interfaces.js';
+import { GeminiSkillsProvider } from '@/modules/providers/list/gemini/gemini-skills.provider.js';
+import type {
+  IProviderAuth,
+  IProviderSessionSynchronizer,
+  IProviderSkills,
+  IProviderSessions,
+} from '@/shared/interfaces.js';
 
 export class GeminiProvider extends AbstractProvider {
   readonly mcp = new GeminiMcpProvider();
   readonly auth: IProviderAuth = new GeminiProviderAuth();
+  readonly skills: IProviderSkills = new GeminiSkillsProvider();
   readonly sessions: IProviderSessions = new GeminiSessionsProvider();
   readonly sessionSynchronizer: IProviderSessionSynchronizer = new GeminiSessionSynchronizer();
 

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

@@ -2,6 +2,7 @@ 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 { 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';
@@ -247,6 +248,17 @@ router.get(
   }),
 );
 
+// ----------------- 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 +323,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/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') {

package/server/modules/providers/services/sessions-watcher.service.ts

@@ -18,16 +18,18 @@ const PROVIDER_WATCH_PATHS: Array<{ provider: LLMProvider; rootPath: string }> =
   },
   {
     provider: 'cursor',
-    rootPath: path.join(os.homedir(), '.cursor', 'chats'),
+    rootPath: path.join(os.homedir(), '.cursor', 'projects'),
   },
   {
     provider: 'codex',
     rootPath: path.join(os.homedir(), '.codex', 'sessions'),
   },
-  {
-    provider: 'gemini',
-    rootPath: path.join(os.homedir(), '.gemini', 'sessions'),
-  },
+  // {
+  //   provider: 'gemini',
+  //   rootPath: path.join(os.homedir(), '.gemini', 'sessions'),
+  // },
+  // Keep `sessions/` watcher disabled: Gemini also mirrors artifacts there,
+  // which causes duplicate synchronization events.
   {
     provider: 'gemini',
     rootPath: path.join(os.homedir(), '.gemini', 'tmp'),