@cloudcli-ai/cloudcli 1.36.0 → 1.36.2

package/server/gemini-response-handler.js

@@ -1,117 +0,0 @@
-// Gemini Response Handler - JSON Stream processing
-import { sessionsService } from './modules/providers/services/sessions.service.js';
-import { createNormalizedMessage } from './shared/utils.js';
-
-function buildGeminiTokenBudget(tokens) {
-  if (!tokens || typeof tokens !== 'object') {
-    return null;
-  }
-
-  const parsedInputTokens = Number(tokens.input);
-  const parsedOutputTokens = Number(tokens.output);
-  const inputTokens = Number.isFinite(parsedInputTokens) ? parsedInputTokens : 0;
-  const outputTokens = Number.isFinite(parsedOutputTokens) ? parsedOutputTokens : 0;
-  const parsedUsed = Number(tokens.total);
-  const used = Number.isFinite(parsedUsed) ? parsedUsed : inputTokens + outputTokens;
-  if (!Number.isFinite(used) || used <= 0) {
-    return null;
-  }
-
-  return {
-    used,
-    inputTokens,
-    outputTokens,
-    breakdown: {
-      input: inputTokens,
-      output: outputTokens,
-    },
-  };
-}
-
-class GeminiResponseHandler {
-  constructor(ws, options = {}) {
-    this.ws = ws;
-    this.buffer = '';
-    this.onContentFragment = options.onContentFragment || null;
-    this.onInit = options.onInit || null;
-    this.onToolUse = options.onToolUse || null;
-    this.onToolResult = options.onToolResult || null;
-  }
-
-  // Process incoming raw data from Gemini stream-json
-  processData(data) {
-    this.buffer += data;
-
-    // Split by newline
-    const lines = this.buffer.split('\n');
-
-    // Keep the last incomplete line in the buffer
-    this.buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-
-      try {
-        const event = JSON.parse(line);
-        this.handleEvent(event);
-      } catch (err) {
-        // Not a JSON line, probably debug output or CLI warnings
-      }
-    }
-  }
-
-  handleEvent(event) {
-    const sid = typeof this.ws.getSessionId === 'function' ? this.ws.getSessionId() : null;
-
-    if (event.type === 'init') {
-      if (this.onInit) {
-        this.onInit(event);
-      }
-      return;
-    }
-
-    // Invoke per-type callbacks for session tracking
-    if (event.type === 'message' && event.role === 'assistant') {
-      const content = event.content || '';
-      if (this.onContentFragment && content) {
-        this.onContentFragment(content);
-      }
-    } else if (event.type === 'tool_use' && this.onToolUse) {
-      this.onToolUse(event);
-    } else if (event.type === 'tool_result' && this.onToolResult) {
-      this.onToolResult(event);
-    }
-
-    // Normalize via adapter and send all resulting messages
-    const normalized = sessionsService.normalizeMessage('gemini', event, sid);
-    for (const msg of normalized) {
-      this.ws.send(msg);
-    }
-
-    const tokenBudget = buildGeminiTokenBudget(event.tokens);
-    if (tokenBudget) {
-      this.ws.send(createNormalizedMessage({
-        kind: 'status',
-        text: 'token_budget',
-        tokenBudget,
-        sessionId: sid,
-        provider: 'gemini',
-      }));
-    }
-  }
-
-  forceFlush() {
-    if (this.buffer.trim()) {
-      try {
-        const event = JSON.parse(this.buffer);
-        this.handleEvent(event);
-      } catch (err) { }
-    }
-  }
-
-  destroy() {
-    this.buffer = '';
-  }
-}
-
-export default GeminiResponseHandler;

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

@@ -1,307 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import spawn from 'cross-spawn';
-
-import type { IProviderAuth } from '@/shared/interfaces.js';
-import type { ProviderAuthStatus } from '@/shared/types.js';
-import { readObjectRecord, readOptionalString } from '@/shared/utils.js';
-
-type GeminiCredentialsStatus = {
-  authenticated: boolean;
-  email: string | null;
-  method: string | null;
-  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.
-   */
-  private checkInstalled(): boolean {
-    const cliPath = process.env.GEMINI_PATH || 'gemini';
-    try {
-      spawn.sync(cliPath, ['--version'], { stdio: 'ignore', timeout: 5000 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Returns Gemini CLI installation and credential status.
-   */
-  async getStatus(): Promise<ProviderAuthStatus> {
-    const installed = this.checkInstalled();
-
-    if (!installed) {
-      return {
-        installed,
-        provider: 'gemini',
-        authenticated: false,
-        email: null,
-        method: null,
-        error: 'Gemini CLI is not installed',
-      };
-    }
-
-    const credentials = await this.checkCredentials();
-
-    return {
-      installed,
-      provider: 'gemini',
-      authenticated: credentials.authenticated,
-      email: credentials.email,
-      method: credentials.method,
-      error: credentials.authenticated ? undefined : credentials.error || 'Not authenticated',
-    };
-  }
-
-  /**
-   * 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.
-   */
-  private async checkCredentials(): Promise<GeminiCredentialsStatus> {
-    if (process.env.GEMINI_API_KEY?.trim()) {
-      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(this.getGeminiCliHome(), '.gemini', 'oauth_creds.json');
-      const content = await readFile(credsPath, 'utf8');
-      const creds = readObjectRecord(JSON.parse(content)) ?? {};
-      const accessToken = readOptionalString(creds.access_token);
-
-      if (!accessToken) {
-        return {
-          authenticated: false,
-          email: null,
-          method: null,
-          error: 'No valid tokens found in oauth_creds',
-        };
-      }
-
-      const refreshToken = readOptionalString(creds.refresh_token);
-      const tokenInfo = await this.getTokenInfoEmail(accessToken);
-      if (tokenInfo.valid) {
-        return {
-          authenticated: true,
-          email: tokenInfo.email || 'OAuth Session',
-          method: 'credentials_file',
-        };
-      }
-
-      if (!refreshToken) {
-        return {
-          authenticated: false,
-          email: null,
-          method: 'credentials_file',
-          error: 'Access token invalid and no refresh token found',
-        };
-      }
-
-      return {
-        authenticated: true,
-        email: await this.getActiveAccountEmail() || 'OAuth Session',
-        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,
-        method: null,
-        error: 'Gemini CLI not configured',
-      };
-    }
-  }
-
-  /**
-   * Validates a Gemini OAuth access token and returns an email when Google reports one.
-   */
-  private async getTokenInfoEmail(accessToken: string): Promise<{ valid: boolean; email: string | null }> {
-    try {
-      const tokenRes = await fetch(`https://oauth2.googleapis.com/tokeninfo?access_token=${accessToken}`);
-      if (!tokenRes.ok) {
-        return { valid: false, email: null };
-      }
-
-      const tokenInfo = readObjectRecord(await tokenRes.json());
-      return {
-        valid: true,
-        email: readOptionalString(tokenInfo?.email) ?? null,
-      };
-    } catch {
-      return { valid: false, email: null };
-    }
-  }
-
-  /**
-   * Reads Gemini's active local Google account as an offline fallback for display.
-   */
-  private async getActiveAccountEmail(): Promise<string | null> {
-    try {
-      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;
-    } catch {
-      return null;
-    }
-  }
-}

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

@@ -1,110 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-
-import { McpProvider } from '@/modules/providers/shared/mcp/mcp.provider.js';
-import type { McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
-import {
-  AppError,
-  readJsonConfig,
-  readObjectRecord,
-  readOptionalString,
-  readStringArray,
-  readStringRecord,
-  writeJsonConfig,
-} from '@/shared/utils.js';
-
-export class GeminiMcpProvider extends McpProvider {
-  constructor() {
-    super('gemini', ['user', 'project'], ['stdio', 'http', 'sse']);
-  }
-
-  protected async readScopedServers(scope: McpScope, workspacePath: string): Promise<Record<string, unknown>> {
-    const filePath = scope === 'user'
-      ? path.join(os.homedir(), '.gemini', 'settings.json')
-      : path.join(workspacePath, '.gemini', 'settings.json');
-    const config = await readJsonConfig(filePath);
-    return readObjectRecord(config.mcpServers) ?? {};
-  }
-
-  protected async writeScopedServers(
-    scope: McpScope,
-    workspacePath: string,
-    servers: Record<string, unknown>,
-  ): Promise<void> {
-    const filePath = scope === 'user'
-      ? path.join(os.homedir(), '.gemini', 'settings.json')
-      : path.join(workspacePath, '.gemini', 'settings.json');
-    const config = await readJsonConfig(filePath);
-    config.mcpServers = servers;
-    await writeJsonConfig(filePath, config);
-  }
-
-  protected buildServerConfig(input: UpsertProviderMcpServerInput): Record<string, unknown> {
-    if (input.transport === 'stdio') {
-      if (!input.command?.trim()) {
-        throw new AppError('command is required for stdio MCP servers.', {
-          code: 'MCP_COMMAND_REQUIRED',
-          statusCode: 400,
-        });
-      }
-
-      return {
-        command: input.command,
-        args: input.args ?? [],
-        env: input.env ?? {},
-        cwd: input.cwd,
-      };
-    }
-
-    if (!input.url?.trim()) {
-      throw new AppError('url is required for http/sse MCP servers.', {
-        code: 'MCP_URL_REQUIRED',
-        statusCode: 400,
-      });
-    }
-
-    return {
-      type: input.transport,
-      url: input.url,
-      headers: input.headers ?? {},
-    };
-  }
-
-  protected normalizeServerConfig(
-    scope: McpScope,
-    name: string,
-    rawConfig: unknown,
-  ): ProviderMcpServer | null {
-    if (!rawConfig || typeof rawConfig !== 'object') {
-      return null;
-    }
-
-    const config = rawConfig as Record<string, unknown>;
-    if (typeof config.command === 'string') {
-      return {
-        provider: 'gemini',
-        name,
-        scope,
-        transport: 'stdio',
-        command: config.command,
-        args: readStringArray(config.args),
-        env: readStringRecord(config.env),
-        cwd: readOptionalString(config.cwd),
-      };
-    }
-
-    if (typeof config.url === 'string') {
-      const transport = readOptionalString(config.type) === 'sse' ? 'sse' : 'http';
-      return {
-        provider: 'gemini',
-        name,
-        scope,
-        transport,
-        url: config.url,
-        headers: readStringRecord(config.headers),
-      };
-    }
-
-    return null;
-  }
-}

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

@@ -1,39 +0,0 @@
-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 GEMINI_FALLBACK_MODELS: ProviderModelsDefinition = {
-  OPTIONS: [
-    { value: 'gemini-3-flash-preview', label: 'Gemini 3 Flash Preview' },
-    { value: 'gemini-3.1-flash-lite-preview', label: 'Gemini 3.1 Flash Lite Preview' },
-    { value: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
-    { value: 'gemini-2.5-flash-lite', label: 'Gemini 2.5 Flash Lite' },
-    { value: 'gemma-4-31b-it', label: 'Gemma 4 31B IT' },
-    { value: 'gemma-4-26b-a4b-it', label: 'Gemma 4 26B A4B IT' },
-  ],
-  DEFAULT: 'gemini-3-flash-preview',
-};
-
-export class GeminiProviderModels implements IProviderModels {
-  async getSupportedModels(): Promise<ProviderModelsDefinition> {
-    return GEMINI_FALLBACK_MODELS;
-  }
-
-  async getCurrentActiveModel(): Promise<ProviderCurrentActiveModel> {
-    return buildDefaultProviderCurrentActiveModel(GEMINI_FALLBACK_MODELS);
-  }
-
-  async changeActiveModel(
-    input: ProviderChangeActiveModelInput,
-  ): Promise<ProviderSessionActiveModelChange> {
-    return writeProviderSessionActiveModelChange('gemini', input);
-  }
-}