@kikkimo/claude-launcher 2.5.0 → 3.1.0

package/lib/api-manager.js

@@ -6,49 +6,210 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { encrypt, decrypt } = require('./crypto');
-const { validateBaseUrl, validateAuthToken, validateModel } = require('./validators');
+const { validateBaseUrl, validateAuthToken, validateModel, validateApiName } = require('./validators');
+const screen = require('./ui/screen');
+
+class DuplicateApiError extends Error {
+    constructor(existingApi) {
+        super(`Duplicate API: ${existingApi.name}`);
+        this.name = 'DuplicateApiError';
+        this.code = 'DUPLICATE_API';
+        this.existingApiId = existingApi.id;
+        this.existingApiName = existingApi.name;
+    }
+}
+
+const MODEL_CONFIG_LABELS = {
+    ANTHROPIC_DEFAULT_SONNET_MODEL: 'Regular Model (Sonnet)',
+    ANTHROPIC_DEFAULT_OPUS_MODEL: 'Heavy Model (Opus)',
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: 'Fast Model (Haiku)',
+    CLAUDE_CODE_SUBAGENT_MODEL: 'Subagent Model',
+    ANTHROPIC_CUSTOM_MODEL_OPTION: 'Custom Model',
+    ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: 'Custom Model Name',
+};
+
+const RUNTIME_CONFIG_LABELS = {
+    API_TIMEOUT_MS: 'Request Timeout',
+    CLAUDE_CODE_ATTRIBUTION_HEADER: 'Output Attribution',
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: 'Reduce Non-Essential Traffic',
+    CLAUDE_CODE_EFFORT_LEVEL: 'Reasoning Effort',
+    CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: 'Experimental Features',
+    CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: 'Disable Non-Streaming Fallback',
+};
 
 class ApiManager {
     constructor() {
         this.configFile = path.join(os.homedir(), '.claude-launcher-apis.json');
-        this.config = this.loadConfig();
+        const { config, migrated } = this.loadConfig();
+        this.config = config;
+        if (migrated) {
+            this.saveConfig();
+        }
     }
 
     /**
      * Load configuration from encrypted file
      */
     loadConfig() {
+        let migrated = false;
         try {
             if (fs.existsSync(this.configFile)) {
                 const encryptedData = fs.readFileSync(this.configFile, 'utf8');
                 const decrypted = decrypt(encryptedData);
                 if (decrypted.success) {
                     const config = JSON.parse(decrypted.value);
-                    // Ensure required fields exist
-                    if (!config.hasOwnProperty('exportPassword')) {
-                        config.exportPassword = null;
-                    }
-                    if (!config.hasOwnProperty('passwordSkipped')) {
-                        config.passwordSkipped = false;
-                    }
+                    if (!config.hasOwnProperty('exportPassword')) config.exportPassword = null;
+                    if (!config.hasOwnProperty('passwordSkipped')) config.passwordSkipped = false;
 
-                    return config;
+                    const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS } = require('./validators');
+                    for (const api of config.apis || []) {
+                        migrated = this._migrateApiEntry(api, PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS) || migrated;
+                    }
+                    return { config, migrated };
                 }
             }
         } catch (error) {
-            console.error(`[!] Could not load API config: ${error.message}`);
+            screen.debug(`[!] Could not load API config: ${error.message}`);
         }
 
         return {
-            apis: [],
-            activeIndex: -1,
-            version: '2.0.0',
-            createdAt: new Date().toISOString(),
-            exportPassword: null, // Hashed export password for validation
-            passwordSkipped: false // Whether user permanently skipped password setup
+            config: {
+                apis: [],
+                activeIndex: -1,
+                version: '2.0.0',
+                createdAt: new Date().toISOString(),
+                exportPassword: null,
+                passwordSkipped: false,
+            },
+            migrated: false,
         };
     }
 
+    _migrateApiEntry(api, MODEL_KEYS, RUNTIME_KEYS) {
+        const before = JSON.stringify({
+            modelEnvVars: api.modelEnvVars,
+            _autoModelEnvVars: api._autoModelEnvVars,
+            runtimeEnvVars: api.runtimeEnvVars,
+            _runtimeEnvSources: api._runtimeEnvSources,
+            customEnvVars: api.customEnvVars,
+            smallFastModel: api.smallFastModel,
+            _autoFilledModel: api._autoFilledModel,
+        });
+        this._normalizeApiFields(api);
+        const after = JSON.stringify({
+            modelEnvVars: api.modelEnvVars,
+            _autoModelEnvVars: api._autoModelEnvVars,
+            runtimeEnvVars: api.runtimeEnvVars,
+            _runtimeEnvSources: api._runtimeEnvSources,
+            customEnvVars: api.customEnvVars,
+            smallFastModel: api.smallFastModel,
+            _autoFilledModel: api._autoFilledModel,
+        });
+        return before !== after;
+    }
+
+    _normalizeApiFields(api) {
+        const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS } = require('./validators');
+        const { getProvider } = require('./presets/providers');
+
+        const effectiveModel = api._autoFilledModel || api.model;
+        const hadAutoModelEnvVars = !!api._autoModelEnvVars;
+
+        const providerConfig = getProvider(api.provider);
+        let template;
+        if (providerConfig && providerConfig.modelEnvTemplate) {
+            template = providerConfig.modelEnvTemplate.getValues(effectiveModel);
+        } else {
+            template = {};
+            for (const k of PREDEFINED_MODEL_ENV_KEYS) template[k] = effectiveModel;
+            template.smallFastModel = effectiveModel;
+        }
+
+        let smallFastWasFixed = false;
+
+        // _autoModelEnvVars — full rebuild via template
+        if (!api._autoModelEnvVars) {
+            api._autoModelEnvVars = { ...template };
+        } else {
+            for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+                if (!(k in api._autoModelEnvVars) || typeof api._autoModelEnvVars[k] !== 'string') {
+                    api._autoModelEnvVars[k] = template[k] || '';
+                }
+            }
+            for (const k of Object.keys(api._autoModelEnvVars)) {
+                if (!PREDEFINED_MODEL_ENV_KEYS.includes(k) && k !== 'smallFastModel') {
+                    delete api._autoModelEnvVars[k];
+                }
+            }
+            if (!('smallFastModel' in api._autoModelEnvVars) || typeof api._autoModelEnvVars.smallFastModel !== 'string') {
+                api._autoModelEnvVars.smallFastModel = template.smallFastModel;
+                smallFastWasFixed = true;
+            }
+        }
+
+        // modelEnvVars — fill with template actual values (NOT "")
+        if (!api.modelEnvVars) {
+            api.modelEnvVars = {};
+        }
+        for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+            if (!(k in api.modelEnvVars) || typeof api.modelEnvVars[k] !== 'string') {
+                api.modelEnvVars[k] = template[k] || '';
+            }
+        }
+        for (const k of Object.keys(api.modelEnvVars)) {
+            if (!PREDEFINED_MODEL_ENV_KEYS.includes(k)) {
+                delete api.modelEnvVars[k];
+            }
+        }
+
+        // smallFastModel — sync with template
+        if (!api.smallFastModel || typeof api.smallFastModel !== 'string'
+            || !hadAutoModelEnvVars || smallFastWasFixed) {
+            api.smallFastModel = template.smallFastModel;
+        }
+
+        // runtimeEnvVars — fill "" not provider values
+        if (!api.runtimeEnvVars) {
+            api.runtimeEnvVars = {};
+        }
+        for (const k of PREDEFINED_RUNTIME_KEYS) {
+            if (!(k in api.runtimeEnvVars) || typeof api.runtimeEnvVars[k] !== 'string') {
+                api.runtimeEnvVars[k] = '';
+            }
+        }
+
+        // _runtimeEnvSources — missing → "auto"
+        if (!api._runtimeEnvSources) {
+            api._runtimeEnvSources = {};
+        }
+        for (const k of PREDEFINED_RUNTIME_KEYS) {
+            if (!(k in api._runtimeEnvSources)) {
+                api._runtimeEnvSources[k] = 'auto';
+            }
+            if (api._runtimeEnvSources[k] !== 'auto' && api._runtimeEnvSources[k] !== 'manual') {
+                api._runtimeEnvSources[k] = 'auto';
+            }
+        }
+
+        // runtime/source conflict resolution
+        for (const k of PREDEFINED_RUNTIME_KEYS) {
+            if (api.runtimeEnvVars[k] !== '' && api._runtimeEnvSources[k] === 'auto') {
+                api.runtimeEnvVars[k] = '';
+            }
+        }
+
+        // customEnvVars
+        if (!api.customEnvVars) {
+            api.customEnvVars = {};
+        }
+
+        if (api._autoFilledModel) {
+            delete api._autoFilledModel;
+        }
+
+        return api;
+    }
+
     /**
      * Save configuration to encrypted file
      */
@@ -60,11 +221,11 @@ class ApiManager {
                 fs.writeFileSync(this.configFile, encrypted.value);
                 return true;
             } else {
-                console.error(`[!] Failed to save API config: ${encrypted.error}`);
+                screen.debug(`[!] Failed to save API config: ${encrypted.error}`);
                 return false;
             }
         } catch (error) {
-            console.error(`[!] Error saving API config: ${error.message}`);
+            screen.debug(`[!] Error saving API config: ${error.message}`);
             return false;
         }
     }
@@ -96,6 +257,10 @@ class ApiManager {
      * Add a new API configuration
      */
     addApi(baseUrl, authToken, model, name, provider = 'custom') {
+        if (this.config.apis.length >= 99) {
+            throw new Error('Maximum 99 APIs supported. Remove unused APIs before adding new ones.');
+        }
+
         // Validate inputs
         const urlValidation = validateBaseUrl(baseUrl);
         if (!urlValidation.valid) {
@@ -115,7 +280,7 @@ class ApiManager {
         // Check for duplicates
         const duplicate = this.checkDuplicate(baseUrl, authToken, model);
         if (duplicate.isDuplicate) {
-            throw new Error(`${duplicate.type} already exists for API: ${duplicate.existing.name}`);
+            throw new DuplicateApiError(duplicate.existing);
         }
 
         // Encrypt the auth token before storing
@@ -124,6 +289,32 @@ class ApiManager {
             throw new Error(`Failed to encrypt auth token: ${encryptedToken.error}`);
         }
 
+        // Compute model env template values
+        const { getProvider } = require('./presets/providers');
+        const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS } = require('./validators');
+        const providerConfig = getProvider(provider);
+        let templateValues;
+        if (providerConfig && providerConfig.modelEnvTemplate) {
+            templateValues = providerConfig.modelEnvTemplate.getValues(modelValidation.value);
+        } else {
+            templateValues = {};
+            for (const k of PREDEFINED_MODEL_ENV_KEYS) templateValues[k] = modelValidation.value;
+            templateValues.smallFastModel = modelValidation.value;
+        }
+
+        const modelEnvVars = {};
+        for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+            modelEnvVars[k] = templateValues[k] || '';
+        }
+        const _autoModelEnvVars = { ...templateValues };
+
+        const runtimeEnvVars = {};
+        const _runtimeEnvSources = {};
+        for (const k of PREDEFINED_RUNTIME_KEYS) {
+            runtimeEnvVars[k] = '';
+            _runtimeEnvSources[k] = 'auto';
+        }
+
         const newApi = {
             id: Date.now().toString(),
             name: name || `API-${this.config.apis.length + 1}`,
@@ -131,15 +322,18 @@ class ApiManager {
             baseUrl: urlValidation.value,
             authToken: encryptedToken.value,
             model: modelValidation.value,
-            smallFastModel: modelValidation.value, // Same as model as requested
+            smallFastModel: templateValues.smallFastModel,
             createdAt: new Date().toISOString(),
-            // Existing statistics fields
             lastUsed: null,
             usageCount: 0,
-            // New statistics fields
             successCount: 0,
             failCount: 0,
-            lastError: null
+            lastError: null,
+            modelEnvVars,
+            _autoModelEnvVars,
+            runtimeEnvVars,
+            _runtimeEnvSources,
+            customEnvVars: {},
         };
 
         this.config.apis.push(newApi);
@@ -241,17 +435,227 @@ class ApiManager {
      * @returns {Object} The updated API object
      */
     updateApiModel(apiId, newModel) {
+        return this.updateApiField(apiId, 'model', newModel);
+    }
+
+    /**
+     * Update a single field of an API configuration with validation
+     * @param {string} apiId - The API id
+     * @param {string} field - Field name: 'name', 'provider', 'baseUrl', 'model'
+     * @param {string} value - New value
+     * @returns {Object} The updated API object
+     */
+    updateApiField(apiId, field, value) {
+        const allowedFields = ['name', 'provider', 'baseUrl', 'model'];
+        if (!allowedFields.includes(field)) {
+            throw new Error(`Field '${field}' is not allowed. Allowed: ${allowedFields.join(', ')}`);
+        }
+
         const index = this.config.apis.findIndex(api => api.id === apiId);
         if (index === -1) {
             throw new Error(`API not found: ${apiId}`);
         }
 
-        this.config.apis[index].model = newModel;
-        this.config.apis[index].smallFastModel = newModel;
+        const api = this.config.apis[index];
+
+        // Manager-level validation
+        switch (field) {
+            case 'name': {
+                if (!value || value.trim() === '') {
+                    throw new Error('Name cannot be empty when editing');
+                }
+                const nameValidation = validateApiName(value);
+                if (!nameValidation.valid) {
+                    throw new Error(`Invalid name: ${nameValidation.error}`);
+                }
+                break;
+            }
+            case 'provider': {
+                const { getAllProviders } = require('./presets/providers');
+                const validIds = getAllProviders().map(p => p.id);
+                if (!validIds.includes(value)) {
+                    throw new Error(`Unknown provider: ${value}. Valid: ${validIds.join(', ')}`);
+                }
+                return this.updateApiProvider(apiId, value).api;
+            }
+            case 'baseUrl': {
+                const urlValidation = validateBaseUrl(value);
+                if (!urlValidation.valid) {
+                    throw new Error(`Invalid URL: ${urlValidation.error}`);
+                }
+                break;
+            }
+            case 'model': {
+                const modelValidation = validateModel(value);
+                if (!modelValidation.valid) {
+                    throw new Error(`Invalid model: ${modelValidation.error}`);
+                }
+                break;
+            }
+        }
+
+        // Duplicate check for uniqueness-affecting fields
+        if (field === 'baseUrl' || field === 'model') {
+            const checkUrl = field === 'baseUrl' ? value : api.baseUrl;
+            const checkModel = field === 'model' ? value : api.model;
+            const decryptedToken = decrypt(api.authToken);
+            const tokenValue = decryptedToken.success ? decryptedToken.value : '';
+
+            // Check against all OTHER apis (exclude self)
+            const duplicate = this.config.apis.find((other, idx) => {
+                if (idx === index) return false;
+                const otherToken = decrypt(other.authToken);
+                const otherTokenValue = otherToken.success ? otherToken.value : '';
+                return other.baseUrl === checkUrl &&
+                       otherTokenValue === tokenValue &&
+                       other.model === checkModel;
+            });
+
+            if (duplicate) {
+                throw new Error(`Duplicate configuration: URL + Token + Model already exists for API '${duplicate.name}'`);
+            }
+        }
+
+        // Apply update
+        api[field] = value.trim();
+        if (field === 'model') {
+            const { getProvider } = require('./presets/providers');
+            const { PREDEFINED_MODEL_ENV_KEYS } = require('./validators');
+            const providerConfig = getProvider(api.provider);
+            let templateVals;
+            if (providerConfig && providerConfig.modelEnvTemplate) {
+                templateVals = providerConfig.modelEnvTemplate.getValues(value.trim());
+            } else {
+                templateVals = {};
+                for (const k of PREDEFINED_MODEL_ENV_KEYS) templateVals[k] = value.trim();
+                templateVals.smallFastModel = value.trim();
+            }
+            if (api._autoModelEnvVars) {
+                if (!api.modelEnvVars) api.modelEnvVars = {};
+                for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+                    if (api.modelEnvVars[k] === api._autoModelEnvVars[k]) {
+                        api.modelEnvVars[k] = templateVals[k] || '';
+                    }
+                }
+                if (api.smallFastModel === api._autoModelEnvVars.smallFastModel) {
+                    api.smallFastModel = templateVals.smallFastModel;
+                }
+            } else {
+                // No snapshot means all fields are auto — overwrite all
+                if (!api.modelEnvVars) api.modelEnvVars = {};
+                for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+                    api.modelEnvVars[k] = templateVals[k] || '';
+                }
+                api.smallFastModel = templateVals.smallFastModel;
+            }
+            api._autoModelEnvVars = { ...templateVals };
+        }
+
+        this.saveConfig();
+        return api;
+    }
+
+    updateModelEnvVar(apiId, key, value) {
+        const { PREDEFINED_MODEL_ENV_KEYS } = require('./validators');
+        if (!PREDEFINED_MODEL_ENV_KEYS.includes(key)) throw new Error(`"${key}" is not a predefined model env key`);
+        if (typeof value !== 'string') throw new Error('model env value must be a string');
+        const index = this.config.apis.findIndex(a => a.id === apiId);
+        if (index === -1) throw new Error(`API not found: ${apiId}`);
+        const api = this.config.apis[index];
+        const autoValue = api._autoModelEnvVars && typeof api._autoModelEnvVars[key] === 'string'
+            ? api._autoModelEnvVars[key]
+            : '';
+        api.modelEnvVars[key] = value === '' ? autoValue : value;
+        this.saveConfig();
+        return api;
+    }
+
+    updateRuntimeEnvVar(apiId, key, value, options = {}) {
+        const { PREDEFINED_RUNTIME_KEYS, validateRuntimeEnvValue } = require('./validators');
+        if (!PREDEFINED_RUNTIME_KEYS.includes(key)) throw new Error(`"${key}" is not a predefined runtime env key`);
+        const validation = validateRuntimeEnvValue(key, value);
+        if (!validation.valid) throw new Error(`Invalid value for ${key}: ${validation.error}`);
+        const index = this.config.apis.findIndex(a => a.id === apiId);
+        if (index === -1) throw new Error(`API not found: ${apiId}`);
+        if (options.source === 'auto') {
+            this.config.apis[index].runtimeEnvVars[key] = '';
+            this.config.apis[index]._runtimeEnvSources[key] = 'auto';
+        } else if (options.source === 'manual') {
+            this.config.apis[index].runtimeEnvVars[key] = value;
+            this.config.apis[index]._runtimeEnvSources[key] = 'manual';
+        } else {
+            this.config.apis[index].runtimeEnvVars[key] = value;
+            this.config.apis[index]._runtimeEnvSources[key] = (value === '') ? 'auto' : 'manual';
+        }
+        this.saveConfig();
+        return this.config.apis[index];
+    }
+
+    setCustomEnvVar(apiId, key, value) {
+        const { validateEnvKey } = require('./validators');
+        const kv = validateEnvKey(key);
+        if (!kv.valid) throw new Error(`Custom env key "${key}" is reserved or invalid`);
+        if (typeof value !== 'string') throw new Error('Custom env value must be a string');
+        const index = this.config.apis.findIndex(a => a.id === apiId);
+        if (index === -1) throw new Error(`API not found: ${apiId}`);
+        this.config.apis[index].customEnvVars[key] = value;
+        this.saveConfig();
+        return this.config.apis[index];
+    }
+
+    deleteCustomEnvVar(apiId, key) {
+        const index = this.config.apis.findIndex(a => a.id === apiId);
+        if (index === -1) throw new Error(`API not found: ${apiId}`);
+        delete this.config.apis[index].customEnvVars[key];
         this.saveConfig();
         return this.config.apis[index];
     }
 
+    updateApiProvider(apiId, newProviderId) {
+        const { getProvider, getAllProviders, detectProvider } = require('./presets/providers');
+        const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS } = require('./validators');
+        const validIds = getAllProviders().map(p => p.id);
+        if (!validIds.includes(newProviderId)) throw new Error(`Unknown provider: ${newProviderId}`);
+        const index = this.config.apis.findIndex(a => a.id === apiId);
+        if (index === -1) throw new Error(`API not found: ${apiId}`);
+        const api = this.config.apis[index];
+        const newProvider = getProvider(newProviderId);
+        const warnings = [];
+        if (!newProvider.models.includes(api.model)) {
+            warnings.push({ code: 'MODEL_NOT_IN_PROVIDER', messageArgs: { model: api.model, providerName: newProvider.name } });
+        }
+        if (detectProvider(api.baseUrl) !== newProviderId) {
+            warnings.push({ code: 'BASE_URL_NOT_UPDATED', messageArgs: { baseUrl: api.baseUrl } });
+        }
+        if (api._runtimeEnvSources) {
+            for (const [key, source] of Object.entries(api._runtimeEnvSources)) {
+                if (source === 'auto' && PREDEFINED_RUNTIME_KEYS.includes(key)) api.runtimeEnvVars[key] = '';
+            }
+        }
+        let templateValues;
+        if (newProvider.modelEnvTemplate) {
+            templateValues = newProvider.modelEnvTemplate.getValues(api.model);
+        } else {
+            templateValues = {};
+            for (const k of PREDEFINED_MODEL_ENV_KEYS) templateValues[k] = api.model;
+            templateValues.smallFastModel = api.model;
+        }
+        if (api._autoModelEnvVars) {
+            if (!api.modelEnvVars) api.modelEnvVars = {};
+            for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+                if (api.modelEnvVars[k] === api._autoModelEnvVars[k]) api.modelEnvVars[k] = templateValues[k] || '';
+            }
+            if (api.smallFastModel === api._autoModelEnvVars.smallFastModel) api.smallFastModel = templateValues.smallFastModel;
+        }
+        api._autoModelEnvVars = { ...templateValues };
+        if (detectProvider(api.baseUrl) !== newProviderId && warnings.some(w => w.code === 'MODEL_NOT_IN_PROVIDER')) {
+            warnings.push({ code: 'MIXED_PROVIDER_CONFIG', messageArgs: { providerId: newProviderId, baseUrl: api.baseUrl, model: api.model } });
+        }
+        api.provider = newProviderId;
+        this.saveConfig();
+        return { api, warnings };
+    }
+
     /**
      * Record a successful API launch
      * @returns {Object|null} The updated API object or null
@@ -289,6 +693,40 @@ class ApiManager {
         return null;
     }
 
+    /**
+     * Record a launch attempt (optimistic success)
+     * Call rollbackLaunchAttempt() if a pre-launch sync error occurs
+     * @returns {Object|null} The updated API object or null
+     */
+    recordLaunchAttempt() {
+        const activeApi = this.getActiveApi();
+        if (activeApi) {
+            const index = this.config.activeIndex;
+            this.config.apis[index].lastUsed = new Date().toISOString();
+            this.config.apis[index].usageCount = (this.config.apis[index].usageCount || 0) + 1;
+            this.config.apis[index].successCount = (this.config.apis[index].successCount || 0) + 1;
+            this.config.apis[index].lastError = null;
+            this.saveConfig();
+            return this.config.apis[index];
+        }
+        return null;
+    }
+
+    /**
+     * Rollback an optimistic launch attempt on pre-launch sync error
+     * @param {string} errorMessage - The error message
+     */
+    rollbackLaunchAttempt(errorMessage) {
+        const activeApi = this.getActiveApi();
+        if (activeApi) {
+            const index = this.config.activeIndex;
+            this.config.apis[index].successCount = Math.max(0, (this.config.apis[index].successCount || 0) - 1);
+            this.config.apis[index].failCount = (this.config.apis[index].failCount || 0) + 1;
+            this.config.apis[index].lastError = errorMessage;
+            this.saveConfig();
+        }
+    }
+
     /**
      * Get statistics about API usage
      */
@@ -456,14 +894,16 @@ class ApiManager {
      * Export configuration as plaintext JSON (already authenticated)
      */
     exportConfigAuthenticated() {
-        // Create export data with plaintext API keys
         const exportData = {
+            configVersion: 2,
             version: this.config.version,
+            warning: 'This file contains plaintext API keys and custom environment variables. Handle with care.',
             exportedAt: new Date().toISOString(),
             apis: this.config.apis.map(api => {
                 const decrypted = decrypt(api.authToken);
+                const { _autoFilledModel, ...safe } = api;
                 return {
-                    ...api,
+                    ...safe,
                     authToken: decrypted.success ? decrypted.value : '***DECRYPTION_FAILED***'
                 };
             }),
@@ -500,84 +940,203 @@ class ApiManager {
     processImportData(configData) {
         let imported = 0;
         let skipped = 0;
+        const warnings = [];
+        const skippedItems = [];
 
         if (!configData.apis || !Array.isArray(configData.apis)) {
             throw new Error('Invalid configuration format - no APIs found');
         }
 
+        const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS, validateRuntimeEnvValue, RESERVED_ENV_KEYS } = require('./validators');
+
         configData.apis.forEach(importApi => {
-            // Validate the API configuration before importing
+            if (this.config.apis.length >= 99) {
+                skipped++;
+                skippedItems.push({ apiName: importApi.name || 'Unknown', reason: 'Maximum 99 APIs reached' });
+                return;
+            }
+
             try {
-                // Validate Base URL
                 const urlValidation = validateBaseUrl(importApi.baseUrl);
                 if (!urlValidation.valid) {
-                    console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Base URL: ${urlValidation.error}`);
-                    skipped++;
-                    return;
+                    skipped++; skippedItems.push({ apiName: importApi.name || 'Unknown', reason: urlValidation.error }); return;
                 }
 
-                // Validate Auth Token (skip validation for placeholder tokens)
                 if (importApi.authToken !== '***REQUIRES_MANUAL_INPUT***') {
                     const tokenValidation = validateAuthToken(importApi.authToken);
                     if (!tokenValidation.valid) {
-                        console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Auth Token: ${tokenValidation.error}`);
-                        skipped++;
-                        return;
+                        skipped++; skippedItems.push({ apiName: importApi.name || 'Unknown', reason: tokenValidation.error }); return;
                     }
                 }
 
-                // Validate Model
                 const modelValidation = validateModel(importApi.model);
                 if (!modelValidation.valid) {
-                    console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Model: ${modelValidation.error}`);
-                    skipped++;
-                    return;
+                    skipped++; skippedItems.push({ apiName: importApi.name || 'Unknown', reason: modelValidation.error }); return;
                 }
 
-                // Check for duplicates using the same logic as addApi
                 const importToken = importApi.authToken === '***REQUIRES_MANUAL_INPUT***' ? '' : importApi.authToken;
                 const duplicate = this.checkDuplicate(importApi.baseUrl, importToken, importApi.model);
 
                 if (duplicate.isDuplicate) {
                     skipped++;
-                } else {
-                    // Encrypt the auth token if it's not already encrypted or masked
-                    let encryptedToken;
-                    if (importApi.authToken === '***REQUIRES_MANUAL_INPUT***') {
-                        encryptedToken = encrypt('').value; // Empty encrypted token
-                    } else {
-                        encryptedToken = encrypt(importApi.authToken).value;
+                    skippedItems.push({ apiName: importApi.name || 'Unknown', reason: 'Duplicate configuration' });
+                    return;
+                }
+
+                // Clean modelEnvVars: whitelist only
+                const cleanedModelEnvVars = {};
+                if (importApi.modelEnvVars) {
+                    for (const k of PREDEFINED_MODEL_ENV_KEYS) {
+                        const v = importApi.modelEnvVars[k];
+                        cleanedModelEnvVars[k] = (typeof v === 'string') ? v : '';
+                    }
+                    for (const k of Object.keys(importApi.modelEnvVars)) {
+                        if (!PREDEFINED_MODEL_ENV_KEYS.includes(k)) {
+                            warnings.push({ code: 'UNKNOWN_MODEL_ENV_KEY', apiName: importApi.name || 'Unknown', key: k });
+                        }
+                    }
+                }
+
+                // Clean runtimeEnvVars: whitelist + validate
+                const cleanedRuntimeEnvVars = {};
+                const cleanedRuntimeEnvSources = {};
+                if (importApi.runtimeEnvVars) {
+                    for (const k of PREDEFINED_RUNTIME_KEYS) {
+                        let v = importApi.runtimeEnvVars[k];
+                        if (typeof v !== 'string') v = '';
+                        if (v !== '' && !validateRuntimeEnvValue(k, v).valid) {
+                            warnings.push({ code: 'INVALID_RUNTIME_ENV_VALUE', apiName: importApi.name || 'Unknown', key: k });
+                            v = '';
+                        }
+                        cleanedRuntimeEnvVars[k] = v;
+                        const src = (importApi._runtimeEnvSources || {})[k];
+                        cleanedRuntimeEnvSources[k] = (src === 'manual' && v !== '') ? 'manual' : 'auto';
+                    }
+                    for (const k of Object.keys(importApi.runtimeEnvVars)) {
+                        if (!PREDEFINED_RUNTIME_KEYS.includes(k)) {
+                            warnings.push({ code: 'UNKNOWN_RUNTIME_ENV_KEY', apiName: importApi.name || 'Unknown', key: k });
+                        }
                     }
+                }
 
-                    const newApi = {
-                        id: Date.now() + Math.random(),
-                        name: importApi.name || `Imported API ${this.config.apis.length + 1}`,
-                        baseUrl: urlValidation.value,
-                        authToken: encryptedToken,
-                        model: modelValidation.value,
-                        provider: importApi.provider || 'custom',
-                        createdAt: new Date().toISOString(),
-                        lastUsed: null,
-                        usageCount: 0
-                    };
-
-                    this.config.apis.push(newApi);
-                    imported++;
-
-                    // Set as active if this is the first API
-                    if (this.config.apis.length === 1) {
-                        this.config.activeIndex = 0;
+                // Clean customEnvVars: skip reserved/predefined
+                const cleanedCustomEnvVars = {};
+                if (importApi.customEnvVars) {
+                    const allP = new Set([...RESERVED_ENV_KEYS, ...PREDEFINED_RUNTIME_KEYS, ...PREDEFINED_MODEL_ENV_KEYS]);
+                    for (const [k, v] of Object.entries(importApi.customEnvVars)) {
+                        if (allP.has(k)) {
+                            warnings.push({ code: 'CUSTOM_ENV_KEY_RESERVED', apiName: importApi.name || 'Unknown', key: k });
+                            continue;
+                        }
+                        if (typeof v === 'string') cleanedCustomEnvVars[k] = v;
                     }
                 }
+
+                const tokenToEncrypt =
+                    importApi.authToken === '***REQUIRES_MANUAL_INPUT***' ? '' : importApi.authToken;
+                const encryptedResult = encrypt(tokenToEncrypt);
+                if (!encryptedResult.success) {
+                    skipped++;
+                    skippedItems.push({
+                        apiName: importApi.name || 'Unknown',
+                        reason: `Failed to encrypt auth token: ${encryptedResult.error}`
+                    });
+                    return;
+                }
+                const encryptedToken = encryptedResult.value;
+
+                const newApi = {
+                    id: Date.now() + Math.random(),
+                    name: importApi.name || `Imported API ${this.config.apis.length + 1}`,
+                    baseUrl: urlValidation.value,
+                    authToken: encryptedToken,
+                    model: modelValidation.value,
+                    provider: importApi.provider || 'custom',
+                    smallFastModel: importApi.smallFastModel || importApi.model,
+                    createdAt: new Date().toISOString(),
+                    lastUsed: null,
+                    usageCount: 0,
+                    modelEnvVars: cleanedModelEnvVars,
+                    runtimeEnvVars: cleanedRuntimeEnvVars,
+                    _runtimeEnvSources: cleanedRuntimeEnvSources,
+                    customEnvVars: cleanedCustomEnvVars,
+                    _autoFilledModel: importApi._autoFilledModel,
+                };
+                if (importApi._autoModelEnvVars) {
+                    newApi._autoModelEnvVars = importApi._autoModelEnvVars;
+                }
+                if (importApi.successCount !== undefined) newApi.successCount = importApi.successCount;
+                if (importApi.failCount !== undefined) newApi.failCount = importApi.failCount;
+                if (importApi.lastError !== undefined) newApi.lastError = importApi.lastError;
+
+                this._normalizeApiFields(newApi);
+                this.config.apis.push(newApi);
+                imported++;
+                if (this.config.apis.length === 1) this.config.activeIndex = 0;
             } catch (error) {
-                console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Validation error: ${error.message}`);
                 skipped++;
+                skippedItems.push({ apiName: importApi.name || 'Unknown', reason: error.message });
             }
         });
 
         this.saveConfig();
-        return { imported, skipped };
+        return { imported, skipped, warnings, skippedItems };
+    }
+
+    // --- Draft methods (no persistence, for pre-create config editing) ---
+
+    static buildApiDraft(provider, baseUrl, authToken, model, name) {
+        const { getProvider } = require('./presets/providers');
+        const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS } = require('./validators');
+        const providerConfig = getProvider(provider);
+        let templateValues;
+        if (providerConfig && providerConfig.modelEnvTemplate) {
+            templateValues = providerConfig.modelEnvTemplate.getValues(model);
+        } else {
+            templateValues = {};
+            for (const k of PREDEFINED_MODEL_ENV_KEYS) templateValues[k] = model;
+            templateValues.smallFastModel = model;
+        }
+        const modelEnvVars = {};
+        for (const k of PREDEFINED_MODEL_ENV_KEYS) modelEnvVars[k] = templateValues[k] || '';
+        const _autoModelEnvVars = { ...templateValues };
+        const runtimeEnvVars = {};
+        const _runtimeEnvSources = {};
+        for (const k of PREDEFINED_RUNTIME_KEYS) { runtimeEnvVars[k] = ''; _runtimeEnvSources[k] = 'auto'; }
+        return { provider, baseUrl, authToken, model, name,
+            smallFastModel: templateValues.smallFastModel,
+            modelEnvVars, _autoModelEnvVars,
+            runtimeEnvVars, _runtimeEnvSources, customEnvVars: {} };
+    }
+
+    static applyDraftEnvChange(draft, section, key, value) {
+        const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS, validateRuntimeEnvValue, validateEnvKey } = require('./validators');
+        if (section === 'model') {
+            if (!PREDEFINED_MODEL_ENV_KEYS.includes(key)) throw new Error(`Unknown model env key: ${key}`);
+            if (typeof value !== 'string') throw new Error('model env value must be string');
+            draft.modelEnvVars[key] = (value === '') ? (draft._autoModelEnvVars[key] || '') : value;
+        } else if (section === 'runtime') {
+            if (!PREDEFINED_RUNTIME_KEYS.includes(key)) throw new Error(`Unknown runtime env key: ${key}`);
+            const v = validateRuntimeEnvValue(key, value);
+            if (!v.valid) throw new Error(`Invalid: ${v.error}`);
+            draft.runtimeEnvVars[key] = value;
+            draft._runtimeEnvSources[key] = (value === '') ? 'auto' : 'manual';
+        } else if (section === 'custom') {
+            const kv = validateEnvKey(key);
+            if (!kv.valid) throw new Error(`Invalid custom key: ${kv.error}`);
+            if (typeof value !== 'string') throw new Error('custom env value must be string');
+            draft.customEnvVars[key] = value;
+        }
+        return draft;
+    }
+
+    static deleteDraftCustomEnvVar(draft, key) {
+        delete draft.customEnvVars[key];
+        return draft;
     }
 }
 
-module.exports = ApiManager;
+module.exports = ApiManager;
+module.exports.DuplicateApiError = DuplicateApiError;
+module.exports.MODEL_CONFIG_LABELS = MODEL_CONFIG_LABELS;
+module.exports.RUNTIME_CONFIG_LABELS = RUNTIME_CONFIG_LABELS;