recoder-code 2.4.6 → 2.5.0

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

@@ -5,14 +5,39 @@ 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';
+import { detectAndReport } from '../providers/local-detection.js';
+import { monitorProviders } from './providers/health.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);
     },
 };
+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',
@@ -21,6 +46,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 +65,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 +83,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);
     },
@@ -55,12 +98,20 @@ 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)
         .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;

package/dist/src/providers/custom-provider-manager.js

@@ -0,0 +1,105 @@
+/**
+ * Custom Provider Manager - Load and manage user-defined providers
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.recoder-code', 'providers');
+const CUSTOM_PROVIDERS_DIR = path.join(CONFIG_DIR, 'custom_providers');
+export class CustomProviderManager {
+    customProviders = new Map();
+    initialized = false;
+    constructor() {
+        this.init();
+    }
+    init() {
+        if (this.initialized)
+            return;
+        this.ensureDirectories();
+        this.loadCustomProviders();
+        this.initialized = true;
+    }
+    ensureDirectories() {
+        if (!fs.existsSync(CUSTOM_PROVIDERS_DIR)) {
+            fs.mkdirSync(CUSTOM_PROVIDERS_DIR, { recursive: true });
+        }
+    }
+    loadCustomProviders() {
+        try {
+            const files = fs.readdirSync(CUSTOM_PROVIDERS_DIR);
+            const jsonFiles = files.filter(f => f.endsWith('.json'));
+            for (const file of jsonFiles) {
+                try {
+                    const filePath = path.join(CUSTOM_PROVIDERS_DIR, file);
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const config = JSON.parse(content);
+                    const provider = {
+                        id: config.id,
+                        name: config.name,
+                        engine: config.engine,
+                        baseUrl: config.baseUrl,
+                        apiKeyEnv: config.apiKeyEnv,
+                        isLocal: config.isLocal ?? false,
+                        isEnabled: true,
+                        isBuiltin: false,
+                        models: config.models,
+                        headers: config.headers,
+                        supportsStreaming: config.supportsStreaming ?? true,
+                    };
+                    this.customProviders.set(config.id, provider);
+                }
+                catch (err) {
+                    console.warn(`Failed to load provider from ${file}:`, err);
+                }
+            }
+        }
+        catch (err) {
+            // Directory doesn't exist yet, that's ok
+        }
+    }
+    async addProvider(config) {
+        const filePath = path.join(CUSTOM_PROVIDERS_DIR, `${config.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(config, null, 2), 'utf-8');
+        const provider = {
+            id: config.id,
+            name: config.name,
+            engine: config.engine,
+            baseUrl: config.baseUrl,
+            apiKeyEnv: config.apiKeyEnv,
+            isLocal: config.isLocal ?? false,
+            isEnabled: true,
+            isBuiltin: false,
+            models: config.models,
+            headers: config.headers,
+            supportsStreaming: config.supportsStreaming ?? true,
+        };
+        this.customProviders.set(config.id, provider);
+    }
+    async removeProvider(id) {
+        const filePath = path.join(CUSTOM_PROVIDERS_DIR, `${id}.json`);
+        await fs.promises.unlink(filePath);
+        this.customProviders.delete(id);
+    }
+    getAll() {
+        return Array.from(this.customProviders.values());
+    }
+    get(id) {
+        return this.customProviders.get(id);
+    }
+    async testConnection(provider) {
+        try {
+            const response = await fetch(`${provider.baseUrl}/v1/models`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...provider.headers,
+                },
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const customProviderManager = new CustomProviderManager();

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

@@ -5,13 +5,14 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { BUILTIN_PROVIDERS, PROVIDER_ALIASES } from './types.js';
+import { customProviderManager } from './custom-provider-manager.js';
 const CONFIG_DIR = path.join(os.homedir(), '.recoder-code');
 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(),
 };
@@ -78,23 +79,7 @@ export class ProviderRegistry {
      * Get all providers (builtin + custom)
      */
     getAllProviders() {
-        const customFromFiles = this.loadCustomProviderFiles();
-        const customProviders = [
-            ...this.config.customProviders,
-            ...customFromFiles,
-        ].map((p) => ({
-            id: p.id,
-            name: p.name,
-            engine: p.engine,
-            baseUrl: p.baseUrl,
-            apiKeyEnv: p.apiKeyEnv,
-            isLocal: p.isLocal ?? false,
-            isEnabled: true,
-            isBuiltin: false,
-            models: p.models,
-            headers: p.headers,
-            supportsStreaming: p.supportsStreaming ?? true,
-        }));
+        const customProviders = customProviderManager.getAll();
         return [...BUILTIN_PROVIDERS, ...customProviders];
     }
     /**

package/dist/src/services/RecoderAuthService.js

@@ -193,23 +193,24 @@ export class RecoderAuthService {
         if (!session?.refresh_token) {
             throw new Error('No refresh token available');
         }
-        const response = await fetch(`${RECODER_API_BASE}/api/auth/cli`, {
+        const response = await fetch(`${RECODER_API_BASE}/api/auth/cli/token`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
-                action: 'refresh_token',
+                grant_type: 'refresh_token',
                 refresh_token: session.refresh_token,
-                client_id: CLIENT_ID,
             }),
         });
         if (!response.ok) {
             throw new Error('Failed to refresh token');
         }
         const data = await response.json();
+        // Calculate expires_at from expires_in (seconds)
+        const expiresAt = new Date(Date.now() + (data.expires_in || 7776000) * 1000);
         await this.saveSession({
             access_token: data.access_token,
             refresh_token: data.refresh_token || session.refresh_token,
-            expires_at: data.expires_at,
+            expires_at: expiresAt.toISOString(),
             user: session.user,
         });
     }
@@ -390,16 +391,12 @@ export class RecoderAuthService {
         };
     }
     async requestDeviceCode() {
-        const response = await fetch(`${RECODER_API_BASE}/api/auth/cli/authorize`, {
+        // Step 1: Request device code from /api/auth/cli/device (unauthenticated)
+        const response = await fetch(`${RECODER_API_BASE}/api/auth/cli/device`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 client_id: CLIENT_ID,
-                scope: 'cli:full profile',
-                deviceInfo: {
-                    platform: process.platform,
-                    hostname: os.hostname(),
-                },
             }),
         });
         if (!response.ok) {
@@ -413,19 +410,27 @@ export class RecoderAuthService {
         while (attempts < maxAttempts) {
             await new Promise(resolve => setTimeout(resolve, interval * 1000));
             try {
+                // Use POST with JSON body as server expects (RFC 8628 compliant)
                 const response = await fetch(`${RECODER_API_BASE}/api/auth/cli/token`, {
-                    method: 'GET',
+                    method: 'POST',
                     headers: {
-                        'X-Device-Code': deviceCode,
-                        'X-Client-Id': CLIENT_ID,
+                        'Content-Type': 'application/json',
                     },
+                    body: JSON.stringify({
+                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                        device_code: deviceCode,
+                        client_id: CLIENT_ID,
+                    }),
                 });
                 const data = await response.json();
-                if (response.ok && data.token) {
+                // Server returns { status, access_token, refresh_token, expires_in, user }
+                if (response.ok && data.status === 'authorized' && data.access_token) {
+                    // Calculate expires_at from expires_in (seconds)
+                    const expiresAt = new Date(Date.now() + (data.expires_in || 7776000) * 1000);
                     return {
-                        access_token: data.token.accessToken,
-                        refresh_token: data.token.refreshToken,
-                        expires_at: data.token.expiresAt,
+                        access_token: data.access_token,
+                        refresh_token: data.refresh_token,
+                        expires_at: expiresAt.toISOString(),
                         user: data.user,
                     };
                 }
@@ -436,6 +441,9 @@ export class RecoderAuthService {
                 if (data.status === 'denied') {
                     throw new Error('Authorization denied by user');
                 }
+                if (data.status === 'expired') {
+                    throw new Error('Device code expired. Please try again.');
+                }
                 throw new Error(data.error || 'Authorization failed');
             }
             catch (error) {