opencode-pollinations-plugin 6.1.0-beta.9 → 6.2.0

package/dist/server/generate-config.js

@@ -1,31 +1,16 @@
-/**
- * generate-config.ts - v6.0 Simplified
- *
- * Single endpoint: gen.pollinations.ai/text/models
- * No more Free tier, no cache ETag, no prefixes
- */
 import * as https from 'https';
 import * as fs from 'fs';
-import { loadConfig } from './config.js';
+import * as path from 'path';
+import { loadConfig, CONFIG_FILE } from './config.js';
+import { log as logSystem } from './logger.js';
 // --- LOGGING ---
-const LOG_FILE = '/tmp/opencode_pollinations_config.log';
 function log(msg) {
-    try {
-        const ts = new Date().toISOString();
-        if (!fs.existsSync(LOG_FILE))
-            fs.writeFileSync(LOG_FILE, '');
-        fs.appendFileSync(LOG_FILE, `[ConfigGen v6.0] ${ts} ${msg}\n`);
-    }
-    catch (e) { }
+    logSystem(`[ConfigGen] ${msg}`);
 }
-// --- NETWORK HELPER ---
+// Fetch Helper
 function fetchJson(url, headers = {}) {
     return new Promise((resolve, reject) => {
-        const finalHeaders = {
-            ...headers,
-            'User-Agent': 'Mozilla/5.0 (compatible; OpenCode-Pollinations/6.0; +https://opencode.ai)'
-        };
-        const req = https.get(url, { headers: finalHeaders }, (res) => {
+        const req = https.get(url, { headers }, (res) => {
             let data = '';
             res.on('data', chunk => data += chunk);
             res.on('end', () => {
@@ -35,7 +20,7 @@ function fetchJson(url, headers = {}) {
                 }
                 catch (e) {
                     log(`JSON Parse Error for ${url}: ${e}`);
-                    resolve([]);
+                    resolve([]); // Fail safe -> empty list
                 }
             });
         });
@@ -43,132 +28,205 @@ function fetchJson(url, headers = {}) {
             log(`Network Error for ${url}: ${e.message}`);
             reject(e);
         });
-        req.setTimeout(15000, () => {
+        req.setTimeout(5000, () => {
             req.destroy();
             reject(new Error('Timeout'));
         });
     });
 }
-// --- GENERATOR LOGIC ---
-export async function generatePollinationsConfig(forceApiKey) {
+function formatName(id, censored = true) {
+    let clean = id.replace(/^pollinations\//, '').replace(/-/g, ' ');
+    clean = clean.replace(/\b\w/g, l => l.toUpperCase());
+    if (!censored)
+        clean += " (Uncensored)";
+    return clean;
+}
+// --- MAIN GENERATOR logic ---
+// --- MAIN GENERATOR logic ---
+export async function generatePollinationsConfig(forceApiKey, forceStrict = false) {
     const config = loadConfig();
     const modelsOutput = [];
+    log(`Starting Configuration (V5.1.22 Hot-Reload)...`);
+    // Use forced key (from Hook) or cached key
     const effectiveKey = forceApiKey || config.apiKey;
-    log(`Starting Configuration v6.0...`);
-    log(`API Key present: ${!!effectiveKey}`);
-    // 1. ALWAYS add "connect" placeholder model
+    // 0. CONNECT MODEL (Always present, first in list)
     modelsOutput.push({
-        id: 'connect',
-        name: '🔑 Connect your Pollinations Account',
-        modalities: { input: ['text'], output: ['text'] },
-        tool_call: false
+        id: 'pollinations/connect',
+        name: '🌸 Pollinations — Guide & Connexion',
+        object: 'model',
+        variants: {}
     });
-    // 2. If no API key, return only connect placeholder
-    if (!effectiveKey || effectiveKey.length < 5 || effectiveKey === 'dummy') {
-        log('No API key configured. Returning connect placeholder only.');
-        return modelsOutput;
-    }
-    // 3. Fetch models from Enterprise endpoint
+    // 1. FREE UNIVERSE
     try {
-        log('Fetching models from gen.pollinations.ai/text/models...');
-        const rawList = await fetchJson('https://gen.pollinations.ai/text/models', {
-            'Authorization': `Bearer ${effectiveKey}`
-        });
-        const modelsList = Array.isArray(rawList) ? rawList : (rawList.data || []);
-        log(`Received ${modelsList.length} models from API`);
-        modelsList.forEach((m) => {
-            // Skip models without tools support (except nomnom - special handling)
-            if (m.tools === false && m.name !== 'nomnom') {
-                log(`Skipping ${m.name} (no tools)`);
-                return;
-            }
-            const mapped = mapModel(m);
+        // Switch to main models endpoint (User provided curl confirms it has 'description')
+        const freeList = await fetchJson('https://text.pollinations.ai/models');
+        const list = Array.isArray(freeList) ? freeList : (freeList.data || []);
+        list.forEach((m) => {
+            const mapped = mapModel(m, 'free/', '');
             modelsOutput.push(mapped);
         });
-        log(`Total models registered: ${modelsOutput.length}`);
-        log(`Model IDs: ${modelsOutput.map(m => m.id).join(', ')}`);
+        log(`Fetched ${modelsOutput.length} Free models.`);
     }
     catch (e) {
-        log(`Error fetching models: ${e.message}`);
-        // Return connect placeholder only on error
+        log(`Error fetching Free models: ${e}`);
+        // Fallback Robust (Offline support)
+        modelsOutput.push({ id: "free/mistral", name: "Mistral Nemo (Fallback)", object: "model", variants: {} });
+        modelsOutput.push({ id: "free/openai", name: "OpenAI (Fallback)", object: "model", variants: {} });
+        modelsOutput.push({ id: "free/gemini", name: "Gemini Flash (Fallback)", object: "model", variants: {} });
+    }
+    // ALIAS Removed for Clean Config
+    // const hasGeminiAlias = modelsOutput.find(m => m.id === 'pollinations/free/gemini');
+    // if (!hasGeminiAlias) {
+    //    modelsOutput.push({ id: "pollinations/free/gemini", name: "[Free] Gemini Flash (Alias)", object: "model", variants: {} });
+    // }
+    // 2. ENTERPRISE UNIVERSE
+    if (effectiveKey && effectiveKey.length > 5 && effectiveKey !== 'dummy') {
+        try {
+            // Use /text/models for full metadata (input_modalities, tools, reasoning, pricing)
+            const enterListRaw = await fetchJson('https://gen.pollinations.ai/text/models', {
+                'Authorization': `Bearer ${effectiveKey}`
+            });
+            const enterList = Array.isArray(enterListRaw) ? enterListRaw : (enterListRaw.data || []);
+            const paidModels = [];
+            enterList.forEach((m) => {
+                if (m.tools === false)
+                    return;
+                const mapped = mapModel(m, 'enter/', '');
+                modelsOutput.push(mapped);
+                if (m.paid_only) {
+                    paidModels.push(mapped.id.replace('enter/', '')); // Store bare ID "gemini-large"
+                }
+            });
+            log(`Total models (Free+Pro): ${modelsOutput.length}`);
+            // Save Paid Models List for Proxy
+            try {
+                const paidListPath = path.join(config.gui ? path.dirname(CONFIG_FILE) : '/tmp', 'pollinations-paid-models.json');
+                // Ensure dir exists (re-use config dir logic from config.ts if possible, or just assume it exists since config loaded)
+                if (fs.existsSync(path.dirname(paidListPath))) {
+                    fs.writeFileSync(paidListPath, JSON.stringify(paidModels));
+                }
+            }
+            catch (e) {
+                log(`Error saving paid models list: ${e}`);
+            }
+        }
+        catch (e) {
+            log(`Error fetching Enterprise models: ${e}`);
+            // STRICT MODE (Validation): Do not return fake fallback models.
+            if (forceStrict)
+                throw e;
+            // Fallback Robust for Enterprise (User has Key but discovery failed)
+            modelsOutput.push({ id: "enter/gpt-4o", name: "GPT-4o (Fallback)", object: "model", variants: {} });
+            // ...
+            modelsOutput.push({ id: "enter/claude-3-5-sonnet", name: "Claude 3.5 Sonnet (Fallback)", object: "model", variants: {} });
+            modelsOutput.push({ id: "enter/deepseek-reasoner", name: "DeepSeek R1 (Fallback)", object: "model", variants: {} });
+        }
     }
     return modelsOutput;
 }
-// --- UTILS ---
+// --- CAPABILITY ICONS ---
 function getCapabilityIcons(raw) {
     const icons = [];
-    // Vision: check both input_modalities and legacy vision flag
-    if (raw.input_modalities?.includes('image') || raw.vision === true) {
+    // Vision: accepts images
+    if (raw.input_modalities?.includes('image'))
         icons.push('👁️');
-    }
-    // Audio input
-    if (raw.input_modalities?.includes('audio') || raw.audio === true) {
+    // Audio Input
+    if (raw.input_modalities?.includes('audio'))
         icons.push('🎙️');
-    }
-    // Audio output
-    if (raw.output_modalities?.includes('audio')) {
+    // Audio Output
+    if (raw.output_modalities?.includes('audio'))
         icons.push('🔊');
-    }
-    // Reasoning
-    if (raw.reasoning === true) {
+    // Reasoning capability
+    if (raw.reasoning === true)
         icons.push('🧠');
-    }
-    // Search capability
-    if (raw.description?.toLowerCase().includes('search') || raw.name?.includes('search')) {
+    // Web Search (from description)
+    if (raw.description?.toLowerCase().includes('search') ||
+        raw.name?.includes('search') ||
+        raw.name?.includes('perplexity')) {
         icons.push('🔍');
     }
-    // Tools
-    if (raw.tools === true) {
-        icons.push('🛠️');
-    }
-    // Paid only
-    if (raw.paid_only === true) {
-        icons.push('💎');
-    }
+    // Tool/Function calling
+    if (raw.tools === true)
+        icons.push('💻');
     return icons.length > 0 ? ` ${icons.join('')}` : '';
 }
-function formatName(id) {
-    let clean = id.replace(/-/g, ' ');
-    clean = clean.replace(/\b\w/g, l => l.toUpperCase());
-    return clean;
-}
-function mapModel(raw) {
-    const rawId = raw.name;
-    // Build display name
+// --- MAPPING ENGINE ---
+function mapModel(raw, prefix, namePrefix) {
+    const rawId = raw.id || raw.name;
+    const fullId = prefix + rawId; // ex: "free/gemini" or "enter/nomnom" (prefix passed is "enter/")
     let baseName = raw.description;
     if (!baseName || baseName === rawId) {
-        baseName = formatName(rawId);
+        baseName = formatName(rawId, raw.censored !== false);
     }
-    // Truncate after first " - "
+    // CLEANUP: Simple Truncation Rule (Requested by User)
+    // "Start from left, find ' - ', delete everything after."
     if (baseName && baseName.includes(' - ')) {
         baseName = baseName.split(' - ')[0].trim();
     }
+    // Gérer les icônes pour paid_only et modèles FREE
+    let paidPrefix = '';
+    let freeSuffix = '';
+    if (raw.paid_only) {
+        paidPrefix = '💎 '; // Icône diamant devant les modèles payants
+    }
+    if (prefix === 'free/') {
+        freeSuffix = ' (free)'; // Suffixe pour l'univers FREE
+    }
+    // Get capability icons from API metadata
     const capabilityIcons = getCapabilityIcons(raw);
-    const finalName = `${baseName}${capabilityIcons}`;
-    // Determine modalities for OpenCode
-    const inputMods = raw.input_modalities || ['text'];
-    const outputMods = raw.output_modalities || ['text'];
+    const finalName = `${paidPrefix}${baseName}${capabilityIcons}${freeSuffix}`;
     const modelObj = {
-        id: rawId, // No prefix! Direct model ID
+        id: fullId,
         name: finalName,
+        object: 'model',
+        variants: {},
+        // Declare modalities for OpenCode vision support
         modalities: {
-            input: inputMods,
-            output: outputMods
-        },
-        tool_call: raw.tools === true && rawId !== 'nomnom' // NomNom: no tools
+            input: raw.input_modalities || ['text'],
+            output: raw.output_modalities || ['text']
+        }
     };
-    // Model-specific limits
+    // --- ENRICHISSEMENT ---
+    if (raw.reasoning === true || rawId.includes('thinking') || rawId.includes('reasoning')) {
+        modelObj.variants = { ...modelObj.variants, high_reasoning: { options: { reasoningEffort: "high", budgetTokens: 16000 } } };
+    }
+    if (rawId.includes('gemini') && !rawId.includes('fast')) {
+        if (!modelObj.variants.high_reasoning && (rawId === 'gemini' || rawId === 'gemini-large')) {
+            modelObj.variants.high_reasoning = { options: { reasoningEffort: "high", budgetTokens: 16000 } };
+        }
+    }
+    if (rawId.includes('claude') || rawId.includes('mistral') || rawId.includes('llama')) {
+        modelObj.variants.safe_tokens = { options: { maxTokens: 8000 } };
+    }
+    // NOVA FIX: Bedrock limit ~10k (User reported error > 10000)
+    // We MUST set the limit on the model object itself so OpenCode respects it by default.
     if (rawId.includes('nova')) {
-        modelObj.limit = { output: 8000, context: 128000 };
+        modelObj.limit = {
+            output: 8000,
+            context: 128000 // Nova Micro/Lite/Pro usually 128k
+        };
+        // Also keep variant just in case
+        modelObj.variants.bedrock_safe = { options: { maxTokens: 8000 } };
+    }
+    // BEDROCK/ENTERPRISE LIMITS (Chickytutor only)
+    if (rawId.includes('chickytutor')) {
+        modelObj.limit = {
+            output: 8192,
+            context: 128000
+        };
     }
-    if (rawId === 'nomnom') {
-        modelObj.limit = { output: 2048, context: 32768 };
-        modelObj.tool_call = false; // NomNom is a router, no external tools
+    // NOMNOM FIX: User reported error if max_tokens is missing.
+    // Also it is a 'Gemini-scrape' model, so we treat it similar to Gemini but with strict limit.
+    if (rawId.includes('nomnom') || rawId.includes('scrape')) {
+        modelObj.limit = {
+            output: 2048, // User used 1500 successfully
+            context: 32768
+        };
     }
-    if (rawId.includes('chicky') || rawId.includes('mistral')) {
-        modelObj.limit = { output: 4096, context: 8192 };
-        modelObj.options = { maxTokens: 4096 };
+    if (rawId.includes('fast') || rawId.includes('flash') || rawId.includes('lite')) {
+        if (!rawId.includes('gemini')) {
+            modelObj.variants.speed = { options: { thinking: { disabled: true } } };
+        }
     }
-    log(`[Mapped] ${modelObj.id} → ${modelObj.name} | tools=${modelObj.tool_call} | modalities=${JSON.stringify(modelObj.modalities)}`);
     return modelObj;
 }

package/dist/server/index.d.ts

@@ -1 +1,2 @@
-export {};
+import type { Plugin } from '@opencode-ai/plugin';
+export declare const plugin: Plugin;

package/dist/server/index.js

@@ -4,7 +4,9 @@ import * as path from 'path';
 import { getAggregatedModels } from './pollinations-api.js';
 import { loadConfig, saveConfig } from './config.js';
 import { handleChatCompletion } from './proxy.js';
-const LOG_FILE = path.join(process.env.HOME || '/tmp', '.config/opencode/plugins/pollinations-v3.log');
+import { createCommandHooks, setClientForCommands, checkKeyPermissions } from './commands.js';
+import { fileURLToPath } from 'url';
+const LOG_FILE = path.join(process.env.HOME || '/tmp', '.config/opencode/plugins/pollinations-v6.log');
 // Simple file logger
 function log(msg) {
     const ts = new Date().toISOString();
@@ -14,170 +16,143 @@ function log(msg) {
         }
         fs.appendFileSync(LOG_FILE, `[${ts}] ${msg}\n`);
     }
-    catch (e) {
-        // silent fail
-    }
-}
-// CRASH GUARD
-const CRASH_LOG = '/tmp/opencode_pollinations_crash.log';
-process.on('uncaughtException', (err) => {
-    try {
-        const msg = `[CRASH] Uncaught Exception: ${err.message}\n${err.stack}\n`;
-        fs.appendFileSync(CRASH_LOG, msg);
-        console.error(msg);
-    }
     catch (e) { }
-    process.exit(1);
-});
-process.on('unhandledRejection', (reason, promise) => {
-    try {
-        const msg = `[CRASH] Unhandled Rejection: ${reason}\n`;
-        fs.appendFileSync(CRASH_LOG, msg);
-    }
-    catch (e) { }
-});
-const server = http.createServer(async (req, res) => {
-    log(`${req.method} ${req.url}`);
-    // CORS Headers
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', '*');
-    if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
+}
+const PORT = parseInt(process.env.POLLINATIONS_PORT || '10001', 10);
+let serverInstance = null;
+// --- SERVER LOGIC ---
+function startServer() {
+    if (serverInstance)
         return;
-    }
-    // AUTH ENDPOINT (Kept for compatibility, though Native Auth is preferred)
-    if (req.method === 'POST' && req.url === '/v1/auth') {
-        const chunks = [];
-        req.on('data', chunk => chunks.push(chunk));
-        req.on('end', async () => {
-            try {
-                const body = JSON.parse(Buffer.concat(chunks).toString());
-                if (body && body.apiKey) {
-                    saveConfig({ apiKey: body.apiKey, mode: 'pro' });
-                    log(`[AUTH] Key saved via Server Endpoint`);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ status: "ok" }));
+    serverInstance = http.createServer(async (req, res) => {
+        log(`${req.method} ${req.url}`);
+        // CORS Headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', '*');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // AUTH ENDPOINT
+        if (req.method === 'POST' && req.url === '/v1/auth') {
+            const chunks = [];
+            req.on('data', chunk => chunks.push(chunk));
+            req.on('end', async () => {
+                try {
+                    const body = JSON.parse(Buffer.concat(chunks).toString());
+                    if (body && body.apiKey) {
+                        saveConfig({ apiKey: body.apiKey, mode: 'pro' });
+                        log(`[AUTH] Key saved via Server Endpoint`);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ status: "ok" }));
+                    }
+                    else {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: "Missing apiKey" }));
+                    }
                 }
-                else {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: "Missing apiKey" }));
+                catch (e) {
+                    log(`[AUTH] Error: ${e}`);
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: String(e) }));
                 }
-            }
-            catch (e) {
-                log(`[AUTH] Error: ${e}`);
-                res.writeHead(500);
-                res.end(JSON.stringify({ error: String(e) }));
-            }
-        });
-        return;
-    }
-    if (req.method === 'GET' && req.url === '/health') {
-        const config = loadConfig();
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            status: "ok",
-            version: "v3.0.0-phase3",
-            mode: config.mode,
-            hasKey: !!config.apiKey
-        }));
-        return;
-    }
-    if (req.method === 'GET' && req.url === '/v1/models') {
-        try {
-            const models = await getAggregatedModels();
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(models));
+            });
+            return;
         }
-        catch (e) {
-            log(`Error fetching models: ${e}`);
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: "Failed to fetch models" }));
+        if (req.method === 'GET' && req.url === '/health') {
+            const config = loadConfig();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                status: "ok",
+                version: "v6.0.0-beta.99",
+                mode: config.mode,
+                hasKey: !!config.apiKey
+            }));
+            return;
         }
-        return;
-    }
-    if (req.method === 'POST' && req.url === '/v1/chat/completions') {
-        // Accumulate body for the proxy
-        const chunks = [];
-        req.on('data', chunk => chunks.push(chunk));
-        req.on('end', async () => {
+        if (req.method === 'GET' && req.url === '/v1/models') {
             try {
-                const bodyRaw = Buffer.concat(chunks).toString();
-                await handleChatCompletion(req, res, bodyRaw);
+                const models = await getAggregatedModels();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(models));
             }
             catch (e) {
-                log(`Error in chat handler: ${e}`);
+                log(`Error fetching models: ${e}`);
                 res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: "Internal Server Error in Chat Handler" }));
+                res.end(JSON.stringify({ error: "Failed to fetch models" }));
             }
-        });
-        return;
-    }
-    res.writeHead(404);
-    res.end("Not Found");
-});
-const PORT = parseInt(process.env.POLLINATIONS_PORT || '10001', 10);
-// ANTI-ZOMBIE (Visible Logs Restored)
-try {
-    const { execSync } = require('child_process');
-    try {
-        console.log(`[POLLINATIONS] Checking port ${PORT}...`);
-        execSync(`fuser -k ${PORT}/tcp || true`);
-        console.log(`[POLLINATIONS] Port ${PORT} cleared.`);
-    }
-    catch (e) {
-        console.log(`[POLLINATIONS] Port check skipped (cmd missing?)`);
-    }
-}
-catch (e) { }
-// LIFECYCLE DEBUG (Sync Write)
-const LIFE_LOG = '/tmp/POLLI_LIFECYCLE.log';
-const LOC_LOG = '/tmp/POLLI_LOCATION.log'; // NEW: Track source location
-try {
-    fs.appendFileSync(LIFE_LOG, `[${new Date().toISOString()}] [STARTUP] PID:${process.pid} Initializing...\n`);
-    fs.writeFileSync(LOC_LOG, `[${new Date().toISOString()}] RUNNING FROM: ${__filename}\n`);
-}
-catch (e) { }
-process.on('exit', (code) => {
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/v1/chat/completions') {
+            const chunks = [];
+            req.on('data', chunk => chunks.push(chunk));
+            req.on('end', async () => {
+                try {
+                    const bodyRaw = Buffer.concat(chunks).toString();
+                    await handleChatCompletion(req, res, bodyRaw);
+                }
+                catch (e) {
+                    log(`Error in chat handler: ${e}`);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: "Internal Server Error in Chat Handler" }));
+                }
+            });
+            return;
+        }
+        res.writeHead(404);
+        res.end("Not Found");
+    });
+    // ANTI-ZOMBIE
     try {
-        fs.appendFileSync(LIFE_LOG, `[${new Date().toISOString()}] [EXIT] PID:${process.pid} Exiting with code ${code}\n`);
+        const { execSync } = require('child_process');
+        try {
+            console.log(`[POLLINATIONS] Checking port ${PORT}...`);
+            execSync(`fuser -k ${PORT}/tcp || true`);
+            console.log(`[POLLINATIONS] Port ${PORT} cleared.`);
+        }
+        catch (e) { }
     }
     catch (e) { }
-});
-// STARTUP CHECK: Re-validate Key (in case of upgrade/config drift)
-import { checkKeyPermissions } from './commands.js';
-(async () => {
-    const config = loadConfig();
-    if (config.apiKey) {
-        try {
-            console.log('Pollinations Plugin: Verifying API Key on startup...');
-            const check = await checkKeyPermissions(config.apiKey);
-            if (!check.ok) {
-                console.warn(`Pollinations Plugin: Limited Key Detected on Startup (${check.reason}). Enforcing Manual Mode.`);
-                saveConfig({
-                    apiKey: config.apiKey,
-                    mode: 'manual',
-                    keyHasAccessToProfile: false
-                });
-            }
-            else {
-                if (config.keyHasAccessToProfile === false) {
-                    saveConfig({ apiKey: config.apiKey, keyHasAccessToProfile: true });
+    // STARTUP CHECK
+    (async () => {
+        const config = loadConfig();
+        if (config.apiKey) {
+            try {
+                console.log('Pollinations Plugin: Verifying API Key on startup...');
+                const check = await checkKeyPermissions(config.apiKey);
+                if (!check.ok) {
+                    console.warn(`Pollinations Plugin: Limited Key Detected on Startup (${check.reason}). Enforcing Manual Mode.`);
+                    saveConfig({ apiKey: config.apiKey, mode: 'manual', keyHasAccessToProfile: false });
+                }
+                else {
+                    if (config.keyHasAccessToProfile === false)
+                        saveConfig({ apiKey: config.apiKey, keyHasAccessToProfile: true });
                 }
             }
+            catch (e) {
+                console.error('Pollinations Plugin: Startup Check Failed:', e);
+            }
         }
-        catch (e) {
-            console.error('Pollinations Plugin: Startup Check Failed:', e);
-        }
-    }
-    server.listen(PORT, '127.0.0.1', () => {
+    })();
+    serverInstance.listen(PORT, '127.0.0.1', () => {
         const url = `http://127.0.0.1:${PORT}`;
-        log(`[SERVER] Started V3 Phase 3 (Auth Enabled) on port ${PORT}`);
-        try {
-            fs.appendFileSync(LIFE_LOG, `[${new Date().toISOString()}] [LISTEN] PID:${process.pid} Listening on ${PORT}\n`);
-        }
-        catch (e) { }
-        console.log(`POLLINATIONS_V3_URL=${url}`);
+        log(`[SERVER] Started V6 (Plugin Mode) on port ${PORT}`);
+        console.log(`POLLINATIONS_V6_URL=${url}`);
     });
-})();
+}
+// --- OPENCODE PLUGIN EXPORT ---
+export const plugin = async ({ client }) => {
+    // 1. Inject Client for Command Handling
+    setClientForCommands(client);
+    // 2. Start Local Proxy Server
+    startServer();
+    // 3. Register Hooks (Commands, TUI, etc.)
+    return createCommandHooks();
+};
+// --- STANDALONE SUPPORT ---
+// If run directly via `node dist/index.js`, start server immediately
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    startServer();
+}

package/dist/server/logger.d.ts

@@ -0,0 +1,8 @@
+export declare function log(msg: string, file?: string): void;
+export declare function logApi(msg: string): void;
+export declare function logToast(msg: string): void;
+export declare const LOG_FILES: {
+    main: string;
+    api: string;
+    toast: string;
+};