recoder-code 2.4.6 → 2.4.7

package/dist/src/commands/connect-cmd.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Connect command module - Add custom providers interactively
+ */
+import type { CommandModule } from 'yargs';
+export declare const connectCommand: CommandModule;

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

@@ -0,0 +1,12 @@
+/**
+ * Connect command module - Add custom providers interactively
+ */
+import { connectProvider } from './connect.js';
+export const connectCommand = {
+    command: 'connect',
+    describe: 'Add a custom AI provider (LM Studio, vLLM, etc.)',
+    handler: async () => {
+        await connectProvider();
+        process.exit(0);
+    },
+};

package/dist/src/commands/connect.d.ts

@@ -1,7 +1,4 @@
 /**
- * /connect command - Interactive provider setup and health check
+ * Interactive provider configuration command
  */
-/**
- * Interactive connect command
- */
-export declare function connectCommand(args?: string[]): Promise<void>;
+export declare function connectProvider(): Promise<void>;

package/dist/src/commands/connect.js

@@ -1,363 +1,88 @@
 /**
- * /connect command - Interactive provider setup and health check
+ * Interactive provider configuration command
  */
-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 { getProviderRegistry } from '../providers/registry.js';
-const CONFIG_DIR = path.join(os.homedir(), '.recoder-code');
-const ENV_FILE = path.join(CONFIG_DIR, '.env');
-const CUSTOM_PROVIDERS_DIR = path.join(CONFIG_DIR, 'custom_providers');
-/**
- * Check health of all providers
- */
-async function checkProviderHealth(provider) {
-    const start = Date.now();
-    try {
-        let url;
-        let headers = {};
-        if (provider.isLocal) {
-            // Local providers - check if running
-            url = provider.engine === 'ollama'
-                ? `${provider.baseUrl}/api/tags`
-                : `${provider.baseUrl}/models`;
-        }
-        else {
-            // Cloud providers - check API with key
-            const apiKey = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : undefined;
-            if (!apiKey) {
-                return { provider, available: false, error: 'No API key configured' };
-            }
-            if (provider.id === 'openrouter') {
-                url = 'https://openrouter.ai/api/v1/models';
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-            else if (provider.id === 'openai') {
-                url = 'https://api.openai.com/v1/models';
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-            else if (provider.id === 'anthropic') {
-                url = 'https://api.anthropic.com/v1/messages';
-                headers['x-api-key'] = apiKey;
-                headers['anthropic-version'] = '2023-06-01';
-                // For Anthropic, we just check if key format is valid
-                if (apiKey.startsWith('sk-ant-')) {
-                    return { provider, available: true, latency: Date.now() - start };
+import inquirer from 'inquirer';
+import { customProviderManager } from '../providers/custom-provider-manager.js';
+export async function connectProvider() {
+    console.log('🔌 Add Custom Provider\n');
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'id',
+            message: 'Provider ID (e.g., my-llm):',
+            validate: (input) => input.length > 0 || 'ID is required',
+        },
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Provider Name:',
+            validate: (input) => input.length > 0 || 'Name is required',
+        },
+        {
+            type: 'list',
+            name: 'engine',
+            message: 'API Compatibility:',
+            choices: [
+                { name: 'OpenAI-compatible (LM Studio, vLLM, llama.cpp)', value: 'openai' },
+                { name: 'Anthropic-compatible', value: 'anthropic' },
+                { name: 'Ollama-compatible', value: 'ollama' },
+                { name: 'Google Gemini-compatible', value: 'google' },
+            ],
+        },
+        {
+            type: 'input',
+            name: 'baseUrl',
+            message: 'Base URL:',
+            default: 'http://localhost:1234/v1',
+            validate: (input) => {
+                try {
+                    new URL(input);
+                    return true;
                 }
-            }
-            else if (provider.id === 'groq') {
-                url = 'https://api.groq.com/openai/v1/models';
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-            else {
-                // Generic OpenAI-compatible check
-                url = `${provider.baseUrl}/models`;
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-        }
-        const response = await fetch(url, {
-            headers,
-            signal: AbortSignal.timeout(5000),
-        });
-        const latency = Date.now() - start;
-        if (response.ok || response.status === 401) {
-            // 401 means the endpoint exists but key is wrong
-            return {
-                provider,
-                available: response.ok,
-                latency,
-                error: response.status === 401 ? 'Invalid API key' : undefined
-            };
-        }
-        return { provider, available: false, latency, error: `HTTP ${response.status}` };
-    }
-    catch (error) {
-        return {
-            provider,
-            available: false,
-            error: error.code === 'ECONNREFUSED' ? 'Not running' : error.message
-        };
-    }
-}
-/**
- * Interactive connect command
- */
-export async function connectCommand(args = []) {
-    const registry = getProviderRegistry();
-    const subcommand = args[0];
-    if (!subcommand || subcommand === 'status') {
-        await showProviderStatus();
-        return;
-    }
-    if (subcommand === 'add') {
-        await addProvider(args[1]);
-        return;
-    }
-    if (subcommand === 'test') {
-        await testProvider(args[1]);
-        return;
-    }
-    if (subcommand === 'local') {
-        await detectLocalProviders();
-        return;
-    }
-    if (subcommand === 'custom') {
-        await addCustomProvider();
-        return;
-    }
-    // If provider name given, configure it
-    await configureProviderKey(subcommand);
-}
-/**
- * Show status of all providers
- */
-async function showProviderStatus() {
-    const registry = getProviderRegistry();
-    const providers = registry.getAllProviders();
-    console.log(chalk.bold.cyan('\n🔌 Provider Status\n'));
-    // Group by type
-    const local = providers.filter(p => p.isLocal);
-    const cloud = providers.filter(p => !p.isLocal && p.isBuiltin);
-    const custom = providers.filter(p => !p.isBuiltin);
-    // Check local providers
-    console.log(chalk.bold('Local AI:'));
-    for (const provider of local) {
-        const status = await checkProviderHealth(provider);
-        const icon = status.available ? chalk.green('✓') : chalk.gray('○');
-        const latencyStr = status.latency ? chalk.gray(` (${status.latency}ms)`) : '';
-        const errorStr = status.error ? chalk.red(` - ${status.error}`) : '';
-        console.log(`  ${icon} ${provider.name}${latencyStr}${errorStr}`);
-    }
-    // Check cloud providers
-    console.log(chalk.bold('\nCloud Providers:'));
-    for (const provider of cloud) {
-        const hasKey = provider.apiKeyEnv ? !!process.env[provider.apiKeyEnv] : false;
-        const icon = hasKey ? chalk.green('✓') : chalk.gray('○');
-        const keyStatus = hasKey ? chalk.gray(' (configured)') : chalk.yellow(' (no key)');
-        console.log(`  ${icon} ${provider.name}${keyStatus}`);
-    }
-    // Custom providers
-    if (custom.length > 0) {
-        console.log(chalk.bold('\nCustom Providers:'));
-        for (const provider of custom) {
-            const status = await checkProviderHealth(provider);
-            const icon = status.available ? chalk.green('✓') : chalk.gray('○');
-            console.log(`  ${icon} ${provider.name} (${provider.baseUrl})`);
-        }
-    }
-    console.log(chalk.gray('\nCommands:'));
-    console.log(chalk.gray('  /connect <provider>  - Configure API key'));
-    console.log(chalk.gray('  /connect local       - Detect local AI servers'));
-    console.log(chalk.gray('  /connect custom      - Add custom provider'));
-    console.log(chalk.gray('  /connect test <provider> - Test connection'));
-    console.log();
-}
-/**
- * Configure provider API key
- */
-async function configureProviderKey(providerId) {
-    const registry = getProviderRegistry();
-    const provider = registry.getProvider(providerId);
-    if (!provider) {
-        console.log(chalk.red(`\n❌ Unknown provider: ${providerId}`));
-        console.log(chalk.gray('Run /connect to see available providers\n'));
-        return;
-    }
-    if (provider.isLocal) {
-        console.log(chalk.yellow(`\n${provider.name} is a local provider - no API key needed.`));
-        console.log(chalk.gray('Run /connect local to check if it\'s running.\n'));
-        return;
-    }
-    if (!provider.apiKeyEnv) {
-        console.log(chalk.yellow(`\n${provider.name} doesn't require an API key.\n`));
-        return;
-    }
-    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.name}\n`));
-    // Show help for getting API key
-    const keyUrls = {
-        openrouter: 'https://openrouter.ai/keys',
-        anthropic: 'https://console.anthropic.com/settings/keys',
-        openai: 'https://platform.openai.com/api-keys',
-        groq: 'https://console.groq.com/keys',
-        deepseek: 'https://platform.deepseek.com/api_keys',
-        together: 'https://api.together.xyz/settings/api-keys',
-        fireworks: 'https://fireworks.ai/account/api-keys',
-        mistral: 'https://console.mistral.ai/api-keys',
-        google: 'https://aistudio.google.com/apikey',
-    };
-    if (keyUrls[provider.id]) {
-        console.log(chalk.gray(`Get your key: ${keyUrls[provider.id]}\n`));
-    }
-    const currentKey = process.env[provider.apiKeyEnv];
-    if (currentKey) {
-        const masked = currentKey.substring(0, 8) + '...' + currentKey.substring(currentKey.length - 4);
-        console.log(chalk.gray(`Current key: ${masked}\n`));
-    }
-    const apiKey = await question(chalk.white(`Enter ${provider.apiKeyEnv}: `));
-    rl.close();
-    if (!apiKey.trim()) {
-        console.log(chalk.yellow('\nNo key provided, skipping.\n'));
-        return;
-    }
-    // Test the key before saving
-    console.log(chalk.gray('\nTesting connection...'));
-    process.env[provider.apiKeyEnv] = apiKey.trim();
-    const status = await checkProviderHealth(provider);
-    if (!status.available && status.error === 'Invalid API key') {
-        console.log(chalk.red('\n❌ API key appears to be invalid.'));
-        const save = await new Promise((resolve) => {
-            const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
-            rl2.question(chalk.yellow('Save anyway? (y/N): '), (answer) => {
-                rl2.close();
-                resolve(answer);
-            });
-        });
-        if (save.toLowerCase() !== 'y') {
-            console.log(chalk.gray('Key not saved.\n'));
-            return;
-        }
-    }
-    else if (status.available) {
-        console.log(chalk.green(`✓ Connected! (${status.latency}ms)`));
-    }
-    // Save to env file
-    saveApiKey(provider.apiKeyEnv, apiKey.trim());
-    console.log(chalk.green(`\n✓ Saved to ${ENV_FILE}`));
-    console.log(chalk.gray(`\nTo use immediately, run:`));
-    console.log(chalk.cyan(`  export ${provider.apiKeyEnv}="${apiKey.trim()}"\n`));
-}
-/**
- * Save API key to env file
- */
-function saveApiKey(envVar, value) {
-    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');
-    }
-    const regex = new RegExp(`^${envVar}=.*$`, 'm');
-    if (regex.test(envContent)) {
-        envContent = envContent.replace(regex, `${envVar}=${value}`);
-    }
-    else {
-        envContent += `\n${envVar}=${value}`;
-    }
-    fs.writeFileSync(ENV_FILE, envContent.trim() + '\n');
-}
-/**
- * Detect local AI servers
- */
-async function detectLocalProviders() {
-    console.log(chalk.bold.cyan('\n🔍 Detecting Local AI Servers\n'));
-    const localServers = [
-        { name: 'Ollama', url: 'http://localhost:11434/api/tags', port: 11434 },
-        { name: 'LM Studio', url: 'http://localhost:1234/v1/models', port: 1234 },
-        { name: 'llama.cpp', url: 'http://localhost:8080/v1/models', port: 8080 },
-        { name: 'vLLM', url: 'http://localhost:8000/v1/models', port: 8000 },
-        { name: 'LocalAI', url: 'http://localhost:8080/v1/models', port: 8080 },
-    ];
-    for (const server of localServers) {
-        try {
-            const start = Date.now();
-            const response = await fetch(server.url, { signal: AbortSignal.timeout(2000) });
-            const latency = Date.now() - start;
-            if (response.ok) {
-                console.log(chalk.green(`✓ ${server.name}`), chalk.gray(`(localhost:${server.port}, ${latency}ms)`));
-                // Get model list for Ollama
-                if (server.name === 'Ollama') {
-                    const data = await response.json();
-                    if (data.models && data.models.length > 0) {
-                        console.log(chalk.gray(`  Models: ${data.models.slice(0, 5).map(m => m.name).join(', ')}${data.models.length > 5 ? '...' : ''}`));
-                    }
+                catch {
+                    return 'Invalid URL';
                 }
-            }
-        }
-        catch {
-            console.log(chalk.gray(`○ ${server.name}`), chalk.gray(`(not running on port ${server.port})`));
-        }
-    }
-    console.log(chalk.gray('\nTo use a local model:'));
-    console.log(chalk.cyan('  recoder --model ollama/llama3.2'));
-    console.log(chalk.cyan('  recoder --model lmstudio/local-model\n'));
-}
-/**
- * Test specific provider connection
- */
-async function testProvider(providerId) {
-    if (!providerId) {
-        console.log(chalk.yellow('\nUsage: /connect test <provider>\n'));
-        return;
-    }
-    const registry = getProviderRegistry();
-    const provider = registry.getProvider(providerId);
-    if (!provider) {
-        console.log(chalk.red(`\n❌ Unknown provider: ${providerId}\n`));
-        return;
-    }
-    console.log(chalk.cyan(`\nTesting ${provider.name}...`));
-    const status = await checkProviderHealth(provider);
-    if (status.available) {
-        console.log(chalk.green(`✓ Connected! (${status.latency}ms)\n`));
-    }
-    else {
-        console.log(chalk.red(`✗ Failed: ${status.error}\n`));
-    }
-}
-/**
- * Add custom provider interactively
- */
-async function addCustomProvider() {
-    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➕ Add Custom Provider\n'));
-    console.log(chalk.gray('Add any OpenAI-compatible API endpoint.\n'));
-    const id = await question(chalk.white('Provider ID (e.g., my-api): '));
-    if (!id.trim()) {
-        rl.close();
-        return;
-    }
-    const name = await question(chalk.white('Display Name: ')) || id;
-    const baseUrl = await question(chalk.white('Base URL (e.g., http://localhost:8000/v1): '));
-    if (!baseUrl.trim()) {
-        console.log(chalk.yellow('\nBase URL required.\n'));
-        rl.close();
-        return;
-    }
-    const apiKeyEnv = await question(chalk.white('API Key env var (optional, e.g., MY_API_KEY): '));
-    const isLocalStr = await question(chalk.white('Is local server? (y/N): '));
-    rl.close();
+            },
+        },
+        {
+            type: 'confirm',
+            name: 'isLocal',
+            message: 'Is this a local provider?',
+            default: true,
+        },
+        {
+            type: 'input',
+            name: 'apiKey',
+            message: 'API Key (leave empty for local):',
+            default: '',
+        },
+    ]);
     const config = {
-        id: id.trim().toLowerCase().replace(/\s+/g, '-'),
-        name: name.trim(),
-        engine: 'openai',
-        baseUrl: baseUrl.trim(),
-        apiKeyEnv: apiKeyEnv.trim() || undefined,
-        isLocal: isLocalStr.toLowerCase() === 'y',
+        id: answers.id,
+        name: answers.name,
+        engine: answers.engine,
+        baseUrl: answers.baseUrl,
+        isLocal: answers.isLocal,
         models: [],
         supportsStreaming: true,
     };
-    // Save to file
-    if (!fs.existsSync(CUSTOM_PROVIDERS_DIR)) {
-        fs.mkdirSync(CUSTOM_PROVIDERS_DIR, { recursive: true });
-    }
-    const filePath = path.join(CUSTOM_PROVIDERS_DIR, `${config.id}.json`);
-    fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
-    console.log(chalk.green(`\n✓ Custom provider saved to ${filePath}`));
-    console.log(chalk.gray(`\nTo use: recoder --model ${config.id}/model-name\n`));
-}
-/**
- * Add provider (alias for configure)
- */
-async function addProvider(providerId) {
-    if (!providerId) {
-        console.log(chalk.yellow('\nUsage: /connect add <provider>\n'));
-        return;
+    if (answers.apiKey) {
+        config.apiKeyEnv = `RECODER_${answers.id.toUpperCase().replace(/-/g, '_')}_API_KEY`;
+        console.log(`\n💡 Set your API key: export ${config.apiKeyEnv}="${answers.apiKey}"`);
+    }
+    await customProviderManager.addProvider(config);
+    console.log(`\n✅ Provider "${answers.name}" added successfully!`);
+    console.log(`   Use it with: recoder --provider ${answers.id}`);
+    // Test connection
+    const provider = customProviderManager.get(answers.id);
+    if (provider) {
+        console.log('\n🔍 Testing connection...');
+        const isConnected = await customProviderManager.testConnection(provider);
+        if (isConnected) {
+            console.log('✅ Connection successful!');
+        }
+        else {
+            console.log('⚠️  Could not connect. Check your configuration.');
+        }
     }
-    await configureProviderKey(providerId);
 }

package/dist/src/commands/providers.js

@@ -5,10 +5,17 @@ import { listProviders } from './providers/list.js';
 import { listProviderModels } from './providers/models.js';
 import { pullModel } from './providers/pull.js';
 import { configureProvider } from './providers/config.js';
+import { RecoderAuthService } from '../services/RecoderAuthService.js';
 const listCommand = {
     command: 'list',
     describe: 'List all available providers',
     handler: async () => {
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         await listProviders();
         process.exit(0);
     },
@@ -21,6 +28,12 @@ const modelsCommand = {
         type: 'string',
     }),
     handler: async (argv) => {
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         await listProviderModels(argv.provider);
         process.exit(0);
     },
@@ -34,6 +47,12 @@ const pullCommand = {
         demandOption: true,
     }),
     handler: async (argv) => {
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         await pullModel(argv.model);
         process.exit(0);
     },
@@ -46,6 +65,12 @@ const configCommand = {
         type: 'string',
     }),
     handler: async (argv) => {
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         await configureProvider(argv.provider);
         process.exit(0);
     },
@@ -61,6 +86,12 @@ export const providersCommand = {
         .demandCommand(0)
         .version(false),
     handler: async () => {
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         await listProviders();
         process.exit(0);
     },

package/dist/src/config/config.js

@@ -22,6 +22,7 @@ import { agentsCommand } from '../commands/agents.js';
 import { hintsCommand } from '../commands/hints.js';
 import { modelsCommand } from '../commands/models-cmd.js';
 import { configureCommand } from '../commands/configure.js';
+import { connectCommand } from '../commands/connect-cmd.js';
 import { resolvePath } from '../utils/resolvePath.js';
 import { getCliVersion } from '../utils/version.js';
 import { annotateActiveExtensions } from './extension.js';
@@ -277,7 +278,9 @@ export async function parseArguments(settings) {
         // Register models command for model management
         .command(modelsCommand)
         // Register configure command for interactive setup
-        .command(configureCommand);
+        .command(configureCommand)
+        // Register connect command for custom providers
+        .command(connectCommand);
     if (settings?.experimental?.extensionManagement ?? false) {
         yargsInstance.command(extensionsCommand);
     }

package/dist/src/gemini.js

@@ -127,6 +127,26 @@ export async function main() {
         await runApiKeySetup();
         process.exit(0);
     }
+    // ===== RECODER.XYZ AUTHENTICATION GUARD =====
+    // Require users to sign up/login before using recoder-code
+    const { RecoderAuthService } = await import('./services/RecoderAuthService.js');
+    const authService = new RecoderAuthService();
+    // Skip auth check for auth commands themselves
+    const isAuthCommand = process.argv.some(arg => arg === 'auth');
+    if (!isAuthCommand) {
+        const isAuthenticated = await authService.isAuthenticated();
+        if (!isAuthenticated) {
+            console.log('\n🚀 Welcome to Recoder Code!\n');
+            console.log('Please sign up to continue. It\'s free - no credit card required.');
+            console.log('Just bring your own API key (OpenRouter, OpenAI, Anthropic, etc.)\n');
+            console.log('🌐 https://recoder.xyz');
+            console.log('🐦 https://x.com/recoderxyz\n');
+            console.log('To authenticate, run:\n');
+            console.log('  recoder auth login\n');
+            process.exit(1);
+        }
+    }
+    // ===== END AUTH GUARD =====
     // Check if API key is configured before proceeding
     const { isApiKeyConfigured, checkAndSetupApiKey } = await import('./setup/apiKeySetup.js');
     if (!isApiKeyConfigured()) {

package/dist/src/providers/custom-provider-manager.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Custom Provider Manager - Load and manage user-defined providers
+ */
+import type { CustomProviderConfig, AIProvider } from './types.js';
+export declare class CustomProviderManager {
+    private customProviders;
+    private initialized;
+    constructor();
+    private init;
+    private ensureDirectories;
+    private loadCustomProviders;
+    addProvider(config: CustomProviderConfig): Promise<void>;
+    removeProvider(id: string): Promise<void>;
+    getAll(): AIProvider[];
+    get(id: string): AIProvider | undefined;
+    testConnection(provider: AIProvider): Promise<boolean>;
+}
+export declare const customProviderManager: CustomProviderManager;