fss-link 1.0.40 → 1.0.45

package/dist/config/database.ts

@@ -0,0 +1,752 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import initSqlJs from 'sql.js';
+import type { Database } from 'sql.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import { USER_SETTINGS_DIR } from './settings.js';
+import type { ModelConfig } from 'fss-link-core';
+
+export interface UserPreference {
+  key: string;
+  value: string;
+}
+
+/**
+ * FSS Link Database Manager
+ * Handles all persistent state for model configurations and user preferences
+ */
+export class FSSLinkDatabase {
+  private db: Database | null = null;
+  private dbPath: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private SQL: any; // SQLite database handle
+  private initialized = false;
+
+  constructor() {
+    // Ensure FSS Link settings directory exists
+    if (!fs.existsSync(USER_SETTINGS_DIR)) {
+      fs.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
+    }
+
+    this.dbPath = path.join(USER_SETTINGS_DIR, 'fss-link.db');
+  }
+
+  /**
+   * Initialize the database - must be called before any operations
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    this.SQL = await initSqlJs();
+    
+    // Load existing database or create new one
+    if (fs.existsSync(this.dbPath)) {
+      const data = fs.readFileSync(this.dbPath);
+      this.db = new this.SQL.Database(data);
+    } else {
+      this.db = new this.SQL.Database();
+    }
+    
+    await this.initializeSchema();
+    this.initialized = true;
+  }
+
+  /**
+   * Ensure database is initialized
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  /**
+   * Save database to disk
+   */
+  private save(): void {
+    if (!this.db) return;
+    const data = this.db.export();
+    fs.writeFileSync(this.dbPath, Buffer.from(data));
+  }
+
+  /**
+   * Initialize database schema
+   */
+  private async initializeSchema(): Promise<void> {
+    if (!this.db) return;
+
+    // Model configurations table
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS model_configs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        auth_type TEXT NOT NULL,
+        model_name TEXT NOT NULL,
+        endpoint_url TEXT,
+        api_key TEXT,
+        display_name TEXT,
+        is_favorite BOOLEAN DEFAULT 0,
+        is_active BOOLEAN DEFAULT 0,
+        last_used DATETIME,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(auth_type, model_name, endpoint_url)
+      )
+    `);
+
+    // User preferences table
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS user_preferences (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+    // Custom endpoints table
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS custom_endpoints (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        provider_id INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        url TEXT NOT NULL,
+        description TEXT,
+        is_default BOOLEAN DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (provider_id) REFERENCES model_configs (id)
+      )
+    `);
+
+    // Provider usage tracking table
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS provider_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        provider_id INTEGER NOT NULL,
+        session_date DATE DEFAULT CURRENT_DATE,
+        session_count INTEGER DEFAULT 1,
+        tokens_used INTEGER DEFAULT 0,
+        session_duration INTEGER DEFAULT 0,
+        FOREIGN KEY (provider_id) REFERENCES model_configs (id),
+        UNIQUE(provider_id, session_date)
+      )
+    `);
+
+    // Provider settings table (for additional configuration like sampling params)
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS provider_settings (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        provider_id INTEGER NOT NULL,
+        setting_key TEXT NOT NULL,
+        setting_value TEXT NOT NULL,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (provider_id) REFERENCES model_configs (id),
+        UNIQUE(provider_id, setting_key)
+      )
+    `);
+
+    // Create indexes for performance
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_model_configs_active ON model_configs(is_active);
+      CREATE INDEX IF NOT EXISTS idx_model_configs_favorite ON model_configs(is_favorite);
+      CREATE INDEX IF NOT EXISTS idx_model_configs_last_used ON model_configs(last_used DESC);
+      CREATE INDEX IF NOT EXISTS idx_model_configs_auth_type ON model_configs(auth_type);
+      CREATE INDEX IF NOT EXISTS idx_custom_endpoints_provider ON custom_endpoints(provider_id);
+      CREATE INDEX IF NOT EXISTS idx_provider_usage_date ON provider_usage(session_date DESC);
+      CREATE INDEX IF NOT EXISTS idx_provider_settings_key ON provider_settings(provider_id, setting_key);
+    `);
+
+    // Insert default configurations if none exist
+    await this.ensureDefaultConfigurations();
+
+    // Save initial schema
+    this.save();
+  }
+
+  /**
+   * Ensure default model configurations exist for new installations
+   */
+  private async ensureDefaultConfigurations(): Promise<void> {
+    if (!this.db) return;
+
+    // Check if any configurations exist
+    const stmt = this.db.prepare('SELECT COUNT(*) as count FROM model_configs');
+    const result = stmt.get() as { count: number };
+    
+    if (result.count === 0) {
+      // Insert default Ollama configuration for new users (no API key needed)
+      const defaultOllamaConfig = {
+        auth_type: 'ollama',
+        model_name: 'qwen3-coder:latest',
+        endpoint_url: 'http://localhost:11434/v1',
+        api_key: null,
+        display_name: 'Qwen3 Coder (Ollama)',
+        is_favorite: 1, // Mark as favorite so it's selected by default
+        is_active: 1,   // Mark as active
+        last_used: null,
+        created_at: new Date().toISOString()
+      };
+
+      const insertStmt = this.db.prepare(`
+        INSERT INTO model_configs (
+          auth_type, model_name, endpoint_url, api_key, display_name,
+          is_favorite, is_active, last_used, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      
+      insertStmt.run(
+        defaultOllamaConfig.auth_type,
+        defaultOllamaConfig.model_name,
+        defaultOllamaConfig.endpoint_url,
+        defaultOllamaConfig.api_key,
+        defaultOllamaConfig.display_name,
+        defaultOllamaConfig.is_favorite,
+        defaultOllamaConfig.is_active,
+        defaultOllamaConfig.last_used,
+        defaultOllamaConfig.created_at
+      );
+
+      // Also insert a default Gemini configuration (inactive) for when users want to configure API keys later
+      const defaultGeminiConfig = {
+        auth_type: 'use_gemini',
+        model_name: 'gemini-2.5-flash-thinking',
+        endpoint_url: 'https://generativelanguage.googleapis.com/v1',
+        api_key: null,
+        display_name: 'Gemini 2.5 Flash Thinking (Requires API Key)',
+        is_favorite: 0,
+        is_active: 0, // Inactive until user configures API key
+        last_used: null,
+        created_at: new Date().toISOString()
+      };
+
+      insertStmt.run(
+        defaultGeminiConfig.auth_type,
+        defaultGeminiConfig.model_name,
+        defaultGeminiConfig.endpoint_url,
+        defaultGeminiConfig.api_key,
+        defaultGeminiConfig.display_name,
+        defaultGeminiConfig.is_favorite,
+        defaultGeminiConfig.is_active,
+        defaultGeminiConfig.last_used,
+        defaultGeminiConfig.created_at
+      );
+
+      // Add default LM Studio configuration (active, optional API key)
+      const defaultLMStudioConfig = {
+        auth_type: 'lm_studio',
+        model_name: 'qwen3-coder:latest',
+        endpoint_url: 'http://localhost:1234/v1',
+        api_key: null, // API key is optional for LM Studio
+        display_name: 'Qwen3 Coder (LM Studio)',
+        is_favorite: 0,
+        is_active: 1, // Active by default since no API key needed
+        last_used: null,
+        created_at: new Date().toISOString()
+      };
+
+      insertStmt.run(
+        defaultLMStudioConfig.auth_type,
+        defaultLMStudioConfig.model_name,
+        defaultLMStudioConfig.endpoint_url,
+        defaultLMStudioConfig.api_key,
+        defaultLMStudioConfig.display_name,
+        defaultLMStudioConfig.is_favorite,
+        defaultLMStudioConfig.is_active,
+        defaultLMStudioConfig.last_used,
+        defaultLMStudioConfig.created_at
+      );
+
+      // Add default OpenAI configuration (inactive, requires API key)
+      const defaultOpenAIConfig = {
+        auth_type: 'use_openai',
+        model_name: 'gpt-4o',
+        endpoint_url: 'https://api.openai.com/v1',
+        api_key: null, // API key required but not set by default
+        display_name: 'GPT-4o (Requires API Key)',
+        is_favorite: 0,
+        is_active: 0, // Inactive until user configures API key
+        last_used: null,
+        created_at: new Date().toISOString()
+      };
+
+      insertStmt.run(
+        defaultOpenAIConfig.auth_type,
+        defaultOpenAIConfig.model_name,
+        defaultOpenAIConfig.endpoint_url,
+        defaultOpenAIConfig.api_key,
+        defaultOpenAIConfig.display_name,
+        defaultOpenAIConfig.is_favorite,
+        defaultOpenAIConfig.is_active,
+        defaultOpenAIConfig.last_used,
+        defaultOpenAIConfig.created_at
+      );
+    }
+  }
+
+  /**
+   * Get the currently active model configuration
+   */
+  async getActiveModel(): Promise<ModelConfig | null> {
+    await this.ensureInitialized();
+    if (!this.db) return null;
+
+    const stmt = this.db.prepare(`
+      SELECT id, auth_type, model_name, endpoint_url, api_key, display_name,
+             is_favorite, is_active, last_used, created_at
+      FROM model_configs 
+      WHERE is_active = 1 
+      LIMIT 1
+    `);
+    
+    const result = stmt.getAsObject({});
+    // Check if we actually got a valid row by looking for the id field
+    // SQLite can return an object with undefined values when no rows match
+    return result && result['id'] ? this.mapRowToModelConfig(result) : null;
+  }
+
+  /**
+   * Set a model as active (and deactivate all others)
+   */
+  async setActiveModel(id: number): Promise<void> {
+    await this.ensureInitialized();
+    if (!this.db) return;
+
+    // Deactivate all models
+    this.db.run('UPDATE model_configs SET is_active = 0');
+    
+    // Activate the selected model and update last_used
+    this.db.run(`
+      UPDATE model_configs 
+      SET is_active = 1, last_used = CURRENT_TIMESTAMP 
+      WHERE id = ?
+    `, [id]);
+    
+    this.save();
+  }
+
+  /**
+   * Add or update a model configuration
+   */
+  async upsertModelConfig(config: ModelConfig): Promise<number> {
+    await this.ensureInitialized();
+    if (!this.db) return -1;
+
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO model_configs 
+      (auth_type, model_name, endpoint_url, api_key, display_name, is_favorite, is_active, last_used)
+      VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+    `);
+    
+    stmt.run([
+      config.authType,
+      config.modelName,
+      config.endpointUrl || null,
+      config.apiKey || null,
+      config.displayName || null,
+      config.isFavorite ? 1 : 0,
+      config.isActive ? 1 : 0
+    ]);
+    
+    this.save();
+    
+    // Get the last inserted row ID
+    const result = this.db.exec('SELECT last_insert_rowid() as id');
+    return result[0]?.values[0]?.[0] as number || -1;
+  }
+
+  /**
+   * Get all model configurations
+   */
+  async getAllModels(): Promise<ModelConfig[]> {
+    await this.ensureInitialized();
+    if (!this.db) return [];
+
+    const stmt = this.db.prepare(`
+      SELECT id, auth_type, model_name, endpoint_url, api_key, display_name,
+             is_favorite, is_active, last_used, created_at
+      FROM model_configs 
+      ORDER BY is_favorite DESC, last_used DESC, created_at DESC
+    `);
+    
+    const results = [];
+    while (stmt.step()) {
+      results.push(this.mapRowToModelConfig(stmt.getAsObject()));
+    }
+    
+    return results;
+  }
+
+  /**
+   * Get favorite models
+   */
+  async getFavoriteModels(): Promise<ModelConfig[]> {
+    await this.ensureInitialized();
+    if (!this.db) return [];
+
+    const stmt = this.db.prepare(`
+      SELECT id, auth_type, model_name, endpoint_url, api_key, display_name,
+             is_favorite, is_active, last_used, created_at
+      FROM model_configs 
+      WHERE is_favorite = 1
+      ORDER BY last_used DESC, created_at DESC
+    `);
+    
+    const results = [];
+    while (stmt.step()) {
+      results.push(this.mapRowToModelConfig(stmt.getAsObject()));
+    }
+    
+    return results;
+  }
+
+  /**
+   * Get recently used models
+   */
+  async getRecentModels(limit: number = 10): Promise<ModelConfig[]> {
+    await this.ensureInitialized();
+    if (!this.db) return [];
+
+    const stmt = this.db.prepare(`
+      SELECT id, auth_type, model_name, endpoint_url, api_key, display_name,
+             is_favorite, is_active, last_used, created_at
+      FROM model_configs 
+      WHERE last_used IS NOT NULL
+      ORDER BY last_used DESC
+      LIMIT ?
+    `, [limit]);
+    
+    const results = [];
+    while (stmt.step()) {
+      results.push(this.mapRowToModelConfig(stmt.getAsObject()));
+    }
+    
+    return results;
+  }
+
+  /**
+   * Toggle favorite status for a model
+   */
+  async toggleModelFavorite(id: number): Promise<void> {
+    await this.ensureInitialized();
+    if (!this.db) return;
+
+    this.db.run(`
+      UPDATE model_configs 
+      SET is_favorite = CASE WHEN is_favorite = 1 THEN 0 ELSE 1 END
+      WHERE id = ?
+    `, [id]);
+    
+    this.save();
+  }
+
+  /**
+   * Delete a model configuration
+   */
+  async deleteModel(id: number): Promise<void> {
+    await this.ensureInitialized();
+    if (!this.db) return;
+
+    this.db.run('DELETE FROM model_configs WHERE id = ?', [id]);
+    this.save();
+  }
+
+  /**
+   * Set user preference
+   */
+  async setUserPreference(key: string, value: string): Promise<void> {
+    await this.ensureInitialized();
+    if (!this.db) return;
+
+    this.db.run(`
+      INSERT OR REPLACE INTO user_preferences (key, value, updated_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP)
+    `, [key, value]);
+    
+    this.save();
+  }
+
+  /**
+   * Get user preference
+   */
+  async getUserPreference(key: string): Promise<string | null> {
+    await this.ensureInitialized();
+    if (!this.db) return null;
+
+    const stmt = this.db.prepare('SELECT value FROM user_preferences WHERE key = ?', [key]);
+    
+    if (stmt.step()) {
+      const result = stmt.getAsObject() as { value: string };
+      return result.value || null;
+    }
+    
+    return null;
+  }
+
+  /**
+   * Get all user preferences
+   */
+  async getAllUserPreferences(): Promise<Record<string, string>> {
+    await this.ensureInitialized();
+    if (!this.db) return {};
+
+    const stmt = this.db.prepare('SELECT key, value FROM user_preferences');
+    const prefs: Record<string, string> = {};
+    
+    while (stmt.step()) {
+      const row = stmt.getAsObject() as { key: string; value: string };
+      prefs[row.key] = row.value;
+    }
+    
+    return prefs;
+  }
+
+  /**
+   * Close database connection
+   */
+  close(): void {
+    if (this.db) {
+      this.save();
+      this.db.close();
+      this.db = null;
+      this.initialized = false;
+    }
+  }
+
+  /**
+   * Get database file path (for debugging)
+   */
+  getDatabasePath(): string {
+    return this.dbPath;
+  }
+
+  /**
+   * Map database row to ModelConfig interface
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private mapRowToModelConfig(row: any): ModelConfig {
+    return {
+      id: row.id,
+      authType: row.auth_type,
+      modelName: row.model_name,
+      endpointUrl: row.endpoint_url,
+      apiKey: row.api_key,
+      displayName: row.display_name,
+      isFavorite: Boolean(row.is_favorite),
+      isActive: Boolean(row.is_active),
+      lastUsed: row.last_used ? new Date(row.last_used) : undefined,
+      createdAt: row.created_at ? new Date(row.created_at) : undefined,
+    };
+  }
+
+  // ============= ENHANCED PROVIDER MANAGEMENT =============
+
+  /**
+   * Record provider usage for intelligent default selection
+   */
+  async recordProviderUsage(providerId: number, tokensUsed: number, sessionDuration: number): Promise<void> {
+    await this.ensureInitialized();
+    if (!this.db) return;
+
+    // Update or insert daily usage statistics
+    this.db.exec(`
+      INSERT INTO provider_usage (provider_id, tokens_used, session_duration)
+      VALUES (?, ?, ?)
+      ON CONFLICT(provider_id, session_date)
+      DO UPDATE SET 
+        session_count = session_count + 1,
+        tokens_used = tokens_used + excluded.tokens_used,
+        session_duration = session_duration + excluded.session_duration
+    `, [providerId, tokensUsed, sessionDuration]);
+
+    // Update last_used timestamp in model_configs
+    this.db.exec(`
+      UPDATE model_configs 
+      SET last_used = CURRENT_TIMESTAMP 
+      WHERE id = ?
+    `, [providerId]);
+
+    this.save();
+  }
+
+  /**
+   * Save custom endpoint for a provider
+   */
+  async saveCustomEndpoint(providerId: number, name: string, url: string, description?: string, isDefault = false): Promise<number> {
+    await this.ensureInitialized();
+    if (!this.db) return -1;
+
+    // If setting as default, unset other defaults for this provider
+    if (isDefault) {
+      this.db.exec(`
+        UPDATE custom_endpoints 
+        SET is_default = 0 
+        WHERE provider_id = ?
+      `, [providerId]);
+    }
+
+    this.db.exec(`
+      INSERT OR REPLACE INTO custom_endpoints (provider_id, name, url, description, is_default)
+      VALUES (?, ?, ?, ?, ?)
+    `, [providerId, name, url, description || null, isDefault ? 1 : 0]);
+
+    this.save();
+
+    const result = this.db.exec('SELECT last_insert_rowid() as id');
+    return result[0]?.values[0]?.[0] as number || -1;
+  }
+
+  /**
+   * Get custom endpoints for a provider
+   */
+  async getCustomEndpoints(providerId: number): Promise<Array<Record<string, unknown>>> {
+    await this.ensureInitialized();
+    if (!this.db) return [];
+
+    const stmt = this.db.prepare(`
+      SELECT id, provider_id, name, url, description, is_default, created_at
+      FROM custom_endpoints
+      WHERE provider_id = ?
+      ORDER BY is_default DESC, created_at DESC
+    `);
+
+    return stmt.all(providerId) || [];
+  }
+
+  /**
+   * Save provider-specific settings (like sampling params)
+   */
+  async saveProviderSetting(providerId: number, key: string, value: string): Promise<void> {
+    await this.ensureInitialized();
+    if (!this.db) return;
+
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO provider_settings (provider_id, setting_key, setting_value)
+      VALUES (?, ?, ?)
+    `);
+    stmt.run(providerId, key, value);
+
+    this.save();
+  }
+
+  /**
+   * Get provider-specific settings
+   */
+  async getProviderSettings(providerId: number): Promise<Record<string, string>> {
+    await this.ensureInitialized();
+    if (!this.db) return {};
+
+    const stmt = this.db.prepare(`
+      SELECT setting_key, setting_value
+      FROM provider_settings
+      WHERE provider_id = ?
+    `);
+
+    const results = stmt.all(providerId) || [];
+    const settings: Record<string, string> = {};
+    
+    for (const row of results) {
+      settings[row.setting_key] = row.setting_value;
+    }
+
+    return settings;
+  }
+
+  /**
+   * Get smart default provider based on usage and preferences
+   */
+  async getSmartDefaultProvider(): Promise<ModelConfig | null> {
+    await this.ensureInitialized();
+    if (!this.db) return null;
+
+    // Priority order:
+    // 1. User-marked favorite (is_favorite = 1)
+    // 2. Most used provider in last 30 days
+    // 3. Most recently used provider
+    const stmt = this.db.prepare(`
+      SELECT 
+        m.id, m.auth_type, m.model_name, m.endpoint_url, m.api_key, 
+        m.display_name, m.is_favorite, m.is_active, m.last_used, m.created_at,
+        COALESCE(u.recent_usage_score, 0) as usage_score
+      FROM model_configs m
+      LEFT JOIN (
+        SELECT 
+          provider_id,
+          SUM(session_count * (1.0 / (julianday('now') - julianday(session_date) + 1))) as recent_usage_score
+        FROM provider_usage
+        WHERE session_date >= date('now', '-30 days')
+        GROUP BY provider_id
+      ) u ON m.id = u.provider_id
+      ORDER BY 
+        m.is_favorite DESC,
+        usage_score DESC,
+        m.last_used DESC,
+        m.created_at DESC
+      LIMIT 1
+    `);
+
+    const result = stmt.get([]);
+    if (!result) return null;
+
+    return {
+      authType: result.auth_type,
+      modelName: result.model_name,
+      endpointUrl: result.endpoint_url,
+      apiKey: result.api_key,
+      displayName: result.display_name,
+      isFavorite: Boolean(result.is_favorite),
+      isActive: Boolean(result.is_active)
+    };
+  }
+
+  /**
+   * Get a specific model configuration by ID
+   */
+  async getModelById(modelId: number): Promise<ModelConfig | null> {
+    await this.ensureInitialized();
+    if (!this.db) return null;
+
+    const stmt = this.db.prepare(`
+      SELECT * FROM models WHERE id = ?
+    `);
+
+    const result = stmt.get(modelId);
+    if (!result) return null;
+
+    return {
+      id: result.id,
+      authType: result.auth_type,
+      modelName: result.model_name,
+      endpointUrl: result.endpoint_url,
+      apiKey: result.api_key,
+      displayName: result.display_name,
+      isFavorite: Boolean(result.is_favorite),
+      isActive: Boolean(result.is_active)
+    };
+  }
+}
+
+// Singleton instance for global access
+let databaseInstance: FSSLinkDatabase | null = null;
+
+/**
+ * Get the global FSS Link database instance
+ */
+export async function getFSSLinkDatabase(): Promise<FSSLinkDatabase> {
+  if (!databaseInstance) {
+    databaseInstance = new FSSLinkDatabase();
+    await databaseInstance.initialize();
+  }
+  return databaseInstance;
+}
+
+/**
+ * Close the global database instance (for cleanup)
+ */
+export function closeFSSLinkDatabase(): void {
+  if (databaseInstance) {
+    databaseInstance.close();
+    databaseInstance = null;
+  }
+}