@jonnyhoo/ccs 1.0.0

package/dist/cliproxy/config-generator.js

@@ -0,0 +1,876 @@
+"use strict";
+/**
+ * Config Generator for CLIProxyAPI
+ *
+ * Generates config.yaml for CLIProxyAPI based on provider.
+ * Handles OAuth token paths and provider-specific settings.
+ *
+ * Model mappings are loaded from config/base-{provider}.settings.json files
+ * to allow easy updates without code changes.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemoteEnvVars = exports.ensureProviderSettings = exports.getEffectiveEnvVars = exports.getClaudeEnvVars = exports.getProviderSettingsPath = exports.deleteConfig = exports.deleteConfigForPort = exports.configExists = exports.configNeedsRegeneration = exports.regenerateConfig = exports.parseUserApiKeys = exports.generateConfig = exports.getBinDir = exports.getCliproxyConfigPath = exports.getConfigPathForPort = exports.getAuthDir = exports.getProviderAuthDir = exports.getCliproxyDir = exports.getModelMapping = exports.getProviderConfig = exports.CLIPROXY_CONFIG_VERSION = exports.getCliproxyWritablePath = exports.CCS_CONTROL_PANEL_SECRET = exports.CCS_INTERNAL_API_KEY = exports.getRemoteDefaultPort = exports.validateRemotePort = exports.normalizeProtocol = exports.CLIPROXY_DEFAULT_PORT = exports.validatePort = exports.applyThinkingConfig = exports.getThinkingValueForTier = exports.applyThinkingSuffix = exports.detectTierFromModel = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_manager_1 = require("../utils/config-manager");
+const helpers_1 = require("../utils/helpers");
+const ui_1 = require("../utils/ui");
+const base_config_loader_1 = require("./base-config-loader");
+const unified_config_loader_1 = require("../config/unified-config-loader");
+const auth_token_manager_1 = require("./auth-token-manager");
+const model_catalog_1 = require("./model-catalog");
+const thinking_validator_1 = require("./thinking-validator");
+/**
+ * Check if warnings should be shown based on thinking config.
+ * Defaults to true if show_warnings is not explicitly false.
+ */
+function shouldShowWarnings(thinkingConfig) {
+    return thinkingConfig.show_warnings !== false;
+}
+/**
+ * Detect tier from model name.
+ * Returns 'sonnet' as default if unclear.
+ */
+function detectTierFromModel(modelName) {
+    const lower = modelName.toLowerCase();
+    if (lower.includes('opus'))
+        return 'opus';
+    if (lower.includes('haiku'))
+        return 'haiku';
+    return 'sonnet'; // Default to sonnet (most common)
+}
+exports.detectTierFromModel = detectTierFromModel;
+/**
+ * Apply thinking suffix to model name.
+ * CLIProxyAPIPlus parses suffixes like model(level) or model(budget).
+ *
+ * @param model - Base model name
+ * @param thinkingValue - Level name (e.g., 'high') or numeric budget
+ * @returns Model name with thinking suffix, e.g., "gemini-3-pro-preview(high)"
+ */
+function applyThinkingSuffix(model, thinkingValue) {
+    // Don't apply if model already ends with a parenthesized suffix (e.g., "model(high)" or "model(8192)")
+    // Matches: ends with "(...)" where content is non-empty
+    if (/\([^)]+\)$/.test(model)) {
+        return model;
+    }
+    return `${model}(${thinkingValue})`;
+}
+exports.applyThinkingSuffix = applyThinkingSuffix;
+/**
+ * Get thinking value for tier based on config.
+ * Respects provider-specific overrides if configured.
+ */
+function getThinkingValueForTier(tier, provider, thinkingConfig) {
+    // Check provider-specific override first
+    const providerOverride = thinkingConfig.provider_overrides?.[provider]?.[tier];
+    if (providerOverride) {
+        return providerOverride;
+    }
+    // Fall back to global tier default (with null guard)
+    return thinkingConfig.tier_defaults?.[tier] ?? 'medium';
+}
+exports.getThinkingValueForTier = getThinkingValueForTier;
+/**
+ * Apply thinking configuration to env vars.
+ * Modifies ANTHROPIC_MODEL and tier models with thinking suffixes.
+ *
+ * @param envVars - Environment variables to modify
+ * @param provider - CLIProxy provider
+ * @param thinkingOverride - Optional CLI override (takes priority over config)
+ * @returns Modified env vars with thinking suffixes applied
+ */
+function applyThinkingConfig(envVars, provider, thinkingOverride) {
+    const thinkingConfig = (0, unified_config_loader_1.getThinkingConfig)();
+    const result = { ...envVars };
+    // Check if thinking is off
+    if (thinkingConfig.mode === 'off' && thinkingOverride === undefined) {
+        return result;
+    }
+    // Get base model to check thinking support
+    const baseModel = result.ANTHROPIC_MODEL || '';
+    if (!(0, model_catalog_1.supportsThinking)(provider, baseModel)) {
+        // U2: Warn user if they explicitly provided --thinking but model doesn't support it
+        if (thinkingOverride !== undefined && shouldShowWarnings(thinkingConfig)) {
+            console.warn((0, ui_1.warn)(`Model ${baseModel || 'unknown'} (provider: ${provider}) does not support thinking budget. --thinking flag ignored.`));
+        }
+        return result;
+    }
+    // Determine thinking value to use
+    let thinkingValue;
+    if (thinkingOverride !== undefined) {
+        // CLI override takes priority
+        thinkingValue = thinkingOverride;
+    }
+    else if (thinkingConfig.mode === 'manual' && thinkingConfig.override !== undefined) {
+        // Config manual mode with override
+        thinkingValue = thinkingConfig.override;
+    }
+    else if (thinkingConfig.mode === 'auto') {
+        // Auto mode: detect tier and apply default
+        const tier = detectTierFromModel(baseModel);
+        thinkingValue = getThinkingValueForTier(tier, provider, thinkingConfig);
+    }
+    else {
+        return result; // No thinking to apply
+    }
+    // Validate thinking value against model capabilities
+    const validation = (0, thinking_validator_1.validateThinking)(provider, baseModel, thinkingValue);
+    if (validation.warning && shouldShowWarnings(thinkingConfig)) {
+        console.warn((0, ui_1.warn)(validation.warning));
+    }
+    thinkingValue = validation.value;
+    // If validation says off, don't apply suffix
+    if (thinkingValue === 'off') {
+        return result;
+    }
+    // Apply thinking suffix to main model
+    if (result.ANTHROPIC_MODEL) {
+        result.ANTHROPIC_MODEL = applyThinkingSuffix(result.ANTHROPIC_MODEL, thinkingValue);
+    }
+    // Apply to tier models if they support thinking
+    const tierModels = [
+        'ANTHROPIC_DEFAULT_OPUS_MODEL',
+        'ANTHROPIC_DEFAULT_SONNET_MODEL',
+        'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    ];
+    for (const tierVar of tierModels) {
+        const model = result[tierVar];
+        if (model && (0, model_catalog_1.supportsThinking)(provider, model)) {
+            // Get tier-specific thinking value
+            const tier = tierVar.includes('OPUS')
+                ? 'opus'
+                : tierVar.includes('SONNET')
+                    ? 'sonnet'
+                    : 'haiku';
+            const tierThinkingValue = thinkingOverride ?? getThinkingValueForTier(tier, provider, thinkingConfig);
+            result[tierVar] = applyThinkingSuffix(model, tierThinkingValue);
+        }
+    }
+    return result;
+}
+exports.applyThinkingConfig = applyThinkingConfig;
+/**
+ * Validate port is a valid positive integer (1-65535).
+ * Returns default port if invalid.
+ *
+ * @param port - Port number to validate
+ * @returns Valid port or CLIPROXY_DEFAULT_PORT (8317) if invalid
+ */
+function validatePort(port) {
+    if (port === undefined || port === null) {
+        return exports.CLIPROXY_DEFAULT_PORT;
+    }
+    if (!Number.isFinite(port) || port < 1 || port > 65535 || !Number.isInteger(port)) {
+        return exports.CLIPROXY_DEFAULT_PORT;
+    }
+    return port;
+}
+exports.validatePort = validatePort;
+/**
+ * Ensure required CLIProxy env vars are present.
+ * Falls back to bundled defaults if missing from user settings.
+ * This prevents 404 errors when users forget to set BASE_URL/AUTH_TOKEN.
+ */
+function ensureRequiredEnvVars(envVars, provider, port) {
+    const validPort = validatePort(port);
+    const result = { ...envVars };
+    const defaults = getClaudeEnvVars(provider, validPort);
+    // Fill in missing required vars from defaults
+    if (!result.ANTHROPIC_BASE_URL?.trim()) {
+        result.ANTHROPIC_BASE_URL = defaults.ANTHROPIC_BASE_URL;
+    }
+    if (!result.ANTHROPIC_AUTH_TOKEN?.trim()) {
+        result.ANTHROPIC_AUTH_TOKEN = defaults.ANTHROPIC_AUTH_TOKEN;
+    }
+    return result;
+}
+/** Default CLIProxy port */
+exports.CLIPROXY_DEFAULT_PORT = 8317;
+/**
+ * Normalize protocol to lowercase and validate.
+ * Handles runtime case sensitivity (e.g., 'HTTPS' → 'https').
+ * Defaults to 'http' for invalid values.
+ */
+function normalizeProtocol(protocol) {
+    if (!protocol)
+        return 'http';
+    const normalized = protocol.toLowerCase();
+    if (normalized === 'https')
+        return 'https';
+    if (normalized === 'http')
+        return 'http';
+    // Invalid protocol (e.g., 'ftp') - default to http
+    return 'http';
+}
+exports.normalizeProtocol = normalizeProtocol;
+/**
+ * Validate and sanitize port number for remote connections.
+ * Returns undefined for invalid ports (letting caller use default).
+ * Valid range: 1-65535, must be integer.
+ */
+function validateRemotePort(port) {
+    if (port === undefined || port === null)
+        return undefined;
+    if (typeof port !== 'number' || !Number.isInteger(port))
+        return undefined;
+    if (port <= 0 || port > 65535)
+        return undefined;
+    return port;
+}
+exports.validateRemotePort = validateRemotePort;
+/**
+ * Get default port for remote CLIProxyAPI based on protocol.
+ * - HTTP: 8317 (CLIProxyAPI default)
+ * - HTTPS: 443 (standard SSL port)
+ */
+function getRemoteDefaultPort(protocol) {
+    return protocol === 'https' ? 443 : exports.CLIPROXY_DEFAULT_PORT;
+}
+exports.getRemoteDefaultPort = getRemoteDefaultPort;
+/** Internal API key for CCS-managed requests */
+exports.CCS_INTERNAL_API_KEY = 'ccs-internal-managed';
+/** Simple secret key for Control Panel login (user-facing) */
+exports.CCS_CONTROL_PANEL_SECRET = 'ccs';
+/**
+ * Get CLIProxy writable directory for logs and runtime files.
+ * This directory is set as WRITABLE_PATH env var when spawning CLIProxy.
+ * Logs will be stored in ~/.ccs/cliproxy/logs/
+ */
+function getCliproxyWritablePath() {
+    return path.join((0, config_manager_1.getCcsDir)(), 'cliproxy');
+}
+exports.getCliproxyWritablePath = getCliproxyWritablePath;
+/**
+ * Config version - bump when config format changes to trigger regeneration
+ * v1: Initial config (port, auth-dir, api-keys only)
+ * v2: Full-featured config with dashboard, quota mgmt, simplified key
+ * v3: Logging disabled by default (user opt-in via ~/.ccs/config.yaml)
+ * v4: Added Kiro (AWS) and GitHub Copilot providers
+ * v5: Added disable-cooling: true for stability
+ */
+exports.CLIPROXY_CONFIG_VERSION = 5;
+/** Provider display names (static metadata) */
+const PROVIDER_DISPLAY_NAMES = {
+    gemini: 'Gemini',
+    codex: 'Codex',
+    agy: 'Antigravity',
+    qwen: 'Qwen Code',
+    iflow: 'iFlow',
+    kiro: 'Kiro (AWS)',
+    ghcp: 'GitHub Copilot (OAuth)',
+    claude: 'Claude (Anthropic)',
+};
+/**
+ * Get provider configuration
+ * Model mappings are loaded from config/base-{provider}.settings.json
+ */
+function getProviderConfig(provider) {
+    const displayName = PROVIDER_DISPLAY_NAMES[provider];
+    if (!displayName) {
+        throw new Error(`Unknown provider: ${provider}`);
+    }
+    // Load models from base config file
+    const models = (0, base_config_loader_1.getModelMappingFromConfig)(provider);
+    return {
+        name: provider,
+        displayName,
+        models,
+        requiresOAuth: true, // All CLIProxy providers require OAuth
+    };
+}
+exports.getProviderConfig = getProviderConfig;
+/**
+ * Get model mapping for provider
+ * Loads from config/base-{provider}.settings.json
+ */
+function getModelMapping(provider) {
+    return getProviderConfig(provider).models;
+}
+exports.getModelMapping = getModelMapping;
+/**
+ * Get CLIProxy base directory
+ * All CLIProxy-related files are stored under ~/.ccs/cliproxy/
+ */
+function getCliproxyDir() {
+    return path.join((0, config_manager_1.getCcsDir)(), 'cliproxy');
+}
+exports.getCliproxyDir = getCliproxyDir;
+/**
+ * Get auth directory for provider
+ * All providers use a FLAT auth directory structure for unified config.
+ * CLIProxyAPI stores OAuth tokens directly in auth/ (not subdirectories).
+ * This enables all providers to be discovered and used concurrently.
+ */
+function getProviderAuthDir(_provider) {
+    // Use flat structure - all auth files in same directory for unified discovery
+    // Provider param kept for API compatibility (CLIProxyAPI handles via auth file type field)
+    return path.join(getCliproxyDir(), 'auth');
+}
+exports.getProviderAuthDir = getProviderAuthDir;
+/**
+ * Get base auth directory for CLIProxyAPI
+ */
+function getAuthDir() {
+    return path.join(getCliproxyDir(), 'auth');
+}
+exports.getAuthDir = getAuthDir;
+/**
+ * Get config file path for a specific port.
+ * Default port uses config.yaml, others use config-{port}.yaml.
+ */
+function getConfigPathForPort(port) {
+    if (port === exports.CLIPROXY_DEFAULT_PORT) {
+        return path.join(getCliproxyDir(), 'config.yaml');
+    }
+    return path.join(getCliproxyDir(), `config-${port}.yaml`);
+}
+exports.getConfigPathForPort = getConfigPathForPort;
+/**
+ * Get CLIProxy config file path (default port)
+ * Named distinctly from config-manager's getConfigPath to avoid confusion.
+ */
+function getCliproxyConfigPath() {
+    return getConfigPathForPort(exports.CLIPROXY_DEFAULT_PORT);
+}
+exports.getCliproxyConfigPath = getCliproxyConfigPath;
+/**
+ * Get binary directory path
+ */
+function getBinDir() {
+    return path.join(getCliproxyDir(), 'bin');
+}
+exports.getBinDir = getBinDir;
+/**
+ * Get CLIProxy logging settings from user config.
+ * Defaults to disabled to prevent disk bloat.
+ */
+function getLoggingSettings() {
+    const config = (0, unified_config_loader_1.loadOrCreateUnifiedConfig)();
+    return {
+        loggingToFile: config.cliproxy.logging?.enabled ?? false,
+        requestLog: config.cliproxy.logging?.request_log ?? false,
+    };
+}
+/**
+ * Generate UNIFIED config.yaml content for ALL providers
+ * This enables concurrent usage of gemini/codex/agy without config conflicts.
+ * CLIProxyAPI routes requests by model name to the appropriate provider.
+ *
+ * @param port - Server port (default: 8317)
+ * @param userApiKeys - User-added API keys to preserve (default: [])
+ */
+function generateUnifiedConfigContent(port = exports.CLIPROXY_DEFAULT_PORT, userApiKeys = []) {
+    const authDir = getAuthDir(); // Base auth dir - CLIProxyAPI scans subdirectories
+    // Convert Windows backslashes to forward slashes for YAML compatibility
+    const authDirNormalized = authDir.split(path.sep).join('/');
+    // Get logging settings from user config (disabled by default)
+    const { loggingToFile, requestLog } = getLoggingSettings();
+    // Get effective auth tokens (respects user customization)
+    const effectiveApiKey = (0, auth_token_manager_1.getEffectiveApiKey)();
+    const effectiveSecret = (0, auth_token_manager_1.getEffectiveManagementSecret)();
+    // Build api-keys section with internal key + preserved user keys
+    const allApiKeys = [effectiveApiKey, ...userApiKeys];
+    const apiKeysYaml = allApiKeys.map((key) => `  - "${key}"`).join('\n');
+    // Unified config with enhanced CLIProxyAPI features
+    const config = `# CLIProxyAPI config generated by CCS v${exports.CLIPROXY_CONFIG_VERSION}
+# Supports: gemini, codex, agy, qwen, iflow (concurrent usage)
+# Generated: ${new Date().toISOString()}
+#
+# This config is auto-managed by CCS. Manual edits may be overwritten.
+# Use 'ccs doctor' to regenerate with latest settings.
+
+# =============================================================================
+# Server Settings
+# =============================================================================
+
+port: ${port}
+debug: false
+
+# =============================================================================
+# Logging
+# =============================================================================
+# WARNING: Logs can grow to several GB if enabled!
+# To enable logging, edit ~/.ccs/config.yaml:
+#   cliproxy:
+#     logging:
+#       enabled: true
+#       request_log: true
+# Then run 'ccs doctor --fix' to regenerate this config.
+# Use 'ccs cleanup' to remove old logs.
+
+# Write logs to file (stored in ~/.ccs/cliproxy/logs/)
+logging-to-file: ${loggingToFile}
+
+# Log individual API requests for debugging/analytics
+request-log: ${requestLog}
+
+# =============================================================================
+# Dashboard & Management
+# =============================================================================
+
+# Enable usage statistics for CCS dashboard analytics
+usage-statistics-enabled: true
+
+# Remote management API for CCS dashboard integration
+remote-management:
+  allow-remote: true
+  secret-key: "${effectiveSecret}"
+  disable-control-panel: false
+
+# =============================================================================
+# Reliability & Quota Management
+# =============================================================================
+
+# Disable quota cooldown scheduling for stability
+disable-cooling: true
+
+# Auto-retry on transient errors (403, 408, 500, 502, 503, 504)
+request-retry: 0
+max-retry-interval: 0
+
+# Auto-switch accounts on quota exceeded (429)
+# This enables seamless multi-account rotation when rate limited
+quota-exceeded:
+  switch-project: true
+  switch-preview-model: true
+
+# =============================================================================
+# Authentication
+# =============================================================================
+
+# API keys for CCS and user-added external requests
+# NOTE: User-added keys are preserved across CCS updates (fix for issue #200)
+api-keys:
+${apiKeysYaml}
+
+# OAuth tokens directory (auto-discovered by CLIProxyAPI)
+auth-dir: "${authDirNormalized}"
+`;
+    return config;
+}
+/**
+ * Generate unified config.yaml file (supports all providers concurrently)
+ * Only regenerates if config doesn't exist.
+ * @returns Path to config file
+ */
+function generateConfig(provider, port = exports.CLIPROXY_DEFAULT_PORT) {
+    const configPath = getConfigPathForPort(port);
+    // Ensure provider auth directory exists
+    const authDir = getProviderAuthDir(provider);
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.mkdirSync(authDir, { recursive: true, mode: 0o700 });
+    // Only generate config if it doesn't exist (unified config serves all providers)
+    if (!fs.existsSync(configPath)) {
+        const configContent = generateUnifiedConfigContent(port);
+        fs.writeFileSync(configPath, configContent, { mode: 0o600 });
+    }
+    return configPath;
+}
+exports.generateConfig = generateConfig;
+/**
+ * Parse user-added API keys from existing config content.
+ * Extracts all keys except the internal CCS key for preservation.
+ *
+ * @param content - Existing config.yaml content
+ * @returns Array of user-added API keys (excludes CCS_INTERNAL_API_KEY)
+ */
+function parseUserApiKeys(content) {
+    const userKeys = [];
+    // Find the api-keys section by looking for lines starting with "  - " after "api-keys:"
+    // Normalize line endings first
+    const normalizedContent = content.replace(/\r\n/g, '\n');
+    // Find the api-keys: line and extract all subsequent key entries
+    const lines = normalizedContent.split('\n');
+    let inApiKeysSection = false;
+    for (const line of lines) {
+        // Check if this is the start of api-keys section
+        if (line.match(/^api-keys:\s*$/)) {
+            inApiKeysSection = true;
+            continue;
+        }
+        // If we're in the api-keys section, look for key entries
+        if (inApiKeysSection) {
+            // Key entries are indented with "  - " or similar
+            const keyMatch = line.match(/^\s+-\s*"([^"]*)"/);
+            if (keyMatch) {
+                const key = keyMatch[1];
+                // Exclude the internal CCS key and empty strings
+                if (key && key !== exports.CCS_INTERNAL_API_KEY) {
+                    userKeys.push(key);
+                }
+            }
+            else if (line.match(/^\S/) && line.trim().length > 0) {
+                // Non-indented line that's not empty means we've left the api-keys section
+                break;
+            }
+            // Continue for blank lines or other indented content
+        }
+    }
+    return userKeys;
+}
+exports.parseUserApiKeys = parseUserApiKeys;
+/**
+ * Force regenerate config.yaml with latest settings.
+ * Preserves user-added API keys and port settings.
+ *
+ * @param port - Default port to use if not found in existing config
+ * @returns Path to new config file
+ */
+function regenerateConfig(port = exports.CLIPROXY_DEFAULT_PORT) {
+    const configPath = getConfigPathForPort(port);
+    // Preserve user settings from existing config
+    let effectivePort = port;
+    let userApiKeys = [];
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            // Preserve port setting
+            const portMatch = content.match(/^port:\s*(\d+)/m);
+            if (portMatch) {
+                effectivePort = parseInt(portMatch[1], 10);
+            }
+            // Preserve user-added API keys (fix for issue #200)
+            userApiKeys = parseUserApiKeys(content);
+        }
+        catch {
+            // Use defaults if reading fails
+        }
+        // Delete existing config
+        fs.unlinkSync(configPath);
+    }
+    // Ensure directories exist
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.mkdirSync(getAuthDir(), { recursive: true, mode: 0o700 });
+    // Generate fresh config with preserved user API keys
+    const configContent = generateUnifiedConfigContent(effectivePort, userApiKeys);
+    fs.writeFileSync(configPath, configContent, { mode: 0o600 });
+    return configPath;
+}
+exports.regenerateConfig = regenerateConfig;
+/**
+ * Check if config needs regeneration (version mismatch)
+ * @returns true if config should be regenerated
+ */
+function configNeedsRegeneration() {
+    const configPath = getCliproxyConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return false; // Will be created on first use
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        // Check for version marker
+        const versionMatch = content.match(/CCS v(\d+)/);
+        if (!versionMatch) {
+            return true; // No version marker = old config
+        }
+        const configVersion = parseInt(versionMatch[1], 10);
+        return configVersion < exports.CLIPROXY_CONFIG_VERSION;
+    }
+    catch {
+        return true; // Error reading = regenerate
+    }
+}
+exports.configNeedsRegeneration = configNeedsRegeneration;
+/**
+ * Check if config exists for port
+ */
+function configExists(port = exports.CLIPROXY_DEFAULT_PORT) {
+    return fs.existsSync(getConfigPathForPort(port));
+}
+exports.configExists = configExists;
+/**
+ * Delete config file for specific port
+ */
+function deleteConfigForPort(port) {
+    const configPath = getConfigPathForPort(port);
+    if (fs.existsSync(configPath)) {
+        fs.unlinkSync(configPath);
+    }
+}
+exports.deleteConfigForPort = deleteConfigForPort;
+/**
+ * Delete config file (default port)
+ */
+function deleteConfig() {
+    deleteConfigForPort(exports.CLIPROXY_DEFAULT_PORT);
+}
+exports.deleteConfig = deleteConfig;
+/**
+ * Get path to user settings file for provider
+ * Example: ~/.ccs/gemini.settings.json
+ */
+function getProviderSettingsPath(provider) {
+    return path.join((0, config_manager_1.getCcsDir)(), `${provider}.settings.json`);
+}
+exports.getProviderSettingsPath = getProviderSettingsPath;
+/**
+ * Get environment variables for Claude CLI (bundled defaults)
+ * Uses provider-specific endpoint (e.g., /api/provider/gemini) for explicit routing.
+ * This enables concurrent gemini/codex usage - each session routes to its provider via URL path.
+ */
+function getClaudeEnvVars(provider, port = exports.CLIPROXY_DEFAULT_PORT) {
+    const models = getModelMapping(provider);
+    // Base env vars from config file (includes ANTHROPIC_MAX_TOKENS, etc.)
+    const baseEnvVars = (0, base_config_loader_1.getEnvVarsFromConfig)(provider);
+    // Core env vars that we always set dynamically
+    const coreEnvVars = {
+        // Provider-specific endpoint - routes to correct provider via URL path
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}/api/provider/${provider}`,
+        ANTHROPIC_AUTH_TOKEN: (0, auth_token_manager_1.getEffectiveApiKey)(),
+        ANTHROPIC_MODEL: models.claudeModel,
+        ANTHROPIC_DEFAULT_OPUS_MODEL: models.opusModel || models.claudeModel,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: models.sonnetModel || models.claudeModel,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: models.haikuModel || models.claudeModel,
+    };
+    // Filter out core env vars from base config to avoid conflicts
+    const { ANTHROPIC_BASE_URL: _baseUrl, ANTHROPIC_AUTH_TOKEN: _authToken, ANTHROPIC_MODEL: _model, ANTHROPIC_DEFAULT_OPUS_MODEL: _opusModel, ANTHROPIC_DEFAULT_SONNET_MODEL: _sonnetModel, ANTHROPIC_DEFAULT_HAIKU_MODEL: _haikuModel, ...additionalEnvVars } = baseEnvVars;
+    // Merge core env vars with additional env vars from base config
+    return {
+        ...coreEnvVars,
+        ...additionalEnvVars, // Includes ANTHROPIC_MAX_TOKENS, etc.
+    };
+}
+exports.getClaudeEnvVars = getClaudeEnvVars;
+/**
+ * Get global env vars to inject into all third-party profiles.
+ * Returns empty object if disabled.
+ */
+function getGlobalEnvVars() {
+    const globalEnvConfig = (0, unified_config_loader_1.getGlobalEnvConfig)();
+    if (!globalEnvConfig.enabled) {
+        return {};
+    }
+    return globalEnvConfig.env;
+}
+/**
+ * Rewrite localhost URLs to remote server URLs.
+ * Handles various localhost patterns: 127.0.0.1, localhost, 0.0.0.0
+ */
+function rewriteLocalhostUrls(envVars, provider, remoteConfig) {
+    const result = { ...envVars };
+    const baseUrl = result.ANTHROPIC_BASE_URL;
+    if (!baseUrl)
+        return result;
+    // Check if URL points to localhost (127.0.0.1, localhost, 0.0.0.0)
+    const localhostPattern = /^https?:\/\/(127\.0\.0\.1|localhost|0\.0\.0\.0)(:\d+)?/i;
+    if (!localhostPattern.test(baseUrl))
+        return result;
+    // Build remote URL with smart port handling (8317 for HTTP, 443 for HTTPS)
+    // Validate port and normalize protocol for defensive handling
+    const normalizedProtocol = normalizeProtocol(remoteConfig.protocol);
+    const validatedPort = validateRemotePort(remoteConfig.port);
+    const effectivePort = validatedPort ?? getRemoteDefaultPort(normalizedProtocol);
+    // Omit port suffix for standard web ports (80/443) for cleaner URLs
+    const standardWebPort = normalizedProtocol === 'https' ? 443 : 80;
+    const portSuffix = effectivePort === standardWebPort ? '' : `:${effectivePort}`;
+    const remoteBaseUrl = `${normalizedProtocol}://${remoteConfig.host}${portSuffix}/api/provider/${provider}`;
+    result.ANTHROPIC_BASE_URL = remoteBaseUrl;
+    // Update auth token if provided
+    if (remoteConfig.authToken) {
+        result.ANTHROPIC_AUTH_TOKEN = remoteConfig.authToken;
+    }
+    return result;
+}
+/**
+ * Get effective environment variables for provider
+ *
+ * Priority order:
+ * 1. Custom settings path (for user-defined CLIProxy variants)
+ * 2. User settings file (~/.ccs/{provider}.settings.json) if exists
+ * 3. Bundled defaults from PROVIDER_CONFIGS
+ *
+ * All results are merged with global_env vars (telemetry/reporting disables).
+ * User takes full responsibility for custom settings.
+ *
+ * If remoteRewriteConfig is provided, localhost URLs are rewritten to remote server.
+ */
+function getEffectiveEnvVars(provider, port = exports.CLIPROXY_DEFAULT_PORT, customSettingsPath, remoteRewriteConfig) {
+    // Get global env vars (DISABLE_TELEMETRY, etc.)
+    const globalEnv = getGlobalEnvVars();
+    let envVars;
+    // Priority 1: Custom settings path (for user-defined variants)
+    if (customSettingsPath) {
+        const expandedPath = (0, helpers_1.expandPath)(customSettingsPath);
+        if (fs.existsSync(expandedPath)) {
+            try {
+                const content = fs.readFileSync(expandedPath, 'utf-8');
+                const settings = JSON.parse(content);
+                if (settings.env && typeof settings.env === 'object') {
+                    // Custom variant settings found - merge with global env
+                    envVars = { ...globalEnv, ...settings.env };
+                    // Ensure required vars are present (fall back to defaults if missing)
+                    envVars = ensureRequiredEnvVars(envVars, provider, port);
+                    // Apply remote rewrite if configured
+                    if (remoteRewriteConfig) {
+                        envVars = rewriteLocalhostUrls(envVars, provider, remoteRewriteConfig);
+                    }
+                    return envVars;
+                }
+            }
+            catch {
+                // Invalid JSON - fall through to provider defaults
+                console.warn((0, ui_1.warn)(`Invalid settings file: ${customSettingsPath}`));
+            }
+        }
+        else {
+            console.warn((0, ui_1.warn)(`Settings file not found: ${customSettingsPath}`));
+        }
+    }
+    // Priority 2: Default provider settings file
+    const settingsPath = getProviderSettingsPath(provider);
+    // Check for user override file
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const content = fs.readFileSync(settingsPath, 'utf-8');
+            const settings = JSON.parse(content);
+            if (settings.env && typeof settings.env === 'object') {
+                // User override found - merge with global env
+                envVars = { ...globalEnv, ...settings.env };
+                // Ensure required vars are present (fall back to defaults if missing)
+                envVars = ensureRequiredEnvVars(envVars, provider, port);
+                // Apply remote rewrite if configured
+                if (remoteRewriteConfig) {
+                    envVars = rewriteLocalhostUrls(envVars, provider, remoteRewriteConfig);
+                }
+                return envVars;
+            }
+        }
+        catch {
+            // Invalid JSON or structure - fall through to defaults
+            // Silent fallback: don't spam errors for broken user files
+        }
+    }
+    // No override or invalid - use bundled defaults merged with global env
+    return { ...globalEnv, ...getClaudeEnvVars(provider, port) };
+}
+exports.getEffectiveEnvVars = getEffectiveEnvVars;
+/**
+ * Copy bundled settings template to user directory if not exists
+ * Called during installation/first run
+ */
+function ensureProviderSettings(provider) {
+    const settingsPath = getProviderSettingsPath(provider);
+    // Only create if doesn't exist (preserve user edits)
+    if (fs.existsSync(settingsPath)) {
+        return;
+    }
+    // Generate default settings from PROVIDER_CONFIGS
+    const envVars = getClaudeEnvVars(provider);
+    const settings = { env: envVars };
+    // Ensure directory exists
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    // Write with restricted permissions
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', {
+        mode: 0o600,
+    });
+}
+exports.ensureProviderSettings = ensureProviderSettings;
+/**
+ * Get environment variables for remote proxy mode.
+ * Uses the remote proxy's provider endpoint as the base URL.
+ * Respects user model settings from custom settings path or provider settings file.
+ *
+ * @param provider CLIProxy provider (gemini, codex, agy, qwen, iflow)
+ * @param remoteConfig Remote proxy connection details
+ * @param customSettingsPath Optional path to user's custom settings file
+ * @returns Environment variables for Claude CLI
+ */
+function getRemoteEnvVars(provider, remoteConfig, customSettingsPath) {
+    // Build URL with smart port handling (8317 for HTTP, 443 for HTTPS)
+    // Validate port and normalize protocol for defensive handling
+    const normalizedProtocol = normalizeProtocol(remoteConfig.protocol);
+    const validatedPort = validateRemotePort(remoteConfig.port);
+    const effectivePort = validatedPort ?? getRemoteDefaultPort(normalizedProtocol);
+    // Omit port suffix for standard web ports (80/443) for cleaner URLs
+    const standardWebPort = normalizedProtocol === 'https' ? 443 : 80;
+    const portSuffix = effectivePort === standardWebPort ? '' : `:${effectivePort}`;
+    // Remote CLIProxyAPI uses root path (e.g., /v1/messages), not /api/provider/{provider}/v1/messages
+    // The /api/provider/ prefix is only for local CLIProxy instances
+    const baseUrl = `${normalizedProtocol}://${remoteConfig.host}${portSuffix}`;
+    // Get global env vars (DISABLE_TELEMETRY, etc.)
+    const globalEnv = getGlobalEnvVars();
+    // Load user settings with priority: custom path > user settings file > base config
+    let userEnvVars = {};
+    // Priority 1: Custom settings path (for user-defined variants)
+    if (customSettingsPath) {
+        const expandedPath = (0, helpers_1.expandPath)(customSettingsPath);
+        if (fs.existsSync(expandedPath)) {
+            try {
+                const content = fs.readFileSync(expandedPath, 'utf-8');
+                const settings = JSON.parse(content);
+                if (settings.env && typeof settings.env === 'object') {
+                    userEnvVars = settings.env;
+                }
+            }
+            catch {
+                // Invalid JSON - fall through to provider defaults
+                console.warn((0, ui_1.warn)(`Invalid settings file: ${customSettingsPath}`));
+            }
+        }
+    }
+    // Priority 2: Default provider settings file (~/.ccs/{provider}.settings.json)
+    if (Object.keys(userEnvVars).length === 0) {
+        const settingsPath = getProviderSettingsPath(provider);
+        if (fs.existsSync(settingsPath)) {
+            try {
+                const content = fs.readFileSync(settingsPath, 'utf-8');
+                const settings = JSON.parse(content);
+                if (settings.env && typeof settings.env === 'object') {
+                    userEnvVars = settings.env;
+                }
+            }
+            catch {
+                // Invalid JSON - fall through to base config
+            }
+        }
+    }
+    // Priority 3: Base config defaults
+    if (Object.keys(userEnvVars).length === 0) {
+        const models = getModelMapping(provider);
+        const baseEnvVars = (0, base_config_loader_1.getEnvVarsFromConfig)(provider);
+        // Filter out URL/auth from base config (we'll set those from remote config)
+        const { ANTHROPIC_BASE_URL: _baseUrl, ANTHROPIC_AUTH_TOKEN: _authToken, ...additionalEnvVars } = baseEnvVars;
+        userEnvVars = {
+            ...additionalEnvVars,
+            ANTHROPIC_MODEL: models.claudeModel,
+            ANTHROPIC_DEFAULT_OPUS_MODEL: models.opusModel || models.claudeModel,
+            ANTHROPIC_DEFAULT_SONNET_MODEL: models.sonnetModel || models.claudeModel,
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: models.haikuModel || models.claudeModel,
+        };
+    }
+    // Build final env: global + user settings + remote URL/auth override
+    const env = {
+        ...globalEnv,
+        ...userEnvVars,
+        // Always override URL and auth token with remote config
+        ANTHROPIC_BASE_URL: baseUrl,
+        ANTHROPIC_AUTH_TOKEN: remoteConfig.authToken || (0, auth_token_manager_1.getEffectiveApiKey)(),
+    };
+    return env;
+}
+exports.getRemoteEnvVars = getRemoteEnvVars;
+//# sourceMappingURL=config-generator.js.map