@cloudcli-ai/cloudcli 1.35.1 → 1.36.1

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

@@ -1,540 +0,0 @@
-import fsSync from 'node:fs';
-import fs from 'node:fs/promises';
-import readline from 'node:readline';
-
-import { sessionsDb } from '@/modules/database/index.js';
-import type { IProviderSessions } from '@/shared/interfaces.js';
-import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
-import { createNormalizedMessage, generateMessageId, readObjectRecord, sliceTailPage } from '@/shared/utils.js';
-
-const PROVIDER = 'gemini';
-
-type GeminiHistoryResult = {
-  messages: AnyRecord[];
-  tokenUsage?: unknown;
-};
-
-function mapGeminiRole(value: unknown): 'user' | 'assistant' | null {
-  if (value === 'user') {
-    return 'user';
-  }
-
-  if (value === 'gemini' || value === 'assistant') {
-    return 'assistant';
-  }
-
-  return null;
-}
-
-function extractGeminiTextContent(content: unknown): string {
-  if (typeof content === 'string') {
-    return content;
-  }
-
-  if (!Array.isArray(content)) {
-    return '';
-  }
-
-  return content
-    .map((part) => {
-      if (typeof part === 'string') {
-        return part;
-      }
-      if (!part || typeof part !== 'object') {
-        return '';
-      }
-
-      const record = part as AnyRecord;
-      if (typeof record.text === 'string') {
-        return record.text;
-      }
-
-      return '';
-    })
-    .filter(Boolean)
-    .join('\n');
-}
-
-function extractGeminiThoughts(thoughts: unknown): string {
-  if (!Array.isArray(thoughts)) {
-    return '';
-  }
-
-  return thoughts
-    .map((item) => {
-      if (!item || typeof item !== 'object') {
-        return '';
-      }
-
-      const record = item as AnyRecord;
-      const subject = typeof record.subject === 'string' ? record.subject.trim() : '';
-      const description = typeof record.description === 'string' ? record.description.trim() : '';
-
-      if (subject && description) {
-        return `${subject}: ${description}`;
-      }
-
-      return description || subject;
-    })
-    .filter(Boolean)
-    .join('\n');
-}
-
-function buildGeminiTokenUsage(tokens: unknown): AnyRecord | undefined {
-  if (!tokens || typeof tokens !== 'object') {
-    return undefined;
-  }
-
-  const record = tokens as AnyRecord;
-  const input = Number(record.input || 0);
-  const output = Number(record.output || 0);
-  const total = Number(record.total || input + output || 0);
-
-  return {
-    used: total,
-    inputTokens: input,
-    outputTokens: output,
-    breakdown: {
-      input,
-      output,
-    },
-  };
-}
-
-async function getGeminiLegacySessionMessages(sessionFilePath: string): Promise<GeminiHistoryResult> {
-  try {
-    const data = await fs.readFile(sessionFilePath, 'utf8');
-    const session = JSON.parse(data) as AnyRecord;
-    const sourceMessages = Array.isArray(session.messages) ? session.messages : [];
-
-    const messages: AnyRecord[] = [];
-    for (const msg of sourceMessages) {
-      const role = mapGeminiRole(msg.type ?? msg.role);
-      if (!role) {
-        continue;
-      }
-
-      messages.push({
-        type: 'message',
-        uuid: typeof msg.id === 'string' ? msg.id : undefined,
-        message: { role, content: msg.content },
-        timestamp: msg.timestamp || null,
-      });
-    }
-
-    return { messages };
-  } catch {
-    return { messages: [] };
-  }
-}
-
-async function getGeminiJsonlSessionMessages(sessionFilePath: string): Promise<GeminiHistoryResult> {
-  const messages: AnyRecord[] = [];
-  let tokenUsage: AnyRecord | undefined;
-
-  try {
-    const fileStream = fsSync.createReadStream(sessionFilePath);
-    const lineReader = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity,
-    });
-
-    for await (const line of lineReader) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        continue;
-      }
-
-      let entry: AnyRecord;
-      try {
-        entry = JSON.parse(trimmed) as AnyRecord;
-      } catch {
-        continue;
-      }
-
-      // Metadata/update lines (e.g. {$set:{lastUpdated:...}}) do not represent chat messages.
-      if (entry.$set) {
-        continue;
-      }
-
-      const role = mapGeminiRole(entry.type);
-      if (role) {
-        const textContent = extractGeminiTextContent(entry.content);
-        if (textContent.trim()) {
-          messages.push({
-            type: 'message',
-            uuid: typeof entry.id === 'string' ? entry.id : undefined,
-            message: { role, content: textContent },
-            timestamp: entry.timestamp || null,
-          });
-        }
-
-        const thinkingContent = extractGeminiThoughts(entry.thoughts);
-        if (thinkingContent.trim()) {
-          messages.push({
-            type: 'thinking',
-            uuid: typeof entry.id === 'string' ? `${entry.id}_thinking` : undefined,
-            message: { role: 'assistant', content: thinkingContent },
-            timestamp: entry.timestamp || null,
-            isReasoning: true,
-          });
-        }
-
-        if (role === 'assistant') {
-          const usage = buildGeminiTokenUsage(entry.tokens);
-          if (usage) {
-            tokenUsage = usage;
-          }
-        }
-
-        continue;
-      }
-
-      if (entry.type === 'tool_use') {
-        messages.push({
-          type: 'tool_use',
-          uuid: typeof entry.id === 'string' ? entry.id : undefined,
-          timestamp: entry.timestamp || null,
-          toolName: entry.tool_name || entry.name || 'Tool',
-          toolInput: entry.parameters ?? entry.input ?? entry.arguments ?? '',
-          toolCallId: entry.tool_id || entry.toolCallId || entry.id,
-        });
-        continue;
-      }
-
-      if (entry.type === 'tool_result') {
-        messages.push({
-          type: 'tool_result',
-          uuid: typeof entry.id === 'string' ? entry.id : undefined,
-          timestamp: entry.timestamp || null,
-          toolCallId: entry.tool_id || entry.toolCallId || entry.id || '',
-          output: entry.output ?? entry.result ?? '',
-          isError: Boolean(entry.error) || entry.status === 'error',
-        });
-      }
-    }
-  } catch {
-    return { messages: [] };
-  }
-
-  messages.sort(
-    (a, b) => new Date(a.timestamp || 0).getTime() - new Date(b.timestamp || 0).getTime(),
-  );
-
-  return { messages, tokenUsage };
-}
-
-async function getGeminiCliSessionMessages(sessionId: string): Promise<GeminiHistoryResult> {
-  const sessionFilePath = sessionsDb.getSessionById(sessionId)?.jsonl_path;
-  if (!sessionFilePath) {
-    return { messages: [] };
-  }
-
-  if (sessionFilePath.endsWith('.jsonl')) {
-    return getGeminiJsonlSessionMessages(sessionFilePath);
-  }
-
-  return getGeminiLegacySessionMessages(sessionFilePath);
-}
-
-export class GeminiSessionsProvider implements IProviderSessions {
-  /**
-   * Normalizes live Gemini stream-json events into the shared message shape.
-   *
-   * Gemini history uses a different session file shape, so fetchHistory handles
-   * that separately after loading raw persisted messages.
-   */
-  normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
-    const raw = readObjectRecord(rawMessage);
-    if (!raw) {
-      return [];
-    }
-
-    const ts = raw.timestamp || new Date().toISOString();
-    const baseId = raw.uuid || generateMessageId('gemini');
-
-    if (raw.type === 'message' && raw.role === 'assistant') {
-      const content = raw.content || '';
-      const messages: NormalizedMessage[] = [];
-      if (content) {
-        messages.push(createNormalizedMessage({
-          id: baseId,
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'stream_delta',
-          content,
-        }));
-      }
-      if (raw.delta !== true) {
-        messages.push(createNormalizedMessage({
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'stream_end',
-        }));
-      }
-      return messages;
-    }
-
-    if (raw.type === 'tool_use') {
-      return [createNormalizedMessage({
-        id: baseId,
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'tool_use',
-        toolName: raw.tool_name,
-        toolInput: raw.parameters || {},
-        toolId: raw.tool_id || baseId,
-      })];
-    }
-
-    if (raw.type === 'tool_result') {
-      return [createNormalizedMessage({
-        id: baseId,
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'tool_result',
-        toolId: raw.tool_id || '',
-        content: raw.output === undefined ? '' : String(raw.output),
-        isError: raw.status === 'error',
-      })];
-    }
-
-    if (raw.type === 'result') {
-      const messages = [createNormalizedMessage({
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'stream_end',
-      })];
-      if (raw.stats?.total_tokens) {
-        messages.push(createNormalizedMessage({
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'status',
-          text: 'Complete',
-          tokens: raw.stats.total_tokens,
-          canInterrupt: false,
-        }));
-      }
-      return messages;
-    }
-
-    if (raw.type === 'error') {
-      return [createNormalizedMessage({
-        id: baseId,
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'error',
-        content: raw.error || raw.message || 'Unknown Gemini streaming error',
-      })];
-    }
-
-    return [];
-  }
-
-  /**
-   * Loads Gemini history from Gemini CLI session files on disk.
-   */
-  async fetchHistory(
-    sessionId: string,
-    options: FetchHistoryOptions = {},
-  ): Promise<FetchHistoryResult> {
-    const { limit = null, offset = 0 } = options;
-
-    let result: GeminiHistoryResult;
-    try {
-      result = await getGeminiCliSessionMessages(sessionId);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(`[GeminiProvider] Failed to load session ${sessionId}:`, message);
-      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
-    }
-
-    const rawMessages = result.messages;
-    const normalized: NormalizedMessage[] = [];
-
-    for (let i = 0; i < rawMessages.length; i++) {
-      const raw = rawMessages[i];
-      const ts = raw.timestamp || new Date().toISOString();
-      const baseId = raw.uuid || generateMessageId('gemini');
-
-      if (raw.type === 'thinking' || raw.isReasoning) {
-        const thinkingContent = typeof raw.message?.content === 'string'
-          ? raw.message.content
-          : typeof raw.content === 'string'
-            ? raw.content
-            : '';
-
-        if (thinkingContent.trim()) {
-          normalized.push(createNormalizedMessage({
-            id: baseId,
-            sessionId,
-            timestamp: ts,
-            provider: PROVIDER,
-            kind: 'thinking',
-            content: thinkingContent,
-          }));
-        }
-        continue;
-      }
-
-      if (raw.type === 'tool_use' || raw.toolName) {
-        normalized.push(createNormalizedMessage({
-          id: baseId,
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'tool_use',
-          toolName: raw.toolName || 'Tool',
-          toolInput: raw.toolInput,
-          toolId: raw.toolCallId || baseId,
-        }));
-        continue;
-      }
-
-      if (raw.type === 'tool_result') {
-        normalized.push(createNormalizedMessage({
-          id: baseId,
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'tool_result',
-          toolId: raw.toolCallId || '',
-          content: raw.output === undefined ? '' : String(raw.output),
-          isError: Boolean(raw.isError),
-        }));
-        continue;
-      }
-
-      const role = raw.message?.role || raw.role;
-      const content = raw.message?.content || raw.content;
-      if (!role || !content) {
-        continue;
-      }
-
-      const normalizedRole = role === 'user' ? 'user' : 'assistant';
-
-      if (Array.isArray(content)) {
-        for (let partIdx = 0; partIdx < content.length; partIdx++) {
-          const part = content[partIdx] as AnyRecord | string;
-
-          if (typeof part === 'string' && part.trim()) {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'text',
-              role: normalizedRole,
-              content: part,
-            }));
-            continue;
-          }
-
-          if (!part || typeof part !== 'object') {
-            continue;
-          }
-
-          if ((part.type === 'text' || !part.type) && typeof part.text === 'string' && part.text.trim()) {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'text',
-              role: normalizedRole,
-              content: part.text,
-            }));
-          } else if (part.type === 'tool_use') {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'tool_use',
-              toolName: part.name,
-              toolInput: part.input,
-              toolId: part.id || generateMessageId('gemini_tool'),
-            }));
-          } else if (part.type === 'tool_result') {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'tool_result',
-              toolId: part.tool_use_id || '',
-              content: part.content === undefined ? '' : String(part.content),
-              isError: Boolean(part.is_error),
-            }));
-          }
-        }
-      } else if (typeof content === 'string' && content.trim()) {
-        normalized.push(createNormalizedMessage({
-          id: baseId,
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'text',
-          role: normalizedRole,
-          content,
-        }));
-      } else {
-        const textContent = extractGeminiTextContent(content);
-        if (textContent.trim()) {
-          normalized.push(createNormalizedMessage({
-            id: baseId,
-            sessionId,
-            timestamp: ts,
-            provider: PROVIDER,
-            kind: 'text',
-            role: normalizedRole,
-            content: textContent,
-          }));
-        }
-      }
-    }
-
-    const toolResultMap = new Map<string, NormalizedMessage>();
-    for (const msg of normalized) {
-      if (msg.kind === 'tool_result' && msg.toolId) {
-        toolResultMap.set(msg.toolId, msg);
-      }
-    }
-    for (const msg of normalized) {
-      if (msg.kind === 'tool_use' && msg.toolId && toolResultMap.has(msg.toolId)) {
-        const toolResult = toolResultMap.get(msg.toolId);
-        if (toolResult) {
-          msg.toolResult = { content: toolResult.content, isError: toolResult.isError };
-        }
-      }
-    }
-
-    const start = Math.max(0, offset);
-    const pageLimit = limit === null ? null : Math.max(0, limit);
-    // Tail pagination via the shared contract: offset 0 returns the most
-    // recent page, matching every other provider.
-    const { page, hasMore } = sliceTailPage(normalized, pageLimit, start);
-    let total = 0;
-    for (const msg of normalized) {
-      if (msg.kind !== 'tool_result') {
-        total += 1;
-      }
-    }
-
-    return {
-      messages: page,
-      total,
-      hasMore,
-      offset: start,
-      limit: pageLimit,
-      tokenUsage: result.tokenUsage,
-    };
-  }
-}

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

@@ -1,44 +0,0 @@
-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: '/',
-      },
-    ];
-  }
-
-  protected async getGlobalSkillSource(): Promise<ProviderSkillSource> {
-    return {
-      scope: 'user',
-      rootDir: path.join(os.homedir(), '.gemini', 'skills'),
-      commandPrefix: '/',
-    };
-  }
-}

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

@@ -1,27 +0,0 @@
-import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
-import { GeminiProviderAuth } from '@/modules/providers/list/gemini/gemini-auth.provider.js';
-import { GeminiProviderModels } from '@/modules/providers/list/gemini/gemini-models.provider.js';
-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 { GeminiSkillsProvider } from '@/modules/providers/list/gemini/gemini-skills.provider.js';
-import type {
-  IProviderAuth,
-  IProviderModels,
-  IProviderSessionSynchronizer,
-  IProviderSkills,
-  IProviderSessions,
-} from '@/shared/interfaces.js';
-
-export class GeminiProvider extends AbstractProvider {
-  readonly models: IProviderModels = new GeminiProviderModels();
-  readonly mcp = new GeminiMcpProvider();
-  readonly auth: IProviderAuth = new GeminiProviderAuth();
-  readonly skills: IProviderSkills = new GeminiSkillsProvider();
-  readonly sessions: IProviderSessions = new GeminiSessionsProvider();
-  readonly sessionSynchronizer: IProviderSessionSynchronizer = new GeminiSessionSynchronizer();
-
-  constructor() {
-    super('gemini');
-  }
-}

package/server/routes/gemini.js

@@ -1,25 +0,0 @@
-import express from 'express';
-
-import sessionManager from '../sessionManager.js';
-import { sessionsDb } from '../modules/database/index.js';
-
-const router = express.Router();
-
-router.delete('/sessions/:sessionId', async (req, res) => {
-    try {
-        const { sessionId } = req.params;
-
-        if (!sessionId || typeof sessionId !== 'string' || !/^[a-zA-Z0-9_.-]{1,100}$/.test(sessionId)) {
-            return res.status(400).json({ success: false, error: 'Invalid session ID format' });
-        }
-
-        await sessionManager.deleteSession(sessionId);
-        sessionsDb.deleteSessionById(sessionId);
-        res.json({ success: true });
-    } catch (error) {
-        console.error(`Error deleting Gemini session ${req.params.sessionId}:`, error);
-        res.status(500).json({ success: false, error: error.message });
-    }
-});
-
-export default router;