feat: OllamaProvider auto-detects extension bridge, falls back to direct connection

src/contexts/ollama-context.tsx

@@ -2,7 +2,7 @@
 
 import { createContext, useContext, useState, useEffect, ReactNode } from "react"
 
-type OllamaMode = "local" | "cloud"
+type OllamaMode = "local" | "cloud" | "bridge"
 
 interface OllamaSettings {
     mode: OllamaMode
@@ -10,6 +10,7 @@ interface OllamaSettings {
     cloudApiKey: string
     enabled: boolean
     availableModels: string[]
+    bridgeDetected: boolean
 }
 
 interface OllamaContextType {
@@ -29,6 +30,7 @@ const defaultSettings: OllamaSettings = {
     cloudApiKey: "",
     enabled: false,
     availableModels: [],
+    bridgeDetected: false,
 }
 
 const OllamaContext = createContext<OllamaContextType | null>(null)
@@ -52,15 +54,42 @@ export function OllamaProvider({ children }: { children: ReactNode }) {
         }
     }, [])
 
+    // Detect extension bridge availability
+    useEffect(() => {
+        const detectBridge = () => {
+            const hasBridge = document.documentElement.getAttribute('data-ollama-bridge') === 'true'
+            if (hasBridge) {
+                setSettings(prev => ({ ...prev, bridgeDetected: true }))
+            }
+        }
+
+        // Check immediately
+        detectBridge()
+
+        // Listen for bridge ready message
+        const handleMessage = (event: MessageEvent) => {
+            if (event.data?.type === 'OLLAMA_BRIDGE_READY') {
+                setSettings(prev => ({ ...prev, bridgeDetected: true }))
+            }
+        }
+
+        window.addEventListener('message', handleMessage)
+        
+        // Also check after a short delay (extension might load after our script)
+        const timer = setTimeout(detectBridge, 2000)
+
+        return () => {
+            window.removeEventListener('message', handleMessage)
+            clearTimeout(timer)
+        }
+    }, [])
+
     // Save settings to localStorage when changed
     const updateSettings = (updates: Partial<OllamaSettings>) => {
         setSettings(prev => {
             const newSettings = { ...prev, ...updates }
             try {
-                // Don't persist the API key in plain text - only save non-sensitive settings
-                const toStore = { ...newSettings }
-                // For security, we still store it but in a real app you might want to encrypt it
-                localStorage.setItem(STORAGE_KEY, JSON.stringify(toStore))
+                localStorage.setItem(STORAGE_KEY, JSON.stringify(newSettings))
             } catch (error) {
                 console.error("Failed to save Ollama settings:", error)
             }
@@ -70,7 +99,8 @@ export function OllamaProvider({ children }: { children: ReactNode }) {
 
     // Get the effective endpoint based on mode
     const getEffectiveEndpoint = (): string => {
-        return settings.mode === "cloud" ? OLLAMA_CLOUD_URL : settings.apiUrl
+        if (settings.mode === "cloud") return OLLAMA_CLOUD_URL
+        return settings.apiUrl
     }
 
     // Get auth headers for API requests
@@ -82,11 +112,16 @@ export function OllamaProvider({ children }: { children: ReactNode }) {
         return headers
     }
 
-    // Test connection to Ollama and fetch available models via API route (avoids CORS)
+    // Test connection to Ollama
     const testConnection = async (): Promise<{ success: boolean; models?: string[]; error?: string }> => {
         setIsLoading(true)
         try {
-            // Use our API route to proxy the request (avoids CORS issues with cloud)
+            // If bridge is available and mode is local, use bridge for zero-config
+            if (settings.bridgeDetected && settings.mode === "local") {
+                return await testViaBridge()
+            }
+
+            // Otherwise use the API route proxy
             const params = new URLSearchParams({
                 mode: settings.mode,
                 url: settings.apiUrl,
@@ -109,9 +144,7 @@ export function OllamaProvider({ children }: { children: ReactNode }) {
             }
 
             const models = data.models?.map((m: { name: string }) => m.name) || []
-
             updateSettings({ availableModels: models, enabled: true })
-
             return { success: true, models }
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Connection failed"
@@ -121,6 +154,39 @@ export function OllamaProvider({ children }: { children: ReactNode }) {
         }
     }
 
+    // Test connection via extension bridge (zero CORS config)
+    const testViaBridge = (): Promise<{ success: boolean; models?: string[]; error?: string }> => {
+        return new Promise((resolve) => {
+            const id = `test_${Date.now()}`
+            const timeout = setTimeout(() => {
+                window.removeEventListener('message', handler)
+                resolve({ success: false, error: 'Bridge timeout — is Ollama running?' })
+            }, 8000)
+
+            const handler = (event: MessageEvent) => {
+                if (event.data?.id !== id) return
+
+                clearTimeout(timeout)
+                window.removeEventListener('message', handler)
+
+                if (event.data.type === 'OLLAMA_ERROR') {
+                    resolve({ success: false, error: event.data.error })
+                } else {
+                    const models = event.data.data?.models?.map((m: { name: string }) => m.name) || []
+                    updateSettings({ availableModels: models, enabled: true, mode: "bridge" })
+                    resolve({ success: true, models })
+                }
+            }
+
+            window.addEventListener('message', handler)
+            window.postMessage({
+                type: 'OLLAMA_LIST_MODELS',
+                id,
+                ollamaUrl: settings.apiUrl,
+            }, '*')
+        })
+    }
+
     return (
         <OllamaContext.Provider value={{ 
             settings,