@xortex/xcode 3.0.0

package/services/api/geminiClient.ts

@@ -0,0 +1,291 @@
+// Gemini client wrapper that mimics the Anthropic SDK interface
+import { GoogleGenerativeAI, type GenerateContentStreamResult } from '@google/generative-ai';
+import type { BetaRawMessageStreamEvent, BetaToolUnion, BetaMessageParam } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs';
+import type { Stream } from '@anthropic-ai/sdk/streaming.mjs';
+import { randomUUID } from 'crypto';
+
+const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY || '');
+
+// Convert Anthropic tools to Gemini function declarations
+function convertTools(tools: BetaToolUnion[] | undefined): any[] | undefined {
+  if (!tools || tools.length === 0) return undefined;
+  
+  return tools.map((tool: any) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: {
+      type: 'object',
+      properties: tool.input_schema?.properties || {},
+      required: tool.input_schema?.required || [],
+    },
+  }));
+}
+
+// Convert Anthropic messages to Gemini content format
+function convertMessages(messages: BetaMessageParam[]): any[] {
+  return messages.map(msg => {
+    const role = msg.role === 'assistant' ? 'model' : 'user';
+    const parts: any[] = [];
+
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content as any[]) {
+        if (block.type === 'text') {
+          parts.push({ text: block.text });
+        } else if (block.type === 'tool_use') {
+          parts.push({
+            functionCall: {
+              name: block.name,
+              args: block.input,
+            },
+          });
+        } else if (block.type === 'tool_result') {
+          parts.push({
+            functionResponse: {
+              name: block.tool_use_id,
+              response: { result: block.content },
+            },
+          });
+        }
+      }
+    } else if (typeof msg.content === 'string') {
+      parts.push({ text: msg.content });
+    }
+
+    return { role, parts };
+  });
+}
+
+// Create a mock stream that converts Gemini stream to Anthropic format
+async function* createGeminiStream(
+  model: string,
+  systemPrompt: string | undefined,
+  messages: BetaMessageParam[],
+  tools: BetaToolUnion[] | undefined,
+  maxTokens: number,
+  signal?: AbortSignal
+): AsyncGenerator<BetaRawMessageStreamEvent> {
+  const geminiTools = convertTools(tools);
+  
+  const generativeModel = genAI.getGenerativeModel({
+    model,
+    tools: geminiTools ? [{ functionDeclarations: geminiTools }] : undefined,
+    systemInstruction: systemPrompt ? {
+      role: 'system',
+      parts: [{ text: systemPrompt }],
+    } : undefined,
+  });
+
+  // Yield message_start
+  yield {
+    type: 'message_start',
+    message: {
+      id: `msg_${randomUUID()}`,
+      type: 'message',
+      role: 'assistant',
+      content: [],
+      model,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0,
+      },
+    },
+  };
+
+  const geminiMessages = convertMessages(messages);
+  
+  try {
+    const result = await generativeModel.generateContentStream({
+      contents: geminiMessages,
+    });
+
+    let contentBlockIndex = 0;
+    let hasToolUse = false;
+    let accumulatedText = '';
+
+    for await (const chunk of result.stream) {
+      if (signal?.aborted) {
+        throw new Error('Request was aborted.');
+      }
+
+      const parts = chunk.candidates?.[0]?.content?.parts || [];
+      
+      for (const part of parts) {
+        if (part.text) {
+          if (contentBlockIndex === 0 && accumulatedText === '') {
+            // First text block - yield content_block_start
+            yield {
+              type: 'content_block_start',
+              index: contentBlockIndex,
+              content_block: {
+                type: 'text',
+                text: '',
+              },
+            };
+          }
+          
+          accumulatedText += part.text;
+          
+          // Yield text delta
+          yield {
+            type: 'content_block_delta',
+            index: contentBlockIndex,
+            delta: {
+              type: 'text_delta',
+              text: part.text,
+            },
+          };
+        } else if (part.functionCall) {
+          hasToolUse = true;
+          
+          // Yield content_block_start for tool_use
+          yield {
+            type: 'content_block_start',
+            index: contentBlockIndex,
+            content_block: {
+              type: 'tool_use',
+              id: `toolu_${randomUUID()}`,
+              name: part.functionCall.name,
+              input: {},
+            },
+          };
+          
+          // Yield input_json_delta
+          const inputJson = JSON.stringify(part.functionCall.args || {});
+          yield {
+            type: 'content_block_delta',
+            index: contentBlockIndex,
+            delta: {
+              type: 'input_json_delta',
+              partial_json: inputJson,
+            },
+          };
+          
+          // Yield content_block_stop
+          yield {
+            type: 'content_block_stop',
+            index: contentBlockIndex,
+          };
+          
+          contentBlockIndex++;
+        }
+      }
+    }
+
+    // If we had text content, stop the text block
+    if (accumulatedText.length > 0) {
+      yield {
+        type: 'content_block_stop',
+        index: contentBlockIndex,
+      };
+    }
+
+    // Yield message_delta
+    yield {
+      type: 'message_delta',
+      delta: {
+        stop_reason: hasToolUse ? 'tool_use' : 'end_turn',
+        stop_sequence: null,
+        usage: {
+          output_tokens: Math.ceil(accumulatedText.length / 4), // Rough estimate
+        },
+      },
+      usage: {
+        output_tokens: Math.ceil(accumulatedText.length / 4),
+        input_tokens: 0,
+      },
+    };
+
+    // Yield message_stop
+    yield {
+      type: 'message_stop',
+    };
+
+  } catch (error) {
+    if (signal?.aborted) {
+      throw new Error('Request was aborted.');
+    }
+    throw error;
+  }
+}
+
+// Mock Anthropic client that uses Gemini
+export class GeminiAnthropicClient {
+  apiKey: string;
+  
+  constructor(options: { apiKey: string }) {
+    this.apiKey = options.apiKey;
+    if (!process.env.GEMINI_API_KEY) {
+      process.env.GEMINI_API_KEY = options.apiKey;
+    }
+  }
+
+  beta = {
+    messages: {
+      create: async (
+        params: {
+          model: string;
+          max_tokens: number;
+          messages: BetaMessageParam[];
+          tools?: BetaToolUnion[];
+          tool_choice?: any;
+          system?: any;
+          stream?: boolean;
+        },
+        options?: { signal?: AbortSignal; headers?: Record<string, string> }
+      ): Promise<Stream<BetaRawMessageStreamEvent>> => {
+        if (!params.stream) {
+          throw new Error('Non-streaming not implemented for Gemini client');
+        }
+
+        const systemPrompt = Array.isArray(params.system) 
+          ? params.system.map(s => typeof s === 'string' ? s : s.text).join('\n')
+          : typeof params.system === 'string' 
+            ? params.system 
+            : undefined;
+
+        // Map Anthropic model names to Gemini models
+        const modelMap: Record<string, string> = {
+          'claude-sonnet-4-6': 'gemini-2.5-pro',
+          'claude-sonnet-4-6': 'gemini-2.5-pro',
+          'claude-3-7-sonnet': 'gemini-2.5-pro',
+          'claude-3-5-sonnet': 'gemini-2.5-pro',
+          'claude-3-5-haiku': 'gemini-2.5-pro',
+          'claude-haiku-4-5': 'gemini-2.5-pro',
+          'claude-3-opus': 'gemini-2.5-pro',
+          'claude-opus-4': 'gemini-2.5-pro',
+        };
+
+        const geminiModel = modelMap[params.model] || 'gemini-2.5-pro';
+
+        const generator = createGeminiStream(
+          geminiModel,
+          systemPrompt,
+          params.messages,
+          params.tools,
+          params.max_tokens,
+          options?.signal
+        );
+
+        // Create a stream object compatible with Anthropic SDK
+        const stream = {
+          [Symbol.asyncIterator]: () => generator,
+          controller: {
+            abort: () => {
+              if (options?.signal) {
+                // Signal is already handled in generator
+              }
+            },
+          },
+        } as unknown as Stream<BetaRawMessageStreamEvent>;
+
+        return stream;
+      },
+    },
+  };
+
+  messages = this.beta.messages;
+}
+
+export default GeminiAnthropicClient;

package/services/api/grove.ts

@@ -0,0 +1,357 @@
+import axios from 'src/utils/axios.js'
+import memoize from 'lodash-es/memoize.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from 'src/services/analytics/index.js'
+import { getOauthAccountInfo, isConsumerSubscriber } from 'src/utils/auth.js'
+import { logForDebugging } from 'src/utils/debug.js'
+import { gracefulShutdown } from 'src/utils/gracefulShutdown.js'
+import { isEssentialTrafficOnly } from 'src/utils/privacyLevel.js'
+import { writeToStderr } from 'src/utils/process.js'
+import { getOauthConfig } from '../../constants/oauth.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import {
+  getAuthHeaders,
+  getUserAgent,
+  withOAuth401Retry,
+} from '../../utils/http.js'
+import { logError } from '../../utils/log.js'
+import { getClaudeCodeUserAgent } from '../../utils/userAgent.js'
+
+// Cache expiration: 24 hours
+const GROVE_CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000
+
+export type AccountSettings = {
+  grove_enabled: boolean | null
+  grove_notice_viewed_at: string | null
+}
+
+export type GroveConfig = {
+  grove_enabled: boolean
+  domain_excluded: boolean
+  notice_is_grace_period: boolean
+  notice_reminder_frequency: number | null
+}
+
+/**
+ * Result type that distinguishes between API failure and success.
+ * - success: true means API call succeeded (data may still contain null fields)
+ * - success: false means API call failed after retry
+ */
+export type ApiResult<T> = { success: true; data: T } | { success: false }
+
+/**
+ * Get the current Grove settings for the user account.
+ * Returns ApiResult to distinguish between API failure and success.
+ * Uses existing OAuth 401 retry, then returns failure if that doesn't help.
+ *
+ * Memoized for the session to avoid redundant per-render requests.
+ * Cache is invalidated in updateGroveSettings() so post-toggle reads are fresh.
+ */
+export const getGroveSettings = memoize(
+  async (): Promise<ApiResult<AccountSettings>> => {
+    // Grove is a notification feature; during an outage, skipping it is correct.
+    if (isEssentialTrafficOnly()) {
+      return { success: false }
+    }
+    try {
+      const response = await withOAuth401Retry(() => {
+        const authHeaders = getAuthHeaders()
+        if (authHeaders.error) {
+          throw new Error(`Failed to get auth headers: ${authHeaders.error}`)
+        }
+        return axios.get<AccountSettings>(
+          `${getOauthConfig().BASE_API_URL}/api/oauth/account/settings`,
+          {
+            headers: {
+              ...authHeaders.headers,
+              'User-Agent': getClaudeCodeUserAgent(),
+            },
+          },
+        )
+      })
+      return { success: true, data: response.data }
+    } catch (err) {
+      logError(err)
+      // Don't cache failures — transient network issues would lock the user
+      // out of privacy settings for the entire session (deadlock: dialog needs
+      // success to render the toggle, toggle calls updateGroveSettings which
+      // is the only other place the cache is cleared).
+      getGroveSettings.cache.clear?.()
+      return { success: false }
+    }
+  },
+)
+
+/**
+ * Mark that the Grove notice has been viewed by the user
+ */
+export async function markGroveNoticeViewed(): Promise<void> {
+  try {
+    await withOAuth401Retry(() => {
+      const authHeaders = getAuthHeaders()
+      if (authHeaders.error) {
+        throw new Error(`Failed to get auth headers: ${authHeaders.error}`)
+      }
+      return axios.post(
+        `${getOauthConfig().BASE_API_URL}/api/oauth/account/grove_notice_viewed`,
+        {},
+        {
+          headers: {
+            ...authHeaders.headers,
+            'User-Agent': getClaudeCodeUserAgent(),
+          },
+        },
+      )
+    })
+    // This mutates grove_notice_viewed_at server-side — Grove.tsx:87 reads it
+    // to decide whether to show the dialog. Without invalidation a same-session
+    // remount would read stale viewed_at:null and re-show the dialog.
+    getGroveSettings.cache.clear?.()
+  } catch (err) {
+    logError(err)
+  }
+}
+
+/**
+ * Update Grove settings for the user account
+ */
+export async function updateGroveSettings(
+  groveEnabled: boolean,
+): Promise<void> {
+  try {
+    await withOAuth401Retry(() => {
+      const authHeaders = getAuthHeaders()
+      if (authHeaders.error) {
+        throw new Error(`Failed to get auth headers: ${authHeaders.error}`)
+      }
+      return axios.patch(
+        `${getOauthConfig().BASE_API_URL}/api/oauth/account/settings`,
+        {
+          grove_enabled: groveEnabled,
+        },
+        {
+          headers: {
+            ...authHeaders.headers,
+            'User-Agent': getClaudeCodeUserAgent(),
+          },
+        },
+      )
+    })
+    // Invalidate memoized settings so the post-toggle confirmation
+    // read in privacy-settings.tsx picks up the new value.
+    getGroveSettings.cache.clear?.()
+  } catch (err) {
+    logError(err)
+  }
+}
+
+/**
+ * Check if user is qualified for Grove (non-blocking, cache-first).
+ *
+ * This function never blocks on network - it returns cached data immediately
+ * and fetches in the background if needed. On cold start (no cache), it returns
+ * false and the Grove dialog won't show until the next session.
+ */
+export async function isQualifiedForGrove(): Promise<boolean> {
+  if (!isConsumerSubscriber()) {
+    return false
+  }
+
+  const accountId = getOauthAccountInfo()?.accountUuid
+  if (!accountId) {
+    return false
+  }
+
+  const globalConfig = getGlobalConfig()
+  const cachedEntry = globalConfig.groveConfigCache?.[accountId]
+  const now = Date.now()
+
+  // No cache - trigger background fetch and return false (non-blocking)
+  // The Grove dialog won't show this session, but will next time if eligible
+  if (!cachedEntry) {
+    logForDebugging(
+      'Grove: No cache, fetching config in background (dialog skipped this session)',
+    )
+    void fetchAndStoreGroveConfig(accountId)
+    return false
+  }
+
+  // Cache exists but is stale - return cached value and refresh in background
+  if (now - cachedEntry.timestamp > GROVE_CACHE_EXPIRATION_MS) {
+    logForDebugging(
+      'Grove: Cache stale, returning cached data and refreshing in background',
+    )
+    void fetchAndStoreGroveConfig(accountId)
+    return cachedEntry.grove_enabled
+  }
+
+  // Cache is fresh - return it immediately
+  logForDebugging('Grove: Using fresh cached config')
+  return cachedEntry.grove_enabled
+}
+
+/**
+ * Fetch Grove config from API and store in cache
+ */
+async function fetchAndStoreGroveConfig(accountId: string): Promise<void> {
+  try {
+    const result = await getGroveNoticeConfig()
+    if (!result.success) {
+      return
+    }
+    const groveEnabled = result.data.grove_enabled
+    const cachedEntry = getGlobalConfig().groveConfigCache?.[accountId]
+    if (
+      cachedEntry?.grove_enabled === groveEnabled &&
+      Date.now() - cachedEntry.timestamp <= GROVE_CACHE_EXPIRATION_MS
+    ) {
+      return
+    }
+    saveGlobalConfig(current => ({
+      ...current,
+      groveConfigCache: {
+        ...current.groveConfigCache,
+        [accountId]: {
+          grove_enabled: groveEnabled,
+          timestamp: Date.now(),
+        },
+      },
+    }))
+  } catch (err) {
+    logForDebugging(`Grove: Failed to fetch and store config: ${err}`)
+  }
+}
+
+/**
+ * Get Grove Statsig configuration from the API.
+ * Returns ApiResult to distinguish between API failure and success.
+ * Uses existing OAuth 401 retry, then returns failure if that doesn't help.
+ */
+export const getGroveNoticeConfig = memoize(
+  async (): Promise<ApiResult<GroveConfig>> => {
+    // Grove is a notification feature; during an outage, skipping it is correct.
+    if (isEssentialTrafficOnly()) {
+      return { success: false }
+    }
+    try {
+      const response = await withOAuth401Retry(() => {
+        const authHeaders = getAuthHeaders()
+        if (authHeaders.error) {
+          throw new Error(`Failed to get auth headers: ${authHeaders.error}`)
+        }
+        return axios.get<GroveConfig>(
+          `${getOauthConfig().BASE_API_URL}/api/claude_code_grove`,
+          {
+            headers: {
+              ...authHeaders.headers,
+              'User-Agent': getUserAgent(),
+            },
+            timeout: 3000, // Short timeout - if slow, skip Grove dialog
+          },
+        )
+      })
+
+      // Map the API response to the GroveConfig type
+      const {
+        grove_enabled,
+        domain_excluded,
+        notice_is_grace_period,
+        notice_reminder_frequency,
+      } = response.data
+
+      return {
+        success: true,
+        data: {
+          grove_enabled,
+          domain_excluded: domain_excluded ?? false,
+          notice_is_grace_period: notice_is_grace_period ?? true,
+          notice_reminder_frequency,
+        },
+      }
+    } catch (err) {
+      logForDebugging(`Failed to fetch Grove notice config: ${err}`)
+      return { success: false }
+    }
+  },
+)
+
+/**
+ * Determines whether the Grove dialog should be shown.
+ * Returns false if either API call failed (after retry) - we hide the dialog on API failure.
+ */
+export function calculateShouldShowGrove(
+  settingsResult: ApiResult<AccountSettings>,
+  configResult: ApiResult<GroveConfig>,
+  showIfAlreadyViewed: boolean,
+): boolean {
+  // Hide dialog on API failure (after retry)
+  if (!settingsResult.success || !configResult.success) {
+    return false
+  }
+
+  const settings = settingsResult.data
+  const config = configResult.data
+
+  const hasChosen = settings.grove_enabled !== null
+  if (hasChosen) {
+    return false
+  }
+  if (showIfAlreadyViewed) {
+    return true
+  }
+  if (!config.notice_is_grace_period) {
+    return true
+  }
+  // Check if we need to remind the user to accept the terms and choose
+  // whether to help improve Claude.
+  const reminderFrequency = config.notice_reminder_frequency
+  if (reminderFrequency !== null && settings.grove_notice_viewed_at) {
+    const daysSinceViewed = Math.floor(
+      (Date.now() - new Date(settings.grove_notice_viewed_at).getTime()) /
+        (1000 * 60 * 60 * 24),
+    )
+    return daysSinceViewed >= reminderFrequency
+  } else {
+    // Show if never viewed before
+    const viewedAt = settings.grove_notice_viewed_at
+    return viewedAt === null || viewedAt === undefined
+  }
+}
+
+export async function checkGroveForNonInteractive(): Promise<void> {
+  const [settingsResult, configResult] = await Promise.all([
+    getGroveSettings(),
+    getGroveNoticeConfig(),
+  ])
+
+  // Check if user hasn't made a choice yet (returns false on API failure)
+  const shouldShowGrove = calculateShouldShowGrove(
+    settingsResult,
+    configResult,
+    false,
+  )
+
+  if (shouldShowGrove) {
+    // shouldShowGrove is only true if both API calls succeeded
+    const config = configResult.success ? configResult.data : null
+    logEvent('tengu_grove_print_viewed', {
+      dismissable:
+        config?.notice_is_grace_period as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    if (config === null || config.notice_is_grace_period) {
+      // Grace period is still active - show informational message and continue
+      writeToStderr(
+        '\nAn update to our Consumer Terms and Privacy Policy will take effect on October 8, 2025. Run `claude` to review the updated terms.\n\n',
+      )
+      await markGroveNoticeViewed()
+    } else {
+      // Grace period has ended - show error message and exit
+      writeToStderr(
+        '\n[ACTION REQUIRED] An update to our Consumer Terms and Privacy Policy has taken effect on October 8, 2025. You must run `claude` to review the updated terms.\n\n',
+      )
+      await gracefulShutdown(1)
+    }
+  }
+}