fss-link 1.1.0 → 1.1.2

package/bundle/fss-link.js

@@ -22084,7 +22084,7 @@ async function createContentGeneratorConfig(config, authType) {
 async function createContentGenerator(config, gcConfig, sessionId2) {
   if (DEBUG_CONTENT)
     console.log(`\u{1F41B} DEBUG createContentGenerator: authType=${config.authType}, apiKey=${config.apiKey}, baseUrl=${config.baseUrl}`);
-  const version = "1.1.0";
+  const version = "1.1.2";
   const userAgent = `FSS-Link/${version} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent
@@ -71176,7 +71176,18 @@ var init_config = __esm({
               console.warn("Database configuration invalid - may need manual setup");
             }
           } else {
-            console.log("Using existing database configuration");
+            const currentAuthType = await this.modelStateProvider.getCurrentAuthType();
+            if (currentAuthType && currentAuthType !== authMethod) {
+              console.log(`Auth type changed: ${currentAuthType} \u2192 ${authMethod}`);
+              const switched = await this.modelStateProvider.switchToAuthType(authMethod);
+              if (switched) {
+                console.log(`\u2705 Switched to ${authMethod} model from database`);
+              } else {
+                console.warn(`\u26A0\uFE0F No ${authMethod} model in database, using defaults`);
+              }
+            } else {
+              console.log("Using existing database configuration");
+            }
           }
         } else {
           console.warn("No model state provider available - database-first authentication unavailable");
@@ -82943,6 +82954,7 @@ var ModelDatabase;
 var init_model_database = __esm({
   "packages/cli/src/config/model-database.ts"() {
     init_database_utils();
+    init_database();
     ModelDatabase = class {
       constructor(db) {
         this.db = db;
@@ -83004,7 +83016,7 @@ var init_model_database = __esm({
         if (!this.db) {
           throw new Error("Database not initialized");
         }
-        const encryptedApiKey = config.apiKey || null;
+        const encryptedApiKey = config.apiKey ? FSSLinkDatabase.encryptApiKey(config.apiKey) : null;
         const normalizedEndpointUrl = config.endpointUrl || "";
         const existingRecord = await safeQueryFirstWithLocking(
           this.db,
@@ -83244,7 +83256,7 @@ var init_model_database = __esm({
           authType: record.auth_type,
           modelName: record.model_name,
           endpointUrl: record.endpoint_url || void 0,
-          apiKey: record.api_key || void 0,
+          apiKey: record.api_key ? FSSLinkDatabase.decryptApiKey(record.api_key) : void 0,
           displayName: record.display_name || void 0,
           isFavorite: record.is_favorite === 1,
           isActive: record.is_active === 1,
@@ -84545,15 +84557,63 @@ var init_database = __esm({
        * Legacy encryption methods (maintained for compatibility)
        */
       encrypt(value) {
-        const cipher = crypto13.createCipher("aes-256-cbc", this.encryptionKey);
-        let encrypted = cipher.update(value, "utf8", "hex");
+        if (!value) return value;
+        const iv = crypto13.randomBytes(16);
+        const cipher = crypto13.createCipheriv("aes-256-cbc", this.encryptionKey, iv);
+        let encrypted = iv.toString("hex") + ":";
+        encrypted += cipher.update(value, "utf8", "hex");
         encrypted += cipher.final("hex");
         return encrypted;
       }
       decrypt(value) {
+        if (!value) return value;
         try {
-          const decipher = crypto13.createDecipher("aes-256-cbc", this.encryptionKey);
-          let decrypted = decipher.update(value, "hex", "utf8");
+          const parts = value.split(":");
+          const iv = Buffer.from(parts[0], "hex");
+          const encrypted = parts[1];
+          const decipher = crypto13.createDecipheriv("aes-256-cbc", this.encryptionKey, iv);
+          let decrypted = decipher.update(encrypted, "hex", "utf8");
+          decrypted += decipher.final("utf8");
+          return decrypted;
+        } catch (error) {
+          return value;
+        }
+      }
+      /**
+       * Static encryption methods for use across database classes
+       */
+      static getEncryptionKey() {
+        const keyPath = path57.join(USER_SETTINGS_DIR, "db.key");
+        if (fs51.existsSync(keyPath)) {
+          return fs51.readFileSync(keyPath);
+        } else {
+          const key = crypto13.randomBytes(32);
+          if (!fs51.existsSync(USER_SETTINGS_DIR)) {
+            fs51.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
+          }
+          fs51.writeFileSync(keyPath, key);
+          return key;
+        }
+      }
+      static encryptApiKey(value) {
+        if (!value) return value;
+        const key = this.getEncryptionKey();
+        const iv = crypto13.randomBytes(16);
+        const cipher = crypto13.createCipheriv("aes-256-cbc", key, iv);
+        let encrypted = iv.toString("hex") + ":";
+        encrypted += cipher.update(value, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        return encrypted;
+      }
+      static decryptApiKey(value) {
+        if (!value) return value;
+        try {
+          const key = this.getEncryptionKey();
+          const parts = value.split(":");
+          const iv = Buffer.from(parts[0], "hex");
+          const encrypted = parts[1];
+          const decipher = crypto13.createDecipheriv("aes-256-cbc", key, iv);
+          let decrypted = decipher.update(encrypted, "hex", "utf8");
           decrypted += decipher.final("utf8");
           return decrypted;
         } catch (error) {
@@ -84673,6 +84733,48 @@ var init_modelManager = __esm({
           return false;
         }
       }
+      /**
+       * Switch to a model with the specified auth type
+       * Finds the most recently used model with matching auth_type and activates it
+       *
+       * @param authType - The auth type to switch to
+       * @returns true if a matching model was found and activated, false otherwise
+       *
+       * 🔒 MIGRATED: Uses UnifiedDatabase for thread-safe operations
+       */
+      async switchToAuthType(authType) {
+        try {
+          if (DEBUG_MODEL) console.log(`\u{1F512} [MODEL-MANAGER] Switching to auth type: ${authType}`);
+          const db = await this.getDb();
+          const models = await db.getModelsByAuthType(authType);
+          if (models.length === 0) {
+            if (DEBUG_MODEL) console.log(`\u274C [MODEL-MANAGER] No models found with auth_type: ${authType}`);
+            return false;
+          }
+          models.sort((a, b) => {
+            const aTime = a.lastUsed?.getTime() || 0;
+            const bTime = b.lastUsed?.getTime() || 0;
+            return bTime - aTime;
+          });
+          const modelToActivate = models[0];
+          if (!modelToActivate.id) {
+            console.error(`\u274C [MODEL-MANAGER] Model missing ID, cannot activate`);
+            return false;
+          }
+          if (DEBUG_MODEL) {
+            console.log(`\u2705 [MODEL-MANAGER] Found model: ${modelToActivate.displayName} (id=${modelToActivate.id})`);
+          }
+          await db.setActiveModel(modelToActivate.id);
+          await this.updateEnvironmentFromModel(modelToActivate);
+          if (DEBUG_MODEL) {
+            console.log(`\u2705 [MODEL-MANAGER] Successfully switched to ${authType}/${modelToActivate.modelName}`);
+          }
+          return true;
+        } catch (error) {
+          console.error(`\u274C [MODEL-MANAGER] Failed to switch to auth type ${authType}:`, error);
+          return false;
+        }
+      }
       /**
        * Get the currently active model
        * 
@@ -84834,9 +84936,8 @@ var init_modelManager = __esm({
         let settings = {};
         try {
           const db = await this.getDb();
-          const providerModel = await db.getModelsByAuthType(model.authType);
-          if (providerModel && providerModel["id"]) {
-            settings = await db.getProviderSettings(providerModel["id"]);
+          if (model.id) {
+            settings = await db.getProviderSettings(model.id);
           }
         } catch (error) {
           console.warn("Failed to load provider settings:", error);
@@ -93827,7 +93928,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.1.0";
+  return "1.1.2";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -93879,7 +93980,7 @@ import open4 from "open";
 import process11 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "7b22143f";
+var GIT_COMMIT_INFO = "5495c6a2";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 init_dist2();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fss-link",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "engines": {
     "node": ">=20.0.0"
   },