recoder-code 2.4.6 → 2.4.7

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/registry.js

@@ -5,6 +5,7 @@ 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');
@@ -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) {