vigthoria-cli 1.6.1 → 1.6.4

package/src/utils/api.ts

@@ -1,526 +0,0 @@
-/**
- * API Client for Vigthoria Backend
- * Connects to coder.vigthoria.io API endpoints
- */
-
-import axios, { AxiosInstance, AxiosError } from 'axios';
-import https from 'https';
-import WebSocket from 'ws';
-import { Config } from './config.js';
-import { Logger } from './logger.js';
-
-export interface ChatMessage {
-  role: 'user' | 'assistant' | 'system';
-  content: string;
-}
-
-export interface ChatResponse {
-  id: string;
-  message: string;
-  model: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-export interface StreamChunk {
-  type: 'content' | 'done' | 'error';
-  content?: string;
-  error?: string;
-}
-
-export interface VigthoriUser {
-  id: string;
-  username: string;
-  email: string;
-  isAdmin: boolean;
-  subscription: {
-    plan: string;
-    projectLimit: number;
-    storageLimit: number;
-    viagen6Access: boolean;
-    aiModelsLimit: number;
-    prioritySupport: boolean;
-    teamCollaboration: boolean;
-    adminAccess: boolean;
-  };
-}
-
-export class APIClient {
-  private client: AxiosInstance;
-  private modelRouterClient: AxiosInstance;
-  private config: Config;
-  private logger: Logger;
-  private ws: WebSocket | null = null;
-
-  constructor(config: Config, logger: Logger) {
-    this.config = config;
-    this.logger = logger;
-
-    // Create HTTPS agent with proper settings for cross-platform compatibility
-    const httpsAgent = new https.Agent({
-      rejectUnauthorized: true,  // Enforce SSL verification
-      keepAlive: true,
-      timeout: 30000,
-    });
-
-    // Main Vigthoria Coder API (coder.vigthoria.io)
-    this.client = axios.create({
-      baseURL: config.get('apiUrl'),
-      timeout: 120000,
-      httpsAgent,
-      headers: {
-        'Content-Type': 'application/json',
-        'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.5.7'}`,
-      },
-    });
-
-    // Direct AI Models API - bypasses Coder for direct model access
-    // This is the centralized Vigthoria API that routes to Model Router
-    this.modelRouterClient = axios.create({
-      baseURL: config.get('modelsApiUrl') || 'https://api.vigthoria.io',
-      timeout: 180000, // 3 minutes for model inference
-      httpsAgent,
-      headers: {
-        'Content-Type': 'application/json',
-        'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.5.9'}`,
-      },
-    });
-
-    // Add auth interceptor
-    this.client.interceptors.request.use((req) => {
-      const token = this.config.get('authToken');
-      if (token) {
-        req.headers.Authorization = `Bearer ${token}`;
-        req.headers.Cookie = `vigthoria-auth-token=${token}`;
-      }
-      return req;
-    });
-
-    this.modelRouterClient.interceptors.request.use((req) => {
-      const token = this.config.get('authToken');
-      if (token) {
-        req.headers.Authorization = `Bearer ${token}`;
-        req.headers.Cookie = `vigthoria-auth-token=${token}`;
-      }
-      return req;
-    });
-
-    // Add response interceptor for token refresh
-    this.client.interceptors.response.use(
-      (res) => res,
-      async (error: AxiosError) => {
-        if (error.response?.status === 401) {
-          const refreshed = await this.refreshToken();
-          if (refreshed && error.config) {
-            return this.client.request(error.config);
-          }
-        }
-        throw error;
-      }
-    );
-  }
-
-  // Authentication - Uses Vigthoria Coder /api/login endpoint
-  async login(email: string, password: string): Promise<boolean> {
-    try {
-      const response = await this.client.post('/api/login', { email, password });
-      
-      if (!response.data.success) {
-        throw new Error(response.data.error || 'Login failed');
-      }
-
-      const { token, user } = response.data as { token: string; user: VigthoriUser };
-      
-      this.config.setAuth({
-        token,
-        userId: user.id,
-        email: user.email,
-      });
-
-      // Set subscription from user data
-      this.config.setSubscription({
-        plan: user.subscription?.plan || 'developer',
-        status: 'active',
-        expiresAt: undefined,
-      });
-      
-      return true;
-    } catch (error) {
-      const axiosError = error as AxiosError;
-      const message = (axiosError.response?.data as { error?: string })?.error || (error as Error).message;
-      this.logger.error('Login failed:', message);
-      return false;
-    }
-  }
-
-  async loginWithToken(token: string): Promise<boolean> {
-    try {
-      // Validate token by making a request to user info endpoint
-      this.config.set('authToken', token);
-      
-      const response = await this.client.get('/api/user/profile', {
-        headers: { 
-          Authorization: `Bearer ${token}`,
-          Cookie: `vigthoria-auth-token=${token}`,
-        },
-      });
-
-      if (response.data && response.data.user) {
-        const user = response.data.user;
-        
-        this.config.setAuth({
-          token,
-          userId: user.id,
-          email: user.email,
-        });
-
-        this.config.setSubscription({
-          plan: user.subscription?.plan || user.subscription_plan || 'developer',
-          status: 'active',
-          expiresAt: undefined,
-        });
-        
-        return true;
-      }
-      
-      return false;
-    } catch (error) {
-      this.config.clearAuth();
-      this.logger.error('Token validation failed:', (error as Error).message);
-      return false;
-    }
-  }
-
-  private async refreshToken(): Promise<boolean> {
-    const refreshToken = this.config.get('refreshToken');
-    if (!refreshToken) return false;
-
-    try {
-      const response = await this.client.post('/api/token/refresh', { 
-        refresh_token: refreshToken 
-      });
-      const { token, access_token, refresh_token } = response.data;
-      
-      this.config.set('authToken', token || access_token);
-      if (refresh_token) {
-        this.config.set('refreshToken', refresh_token);
-      }
-      
-      return true;
-    } catch {
-      this.config.clearAuth();
-      return false;
-    }
-  }
-
-  async getSubscriptionStatus(): Promise<void> {
-    try {
-      const response = await this.client.get('/api/user/subscription');
-      const data = response.data;
-      
-      this.config.setSubscription({ 
-        plan: data.plan || data.subscription_plan || 'developer', 
-        status: data.status || 'active', 
-        expiresAt: data.expiresAt || data.expires_at 
-      });
-    } catch (error) {
-      this.logger.debug('Failed to get subscription status:', (error as Error).message);
-    }
-  }
-
-  /**
-   * Chat API - Direct Vigthoria Models API Architecture
-   * 
-   * PRIMARY: api.vigthoria.io - Direct access to Vigthoria Model Router
-   *          This is the centralized public API for all AI operations.
-   *          Works for both authenticated and unauthenticated users.
-   * 
-   * FALLBACK: Coder Cloud API - For authenticated users only
-   * 
-   * NO localhost fallbacks - CLI is for external users, not server-side!
-   */
-  async chat(messages: ChatMessage[], model: string, useLocal: boolean = false): Promise<ChatResponse> {
-    const resolvedModel = this.resolveModelId(model);
-    
-    // STRATEGY 1: Direct Vigthoria Models API (api.vigthoria.io)
-    // This is the preferred method - direct access to Model Router
-    try {
-      this.logger.debug(`Direct Vigthoria Models API: ${resolvedModel}`);
-      const token = this.config.get('authToken');
-      const response = await this.modelRouterClient.post('/v1/chat/completions', {
-        model: resolvedModel,
-        messages,
-        max_tokens: this.config.get('preferences').maxTokens,
-        temperature: 0.7,
-        stream: false,
-      }, {
-        headers: token ? { Authorization: `Bearer ${token}` } : {},
-      });
-
-      if (response.data.choices && response.data.choices.length > 0) {
-        return {
-          id: response.data.id || `vigthoria-${Date.now()}`,
-          message: response.data.choices[0].message?.content || response.data.choices[0].text,
-          model: response.data.model || model,
-          usage: response.data.usage,
-        };
-      }
-      this.logger.debug('Direct API returned no choices');
-    } catch (error: any) {
-      const errMsg = error.response?.data?.error || error.message || 'Unknown error';
-      this.logger.debug(`Direct Vigthoria Models API failed: ${errMsg}`);
-      // Continue to fallback
-    }
-    
-    // STRATEGY 2: Vigthoria Cloud API via Coder (authenticated users only)
-    if (this.config.isAuthenticated()) {
-      try {
-        this.logger.debug(`Vigthoria Cloud API fallback: ${resolvedModel}`);
-        const response = await this.client.post('/api/ai/chat', {
-          messages,
-          model: resolvedModel,
-          maxTokens: this.config.get('preferences').maxTokens,
-          temperature: 0.7,
-        });
-
-        if (response.data.success !== false) {
-          return {
-            id: response.data.id || `vigthoria-coder-${Date.now()}`,
-            message: response.data.response || response.data.message || response.data.content,
-            model: response.data.model || model,
-            usage: response.data.usage,
-          };
-        }
-        this.logger.debug(`Cloud API returned success=false`);
-      } catch (error: any) {
-        const errMsg = error.response?.data?.error || error.message || 'Unknown error';
-        this.logger.debug(`Vigthoria Cloud API failed: ${errMsg}`);
-      }
-    }
-
-    // No more localhost fallbacks - CLI is for external users!
-    throw new Error('AI service unavailable. Please check your internet connection or try again later.');
-  }
-
-  // Streaming chat
-  async *chatStream(
-    messages: ChatMessage[],
-    model: string
-  ): AsyncGenerator<StreamChunk> {
-    const wsUrl = this.config.get('wsUrl');
-    const token = this.config.get('authToken');
-
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(`${wsUrl}/chat`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-
-      ws.on('open', () => {
-        ws.send(JSON.stringify({
-          type: 'chat',
-          messages,
-          model: this.resolveModelId(model),
-          stream: true,
-        }));
-      });
-
-      ws.on('message', (data) => {
-        const chunk = JSON.parse(data.toString());
-        // Yield chunk - but this pattern won't work directly
-        // Need to use event emitter pattern instead
-      });
-
-      ws.on('error', (error) => {
-        reject(error);
-      });
-
-      ws.on('close', () => {
-        resolve(undefined);
-      });
-    });
-  }
-
-  // Non-streaming alternative with callback
-  async chatWithCallback(
-    messages: ChatMessage[],
-    model: string,
-    onChunk: (chunk: string) => void,
-    onDone: () => void,
-    onError: (error: Error) => void
-  ): Promise<void> {
-    const wsUrl = this.config.get('wsUrl');
-    const token = this.config.get('authToken');
-
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(`${wsUrl}/chat`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-
-      ws.on('open', () => {
-        ws.send(JSON.stringify({
-          type: 'chat',
-          messages,
-          model: this.resolveModelId(model),
-          stream: true,
-        }));
-      });
-
-      ws.on('message', (data) => {
-        try {
-          const chunk = JSON.parse(data.toString());
-          if (chunk.type === 'content') {
-            onChunk(chunk.content);
-          } else if (chunk.type === 'done') {
-            onDone();
-            ws.close();
-            resolve();
-          } else if (chunk.type === 'error') {
-            onError(new Error(chunk.error));
-            ws.close();
-            reject(new Error(chunk.error));
-          }
-        } catch (e) {
-          // Raw text chunk
-          onChunk(data.toString());
-        }
-      });
-
-      ws.on('error', (error) => {
-        onError(error as Error);
-        reject(error);
-      });
-
-      ws.on('close', () => {
-        resolve();
-      });
-    });
-  }
-
-  // Code operations - Using Vigthoria Centralized API
-  async generateCode(prompt: string, language: string, model: string): Promise<string> {
-    const response = await this.client.post('/api/ai/generate', {
-      prompt,
-      language,
-      model: this.resolveModelId(model),
-    });
-
-    return response.data.code;
-  }
-
-  // Senior Developer Mode - Planning + Generation + Quality Check
-  async generateProject(prompt: string, projectType: string, model: string): Promise<{
-    code: string;
-    plan?: any;
-    quality?: {
-      lineCount: number;
-      score: number;
-      checks: {
-        hasAnimations: boolean;
-        hasNeonEffects: boolean;
-        hasResponsive: boolean;
-        hasFontAwesome: boolean;
-        hasGoogleFonts: boolean;
-      };
-    };
-  }> {
-    const response = await this.client.post('/api/ai/generate-project', {
-      prompt,
-      projectType,
-      model: this.resolveModelId(model),
-    }, {
-      timeout: 300000, // 5 minutes for complex generation
-    });
-
-    return {
-      code: response.data.code,
-      plan: response.data.plan,
-      quality: response.data.quality,
-    };
-  }
-
-  async explainCode(code: string, language: string): Promise<string> {
-    const response = await this.client.post('/api/ai/explain', {
-      code,
-      language,
-    });
-
-    return response.data.explanation;
-  }
-
-  async reviewCode(code: string, language: string): Promise<{
-    score: number;
-    issues: { type: string; line: number; message: string; severity: string }[];
-    suggestions: string[];
-  }> {
-    const response = await this.client.post('/api/ai/review', {
-      code,
-      language,
-    });
-
-    return response.data;
-  }
-
-  async fixCode(code: string, language: string, fixType: string): Promise<{
-    fixed: string;
-    changes: { line: number; before: string; after: string; reason: string }[];
-  }> {
-    const response = await this.client.post('/api/ai/fix', {
-      code,
-      language,
-      fixType,
-    });
-
-    return response.data;
-  }
-
-  // Model resolution - maps Vigthoria model names to internal IDs
-  // INTERNAL USE ONLY - users see only Vigthoria branding
-  private resolveModelId(shortName: string): string {
-    const modelMap: Record<string, string> = {
-      // ═══════════════════════════════════════════════════════════════
-      // VIGTHORIA LOCAL - Self-hosted models
-      // ═══════════════════════════════════════════════════════════════
-      'fast': 'vigthoria-fast-1.7b',
-      'mini': 'vigthoria-fast-1.7b',
-      'balanced': 'vigthoria-balanced-4b',
-      'creative': 'vigthoria-creative-9b-v4',
-      
-      // Code Models - 30B is the default powerhouse
-      'code': 'qwen3-coder:latest',           // Internal: qwen3-coder 30B
-      'code-30b': 'qwen3-coder:latest',
-      'code-8b': 'vigthoria-v2-code-8b',
-      'pro': 'qwen3-coder:latest',
-      
-      // ═══════════════════════════════════════════════════════════════
-      // VIGTHORIA CLOUD - Premium cloud models (internal routing)
-      // ═══════════════════════════════════════════════════════════════
-      'cloud': 'deepseek-v3.1:671b-cloud',
-      'cloud-reason': 'moonshotai/kimi-k2.5',
-      'agent': 'deepseek-v3.1:671b-cloud',
-      'ultra': 'deepseek-v3.1:671b-cloud',
-    };
-
-    // If already a full model ID, return as-is
-    if (shortName.includes('vigthoria') || shortName.includes('/') || shortName.includes(':')) {
-      if (modelMap[shortName]) {
-        return modelMap[shortName];
-      }
-      return shortName;
-    }
-
-    return modelMap[shortName] || 'qwen3-coder:latest';  // Default to 30B
-  }
-
-  // Health check
-  async healthCheck(): Promise<boolean> {
-    try {
-      const response = await this.client.get('/api/health', { timeout: 10000 });
-      return response.data?.status === 'ok' || response.data?.healthy === true;
-    } catch {
-      return false;
-    }
-  }
-}