recoder-code 2.4.7 → 2.5.1

package/dist/src/commands/models-cmd.js

@@ -6,6 +6,17 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { getOllamaProvider, getOpenRouterProvider, getAnthropicProvider, getOpenAIProvider, getGroqProvider, parseModelId, } from '../providers/index.js';
+import { selectModel } from './models/select.js';
+import { compareModels } from './models/compare.js';
+import { RecoderAuthService } from '../services/RecoderAuthService.js';
+async function requireAuth() {
+    const authService = new RecoderAuthService();
+    const session = await authService.getSession();
+    if (!session) {
+        console.error('❌ Please login first: recoder auth login');
+        process.exit(1);
+    }
+}
 const CONFIG_DIR = path.join(os.homedir(), '.recoder-code');
 const CUSTOM_MODELS_FILE = path.join(CONFIG_DIR, 'custom-models.json');
 const DEFAULT_MODEL_FILE = path.join(CONFIG_DIR, 'default-model.json');
@@ -45,6 +56,7 @@ const listCommand = {
         type: 'string',
     }),
     handler: async (argv) => {
+        await requireAuth();
         console.log(chalk.bold.cyan('\n🤖 Available Models\n'));
         const defaultModel = getDefaultModel();
         if (defaultModel) {
@@ -120,6 +132,7 @@ const addCommand = {
         .option('name', { describe: 'Display name', type: 'string' })
         .option('provider', { describe: 'Provider', type: 'string' }),
     handler: async (argv) => {
+        await requireAuth();
         const parsed = parseModelId(argv.model);
         const models = loadCustomModels();
         if (models.some((m) => m.id === argv.model)) {
@@ -141,6 +154,7 @@ const removeCommand = {
     describe: 'Remove a custom model',
     builder: (yargs) => yargs.positional('model', { describe: 'Model ID', type: 'string', demandOption: true }),
     handler: async (argv) => {
+        await requireAuth();
         const models = loadCustomModels();
         const filtered = models.filter((m) => m.id !== argv.model);
         if (filtered.length === models.length) {
@@ -157,16 +171,37 @@ const setDefaultCommand = {
     describe: 'Set default model',
     builder: (yargs) => yargs.positional('model', { describe: 'Model ID', type: 'string', demandOption: true }),
     handler: async (argv) => {
+        await requireAuth();
         setDefaultModel(argv.model);
         console.log(chalk.green(`\n✓ Default model set to ${argv.model}\n`));
         process.exit(0);
     },
 };
+const selectCommand = {
+    command: 'select',
+    describe: 'Interactive model selection with fuzzy search',
+    handler: async () => {
+        await requireAuth();
+        await selectModel();
+        process.exit(0);
+    },
+};
+const compareCommand = {
+    command: 'compare',
+    describe: 'Compare multiple models side-by-side',
+    handler: async () => {
+        await requireAuth();
+        await compareModels();
+        process.exit(0);
+    },
+};
 export const modelsCommand = {
     command: 'models',
     describe: 'Manage AI models',
     builder: (yargs) => yargs
         .command(listCommand)
+        .command(selectCommand)
+        .command(compareCommand)
         .command(addCommand)
         .command(removeCommand)
         .command(setDefaultCommand)

package/dist/src/commands/providers/config.d.ts

@@ -1,4 +1,4 @@
 /**
- * Providers config command - Configure API keys
+ * Providers config command - Configure API keys with secure storage
  */
 export declare function configureProvider(provider?: string): Promise<void>;

package/dist/src/commands/providers/config.js

@@ -1,11 +1,12 @@
 /**
- * Providers config command - Configure API keys
+ * Providers config command - Configure API keys with secure storage
  */
 import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as readline from 'readline';
+import { SecureKeyStorage } from '../../utils/secure-storage.js';
 const CONFIG_DIR = path.join(os.homedir(), '.recoder-code');
 const ENV_FILE = path.join(CONFIG_DIR, '.env');
 export async function configureProvider(provider) {
@@ -19,6 +20,13 @@ export async function configureProvider(provider) {
         console.log();
         console.log(chalk.cyan('Usage: recoder providers config <provider>'));
         console.log();
+        // Show stored keys
+        const stored = await SecureKeyStorage.list();
+        if (stored.length > 0) {
+            console.log(chalk.green('Configured providers:'));
+            stored.forEach(p => console.log(chalk.gray(`  ✓ ${p}`)));
+            console.log();
+        }
         return;
     }
     const envVars = {
@@ -36,30 +44,40 @@ export async function configureProvider(provider) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const question = (q) => new Promise((resolve) => rl.question(q, resolve));
     console.log(chalk.bold.cyan(`\n⚙️  Configure ${provider}\n`));
+    console.log(chalk.gray('API key will be stored securely in keychain\n'));
     const apiKey = await question(chalk.white(`Enter ${envVar}: `));
     rl.close();
     if (!apiKey.trim()) {
         console.log(chalk.yellow('\nNo key provided, skipping.\n'));
         return;
     }
-    // Save to env file
-    if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-    let envContent = '';
-    if (fs.existsSync(ENV_FILE)) {
-        envContent = fs.readFileSync(ENV_FILE, 'utf-8');
-    }
-    // Update or add the key
-    const regex = new RegExp(`^${envVar}=.*$`, 'm');
-    if (regex.test(envContent)) {
-        envContent = envContent.replace(regex, `${envVar}=${apiKey.trim()}`);
+    try {
+        // Store in secure keychain
+        await SecureKeyStorage.set(provider.toLowerCase(), apiKey.trim());
+        // Also save to env file for backward compatibility
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        let envContent = '';
+        if (fs.existsSync(ENV_FILE)) {
+            envContent = fs.readFileSync(ENV_FILE, 'utf-8');
+        }
+        // Update or add the key
+        const regex = new RegExp(`^${envVar}=.*$`, 'm');
+        if (regex.test(envContent)) {
+            envContent = envContent.replace(regex, `${envVar}=${apiKey.trim()}`);
+        }
+        else {
+            envContent += `\n${envVar}=${apiKey.trim()}`;
+        }
+        fs.writeFileSync(ENV_FILE, envContent.trim() + '\n');
+        console.log(chalk.green(`\n✓ API key stored securely`));
+        console.log(chalk.gray(`  Keychain: ${process.platform === 'darwin' ? 'macOS Keychain' : 'Encrypted file'}`));
+        console.log(chalk.gray(`  Fallback: ${ENV_FILE}`));
+        console.log();
     }
-    else {
-        envContent += `\n${envVar}=${apiKey.trim()}`;
+    catch (err) {
+        console.log(chalk.red(`\n❌ Error: ${err.message}`));
+        console.log();
     }
-    fs.writeFileSync(ENV_FILE, envContent.trim() + '\n');
-    console.log(chalk.green(`\n✓ Saved to ${ENV_FILE}`));
-    console.log(chalk.gray(`  Add to shell: export ${envVar}="${apiKey.trim()}"`));
-    console.log();
 }

package/dist/src/commands/providers/health.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Provider health monitoring
+ */
+export declare function monitorProviders(): Promise<void>;

package/dist/src/commands/providers/health.js

@@ -0,0 +1,90 @@
+/**
+ * Provider health monitoring
+ */
+import chalk from 'chalk';
+import { getProviderRegistry } from '../../providers/registry.js';
+async function checkProviderHealth(provider) {
+    const start = Date.now();
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        let endpoint = provider.baseUrl;
+        if (provider.engine === 'openai') {
+            endpoint = `${provider.baseUrl}/models`;
+        }
+        else if (provider.engine === 'ollama') {
+            endpoint = `${provider.baseUrl}/api/tags`;
+        }
+        const response = await fetch(endpoint, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...provider.headers,
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        const responseTime = Date.now() - start;
+        if (response.ok) {
+            return {
+                provider: provider.id,
+                name: provider.name,
+                status: 'online',
+                responseTime,
+            };
+        }
+        else {
+            return {
+                provider: provider.id,
+                name: provider.name,
+                status: 'error',
+                error: `HTTP ${response.status}`,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            provider: provider.id,
+            name: provider.name,
+            status: 'offline',
+            error: err.message || 'Connection failed',
+        };
+    }
+}
+export async function monitorProviders() {
+    console.log(chalk.bold.cyan('\n🏥 Provider Health Monitor\n'));
+    console.log(chalk.gray('Checking all providers...\n'));
+    const registry = getProviderRegistry();
+    const providers = registry.getAllProviders();
+    const results = [];
+    for (const provider of providers) {
+        const status = await checkProviderHealth(provider);
+        results.push(status);
+    }
+    // Display results
+    console.log(chalk.bold('Status Report:'));
+    console.log(chalk.gray('─'.repeat(60)));
+    const online = results.filter(r => r.status === 'online');
+    const offline = results.filter(r => r.status === 'offline');
+    const errors = results.filter(r => r.status === 'error');
+    online.forEach(r => {
+        console.log(chalk.green('✓') + ' ' +
+            chalk.bold(r.name) + ' ' +
+            chalk.gray(`(${r.responseTime}ms)`));
+    });
+    errors.forEach(r => {
+        console.log(chalk.yellow('⚠') + ' ' +
+            chalk.bold(r.name) + ' ' +
+            chalk.gray(`- ${r.error}`));
+    });
+    offline.forEach(r => {
+        console.log(chalk.red('✗') + ' ' +
+            chalk.bold(r.name) + ' ' +
+            chalk.gray(`- ${r.error}`));
+    });
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.green(`${online.length} online`) + ' | ' +
+        chalk.yellow(`${errors.length} errors`) + ' | ' +
+        chalk.red(`${offline.length} offline`));
+    console.log();
+}

package/dist/src/commands/providers.js

@@ -6,6 +6,8 @@ import { listProviderModels } from './providers/models.js';
 import { pullModel } from './providers/pull.js';
 import { configureProvider } from './providers/config.js';
 import { RecoderAuthService } from '../services/RecoderAuthService.js';
+import { detectAndReport } from '../providers/local-detection.js';
+import { monitorProviders } from './providers/health.js';
 const listCommand = {
     command: 'list',
     describe: 'List all available providers',
@@ -20,6 +22,22 @@ const listCommand = {
         process.exit(0);
     },
 };
+const detectCommand = {
+    command: 'detect',
+    describe: 'Detect running local AI servers',
+    handler: async () => {
+        await detectAndReport();
+        process.exit(0);
+    },
+};
+const healthCommand = {
+    command: 'health',
+    describe: 'Monitor provider health status',
+    handler: async () => {
+        await monitorProviders();
+        process.exit(0);
+    },
+};
 const modelsCommand = {
     command: 'models [provider]',
     describe: 'List models from all providers',
@@ -80,6 +98,8 @@ export const providersCommand = {
     describe: 'Manage AI providers (Ollama, OpenRouter, etc.)',
     builder: (yargs) => yargs
         .command(listCommand)
+        .command(detectCommand)
+        .command(healthCommand)
         .command(modelsCommand)
         .command(pullCommand)
         .command(configCommand)

package/dist/src/providers/local-detection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Local Provider Detection - Auto-detect running local AI servers
+ */
+import type { AIProvider } from './types.js';
+export declare function detectLocalProviders(): Promise<AIProvider[]>;
+export declare function detectAndReport(): Promise<void>;

package/dist/src/providers/local-detection.js

@@ -0,0 +1,86 @@
+/**
+ * Local Provider Detection - Auto-detect running local AI servers
+ */
+const LOCAL_PROVIDERS = [
+    {
+        id: 'lmstudio',
+        name: 'LM Studio',
+        port: 1234,
+        baseUrl: 'http://localhost:1234/v1',
+        engine: 'openai',
+    },
+    {
+        id: 'ollama',
+        name: 'Ollama',
+        port: 11434,
+        baseUrl: 'http://localhost:11434',
+        engine: 'ollama',
+    },
+    {
+        id: 'llamacpp',
+        name: 'llama.cpp',
+        port: 8080,
+        baseUrl: 'http://localhost:8080/v1',
+        engine: 'openai',
+    },
+    {
+        id: 'vllm',
+        name: 'vLLM',
+        port: 8000,
+        baseUrl: 'http://localhost:8000/v1',
+        engine: 'openai',
+    },
+];
+async function checkServer(url) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1000);
+        const response = await fetch(url, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectLocalProviders() {
+    const detected = [];
+    for (const provider of LOCAL_PROVIDERS) {
+        const isRunning = await checkServer(provider.baseUrl);
+        if (isRunning) {
+            detected.push({
+                id: provider.id,
+                name: provider.name,
+                engine: provider.engine,
+                baseUrl: provider.baseUrl,
+                isLocal: true,
+                isEnabled: true,
+                isBuiltin: false,
+                supportsStreaming: true,
+            });
+        }
+    }
+    return detected;
+}
+export async function detectAndReport() {
+    console.log('🔍 Detecting local AI servers...\n');
+    const detected = await detectLocalProviders();
+    if (detected.length === 0) {
+        console.log('❌ No local AI servers detected');
+        console.log('\n💡 Start one of these:');
+        LOCAL_PROVIDERS.forEach(p => {
+            console.log(`   • ${p.name} (port ${p.port})`);
+        });
+    }
+    else {
+        console.log('✅ Detected local servers:\n');
+        detected.forEach(p => {
+            console.log(`   • ${p.name} - ${p.baseUrl}`);
+        });
+        console.log('\n💡 Use with: recoder --provider ' + detected[0].id);
+    }
+    console.log();
+}

package/dist/src/providers/registry.js

@@ -11,8 +11,8 @@ const PROVIDERS_FILE = path.join(CONFIG_DIR, 'providers.json');
 const CUSTOM_PROVIDERS_DIR = path.join(CONFIG_DIR, 'custom_providers');
 const DEFAULT_CONFIG = {
     version: '1.0',
-    defaultProvider: 'anthropic',
-    defaultModel: 'claude-sonnet-4-20250514',
+    defaultProvider: 'openrouter',
+    defaultModel: 'anthropic/claude-sonnet-4-20250514',
     customProviders: [],
     lastUpdated: new Date().toISOString(),
 };

package/dist/src/utils/secure-storage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Secure keychain storage for API keys
+ * Uses macOS Keychain on macOS, encrypted file on other platforms
+ */
+export declare class SecureKeyStorage {
+    /**
+     * Store API key securely
+     */
+    static set(provider: string, apiKey: string): Promise<void>;
+    /**
+     * Retrieve API key
+     */
+    static get(provider: string): Promise<string | null>;
+    /**
+     * Delete API key
+     */
+    static delete(provider: string): Promise<void>;
+    /**
+     * List all stored providers
+     */
+    static list(): Promise<string[]>;
+    private static loadEncryptedFile;
+    private static saveEncryptedFile;
+}

package/dist/src/utils/secure-storage.js

@@ -0,0 +1,150 @@
+/**
+ * Secure keychain storage for API keys
+ * Uses macOS Keychain on macOS, encrypted file on other platforms
+ */
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+const KEYCHAIN_SERVICE = 'xyz.recoder.cli';
+const ENCRYPTED_FILE = path.join(os.homedir(), '.recoder-code', '.keys.enc');
+const ALGORITHM = 'aes-256-gcm';
+function isMacOS() {
+    return process.platform === 'darwin';
+}
+function getMachineId() {
+    try {
+        if (isMacOS()) {
+            return execSync('ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID', { encoding: 'utf-8' })
+                .split('=')[1]
+                .trim()
+                .replace(/"/g, '');
+        }
+        return os.hostname() + os.userInfo().username;
+    }
+    catch {
+        return os.hostname();
+    }
+}
+function getEncryptionKey() {
+    const machineId = getMachineId();
+    return crypto.scryptSync(machineId, 'recoder-salt', 32);
+}
+export class SecureKeyStorage {
+    /**
+     * Store API key securely
+     */
+    static async set(provider, apiKey) {
+        if (isMacOS()) {
+            try {
+                // Try to delete existing first
+                try {
+                    execSync(`security delete-generic-password -s "${KEYCHAIN_SERVICE}" -a "${provider}" 2>/dev/null`);
+                }
+                catch {
+                    // Ignore if doesn't exist
+                }
+                // Add new key
+                execSync(`security add-generic-password -s "${KEYCHAIN_SERVICE}" -a "${provider}" -w "${apiKey}"`);
+            }
+            catch (err) {
+                throw new Error(`Failed to store key in keychain: ${err}`);
+            }
+        }
+        else {
+            // Encrypted file storage for non-macOS
+            const keys = this.loadEncryptedFile();
+            keys[provider] = apiKey;
+            this.saveEncryptedFile(keys);
+        }
+    }
+    /**
+     * Retrieve API key
+     */
+    static async get(provider) {
+        if (isMacOS()) {
+            try {
+                const result = execSync(`security find-generic-password -s "${KEYCHAIN_SERVICE}" -a "${provider}" -w`, { encoding: 'utf-8' });
+                return result.trim();
+            }
+            catch {
+                return null;
+            }
+        }
+        else {
+            const keys = this.loadEncryptedFile();
+            return keys[provider] || null;
+        }
+    }
+    /**
+     * Delete API key
+     */
+    static async delete(provider) {
+        if (isMacOS()) {
+            try {
+                execSync(`security delete-generic-password -s "${KEYCHAIN_SERVICE}" -a "${provider}"`);
+            }
+            catch {
+                // Ignore if doesn't exist
+            }
+        }
+        else {
+            const keys = this.loadEncryptedFile();
+            delete keys[provider];
+            this.saveEncryptedFile(keys);
+        }
+    }
+    /**
+     * List all stored providers
+     */
+    static async list() {
+        if (isMacOS()) {
+            try {
+                const result = execSync(`security dump-keychain | grep -A 1 "${KEYCHAIN_SERVICE}" | grep "acct" | cut -d'"' -f4`, { encoding: 'utf-8' });
+                return result.trim().split('\n').filter(Boolean);
+            }
+            catch {
+                return [];
+            }
+        }
+        else {
+            const keys = this.loadEncryptedFile();
+            return Object.keys(keys);
+        }
+    }
+    static loadEncryptedFile() {
+        try {
+            if (!fs.existsSync(ENCRYPTED_FILE))
+                return {};
+            const encrypted = fs.readFileSync(ENCRYPTED_FILE, 'utf-8');
+            const [ivHex, authTagHex, encryptedData] = encrypted.split(':');
+            const key = getEncryptionKey();
+            const iv = Buffer.from(ivHex, 'hex');
+            const authTag = Buffer.from(authTagHex, 'hex');
+            const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+            decipher.setAuthTag(authTag);
+            let decrypted = decipher.update(encryptedData, 'hex', 'utf-8');
+            decrypted += decipher.final('utf-8');
+            return JSON.parse(decrypted);
+        }
+        catch {
+            return {};
+        }
+    }
+    static saveEncryptedFile(keys) {
+        const dir = path.dirname(ENCRYPTED_FILE);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const key = getEncryptionKey();
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+        let encrypted = cipher.update(JSON.stringify(keys), 'utf-8', 'hex');
+        encrypted += cipher.final('hex');
+        const authTag = cipher.getAuthTag();
+        const output = `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+        fs.writeFileSync(ENCRYPTED_FILE, output, 'utf-8');
+        fs.chmodSync(ENCRYPTED_FILE, 0o600); // Owner read/write only
+    }
+}