refactor: restructure project to monorepo with apps directory

apps/app/electron/services/model-provider.js

@@ -0,0 +1,524 @@
+/**
+ * Model Provider Abstraction Layer
+ *
+ * This module provides an abstract interface for model providers (Claude, Codex, etc.)
+ * allowing the application to use different AI models through a unified API.
+ */
+
+/**
+ * Base class for model providers
+ * Concrete implementations should extend this class
+ */
+class ModelProvider {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = 'base';
+  }
+
+  /**
+   * Get provider name
+   * @returns {string} Provider name
+   */
+  getName() {
+    return this.name;
+  }
+
+  /**
+   * Execute a query with the model provider
+   * @param {Object} options Query options
+   * @param {string} options.prompt The prompt to send
+   * @param {string} options.model The model to use
+   * @param {string} options.systemPrompt System prompt
+   * @param {string} options.cwd Working directory
+   * @param {number} options.maxTurns Maximum turns
+   * @param {string[]} options.allowedTools Allowed tools
+   * @param {Object} options.mcpServers MCP servers configuration
+   * @param {AbortController} options.abortController Abort controller
+   * @param {Object} options.thinking Thinking configuration
+   * @returns {AsyncGenerator} Async generator yielding messages
+   */
+  async *executeQuery(options) {
+    throw new Error('executeQuery must be implemented by subclass');
+  }
+
+  /**
+   * Detect if this provider's CLI/SDK is installed
+   * @returns {Promise<Object>} Installation status
+   */
+  async detectInstallation() {
+    throw new Error('detectInstallation must be implemented by subclass');
+  }
+
+  /**
+   * Get list of available models for this provider
+   * @returns {Array<Object>} Array of model definitions
+   */
+  getAvailableModels() {
+    throw new Error('getAvailableModels must be implemented by subclass');
+  }
+
+  /**
+   * Validate provider configuration
+   * @returns {Object} Validation result { valid: boolean, errors: string[] }
+   */
+  validateConfig() {
+    throw new Error('validateConfig must be implemented by subclass');
+  }
+
+  /**
+   * Get the full model string for a model key
+   * @param {string} modelKey Short model key (e.g., 'opus', 'gpt-5.1-codex')
+   * @returns {string} Full model string
+   */
+  getModelString(modelKey) {
+    throw new Error('getModelString must be implemented by subclass');
+  }
+
+  /**
+   * Check if provider supports a specific feature
+   * @param {string} feature Feature name (e.g., 'thinking', 'tools', 'streaming')
+   * @returns {boolean} Whether the feature is supported
+   */
+  supportsFeature(feature) {
+    return false;
+  }
+}
+
+/**
+ * Claude Provider - Uses Anthropic Claude Agent SDK
+ */
+class ClaudeProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'claude';
+    this.sdk = null;
+  }
+
+  /**
+   * Try to load credentials from the app's own credentials.json file.
+   * This is where we store OAuth tokens and API keys that users enter in the setup wizard.
+   * Returns { oauthToken, apiKey } or null values if not found.
+   */
+  loadTokenFromAppCredentials() {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const { app } = require('electron');
+      const credentialsPath = path.join(app.getPath('userData'), 'credentials.json');
+
+      if (!fs.existsSync(credentialsPath)) {
+        console.log('[ClaudeProvider] App credentials file does not exist:', credentialsPath);
+        return { oauthToken: null, apiKey: null };
+      }
+
+      const raw = fs.readFileSync(credentialsPath, 'utf-8');
+      const parsed = JSON.parse(raw);
+
+      // Check for OAuth token first (from claude setup-token), then API key
+      const oauthToken = parsed.anthropic_oauth_token || null;
+      const apiKey = parsed.anthropic || parsed.anthropic_api_key || null;
+
+      console.log('[ClaudeProvider] App credentials check - OAuth token:', !!oauthToken, ', API key:', !!apiKey);
+      return { oauthToken, apiKey };
+    } catch (err) {
+      console.warn('[ClaudeProvider] Failed to read app credentials:', err?.message);
+      return { oauthToken: null, apiKey: null };
+    }
+  }
+
+  /**
+   * Try to load a Claude OAuth token from the local CLI config (~/.claude/config.json).
+   * Returns the token string or null if not found.
+   * NOTE: Claude's credentials.json is encrypted, so we only try config.json
+   */
+  loadTokenFromCliConfig() {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const configPath = path.join(require('os').homedir(), '.claude', 'config.json');
+      if (!fs.existsSync(configPath)) {
+        return null;
+      }
+      const raw = fs.readFileSync(configPath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      // CLI config stores token as oauth_token (newer) or token (older)
+      return parsed.oauth_token || parsed.token || null;
+    } catch (err) {
+      console.warn('[ClaudeProvider] Failed to read CLI config token:', err?.message);
+      return null;
+    }
+  }
+
+  ensureAuthEnv() {
+    // If API key or token already present in environment, keep as-is.
+    if (process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+      console.log('[ClaudeProvider] Auth already present in environment');
+      return true;
+    }
+
+    // Priority 1: Try to load from app's own credentials (setup wizard)
+    const appCredentials = this.loadTokenFromAppCredentials();
+    if (appCredentials.oauthToken) {
+      process.env.CLAUDE_CODE_OAUTH_TOKEN = appCredentials.oauthToken;
+      console.log('[ClaudeProvider] Loaded CLAUDE_CODE_OAUTH_TOKEN from app credentials');
+      return true;
+    }
+    if (appCredentials.apiKey) {
+      process.env.ANTHROPIC_API_KEY = appCredentials.apiKey;
+      console.log('[ClaudeProvider] Loaded ANTHROPIC_API_KEY from app credentials');
+      return true;
+    }
+
+    // Priority 2: Try to hydrate from CLI login config (legacy)
+    const token = this.loadTokenFromCliConfig();
+    if (token) {
+      process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
+      console.log('[ClaudeProvider] Loaded CLAUDE_CODE_OAUTH_TOKEN from ~/.claude/config.json');
+      return true;
+    }
+
+    // Check if CLI is installed but not logged in
+    try {
+      const claudeCliDetector = require('./claude-cli-detector');
+      const detection = claudeCliDetector.detectClaudeInstallation();
+      if (detection.installed && detection.method === 'cli') {
+        console.error('[ClaudeProvider] Claude CLI is installed but not authenticated. Use the setup wizard or set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN environment variable.');
+      } else {
+        console.error('[ClaudeProvider] No Anthropic auth found. Use the setup wizard or set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN.');
+      }
+    } catch (err) {
+      console.error('[ClaudeProvider] No Anthropic auth found. Use the setup wizard or set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN.');
+    }
+    return false;
+  }
+
+  /**
+   * Lazily load the Claude SDK
+   */
+  loadSdk() {
+    if (!this.sdk) {
+      this.sdk = require('@anthropic-ai/claude-agent-sdk');
+    }
+    return this.sdk;
+  }
+
+  async *executeQuery(options) {
+    // Ensure we have auth; fall back to app credentials or CLI login token if available.
+    if (!this.ensureAuthEnv()) {
+      // Check if CLI is installed to provide better error message
+      let msg = 'Missing Anthropic auth. Go to Settings > Setup to configure your Claude authentication.';
+      try {
+        const claudeCliDetector = require('./claude-cli-detector');
+        const detection = claudeCliDetector.detectClaudeInstallation();
+        if (detection.installed && detection.method === 'cli') {
+          msg = 'Claude CLI is installed but not authenticated. Go to Settings > Setup to provide your subscription token (from `claude setup-token`) or API key.';
+        } else {
+          msg = 'Missing Anthropic auth. Go to Settings > Setup to configure your Claude authentication, or set ANTHROPIC_API_KEY environment variable.';
+        }
+      } catch (err) {
+        // Fallback to default message
+      }
+      console.error(`[ClaudeProvider] ${msg}`);
+      yield { type: 'error', error: msg };
+      return;
+    }
+
+    const { query } = this.loadSdk();
+
+    const sdkOptions = {
+      model: options.model,
+      systemPrompt: options.systemPrompt,
+      maxTurns: options.maxTurns || 1000,
+      cwd: options.cwd,
+      mcpServers: options.mcpServers,
+      allowedTools: options.allowedTools,
+      permissionMode: options.permissionMode || 'acceptEdits',
+      sandbox: options.sandbox,
+      abortController: options.abortController,
+    };
+
+    // Add thinking configuration if enabled
+    if (options.thinking) {
+      sdkOptions.thinking = options.thinking;
+    }
+
+    const currentQuery = query({ prompt: options.prompt, options: sdkOptions });
+
+    for await (const msg of currentQuery) {
+      yield msg;
+    }
+  }
+
+  async detectInstallation() {
+    const claudeCliDetector = require('./claude-cli-detector');
+    return claudeCliDetector.getFullStatus();
+  }
+
+  getAvailableModels() {
+    return [
+      {
+        id: 'haiku',
+        name: 'Claude Haiku',
+        modelString: 'claude-haiku-4-5',
+        provider: 'claude',
+        description: 'Fast and efficient for simple tasks',
+        tier: 'basic'
+      },
+      {
+        id: 'sonnet',
+        name: 'Claude Sonnet',
+        modelString: 'claude-sonnet-4-20250514',
+        provider: 'claude',
+        description: 'Balanced performance and capabilities',
+        tier: 'standard'
+      },
+      {
+        id: 'opus',
+        name: 'Claude Opus 4.5',
+        modelString: 'claude-opus-4-5-20251101',
+        provider: 'claude',
+        description: 'Most capable model for complex tasks',
+        tier: 'premium'
+      }
+    ];
+  }
+
+  validateConfig() {
+    const errors = [];
+
+    // Ensure auth is available (try to auto-load from app credentials or CLI config)
+    this.ensureAuthEnv();
+
+    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN && !process.env.ANTHROPIC_API_KEY) {
+      errors.push('No Claude authentication found. Go to Settings > Setup to configure your subscription token or API key.');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  getModelString(modelKey) {
+    const modelMap = {
+      haiku: 'claude-haiku-4-5',
+      sonnet: 'claude-sonnet-4-20250514',
+      opus: 'claude-opus-4-5-20251101'
+    };
+    return modelMap[modelKey] || modelMap.opus;
+  }
+
+  supportsFeature(feature) {
+    const supportedFeatures = ['thinking', 'tools', 'streaming', 'mcp'];
+    return supportedFeatures.includes(feature);
+  }
+}
+
+/**
+ * Codex Provider - Uses OpenAI Codex CLI
+ */
+class CodexProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'codex';
+  }
+
+  async *executeQuery(options) {
+    const codexExecutor = require('./codex-executor');
+
+    // Validate that we're not receiving a Claude model string
+    if (options.model && options.model.startsWith('claude-')) {
+      const errorMsg = `Codex provider cannot use Claude model '${options.model}'. Codex only supports OpenAI models (gpt-5.1-codex-max, gpt-5.1-codex, gpt-5.1-codex-mini, gpt-5.1).`;
+      console.error(`[CodexProvider] ${errorMsg}`);
+      yield {
+        type: 'error',
+        error: errorMsg
+      };
+      return;
+    }
+
+    const executeOptions = {
+      prompt: options.prompt,
+      model: options.model,
+      cwd: options.cwd,
+      systemPrompt: options.systemPrompt,
+      maxTurns: options.maxTurns || 20,
+      allowedTools: options.allowedTools,
+      mcpServers: options.mcpServers, // Pass MCP servers config to executor
+      env: {
+        ...process.env,
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY
+      }
+    };
+
+    // Execute and yield results
+    const generator = codexExecutor.execute(executeOptions);
+    for await (const msg of generator) {
+      yield msg;
+    }
+  }
+
+  async detectInstallation() {
+    const codexCliDetector = require('./codex-cli-detector');
+    return codexCliDetector.getInstallationInfo();
+  }
+
+  getAvailableModels() {
+    return [
+      {
+        id: 'gpt-5.1-codex-max',
+        name: 'GPT-5.1 Codex Max',
+        modelString: 'gpt-5.1-codex-max',
+        provider: 'codex',
+        description: 'Latest flagship - deep and fast reasoning for coding',
+        tier: 'premium',
+        default: true
+      },
+      {
+        id: 'gpt-5.1-codex',
+        name: 'GPT-5.1 Codex',
+        modelString: 'gpt-5.1-codex',
+        provider: 'codex',
+        description: 'Optimized for code generation',
+        tier: 'standard'
+      },
+      {
+        id: 'gpt-5.1-codex-mini',
+        name: 'GPT-5.1 Codex Mini',
+        modelString: 'gpt-5.1-codex-mini',
+        provider: 'codex',
+        description: 'Faster and cheaper option',
+        tier: 'basic'
+      },
+      {
+        id: 'gpt-5.1',
+        name: 'GPT-5.1',
+        modelString: 'gpt-5.1',
+        provider: 'codex',
+        description: 'Broad world knowledge with strong reasoning',
+        tier: 'standard'
+      }
+    ];
+  }
+
+  validateConfig() {
+    const errors = [];
+    const codexCliDetector = require('./codex-cli-detector');
+    const installation = codexCliDetector.detectCodexInstallation();
+
+    if (!installation.installed && !process.env.OPENAI_API_KEY) {
+      errors.push('Codex CLI not installed and no OPENAI_API_KEY found.');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  getModelString(modelKey) {
+    // Codex models use the key directly as the model string
+    const modelMap = {
+      'gpt-5.1-codex-max': 'gpt-5.1-codex-max',
+      'gpt-5.1-codex': 'gpt-5.1-codex',
+      'gpt-5.1-codex-mini': 'gpt-5.1-codex-mini',
+      'gpt-5.1': 'gpt-5.1'
+    };
+    return modelMap[modelKey] || 'gpt-5.1-codex-max';
+  }
+
+  supportsFeature(feature) {
+    const supportedFeatures = ['tools', 'streaming'];
+    return supportedFeatures.includes(feature);
+  }
+}
+
+/**
+ * Model Provider Factory
+ * Creates the appropriate provider based on model or provider name
+ */
+class ModelProviderFactory {
+  static providers = {
+    claude: ClaudeProvider,
+    codex: CodexProvider
+  };
+
+  /**
+   * Get provider for a specific model
+   * @param {string} modelId Model ID (e.g., 'opus', 'gpt-5.1-codex')
+   * @returns {ModelProvider} Provider instance
+   */
+  static getProviderForModel(modelId) {
+    // Check if it's a Claude model
+    const claudeModels = ['haiku', 'sonnet', 'opus'];
+    if (claudeModels.includes(modelId)) {
+      return new ClaudeProvider();
+    }
+
+    // Check if it's a Codex/OpenAI model
+    const codexModels = [
+      'gpt-5.1-codex-max', 'gpt-5.1-codex', 'gpt-5.1-codex-mini', 'gpt-5.1'
+    ];
+    if (codexModels.includes(modelId)) {
+      return new CodexProvider();
+    }
+
+    // Default to Claude
+    return new ClaudeProvider();
+  }
+
+  /**
+   * Get provider by name
+   * @param {string} providerName Provider name ('claude' or 'codex')
+   * @returns {ModelProvider} Provider instance
+   */
+  static getProvider(providerName) {
+    const ProviderClass = this.providers[providerName];
+    if (!ProviderClass) {
+      throw new Error(`Unknown provider: ${providerName}`);
+    }
+    return new ProviderClass();
+  }
+
+  /**
+   * Get all available providers
+   * @returns {string[]} List of provider names
+   */
+  static getAvailableProviders() {
+    return Object.keys(this.providers);
+  }
+
+  /**
+   * Get all available models across all providers
+   * @returns {Array<Object>} All available models
+   */
+  static getAllModels() {
+    const allModels = [];
+    for (const providerName of this.getAvailableProviders()) {
+      const provider = this.getProvider(providerName);
+      const models = provider.getAvailableModels();
+      allModels.push(...models);
+    }
+    return allModels;
+  }
+
+  /**
+   * Check installation status for all providers
+   * @returns {Promise<Object>} Installation status for each provider
+   */
+  static async checkAllProviders() {
+    const status = {};
+    for (const providerName of this.getAvailableProviders()) {
+      const provider = this.getProvider(providerName);
+      status[providerName] = await provider.detectInstallation();
+    }
+    return status;
+  }
+}
+
+module.exports = {
+  ModelProvider,
+  ClaudeProvider,
+  CodexProvider,
+  ModelProviderFactory
+};