Refactor: Migrate Settings from electron-store to Centralized Database #113

Author: tarsyang

package-lock.json

@@ -36,7 +36,7 @@
         "@google/genai": "^1.8.0",
         "@google/generative-ai": "^0.24.1",
         "axios": "^1.10.0",
-        "better-sqlite3": "^9.4.3",
+        "better-sqlite3": "^9.6.0",
         "cors": "^2.8.5",
         "dotenv": "^17.0.0",
         "electron-squirrel-startup": "^1.0.1",
@@ -49,6 +49,7 @@
         "keytar": "^7.9.0",
         "node-fetch": "^2.7.0",
         "openai": "^4.70.0",
+        "portkey-ai": "^1.10.1",
         "react-hot-toast": "^2.5.2",
         "sharp": "^0.34.2",
         "validator": "^13.11.0",

package.json

@@ -46,7 +46,8 @@ router.post('/find-or-create', async (req, res) => {
 
 router.post('/api-key', async (req, res) => {
     try {
-        await ipcRequest(req, 'save-api-key', req.body.apiKey);
+        const { apiKey, provider = 'openai' } = req.body;
+        await ipcRequest(req, 'save-api-key', { apiKey, provider });
         res.json({ message: 'API key saved successfully' });
     } catch (error) {
         console.error('Failed to save API key via IPC:', error);

pickleglass_web/backend_node/routes/user.js

@@ -66,15 +66,14 @@ const PROVIDERS = {
   'whisper': {
       name: 'Whisper (Local)',
       handler: () => {
-          // Only load in main process
+          // This needs to remain a function due to its conditional logic for renderer/main process
           if (typeof window === 'undefined') {
               return require("./providers/whisper");
           }
-          // Return dummy for renderer
+          // Return a dummy object for the renderer process
           return {
+              validateApiKey: async () => ({ success: true }), // Mock validate for renderer
               createSTT: () => { throw new Error('Whisper STT is only available in main process'); },
-              createLLM: () => { throw new Error('Whisper does not support LLM'); },
-              createStreamingLLM: () => { throw new Error('Whisper does not support LLM'); }
           };
       },
       llmModels: [],
@@ -130,6 +129,32 @@ function createStreamingLLM(provider, opts) {
   return handler.createStreamingLLM(opts);
 }
 
+function getProviderClass(providerId) {
+    const providerConfig = PROVIDERS[providerId];
+    if (!providerConfig) return null;
+    
+    // Handle special cases for glass providers
+    let actualProviderId = providerId;
+    if (providerId === 'openai-glass') {
+        actualProviderId = 'openai';
+    }
+    
+    // The handler function returns the module, from which we get the class.
+    const module = providerConfig.handler();
+    
+    // Map provider IDs to their actual exported class names
+    const classNameMap = {
+        'openai': 'OpenAIProvider',
+        'anthropic': 'AnthropicProvider',
+        'gemini': 'GeminiProvider',
+        'ollama': 'OllamaProvider',
+        'whisper': 'WhisperProvider'
+    };
+    
+    const className = classNameMap[actualProviderId];
+    return className ? module[className] : null;
+}
+
 function getAvailableProviders() {
   const stt = [];
   const llm = [];
@@ -145,5 +170,6 @@ module.exports = {
   createSTT,
   createLLM,
   createStreamingLLM,
+  getProviderClass,
   getAvailableProviders,
 };

src/common/ai/factory.js

@@ -1,4 +1,38 @@
-const Anthropic = require("@anthropic-ai/sdk")
+const { Anthropic } = require("@anthropic-ai/sdk")
+
+class AnthropicProvider {
+    static async validateApiKey(key) {
+        if (!key || typeof key !== 'string' || !key.startsWith('sk-ant-')) {
+            return { success: false, error: 'Invalid Anthropic API key format.' };
+        }
+
+        try {
+            const response = await fetch("https://api.anthropic.com/v1/messages", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": key,
+                    "anthropic-version": "2023-06-01",
+                },
+                body: JSON.stringify({
+                    model: "claude-3-haiku-20240307",
+                    max_tokens: 1,
+                    messages: [{ role: "user", content: "Hi" }],
+                }),
+            });
+
+            if (response.ok || response.status === 400) { // 400 is a valid response for a bad request, not a bad key
+                return { success: true };
+            } else {
+                const errorData = await response.json().catch(() => ({}));
+                return { success: false, error: errorData.error?.message || `Validation failed with status: ${response.status}` };
+            }
+        } catch (error) {
+            console.error(`[AnthropicProvider] Network error during key validation:`, error);
+            return { success: false, error: 'A network error occurred during validation.' };
+        }
+    }
+}
 
 /**
  * Creates an Anthropic STT session
@@ -286,7 +320,8 @@ function createStreamingLLM({
 }
 
 module.exports = {
-  createSTT,
-  createLLM,
-  createStreamingLLM,
-}
+    AnthropicProvider,
+    createSTT,
+    createLLM,
+    createStreamingLLM
+};

src/common/ai/providers/anthropic.js

@@ -1,6 +1,31 @@
 const { GoogleGenerativeAI } = require("@google/generative-ai")
 const { GoogleGenAI } = require("@google/genai")
 
+class GeminiProvider {
+    static async validateApiKey(key) {
+        if (!key || typeof key !== 'string') {
+            return { success: false, error: 'Invalid Gemini API key format.' };
+        }
+
+        try {
+            const validationUrl = `https://generativelanguage.googleapis.com/v1beta/models?key=${key}`;
+            const response = await fetch(validationUrl);
+
+            if (response.ok) {
+                return { success: true };
+            } else {
+                const errorData = await response.json().catch(() => ({}));
+                const message = errorData.error?.message || `Validation failed with status: ${response.status}`;
+                return { success: false, error: message };
+            }
+        } catch (error) {
+            console.error(`[GeminiProvider] Network error during key validation:`, error);
+            return { success: false, error: 'A network error occurred during validation.' };
+        }
+    }
+}
+
+
 /**
  * Creates a Gemini STT session
  * @param {object} opts - Configuration options
@@ -296,7 +321,8 @@ function createStreamingLLM({ apiKey, model = "gemini-2.5-flash", temperature =
 }
 
 module.exports = {
-  createSTT,
-  createLLM,
-  createStreamingLLM,
-}
+    GeminiProvider,
+    createSTT,
+    createLLM,
+    createStreamingLLM
+};

src/common/ai/providers/gemini.js

@@ -1,6 +1,22 @@
 const http = require('http');
 const fetch = require('node-fetch');
 
+class OllamaProvider {
+    static async validateApiKey() {
+        try {
+            const response = await fetch('http://localhost:11434/api/tags');
+            if (response.ok) {
+                return { success: true };
+            } else {
+                return { success: false, error: 'Ollama service is not running. Please start Ollama first.' };
+            }
+        } catch (error) {
+            return { success: false, error: 'Cannot connect to Ollama. Please ensure Ollama is installed and running.' };
+        }
+    }
+}
+
+
 function convertMessagesToOllamaFormat(messages) {
     return messages.map(msg => {
         if (Array.isArray(msg.content)) {
@@ -237,6 +253,8 @@ function createStreamingLLM({
 }
 
 module.exports = {
+    OllamaProvider,
     createLLM,
-    createStreamingLLM
+    createStreamingLLM,
+    convertMessagesToOllamaFormat
 }; 

src/common/ai/providers/ollama.js

@@ -1,5 +1,35 @@
 const OpenAI = require('openai');
 const WebSocket = require('ws');
+const { Portkey } = require('portkey-ai');
+const { Readable } = require('stream');
+const { getProviderForModel } = require('../factory.js');
+
+
+class OpenAIProvider {
+    static async validateApiKey(key) {
+        if (!key || typeof key !== 'string' || !key.startsWith('sk-')) {
+            return { success: false, error: 'Invalid OpenAI API key format.' };
+        }
+
+        try {
+            const response = await fetch('https://api.openai.com/v1/models', {
+                headers: { 'Authorization': `Bearer ${key}` }
+            });
+
+            if (response.ok) {
+                return { success: true };
+            } else {
+                const errorData = await response.json().catch(() => ({}));
+                const message = errorData.error?.message || `Validation failed with status: ${response.status}`;
+                return { success: false, error: message };
+            }
+        } catch (error) {
+            console.error(`[OpenAIProvider] Network error during key validation:`, error);
+            return { success: false, error: 'A network error occurred during validation.' };
+        }
+    }
+}
+
 
 /**
  * Creates an OpenAI STT session
@@ -206,7 +236,7 @@ function createLLM({ apiKey, model = 'gpt-4.1', temperature = 0.7, maxTokens = 2
   };
 }
 
-/**
+/** 
  * Creates an OpenAI streaming LLM instance
  * @param {object} opts - Configuration options
  * @param {string} opts.apiKey - OpenAI API key
@@ -257,7 +287,8 @@ function createStreamingLLM({ apiKey, model = 'gpt-4.1', temperature = 0.7, maxT
 }
 
 module.exports = {
-  createSTT,
-  createLLM,
-  createStreamingLLM
+    OpenAIProvider,
+    createSTT,
+    createLLM,
+    createStreamingLLM
 }; 

src/common/ai/providers/openai.js

@@ -173,6 +173,11 @@ class WhisperSTTSession extends EventEmitter {
 }
 
 class WhisperProvider {
+    static async validateApiKey() {
+        // Whisper is a local service, no API key validation needed.
+        return { success: true };
+    }
+
     constructor() {
         this.whisperService = null;
     }
@@ -224,8 +229,12 @@ class WhisperProvider {
     }
 
     async createStreamingLLM() {
-        throw new Error('Whisper provider does not support streaming LLM functionality');
+        console.warn('[WhisperProvider] Streaming LLM is not supported by Whisper.');
+        throw new Error('Whisper does not support LLM.');
     }
 }
 
-module.exports = new WhisperProvider();
+module.exports = {
+    WhisperProvider,
+    WhisperSTTSession
+};