fss-link 1.1.5 → 1.1.6

package/bundle/fss-link.js

@@ -22090,7 +22090,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.5";
+  const version = "1.1.6";
   const userAgent = `FSS-Link/${version} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent
@@ -81787,6 +81787,29 @@ var init_databaseMigrations = __esm({
             db.exec("DROP TABLE IF EXISTS model_configs");
           }
         });
+        this.migrations.push({
+          version: 2,
+          name: "normalize_endpoint_urls",
+          up: (db) => {
+            db.exec(`
+          UPDATE model_configs
+          SET endpoint_url = NULL
+          WHERE endpoint_url = '' OR TRIM(endpoint_url) = ''
+        `);
+            if (process.env["FSS_DEBUG"] === "true") {
+              const result = db.exec(`
+            SELECT COUNT(*) as count
+            FROM model_configs
+            WHERE endpoint_url IS NULL
+          `);
+              const count = result[0]?.values?.[0]?.[0] || 0;
+              console.log(`Migration v2: Normalized endpoints (${count} records with NULL endpoint)`);
+            }
+          },
+          down: (db) => {
+            console.warn("Migration v2 rollback not implemented - endpoint normalization is one-way");
+          }
+        });
       }
       /**
        * Get current schema version from database
@@ -83117,57 +83140,167 @@ var init_model_database = __esm({
           [id]
         );
       }
+      /**
+       * Normalize endpoint URL to canonical form:
+       * - undefined → NULL
+       * - '' (empty string) → NULL
+       * - whitespace-only → NULL
+       * - Non-empty string → trimmed string
+       *
+       * This ensures UNIQUE(auth_type, model_name, endpoint_url) works correctly
+       */
+      normalizeEndpointUrl(endpointUrl) {
+        if (!endpointUrl || endpointUrl.trim() === "") {
+          return null;
+        }
+        return endpointUrl.trim();
+      }
+      /**
+       * Find model by UNIQUE constraint (auth_type, model_name, endpoint_url)
+       * With canonical NULL normalization, we use simple exact match
+       */
+      async findByUniqueKey(authType, modelName, endpointUrl) {
+        if (endpointUrl === null) {
+          return await safeQueryFirstWithLocking(
+            this.db,
+            `SELECT id FROM model_configs
+         WHERE auth_type = ?
+           AND model_name = ?
+           AND endpoint_url IS NULL
+         LIMIT 1`,
+            [authType, modelName]
+          );
+        } else {
+          return await safeQueryFirstWithLocking(
+            this.db,
+            `SELECT id FROM model_configs
+         WHERE auth_type = ?
+           AND model_name = ?
+           AND endpoint_url = ?
+         LIMIT 1`,
+            [authType, modelName, endpointUrl]
+          );
+        }
+      }
+      /**
+       * Update existing model record with canonical normalization
+       */
+      async updateModelRecord(recordId, config, normalizedModelName, normalizedEndpointUrl, encryptedApiKey) {
+        const updateParams = [
+          config.authType || "",
+          normalizedModelName,
+          normalizedEndpointUrl,
+          // NULL or actual URL (never '')
+          encryptedApiKey,
+          config.displayName || null,
+          config.isFavorite === true ? 1 : 0,
+          config.isActive === true ? 1 : 0,
+          recordId
+        ];
+        await safeExecWithLocking(this.db, `
+      UPDATE model_configs SET
+        auth_type = ?,
+        model_name = ?,
+        endpoint_url = ?,  -- Can be NULL
+        api_key = ?,
+        display_name = ?,
+        is_favorite = ?,
+        is_active = ?,
+        last_used = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `, updateParams);
+        return recordId;
+      }
+      /**
+       * Insert new model record with canonical normalization
+       */
+      async insertModelRecord(config, normalizedModelName, normalizedEndpointUrl, encryptedApiKey) {
+        const insertParams = [
+          config.authType || "",
+          normalizedModelName,
+          normalizedEndpointUrl,
+          // NULL or actual URL (never '')
+          encryptedApiKey,
+          config.displayName || null,
+          config.isFavorite === true ? 1 : 0,
+          config.isActive === true ? 1 : 0,
+          config.source || "db"
+        ];
+        await safeExecWithLocking(this.db, `
+      INSERT INTO model_configs
+      (auth_type, model_name, endpoint_url, api_key, display_name, is_favorite, is_active, last_used, source)
+      VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, ?)
+    `, insertParams);
+        return getLastInsertId(this.db);
+      }
       /**
        * Upsert model configuration - UPDATE existing or INSERT new
+       *
+       * Uses cascading lookup strategy:
+       * 1. Level 1: Lookup by ID (explicit update)
+       * 2. Level 2: Lookup by UNIQUE key (auth_type, model_name, endpoint_url)
+       * 3. Level 3: Fallback to auth_type only (backward compatibility)
        */
       async upsertModelConfig(config) {
         if (!this.db) {
           throw new Error("Database not initialized");
         }
         const encryptedApiKey = config.apiKey ? FSSLinkDatabase.encryptApiKey(config.apiKey) : null;
-        const normalizedEndpointUrl = config.endpointUrl || "";
-        const existingRecord = await safeQueryFirstWithLocking(
-          this.db,
-          "SELECT id FROM model_configs WHERE auth_type = ?",
-          [config.authType]
+        const normalizedEndpointUrl = this.normalizeEndpointUrl(config.endpointUrl);
+        const normalizedModelName = config.modelName?.trim() || "";
+        let existingRecord = null;
+        if (config.id) {
+          existingRecord = await safeQueryFirstWithLocking(
+            this.db,
+            "SELECT id FROM model_configs WHERE id = ?",
+            [config.id]
+          );
+          if (existingRecord) {
+            return await this.updateModelRecord(
+              existingRecord.id,
+              config,
+              normalizedModelName,
+              normalizedEndpointUrl,
+              encryptedApiKey
+            );
+          }
+        }
+        existingRecord = await this.findByUniqueKey(
+          config.authType,
+          normalizedModelName,
+          normalizedEndpointUrl
         );
-        if (existingRecord || config.id) {
-          const recordId = existingRecord?.id || config.id;
-          const updateParams = [
-            config.authType || "",
-            config.modelName || "",
-            normalizedEndpointUrl,
-            encryptedApiKey || null,
-            config.displayName || null,
-            config.isFavorite === true ? 1 : 0,
-            config.isActive === true ? 1 : 0,
-            recordId
-          ];
-          await safeExecWithLocking(this.db, `
-        UPDATE model_configs SET 
-          auth_type = ?, model_name = ?, endpoint_url = ?, api_key = ?, 
-          display_name = ?, is_favorite = ?, is_active = ?, last_used = CURRENT_TIMESTAMP
-        WHERE id = ?
-      `, updateParams);
-          return recordId || 0;
-        } else {
-          const insertParams = [
-            config.authType || "",
-            config.modelName || "",
+        if (existingRecord) {
+          return await this.updateModelRecord(
+            existingRecord.id,
+            config,
+            normalizedModelName,
             normalizedEndpointUrl,
-            encryptedApiKey || null,
-            config.displayName || null,
-            config.isFavorite === true ? 1 : 0,
-            config.isActive === true ? 1 : 0,
-            config.source || "db"
-          ];
-          await safeExecWithLocking(this.db, `
-        INSERT INTO model_configs 
-        (auth_type, model_name, endpoint_url, api_key, display_name, is_favorite, is_active, last_used, source)
-        VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, ?)
-      `, insertParams);
-          return getLastInsertId(this.db);
+            encryptedApiKey
+          );
         }
+        if (!normalizedModelName || normalizedModelName === "") {
+          existingRecord = await safeQueryFirstWithLocking(
+            this.db,
+            "SELECT id FROM model_configs WHERE auth_type = ? LIMIT 1",
+            [config.authType]
+          );
+          if (existingRecord) {
+            return await this.updateModelRecord(
+              existingRecord.id,
+              config,
+              normalizedModelName,
+              normalizedEndpointUrl,
+              encryptedApiKey
+            );
+          }
+        }
+        return await this.insertModelRecord(
+          config,
+          normalizedModelName,
+          normalizedEndpointUrl,
+          encryptedApiKey
+        );
       }
       /**
        * Get all model configurations
@@ -94147,7 +94280,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.1.5";
+  return "1.1.6";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -94199,7 +94332,7 @@ import open4 from "open";
 import process11 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "425b354b";
+var GIT_COMMIT_INFO = "2fbcfa4c";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 init_dist2();

package/package.json

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