opencode-pollinations-plugin 5.6.0-beta.2 → 5.6.0-beta.20

package/dist/debug_check.js

@@ -0,0 +1,36 @@
+import * as https from 'https';
+
+function checkEndpoint(ep, key) {
+    return new Promise((resolve) => {
+        console.log(`Checking ${ep}...`);
+        const req = https.request({
+            hostname: 'gen.pollinations.ai',
+            path: ep,
+            method: 'GET',
+            headers: { 'Authorization': `Bearer ${key}` }
+        }, (res) => {
+            console.log(`Status Code: ${res.statusCode}`);
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                console.log(`Headers:`, res.headers);
+                console.log(`Body Full: ${data}`);
+                if (res.statusCode === 200) resolve({ ok: true, body: data });
+                else resolve({ ok: false, status: res.statusCode, body: data });
+            });
+        });
+        req.on('error', (e) => {
+            console.log(`Error: ${e.message}`);
+            resolve({ ok: false, status: e.message || 'Error' });
+        });
+        req.setTimeout(10000, () => req.destroy());
+        req.end();
+    });
+}
+
+const KEY = "plln_sk_F7a4RcBG4AVCeBSo6lnS36EKwm0nPn1O";
+
+(async () => {
+    const res = await checkEndpoint('/account/profile', KEY);
+    console.log('Result:', res);
+})();

package/dist/index.js

@@ -97,7 +97,7 @@ export const PollinationsPlugin = async (ctx) => {
             if (!config.provider)
                 config.provider = {};
             // Dynamic Provider Name
-            const version = require('../../package.json').version;
+            const version = require('../package.json').version;
             config.provider['pollinations'] = {
                 id: 'pollinations',
                 name: `Pollinations AI (v${version})`,

package/dist/server/commands.d.ts

@@ -1,3 +1,9 @@
+interface CheckResult {
+    ok: boolean;
+    status?: number | string;
+    reason?: string;
+}
+export declare function checkKeyPermissions(key: string): Promise<CheckResult>;
 interface CommandResult {
     handled: boolean;
     response?: string;

package/dist/server/commands.js

@@ -1,8 +1,60 @@
+import * as https from 'https';
 import { loadConfig, saveConfig } from './config.js';
 import { getQuotaStatus } from './quota.js';
 import { emitStatusToast } from './toast.js';
 import { getDetailedUsage } from './pollinations-api.js';
 import { generatePollinationsConfig } from './generate-config.js';
+function checkEndpoint(ep, key) {
+    return new Promise((resolve) => {
+        const req = https.request({
+            hostname: 'gen.pollinations.ai',
+            path: ep,
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${key}`,
+                'User-Agent': 'Pollinations-Plugin/5.6.0' // Identify cleanly
+            }
+        }, (res) => {
+            const isJson = res.headers['content-type']?.includes('application/json');
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode === 200 && isJson) {
+                    // Double Check Check Body for Logical Errors masked as 200
+                    try {
+                        const json = JSON.parse(data);
+                        if (json.error || json.success === false) {
+                            resolve({ ok: false, reason: "API Logical Error", status: 200 });
+                        }
+                        else {
+                            resolve({ ok: true });
+                        }
+                    }
+                    catch (e) {
+                        resolve({ ok: false, reason: "Invalid JSON", status: 200 });
+                    }
+                }
+                else {
+                    resolve({ ok: false, status: res.statusCode, reason: isJson ? "API Error" : "Not JSON (Cloudflare?)" });
+                }
+            });
+        });
+        req.on('error', (e) => resolve({ ok: false, status: e.message || 'Error' }));
+        req.setTimeout(10000, () => req.destroy()); // 10s Timeout
+        req.end();
+    });
+}
+export async function checkKeyPermissions(key) {
+    // SEQUENTIAL CHECK (Avoid Rate Limits on Key Verification)
+    const endpoints = ['/account/profile', '/account/balance', '/account/usage'];
+    for (const ep of endpoints) {
+        const res = await checkEndpoint(ep, key);
+        if (!res.ok) {
+            return { ok: false, reason: `${ep} (${res.status})` };
+        }
+    }
+    return { ok: true };
+}
 // === CONSTANTS & PRICING ===
 const TIER_LIMITS = {
     spore: { pollen: 1, emoji: '🦠' },
@@ -87,11 +139,11 @@ export async function handleCommand(command) {
     const args = parts.slice(2);
     switch (subCommand) {
         case 'mode':
-            return handleModeCommand(args);
+            return await handleModeCommand(args);
         case 'usage':
             return await handleUsageCommand(args);
         case 'connect':
-            return handleConnectCommand(args);
+            return await handleConnectCommand(args);
         case 'fallback':
             return handleFallbackCommand(args);
         case 'config':
@@ -106,7 +158,7 @@ export async function handleCommand(command) {
     }
 }
 // === SUB-COMMANDS ===
-function handleModeCommand(args) {
+async function handleModeCommand(args) {
     const mode = args[0];
     if (!mode) {
         const config = loadConfig();
@@ -121,6 +173,32 @@ function handleModeCommand(args) {
             error: `Mode invalide: ${mode}. Valeurs: manual, alwaysfree, pro`
         };
     }
+    const checkConfig = loadConfig();
+    // JIT VERIFICATION for PRO Mode
+    if (mode === 'pro') {
+        const key = checkConfig.apiKey;
+        if (!key) {
+            return { handled: true, error: "❌ Mode Pro nécessite une Clé API configurée." };
+        }
+        emitStatusToast('info', 'Vérification des droits...', 'Mode Pro');
+        try {
+            // Force verify permissions NOW
+            const check = await checkKeyPermissions(key);
+            if (!check.ok) {
+                saveConfig({ mode: 'manual', keyHasAccessToProfile: false });
+                return {
+                    handled: true,
+                    error: `❌ **Mode Refusé**\nVotre clé est limitée (Code ${check.status}: ${check.reason}).\nPassage en mode **manual**.`
+                };
+            }
+            // Valid -> Ensure flag is true
+            saveConfig({ keyHasAccessToProfile: true });
+        }
+        catch (e) {
+            return { handled: true, error: `❌ Erreur de vérification: ${e.message}` };
+        }
+    }
+    // Allow switch (if alwaysfree or manual, or verified pro)
     saveConfig({ mode: mode });
     const config = loadConfig();
     if (config.gui.status !== 'none') {
@@ -230,10 +308,34 @@ async function handleConnectCommand(args) {
             const masked = key.substring(0, 6) + '...';
             // Count Paid Only models found
             const diamondCount = enterpriseModels.filter(m => m.name.includes('💎')).length;
+            // CHECK RESTRICTIONS: Strict Check (Usage + Profile + Balance)
+            let forcedModeMsg = "";
+            let isLimited = false;
+            let limitReason = "";
+            try {
+                // Strict Probe: Must be able to read ALL accounting data
+                const check = await checkKeyPermissions(key);
+                if (!check.ok) {
+                    isLimited = true;
+                    limitReason = check.reason || "Unknown";
+                }
+            }
+            catch (e) {
+                isLimited = true;
+                limitReason = e.message;
+            }
+            // If Limited -> FORCE MANUAL
+            if (isLimited) {
+                saveConfig({ apiKey: key, mode: 'manual', keyHasAccessToProfile: false });
+                forcedModeMsg = `\n⚠️ **Clé Limitée** (Echec: ${limitReason}) -> Mode **MANUEL** forcé.\n*Requis pour mode Auto: Profile, Balance & Usage.*`;
+            }
+            else {
+                saveConfig({ apiKey: key, keyHasAccessToProfile: true }); // Let user keep current mode or default
+            }
             emitStatusToast('success', `Clé Valide! (${enterpriseModels.length} modèles Pro débloqués)`, 'Pollinations Config');
             return {
                 handled: true,
-                response: `✅ **Connexion Réussie!**\n- Clé: \`${masked}\`\n- Mode: **PRO** (Activé)\n- Modèles Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)`
+                response: `✅ **Connexion Réussie!**\n- Clé: \`${masked}\`\n- Modèles Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)${forcedModeMsg}`
             };
         }
         else {

package/dist/server/index.js

@@ -145,12 +145,39 @@ process.on('exit', (code) => {
     }
     catch (e) { }
 });
-server.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`);
+// 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 });
+                }
+            }
+        }
+        catch (e) {
+            console.error('Pollinations Plugin: Startup Check Failed:', e);
+        }
     }
-    catch (e) { }
-    console.log(`POLLINATIONS_V3_URL=${url}`);
-});
+    server.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}`);
+    });
+})();

package/dist/server/proxy.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { loadConfig } from './config.js';
+import { loadConfig, saveConfig } from './config.js';
 import { handleCommand } from './commands.js';
 import { emitStatusToast, emitLogToast } from './toast.js';
 // --- PERSISTENCE: SIGNATURE MAP (Multi-Round Support) ---
@@ -258,11 +258,22 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             }
         }
         // B. SAFETY NETS (The Core V5 Logic)
+        // 0. GLOBAL CHECK: Auth Limited (403 on Quota)
+        // If we can't read quota because of 403, we MUST STOP and force manual.
+        if (isEnterprise && quota.errorType === 'auth_limited') {
+            log(`[SafetyNet] CRITICAL: Limited Key Detected (403). Enforcing Manual Mode.`);
+            saveConfig({ mode: 'manual', keyHasAccessToProfile: false });
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: "Clé Limitée - Accès Profil Refusé",
+                message: "Votre clé ne permet pas le suivi des quotas via /account/profile.\nLe mode automatique est désactivé.\nVeuillez passer en mode Manual ou utiliser une clé complète.",
+                code: "AUTH_LIMITED"
+            }));
+            return;
+        }
         if (config.mode === 'alwaysfree') {
             if (isEnterprise) {
                 // NEW: Paid Only Check for Always Free
-                // If the user asks for a 💎 Paid Only model while in Always Free, we BLOCK it to save wallet
-                // and fallback to free specific message.
                 try {
                     const homedir = process.env.HOME || '/tmp';
                     const standardPaidPath = path.join(homedir, '.pollinations', 'pollinations-paid-models.json');
@@ -279,6 +290,7 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 }
                 catch (e) { }
                 if (!isFallbackActive && quota.tier === 'error') {
+                    // Network error or unknown error (but NOT auth_limited, handled above)
                     log(`[SafetyNet] AlwaysFree Mode: Quota Check Failed. Switching to Free Fallback.`);
                     actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
@@ -300,6 +312,7 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         else if (config.mode === 'pro') {
             if (isEnterprise) {
                 if (quota.tier === 'error') {
+                    // Network error or unknown
                     log(`[SafetyNet] Pro Mode: Quota Unreachable. Switching to Free Fallback.`);
                     actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
@@ -308,11 +321,6 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 }
                 else {
                     const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
-                    // Logic: Fallback if Wallet is Low (< Threshold) AND Tier is Exhausted (< Threshold %)
-                    // Wait, user wants priority to Free Tier.
-                    // If Free Tier is available (Ratio > Threshold), we usage it (don't fallback).
-                    // If Free Tier is exhausted (Ratio <= Threshold), THEN check Wallet.
-                    // If Wallet also Low, THEN Fallback.
                     if (quota.walletBalance < config.thresholds.wallet && tierRatio <= (config.thresholds.tier / 100)) {
                         log(`[SafetyNet] Pro Mode: Wallet < $${config.thresholds.wallet} AND Tier < ${config.thresholds.tier}%. Switching.`);
                         actualModel = config.fallbacks.free.main.replace('free/', '');

package/dist/server/quota.d.ts

@@ -10,6 +10,7 @@ export interface QuotaStatus {
     needsAlert: boolean;
     tier: string;
     tierEmoji: string;
+    errorType?: 'auth_limited' | 'network' | 'unknown';
 }
 export declare function getQuotaStatus(forceRefresh?: boolean): Promise<QuotaStatus>;
 export declare function formatQuotaForToast(quota: QuotaStatus): string;

package/dist/server/quota.js

@@ -44,12 +44,11 @@ export async function getQuotaStatus(forceRefresh = false) {
     }
     try {
         logQuota("Fetching Quota Data...");
-        // Fetch parallèle using HTTPS helper
-        const [profileRes, balanceRes, usageRes] = await Promise.all([
-            fetchAPI('/account/profile', config.apiKey),
-            fetchAPI('/account/balance', config.apiKey),
-            fetchAPI('/account/usage', config.apiKey)
-        ]);
+        // SEQUENTIAL FETCH (Avoid Rate Limits)
+        // We fetch one by one. If one fails, we catch and return fallback.
+        const profileRes = await fetchAPI('/account/profile', config.apiKey);
+        const balanceRes = await fetchAPI('/account/balance', config.apiKey);
+        const usageRes = await fetchAPI('/account/usage', config.apiKey);
         logQuota(`Fetch Success. Tier: ${profileRes.tier}, Balance: ${balanceRes.balance}`);
         const profile = profileRes;
         const balance = balanceRes.balance;
@@ -83,7 +82,14 @@ export async function getQuotaStatus(forceRefresh = false) {
         return cachedQuota;
     }
     catch (e) {
-        logQuota(`ERROR fetching quota: ${e}`);
+        logQuota(`ERROR fetching quota: ${e.message}`);
+        let errorType = 'unknown';
+        if (e.message && e.message.includes('403')) {
+            errorType = 'auth_limited';
+        }
+        else if (e.message && e.message.includes('Network Error')) {
+            errorType = 'network';
+        }
         // Retourner le cache ou un état par défaut safe
         return cachedQuota || {
             tierRemaining: 0,
@@ -96,7 +102,8 @@ export async function getQuotaStatus(forceRefresh = false) {
             isUsingWallet: false,
             needsAlert: true,
             tier: 'error',
-            tierEmoji: '⚠️'
+            tierEmoji: '⚠️',
+            errorType
         };
     }
 }
@@ -198,6 +205,9 @@ function calculateCurrentPeriodUsage(usage, resetInfo) {
 }
 // === EXPORT POUR LES ALERTES ===
 export function formatQuotaForToast(quota) {
+    if (quota.errorType === 'auth_limited') {
+        return `🔑 CLE LIMITÉE (Génération Seule) | 💎 Wallet: N/A | ⏰ Reset: N/A`;
+    }
     const tierPercent = quota.tierLimit > 0
         ? Math.round((quota.tierRemaining / quota.tierLimit) * 100)
         : 0;

package/dist/test-require.js

@@ -0,0 +1,9 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+try {
+    const pkg = require('../package.json');
+    console.log("SUCCESS: Loaded version " + pkg.version);
+} catch (e) {
+    console.error("FAILURE:", e.message);
+    process.exit(1);
+}

package/package.json

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