opencode-pollinations-plugin 6.0.0-beta.23 → 6.0.0-beta.25

package/dist/index.js

@@ -92,80 +92,7 @@ const startProxy = () => {
     });
 };
 // === AUTH HOOK: Native /connect Integration ===
-const createAuthHook = () => ({
-    provider: 'pollinations',
-    // LOADER: Called by OpenCode when it needs credentials
-    // This enables HOT RELOAD - called before each request that needs auth
-    loader: async (auth, provider) => {
-        log('[AuthHook] loader() called - fetching credentials');
-        try {
-            const authData = await auth();
-            if (authData && 'key' in authData && authData.key) {
-                log(`[AuthHook] Got key from OpenCode auth: ${authData.key.substring(0, 8)}...`);
-                // Sync to our config for other parts of the plugin
-                saveConfig({ apiKey: authData.key });
-                return { apiKey: authData.key };
-            }
-        }
-        catch (e) {
-            log(`[AuthHook] loader() error: ${e}`);
-        }
-        // Fallback to our own config
-        const config = loadConfig();
-        if (config.apiKey) {
-            log(`[AuthHook] Using key from plugin config: ${config.apiKey.substring(0, 8)}...`);
-            return { apiKey: config.apiKey };
-        }
-        log('[AuthHook] No API key available');
-        return {};
-    },
-    // METHODS: Define how user can authenticate
-    methods: [{
-            type: 'api',
-            label: 'API Key',
-            prompts: [{
-                    type: 'text',
-                    key: 'apiKey',
-                    message: 'Enter your Pollinations API Key',
-                    placeholder: 'sk_...',
-                    validate: (value) => {
-                        if (!value || value.length < 10) {
-                            return 'API key must be at least 10 characters';
-                        }
-                        if (!value.startsWith('sk_') && !value.startsWith('sk-')) {
-                            return 'API key should start with sk_ or sk-';
-                        }
-                        return undefined; // Valid
-                    }
-                }],
-            authorize: async (inputs) => {
-                log(`[AuthHook] authorize() called with key: ${inputs?.apiKey?.substring(0, 8)}...`);
-                if (!inputs?.apiKey) {
-                    return { type: 'failed' };
-                }
-                // Validate key by testing API
-                try {
-                    const response = await fetch('https://gen.pollinations.ai/text/models', {
-                        headers: { 'Authorization': `Bearer ${inputs.apiKey}` }
-                    });
-                    if (response.ok) {
-                        log('[AuthHook] Key validated successfully');
-                        // Save to our config for immediate use
-                        saveConfig({ apiKey: inputs.apiKey });
-                        return { type: 'success', key: inputs.apiKey };
-                    }
-                    else {
-                        log(`[AuthHook] Key validation failed: ${response.status}`);
-                        return { type: 'failed' };
-                    }
-                }
-                catch (e) {
-                    log(`[AuthHook] Key validation error: ${e}`);
-                    return { type: 'failed' };
-                }
-            }
-        }]
-});
+// Auth Hook moved inside plugin to access context
 // === PLUGIN EXPORT ===
 export const PollinationsPlugin = async (ctx) => {
     log(`Plugin Initializing v${require('../package.json').version}...`);
@@ -189,22 +116,36 @@ export const PollinationsPlugin = async (ctx) => {
                 modelsObj[m.id] = m;
             }
             const version = require('../package.json').version;
-            // Use Server API to PATCH the config at runtime
+            // CRITICAL: Fetch current config first to avoid overwriting other providers
+            let currentConfig = {};
+            try {
+                // Try to fetch existing config to preserve other providers
+                const response = await ctx.client.fetch('/config');
+                if (response.ok) {
+                    currentConfig = await response.json();
+                }
+            }
+            catch (err) {
+                log(`[Event] Warning: Could not fetch current config: ${err}`);
+            }
+            // Safe Merge
+            if (!currentConfig.provider)
+                currentConfig.provider = {};
+            currentConfig.provider.pollinations = {
+                id: 'openai',
+                name: `Pollinations AI (v${version})`,
+                options: {
+                    baseURL: localBaseUrl,
+                    apiKey: 'plugin-managed',
+                },
+                models: modelsObj
+            };
+            // Use Server API to update config with the MERGED object
             await ctx.client.fetch('/config', {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({
-                    provider: {
-                        pollinations: {
-                            id: 'openai',
-                            name: `Pollinations AI (v${version})`,
-                            options: {
-                                baseURL: localBaseUrl,
-                                apiKey: 'plugin-managed',
-                            },
-                            models: modelsObj
-                        }
-                    }
+                    provider: currentConfig.provider
                 })
             });
             log(`[Event] Provider config refreshed with ${Object.keys(modelsObj).length} models.`);
@@ -218,20 +159,61 @@ export const PollinationsPlugin = async (ctx) => {
         }
     };
     return {
-        // AUTH HOOK: Native /connect integration
-        auth: createAuthHook(),
-        // EVENT HOOK: Listen ONLY for explicit /connect command
-        // We removed installation.updated/server.connected because they caused infinite loops
-        event: async ({ event }) => {
-            if (event.type === 'tui.command.execute') {
-                const cmd = event.command || event.data?.command;
-                if (cmd === 'connect' || cmd === '/connect') {
-                    log('[Event] /connect command detected - will refresh after auth hook completes');
-                    // Small delay to let auth hook complete
-                    setTimeout(() => refreshProviderConfig(), 2000);
+        // AUTH HOOK: Native /connect integration (INLINED)
+        auth: {
+            provider: 'pollinations',
+            loader: async (auth, provider) => {
+                log('[AuthHook] loader() called');
+                try {
+                    const authData = await auth();
+                    if (authData && 'key' in authData) {
+                        const k = authData.key;
+                        saveConfig({ apiKey: k });
+                        return { apiKey: k };
+                    }
                 }
-            }
+                catch (e) {
+                    log(`[AuthHook] loader error: ${e}`);
+                }
+                const config = loadConfig();
+                if (config.apiKey)
+                    return { apiKey: config.apiKey };
+                return {};
+            },
+            methods: [{
+                    type: 'api',
+                    label: 'Pollinations API Key',
+                    prompts: [{
+                            type: 'text',
+                            key: 'apiKey',
+                            message: 'Enter Pollinations API Key (starts with sk_)',
+                            validate: (v) => (!v || v.length < 10) ? 'Invalid key' : undefined
+                        }],
+                    authorize: async (inputs) => {
+                        log(`[AuthHook] authorize() called`);
+                        if (!inputs?.apiKey)
+                            return { type: 'failed' };
+                        try {
+                            const r = await fetch('https://gen.pollinations.ai/text/models', {
+                                headers: { 'Authorization': `Bearer ${inputs.apiKey}` }
+                            });
+                            if (r.ok) {
+                                log('[AuthHook] Success. Saving & Refreshing Config...');
+                                saveConfig({ apiKey: inputs.apiKey });
+                                // CRITICAL: Refresh config IMMEDIATELY after successful auth
+                                await refreshProviderConfig();
+                                return { type: 'success', key: inputs.apiKey };
+                            }
+                        }
+                        catch (e) {
+                            log(`[AuthHook] Auth error: ${e}`);
+                        }
+                        return { type: 'failed' };
+                    }
+                }]
         },
+        // Event hook removed (logic moved to authorize)
+        event: async ({ event }) => { },
         async config(config) {
             log("[Hook] config() called");
             // Generate models based on current auth state

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opencode-pollinations-plugin",
     "displayName": "Pollinations AI (V5.6)",
-    "version": "6.0.0-beta.23",
+    "version": "6.0.0-beta.25",
     "description": "Native Pollinations.ai Provider Plugin for OpenCode",
     "publisher": "pollinations",
     "repository": {