fss-link 1.0.6 → 1.0.9

package/bundle/fss-link.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 
 // packages/cli/src/gemini.tsx
 import React28 from "react";
@@ -6099,7 +6098,7 @@ async function cleanupCheckpoints() {
 import { AuthType } from "@fsscoding/fss-link-core";
 
 // packages/cli/src/config/database.ts
-import Database from "better-sqlite3";
+import initSqlJs from "sql.js";
 import * as path5 from "path";
 import * as fs6 from "fs";
 
@@ -6468,21 +6467,52 @@ function saveSettings(settingsFile) {
 
 // packages/cli/src/config/database.ts
 var FSSLinkDatabase = class {
-  db;
+  db = null;
   dbPath;
+  SQL;
+  initialized = false;
   constructor() {
     if (!fs6.existsSync(USER_SETTINGS_DIR)) {
       fs6.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
     }
     this.dbPath = path5.join(USER_SETTINGS_DIR, "fss-link.db");
-    this.db = new Database(this.dbPath);
-    this.db.pragma("journal_mode = WAL");
+  }
+  /**
+   * Initialize the database - must be called before any operations
+   */
+  async initialize() {
+    if (this.initialized) return;
+    this.SQL = await initSqlJs();
+    if (fs6.existsSync(this.dbPath)) {
+      const data = fs6.readFileSync(this.dbPath);
+      this.db = new this.SQL.Database(data);
+    } else {
+      this.db = new this.SQL.Database();
+    }
     this.initializeSchema();
+    this.initialized = true;
+  }
+  /**
+   * Ensure database is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Save database to disk
+   */
+  save() {
+    if (!this.db) return;
+    const data = this.db.export();
+    fs6.writeFileSync(this.dbPath, Buffer.from(data));
   }
   /**
    * Initialize database schema
    */
   initializeSchema() {
+    if (!this.db) return;
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS model_configs (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -6511,11 +6541,14 @@ var FSSLinkDatabase = class {
       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);
     `);
+    this.save();
   }
   /**
    * Get the currently active model configuration
    */
-  getActiveModel() {
+  async getActiveModel() {
+    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
@@ -6523,32 +6556,35 @@ var FSSLinkDatabase = class {
       WHERE is_active = 1 
       LIMIT 1
     `);
-    const result = stmt.get();
-    return result ? this.mapRowToModelConfig(result) : null;
+    const result = stmt.getAsObject({});
+    return result && Object.keys(result).length > 0 ? this.mapRowToModelConfig(result) : null;
   }
   /**
    * Set a model as active (and deactivate all others)
    */
-  setActiveModel(id) {
-    this.db.transaction(() => {
-      this.db.prepare("UPDATE model_configs SET is_active = 0").run();
-      this.db.prepare(`
-        UPDATE model_configs 
-        SET is_active = 1, last_used = CURRENT_TIMESTAMP 
-        WHERE id = ?
-      `).run(id);
-    })();
+  async setActiveModel(id) {
+    await this.ensureInitialized();
+    if (!this.db) return;
+    this.db.run("UPDATE model_configs SET is_active = 0");
+    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
    */
-  upsertModelConfig(config) {
+  async upsertModelConfig(config) {
+    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)
     `);
-    const result = stmt.run(
+    stmt.run([
       config.authType,
       config.modelName,
       config.endpointUrl || null,
@@ -6556,25 +6592,35 @@ var FSSLinkDatabase = class {
       config.displayName || null,
       config.isFavorite ? 1 : 0,
       config.isActive ? 1 : 0
-    );
-    return result.lastInsertRowid;
+    ]);
+    this.save();
+    const result = this.db.exec("SELECT last_insert_rowid() as id");
+    return result[0]?.values[0]?.[0] || -1;
   }
   /**
    * Get all model configurations
    */
-  getAllModels() {
+  async getAllModels() {
+    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
     `);
-    return stmt.all().map((row) => this.mapRowToModelConfig(row));
+    const results = [];
+    while (stmt.step()) {
+      results.push(this.mapRowToModelConfig(stmt.getAsObject()));
+    }
+    return results;
   }
   /**
    * Get favorite models
    */
-  getFavoriteModels() {
+  async getFavoriteModels() {
+    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
@@ -6582,12 +6628,18 @@ var FSSLinkDatabase = class {
       WHERE is_favorite = 1
       ORDER BY last_used DESC, created_at DESC
     `);
-    return stmt.all().map((row) => this.mapRowToModelConfig(row));
+    const results = [];
+    while (stmt.step()) {
+      results.push(this.mapRowToModelConfig(stmt.getAsObject()));
+    }
+    return results;
   }
   /**
    * Get recently used models
    */
-  getRecentModels(limit = 10) {
+  async getRecentModels(limit = 10) {
+    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
@@ -6595,48 +6647,70 @@ var FSSLinkDatabase = class {
       WHERE last_used IS NOT NULL
       ORDER BY last_used DESC
       LIMIT ?
-    `);
-    return stmt.all(limit).map((row) => this.mapRowToModelConfig(row));
+    `, [limit]);
+    const results = [];
+    while (stmt.step()) {
+      results.push(this.mapRowToModelConfig(stmt.getAsObject()));
+    }
+    return results;
   }
   /**
    * Toggle favorite status for a model
    */
-  toggleModelFavorite(id) {
-    this.db.prepare(`
+  async toggleModelFavorite(id) {
+    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 = ?
-    `).run(id);
+    `, [id]);
+    this.save();
   }
   /**
    * Delete a model configuration
    */
-  deleteModel(id) {
-    this.db.prepare("DELETE FROM model_configs WHERE id = ?").run(id);
+  async deleteModel(id) {
+    await this.ensureInitialized();
+    if (!this.db) return;
+    this.db.run("DELETE FROM model_configs WHERE id = ?", [id]);
+    this.save();
   }
   /**
    * Set user preference
    */
-  setUserPreference(key, value) {
-    this.db.prepare(`
+  async setUserPreference(key, value) {
+    await this.ensureInitialized();
+    if (!this.db) return;
+    this.db.run(`
       INSERT OR REPLACE INTO user_preferences (key, value, updated_at)
       VALUES (?, ?, CURRENT_TIMESTAMP)
-    `).run(key, value);
+    `, [key, value]);
+    this.save();
   }
   /**
    * Get user preference
    */
-  getUserPreference(key) {
-    const result = this.db.prepare("SELECT value FROM user_preferences WHERE key = ?").get(key);
-    return result ? result.value : null;
+  async getUserPreference(key) {
+    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();
+      return result.value || null;
+    }
+    return null;
   }
   /**
    * Get all user preferences
    */
-  getAllUserPreferences() {
-    const rows = this.db.prepare("SELECT key, value FROM user_preferences").all();
+  async getAllUserPreferences() {
+    await this.ensureInitialized();
+    if (!this.db) return {};
+    const stmt = this.db.prepare("SELECT key, value FROM user_preferences");
     const prefs = {};
-    for (const row of rows) {
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
       prefs[row.key] = row.value;
     }
     return prefs;
@@ -6645,7 +6719,12 @@ var FSSLinkDatabase = class {
    * Close database connection
    */
   close() {
-    this.db.close();
+    if (this.db) {
+      this.save();
+      this.db.close();
+      this.db = null;
+      this.initialized = false;
+    }
   }
   /**
    * Get database file path (for debugging)
@@ -6672,23 +6751,27 @@ var FSSLinkDatabase = class {
   }
 };
 var databaseInstance = null;
-function getFSSLinkDatabase() {
+async function getFSSLinkDatabase() {
   if (!databaseInstance) {
     databaseInstance = new FSSLinkDatabase();
+    await databaseInstance.initialize();
   }
   return databaseInstance;
 }
 
 // packages/cli/src/config/modelManager.ts
 var ModelManager = class {
-  db = getFSSLinkDatabase();
+  async getDb() {
+    return await getFSSLinkDatabase();
+  }
   /**
    * Set up a new model configuration and make it active
    * Implements ModelStateProvider.setActiveModel
    */
   async setActiveModel(config) {
-    const modelId = this.db.upsertModelConfig(config);
-    this.db.setActiveModel(modelId);
+    const db = await this.getDb();
+    const modelId = await db.upsertModelConfig(config);
+    await db.setActiveModel(modelId);
     this.updateEnvironmentFromModel(config);
     return modelId;
   }
@@ -6696,6 +6779,7 @@ var ModelManager = class {
    * Set up a new model configuration and make it active (legacy method)
    */
   async configureModel(authType, modelName, endpointUrl, apiKey, displayName) {
+    const db = await this.getDb();
     const config = {
       authType: this.mapAuthType(authType),
       modelName,
@@ -6706,8 +6790,8 @@ var ModelManager = class {
       isActive: true
       // Make this the active model
     };
-    const modelId = this.db.upsertModelConfig(config);
-    this.db.setActiveModel(modelId);
+    const modelId = await db.upsertModelConfig(config);
+    await db.setActiveModel(modelId);
     this.updateEnvironmentFromModel(config);
     return modelId;
   }
@@ -6716,8 +6800,9 @@ var ModelManager = class {
    */
   async switchToModel(modelId) {
     try {
-      this.db.setActiveModel(modelId);
-      const activeModel = this.db.getActiveModel();
+      const db = await this.getDb();
+      await db.setActiveModel(modelId);
+      const activeModel = await db.getActiveModel();
       if (activeModel) {
         this.updateEnvironmentFromModel(activeModel);
         return true;
@@ -6731,45 +6816,52 @@ var ModelManager = class {
   /**
    * Get the currently active model
    */
-  getActiveModel() {
-    return this.db.getActiveModel();
+  async getActiveModel() {
+    const db = await this.getDb();
+    return await db.getActiveModel();
   }
   /**
    * Get all configured models
    */
-  getAllModels() {
-    return this.db.getAllModels();
+  async getAllModels() {
+    const db = await this.getDb();
+    return await db.getAllModels();
   }
   /**
    * Get favorite models
    */
-  getFavoriteModels() {
-    return this.db.getFavoriteModels();
+  async getFavoriteModels() {
+    const db = await this.getDb();
+    return await db.getFavoriteModels();
   }
   /**
    * Get recently used models
    */
-  getRecentModels(limit = 5) {
-    return this.db.getRecentModels(limit);
+  async getRecentModels(limit = 5) {
+    const db = await this.getDb();
+    return await db.getRecentModels(limit);
   }
   /**
    * Toggle favorite status for a model
    */
-  toggleFavorite(modelId) {
-    this.db.toggleModelFavorite(modelId);
+  async toggleFavorite(modelId) {
+    const db = await this.getDb();
+    await db.toggleModelFavorite(modelId);
   }
   /**
    * Delete a model configuration
    */
-  deleteModel(modelId) {
-    this.db.deleteModel(modelId);
+  async deleteModel(modelId) {
+    const db = await this.getDb();
+    await db.deleteModel(modelId);
   }
   /**
    * Initialize environment variables from active model on startup
    * Implements ModelStateProvider.initializeFromStore
    */
-  initializeFromStore() {
-    const activeModel = this.db.getActiveModel();
+  async initializeFromStore() {
+    const db = await this.getDb();
+    const activeModel = await db.getActiveModel();
     if (activeModel) {
       this.updateEnvironmentFromModel(activeModel);
       return true;
@@ -6779,16 +6871,18 @@ var ModelManager = class {
   /**
    * Check if we have a valid active model configuration
    */
-  hasValidConfiguration() {
-    const activeModel = this.db.getActiveModel();
+  async hasValidConfiguration() {
+    const db = await this.getDb();
+    const activeModel = await db.getActiveModel();
     return activeModel !== null;
   }
   /**
    * Get current auth type from active model
    * Implements ModelStateProvider.getCurrentAuthType
    */
-  getCurrentAuthType() {
-    const activeModel = this.db.getActiveModel();
+  async getCurrentAuthType() {
+    const db = await this.getDb();
+    const activeModel = await db.getActiveModel();
     if (!activeModel) return void 0;
     const authType = this.mapToFSSLinkAuthType(activeModel.authType);
     return authType;
@@ -6796,8 +6890,9 @@ var ModelManager = class {
   /**
    * Get current auth type as FSS Link AuthType enum (legacy method)
    */
-  getCurrentFSSAuthType() {
-    const activeModel = this.db.getActiveModel();
+  async getCurrentFSSAuthType() {
+    const db = await this.getDb();
+    const activeModel = await db.getActiveModel();
     if (!activeModel) return void 0;
     return this.mapToFSSLinkAuthType(activeModel.authType);
   }
@@ -7584,7 +7679,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.0.6";
+  return "1.0.9";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -7636,7 +7731,7 @@ import open from "open";
 import process6 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "1134d1d";
+var GIT_COMMIT_INFO = "0373c69";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 import { sessionId as sessionId3 } from "@fsscoding/fss-link-core";
@@ -18355,16 +18450,19 @@ function SearchEngineConfigDialog({
   const [currentField, setCurrentField] = useState33("braveApiKey");
   const [isLoading, setIsLoading] = useState33(true);
   useEffect32(() => {
-    const db = getFSSLinkDatabase();
-    const existingBrave = db.getUserPreference("webscraper.brave_api_key");
-    const existingTavily = db.getUserPreference("webscraper.tavily_api_key");
-    if (existingBrave) {
-      setBraveApiKey(existingBrave);
-    }
-    if (existingTavily) {
-      setTavilyApiKey(existingTavily);
-    }
-    setIsLoading(false);
+    const loadConfig = async () => {
+      const db = await getFSSLinkDatabase();
+      const existingBrave = await db.getUserPreference("webscraper.brave_api_key");
+      const existingTavily = await db.getUserPreference("webscraper.tavily_api_key");
+      if (existingBrave) {
+        setBraveApiKey(existingBrave);
+      }
+      if (existingTavily) {
+        setTavilyApiKey(existingTavily);
+      }
+      setIsLoading(false);
+    };
+    loadConfig().catch(console.error);
   }, []);
   useInput4((input, key) => {
     if (isLoading) return;
@@ -18391,15 +18489,18 @@ function SearchEngineConfigDialog({
           setCurrentField("braveApiKey");
           return;
         }
-        const db = getFSSLinkDatabase();
-        if (braveApiKey.trim()) {
-          db.setUserPreference("webscraper.brave_api_key", braveApiKey.trim());
-          process.env["BRAVE_SEARCH_API_KEY"] = braveApiKey.trim();
-        }
-        if (tavilyApiKey.trim()) {
-          db.setUserPreference("webscraper.tavily_api_key", tavilyApiKey.trim());
-          process.env["TAVILY_API_KEY"] = tavilyApiKey.trim();
-        }
+        const saveConfig = async () => {
+          const db = await getFSSLinkDatabase();
+          if (braveApiKey.trim()) {
+            await db.setUserPreference("webscraper.brave_api_key", braveApiKey.trim());
+            process.env["BRAVE_SEARCH_API_KEY"] = braveApiKey.trim();
+          }
+          if (tavilyApiKey.trim()) {
+            await db.setUserPreference("webscraper.tavily_api_key", tavilyApiKey.trim());
+            process.env["TAVILY_API_KEY"] = tavilyApiKey.trim();
+          }
+        };
+        saveConfig().catch(console.error);
         onSubmit({
           braveApiKey: braveApiKey.trim() || void 0,
           braveEnabled: !!braveApiKey.trim(),
@@ -23025,10 +23126,10 @@ var SearchEngineConfigProvider = class _SearchEngineConfigProvider {
   /**
    * Load search engine configuration from database and set environment variables
    */
-  loadConfiguration() {
-    const db = getFSSLinkDatabase();
-    const braveApiKey = db.getUserPreference("webscraper.brave_api_key");
-    const tavilyApiKey = db.getUserPreference("webscraper.tavily_api_key");
+  async loadConfiguration() {
+    const db = await getFSSLinkDatabase();
+    const braveApiKey = await db.getUserPreference("webscraper.brave_api_key");
+    const tavilyApiKey = await db.getUserPreference("webscraper.tavily_api_key");
     if (braveApiKey) {
       process.env["BRAVE_SEARCH_API_KEY"] = braveApiKey;
     }
@@ -23043,31 +23144,31 @@ var SearchEngineConfigProvider = class _SearchEngineConfigProvider {
   /**
    * Save search engine configuration to database
    */
-  saveConfiguration(config) {
-    const db = getFSSLinkDatabase();
+  async saveConfiguration(config) {
+    const db = await getFSSLinkDatabase();
     if (config.braveApiKey) {
-      db.setUserPreference("webscraper.brave_api_key", config.braveApiKey);
-      db.setUserPreference("webscraper.brave_enabled", "true");
+      await db.setUserPreference("webscraper.brave_api_key", config.braveApiKey);
+      await db.setUserPreference("webscraper.brave_enabled", "true");
       process.env["BRAVE_SEARCH_API_KEY"] = config.braveApiKey;
     }
     if (config.tavilyApiKey) {
-      db.setUserPreference("webscraper.tavily_api_key", config.tavilyApiKey);
-      db.setUserPreference("webscraper.tavily_enabled", "true");
+      await db.setUserPreference("webscraper.tavily_api_key", config.tavilyApiKey);
+      await db.setUserPreference("webscraper.tavily_enabled", "true");
       process.env["TAVILY_API_KEY"] = config.tavilyApiKey;
     }
   }
   /**
    * Check if search engines are configured
    */
-  hasConfiguration() {
-    const config = this.loadConfiguration();
+  async hasConfiguration() {
+    const config = await this.loadConfiguration();
     return !!(config.braveApiKey || config.tavilyApiKey);
   }
   /**
    * Get configuration status for display
    */
-  getConfigurationStatus() {
-    const config = this.loadConfiguration();
+  async getConfigurationStatus() {
+    const config = await this.loadConfiguration();
     let status = "\u{1F50D} Search Engine Configuration:\n";
     if (config.braveApiKey) {
       status += `\u2705 Brave Search: Configured

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fss-link",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -96,11 +96,11 @@
     "@google/genai": "1.9.0",
     "@iarna/toml": "^2.2.5",
     "@modelcontextprotocol/sdk": "^1.15.1",
-    "@types/better-sqlite3": "^7.6.13",
+    "@types/sql.js": "^1.4.9",
     "@types/fs-extra": "^11.0.4",
     "@types/update-notifier": "^6.0.8",
     "axios": "^1.11.0",
-    "better-sqlite3": "^12.2.0",
+    "sql.js": "^1.11.0",
     "cheerio": "^1.1.2",
     "command-exists": "^1.2.9",
     "diff": "^7.0.0",