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

package/dist/server/config.d.ts

@@ -1,6 +1,9 @@
-export interface PollinationsConfigV6 {
+export declare function getConfigDir(): string;
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+export interface PollinationsConfigV5 {
     version: string | number;
-    mode: 'manual' | 'economy' | 'pro';
+    mode: 'manual' | 'alwaysfree' | 'pro';
     apiKey?: string;
     keyHasAccessToProfile?: boolean;
     gui: {
@@ -9,24 +12,28 @@ export interface PollinationsConfigV6 {
     };
     thresholds: {
         tier: number;
-        wallet_warn: number;
-        wallet_stop: number;
+        wallet: number;
     };
     fallbacks: {
-        economy: string;
-        pro: string;
-    };
-    session: {
-        wallet_initial?: number;
-        session_start?: string;
+        free: {
+            main: string;
+            agent: string;
+        };
+        enter: {
+            agent: string;
+        };
     };
     enablePaidTools: boolean;
+    costThreshold: number;
+    costConfirmationRequired: boolean;
     statusBar: boolean;
+    costEstimator: boolean;
+    lang?: string;
 }
-export declare function loadConfig(): PollinationsConfigV6;
-export declare function saveConfig(updates: Partial<PollinationsConfigV6>): {
+export declare function loadConfig(): PollinationsConfigV5;
+export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
     version: string;
-    mode: "manual" | "economy" | "pro";
+    mode: "manual" | "alwaysfree" | "pro";
     apiKey?: string;
     keyHasAccessToProfile?: boolean;
     gui: {
@@ -35,19 +42,23 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV6>): {
     };
     thresholds: {
         tier: number;
-        wallet_warn: number;
-        wallet_stop: number;
+        wallet: number;
     };
     fallbacks: {
-        economy: string;
-        pro: string;
-    };
-    session: {
-        wallet_initial?: number;
-        session_start?: string;
+        free: {
+            main: string;
+            agent: string;
+        };
+        enter: {
+            agent: string;
+        };
     };
     enablePaidTools: boolean;
+    costThreshold: number;
+    costConfirmationRequired: boolean;
     statusBar: boolean;
+    costEstimator: boolean;
+    lang?: string;
 };
-export declare function initSessionWallet(walletBalance: number): void;
-export declare function getWalletWarnPercent(): number;
+export declare function saveKeyToAuthJson(key: string): boolean;
+export declare function migrateLegacyConfig(): void;

package/dist/server/config.js

@@ -2,14 +2,61 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 // PATHS
+// PATHS & CROSS-PLATFORM LOGIC
+export function getConfigDir() {
+    switch (process.platform) {
+        case 'win32':
+            return path.join(process.env.APPDATA || os.homedir(), 'pollinations');
+        case 'darwin':
+            return path.join(os.homedir(), 'Library', 'Application Support', 'pollinations');
+        default:
+            return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'pollinations');
+    }
+}
+export const CONFIG_DIR = getConfigDir();
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// Legacy/External Paths (OpenCode specific)
 const HOMEDIR = os.homedir();
-const CONFIG_DIR_POLLI = path.join(HOMEDIR, '.pollinations');
-const CONFIG_FILE = path.join(CONFIG_DIR_POLLI, 'config.json');
-const CONFIG_DIR_OPENCODE = path.join(HOMEDIR, '.config', 'opencode');
-const OPENCODE_CONFIG_FILE = path.join(CONFIG_DIR_OPENCODE, 'opencode.json');
-const AUTH_FILE = path.join(HOMEDIR, '.local', 'share', 'opencode', 'auth.json');
+// Multi-OS Candidate Paths for Auth & Global Config
+function getExternalConfigPaths() {
+    const candidatesAuth = [];
+    const candidatesConfig = [];
+    // 0. OpenCode Environment Variables (Highest Priority)
+    if (process.env.OPENCODE_CONFIG) {
+        // Direct config file path
+        candidatesConfig.push(process.env.OPENCODE_CONFIG);
+    }
+    if (process.env.OPENCODE_CONFIG_DIR) {
+        // Config directory override
+        candidatesConfig.push(path.join(process.env.OPENCODE_CONFIG_DIR, 'opencode.json'));
+        candidatesConfig.push(path.join(process.env.OPENCODE_CONFIG_DIR, 'config.json'));
+        candidatesAuth.push(path.join(process.env.OPENCODE_CONFIG_DIR, 'auth.json'));
+    }
+    // Also check standard env vars often used in overrides
+    if (process.env.OPENCODE_AUTH)
+        candidatesAuth.push(process.env.OPENCODE_AUTH);
+    // 1. Linux Standard (Current)
+    // ... rest of function ...
+    candidatesAuth.push(path.join(HOMEDIR, '.local', 'share', 'opencode', 'auth.json'));
+    candidatesConfig.push(path.join(HOMEDIR, '.config', 'opencode', 'opencode.json'));
+    // 2. Windows Standard (%APPDATA%)
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(HOMEDIR, 'AppData', 'Roaming');
+        candidatesAuth.push(path.join(appData, 'opencode', 'auth.json'));
+        candidatesAuth.push(path.join(appData, 'OpenCode', 'auth.json'));
+        candidatesConfig.push(path.join(appData, 'opencode', 'config.json'));
+    }
+    // 3. Mac Standard
+    if (process.platform === 'darwin') {
+        const support = path.join(HOMEDIR, 'Library', 'Application Support', 'OpenCode');
+        candidatesAuth.push(path.join(support, 'auth.json'));
+        candidatesConfig.push(path.join(support, 'config.json'));
+    }
+    return { auth: candidatesAuth, config: candidatesConfig };
+}
+const EXTERNAL_PATHS = getExternalConfigPaths();
 // LOAD PACKAGE VERSION
-let PKG_VERSION = '6.1.0';
+let PKG_VERSION = '5.2.0';
 try {
     const pkgPath = path.join(__dirname, '../../package.json');
     if (fs.existsSync(pkgPath)) {
@@ -17,118 +64,113 @@ try {
         PKG_VERSION = pkg.version;
     }
 }
-catch (e) { }
-const DEFAULT_CONFIG_V6 = {
+catch (e) {
+    logSystem(`[Config] Error loading package version: ${e}`);
+}
+const DEFAULT_CONFIG_V5 = {
     version: PKG_VERSION,
-    mode: 'economy', // Défaut: economy (protège le wallet)
+    mode: 'manual',
     gui: { status: 'alert', logs: 'none' },
-    thresholds: {
-        tier: 20, // 20% tier restant → alerte/fallback
-        wallet_warn: 20, // 20% wallet restant → alerte (pro)
-        wallet_stop: 0.50 // $0.50 → stop absolu (pro)
-    },
+    thresholds: { tier: 10, wallet: 5 },
     fallbacks: {
-        economy: 'nova-fast',
-        pro: 'qwen-coder'
+        free: { main: 'free/mistral', agent: 'free/openai-fast' },
+        enter: { agent: 'free/openai-fast' }
     },
-    session: {},
     enablePaidTools: false,
-    keyHasAccessToProfile: true,
-    statusBar: true
+    costThreshold: 0.15, // Default 0.15 🌻
+    costConfirmationRequired: true, // Ask confirmation when cost exceeds threshold
+    keyHasAccessToProfile: true, // Default true for legacy keys
+    statusBar: true,
+    costEstimator: true, // Show cost estimates by default
+    lang: 'en', // Default language is English
 };
+import { log as logSystem } from './logger.js';
 function logConfig(msg) {
-    try {
-        if (!fs.existsSync('/tmp/opencode_pollinations_config_debug.log')) {
-            fs.writeFileSync('/tmp/opencode_pollinations_config_debug.log', '');
-        }
-        fs.appendFileSync('/tmp/opencode_pollinations_config_debug.log', `[${new Date().toISOString()}] ${msg}\n`);
-    }
-    catch (e) { }
-}
-// MIGRATION: alwaysfree → economy
-function migrateConfig(config) {
-    if (config.mode === 'alwaysfree') {
-        config.mode = 'economy';
-        logConfig('[Migration] alwaysfree → economy');
-    }
-    // Migrate old fallbacks structure
-    if (config.fallbacks?.free?.main) {
-        if (!config.fallbacks)
-            config.fallbacks = {};
-        config.fallbacks.economy = config.fallbacks.free.main.replace('free/', '');
-        delete config.fallbacks.free;
-        logConfig('[Migration] fallbacks.free → fallbacks.economy');
-    }
-    // Remove obsolete 'enter' fallback
-    if (config.fallbacks?.enter) {
-        delete config.fallbacks.enter;
-        logConfig('[Migration] Removed obsolete fallbacks.enter');
-    }
-    // Migrate old wallet threshold
-    if (config.thresholds?.wallet) {
-        if (!config.thresholds.wallet_warn) {
-            config.thresholds.wallet_warn = config.thresholds.wallet;
-        }
-        delete config.thresholds.wallet;
-        logConfig('[Migration] thresholds.wallet → thresholds.wallet_warn');
-    }
-    return config;
+    logSystem(`[Config] ${msg}`);
 }
 // SIMPLE LOAD (Direct Disk Read - No Caching, No Watchers)
+// This ensures the Proxy ALWAYS sees the latest state from auth.json
 export function loadConfig() {
     return readConfigFromDisk();
 }
 function readConfigFromDisk() {
-    let config = { ...DEFAULT_CONFIG_V6 };
+    let config = { ...DEFAULT_CONFIG_V5 };
     let finalKey = undefined;
     let source = 'none';
+    // TIMESTAMP BASED PRIORITY LOGIC
+    // We want the most recently updated Valid Key to win.
     let configTime = 0;
     let authTime = 0;
     try {
         if (fs.existsSync(CONFIG_FILE))
             configTime = fs.statSync(CONFIG_FILE).mtime.getTime();
     }
-    catch (e) { }
+    catch (e) {
+        logSystem(`[Config] Error stat config: ${e}`);
+    }
+    try {
+        if (fs.existsSync(CONFIG_FILE))
+            configTime = fs.statSync(CONFIG_FILE).mtime.getTime();
+    }
+    catch (e) {
+        logSystem(`[Config] Error stat config: ${e}`);
+    }
     try {
-        if (fs.existsSync(AUTH_FILE))
-            authTime = fs.statSync(AUTH_FILE).mtime.getTime();
+        for (const f of EXTERNAL_PATHS.auth) {
+            if (fs.existsSync(f)) {
+                authTime = Math.max(authTime, fs.statSync(f).mtime.getTime());
+            }
+        }
+    }
+    catch (e) {
+        logSystem(`[Config] Error stat auth candidates: ${e}`);
     }
-    catch (e) { }
+    // 1. EXTRACT KEYS
     // 1. EXTRACT KEYS
     let configKey = undefined;
     if (fs.existsSync(CONFIG_FILE)) {
         try {
             const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
             const custom = JSON.parse(raw);
-            const migrated = migrateConfig(custom);
-            // DEEP MERGE for nested objects to preserve defaults vs overrides
-            config = {
-                ...config,
-                ...migrated,
-                thresholds: { ...config.thresholds, ...(migrated.thresholds || {}) },
-                fallbacks: { ...config.fallbacks, ...(migrated.fallbacks || {}) },
-                gui: { ...config.gui, ...(migrated.gui || {}) }
-            };
+            config = { ...config, ...custom }; // Helper: We load the rest of config anyway
             if (custom.apiKey && custom.apiKey.length > 5)
                 configKey = custom.apiKey;
         }
-        catch (e) { }
+        catch (e) {
+            logConfig(`ERROR reading config.json: ${e}`);
+            // Backup corrupt file to avoid overwrite loop
+            try {
+                fs.copyFileSync(CONFIG_FILE, CONFIG_FILE + '.corrupt');
+            }
+            catch (e) {
+                logSystem(`[Config] Error copying corrupt config: ${e}`);
+            }
+        }
     }
     let authKey = undefined;
-    if (fs.existsSync(AUTH_FILE)) {
-        try {
-            const raw = fs.readFileSync(AUTH_FILE, 'utf-8');
-            const authData = JSON.parse(raw);
-            const entry = authData['pollinations'] || authData['pollinations_enter'] || authData['pollinations_api_key'];
-            if (entry) {
-                const k = (typeof entry === 'object' && entry.key) ? entry.key : entry;
-                if (k && typeof k === 'string' && k.length > 10)
-                    authKey = k;
+    // Check all auth candidates
+    for (const authFile of EXTERNAL_PATHS.auth) {
+        if (fs.existsSync(authFile)) {
+            try {
+                authTime = Math.max(authTime, fs.statSync(authFile).mtime.getTime()); // Track newest
+                const raw = fs.readFileSync(authFile, 'utf-8');
+                const authData = JSON.parse(raw);
+                const entry = authData['pollinations'] || authData['pollinations_enter'] || authData['pollinations_api_key'];
+                if (entry) {
+                    const k = (typeof entry === 'object' && entry.key) ? entry.key : entry;
+                    if (k && typeof k === 'string' && k.length > 10) {
+                        authKey = k;
+                        break; // Found a key, stop looking (priority to first found? or newest? First in list is Linux default so ok)
+                    }
+                }
+            }
+            catch (e) {
+                logConfig(`ERROR reading auth candidate ${authFile}: ${e}`);
             }
         }
-        catch (e) { }
     }
     // 2. DETERMINE WINNER
+    // If both exist, newest wins. If one exists, it wins.
     if (configKey && authKey) {
         if (configTime >= authTime) {
             finalKey = configKey;
@@ -150,25 +192,37 @@ function readConfigFromDisk() {
     // 3. Fallback to OpenCode Global Config (Lowest Priority)
     if (!finalKey) {
         try {
-            if (fs.existsSync(OPENCODE_CONFIG_FILE)) {
-                const raw = fs.readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
-                const data = JSON.parse(raw);
-                const nativeKey = data?.provider?.pollinations?.options?.apiKey ||
-                    data?.provider?.pollinations_enter?.options?.apiKey;
-                if (nativeKey && nativeKey.length > 5 && nativeKey !== 'dummy') {
-                    finalKey = nativeKey;
-                    source = 'opencode.json';
+            for (const configFile of EXTERNAL_PATHS.config) {
+                if (fs.existsSync(configFile)) {
+                    const raw = fs.readFileSync(configFile, 'utf-8');
+                    const data = JSON.parse(raw);
+                    const nativeKey = data?.provider?.pollinations?.options?.apiKey ||
+                        data?.provider?.pollinations_enter?.options?.apiKey;
+                    if (nativeKey && nativeKey.length > 5 && nativeKey !== 'dummy') {
+                        finalKey = nativeKey;
+                        source = 'opencode_global';
+                        break;
+                    }
                 }
             }
         }
-        catch (e) { }
+        catch (e) {
+            logSystem(`[Config] Error reading global override config: ${e}`);
+        }
     }
     // 4. APPLY
     if (finalKey) {
         config.apiKey = finalKey;
+        // config.mode = 'pro'; // REMOVED: Mode is decoupled from Key presence.
     }
     else {
+        // Ensure no phantom key remains
         delete config.apiKey;
+        // if (config.mode === 'pro') config.mode = 'manual'; // OPTIONAL: Downgrade if no key? User says "No link".
+        // Actually, if I am in PRO mode and lose my key, I am broken. Falling back to manual is safer?
+        // User said "Manual mode is like standard API".
+        // Let's REMOVE this auto-downgrade too to be strictly "Decoupled".
+        // If user is in PRO without key, they get "Missing Key" error, which is correct.
     }
     return { ...config, version: PKG_VERSION };
 }
@@ -176,11 +230,10 @@ export function saveConfig(updates) {
     try {
         const current = readConfigFromDisk();
         const updated = { ...current, ...updates, version: PKG_VERSION };
-        if (!fs.existsSync(CONFIG_DIR_POLLI)) {
-            fs.mkdirSync(CONFIG_DIR_POLLI, { recursive: true });
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
         }
         fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
-        logConfig(`[SaveConfig] Updated: ${Object.keys(updates).join(', ')}`);
         return updated;
     }
     catch (e) {
@@ -188,23 +241,62 @@ export function saveConfig(updates) {
         throw e;
     }
 }
-// SESSION WALLET TRACKING
-export function initSessionWallet(walletBalance) {
-    const config = loadConfig();
-    if (!config.session.wallet_initial) {
-        saveConfig({
-            session: {
-                wallet_initial: walletBalance,
-                session_start: new Date().toISOString()
+// === NATIVE AUTH SYNC ===
+export function saveKeyToAuthJson(key) {
+    let success = false;
+    for (const authFile of EXTERNAL_PATHS.auth) {
+        try {
+            let authData = {};
+            if (fs.existsSync(authFile)) {
+                authData = JSON.parse(fs.readFileSync(authFile, 'utf-8'));
+            }
+            else {
+                // Ensure directory exists if we create a new auth.json
+                fs.mkdirSync(path.dirname(authFile), { recursive: true });
             }
-        });
-        logConfig(`[Session] Wallet initial stocké: $${walletBalance}`);
+            // Set the key (OpenCode standard struct)
+            authData['pollinations'] = {
+                type: "api",
+                key: key
+            };
+            fs.writeFileSync(authFile, JSON.stringify(authData, null, 2), 'utf-8');
+            logConfig(`Synchronized API key to native auth file: ${authFile}`);
+            success = true;
+            // Only write to the first valid one we find/create, or write to all existing?
+            // Usually writing to all existing ones is safest to avoid desync
+        }
+        catch (e) {
+            logConfig(`Failed to sync to auth file ${authFile}: ${e}`);
+        }
     }
+    return success;
 }
-export function getWalletWarnPercent() {
-    const config = loadConfig();
-    const initial = config.session.wallet_initial;
-    if (!initial || initial <= 0)
-        return 100; // No reference = no warning
-    return config.thresholds.wallet_warn;
+// === MIGRATION UTIL ===
+export function migrateLegacyConfig() {
+    try {
+        const legacyDir = path.join(os.homedir(), '.pollinations');
+        const newDir = getConfigDir();
+        if (fs.existsSync(legacyDir) && legacyDir !== newDir) {
+            logConfig(`Migrating legacy config from ${legacyDir} to ${newDir}`);
+            if (!fs.existsSync(newDir))
+                fs.mkdirSync(newDir, { recursive: true });
+            const files = fs.readdirSync(legacyDir);
+            for (const file of files) {
+                const srcPath = path.join(legacyDir, file);
+                const destPath = path.join(newDir, file);
+                // Don't overwrite existing new files (priority to new system)
+                if (!fs.existsSync(destPath)) {
+                    // Check if it's a file
+                    if (fs.statSync(srcPath).isFile()) {
+                        fs.copyFileSync(srcPath, destPath); // Copy first
+                        // fs.unlinkSync(srcPath); // Optional: Delete old? Let's keep for safety for now.
+                        logConfig(`Migrated: ${file}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        logConfig(`Migration Error: ${e}`);
+    }
 }

package/dist/server/connect-response.d.ts

@@ -0,0 +1,2 @@
+import { PollinationsConfigV5 } from './config.js';
+export declare function buildConnectResponse(config: PollinationsConfigV5): Promise<string>;

package/dist/server/connect-response.js

@@ -0,0 +1,59 @@
+import { t } from '../locales/index.js';
+export async function buildConnectResponse(config) {
+    const hasKey = !!config.apiKey;
+    const mode = config.mode;
+    let name = "Developer";
+    let tier = "anonymous";
+    if (hasKey) {
+        try {
+            const res = await fetch('https://gen.pollinations.ai/account/profile', {
+                headers: { 'Authorization': `Bearer ${config.apiKey}` }
+            });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.name)
+                    name = data.name;
+                tier = data.tier || "anonymous";
+            }
+        }
+        catch (e) {
+            // Ignorer l'erreur réseau et garder les valeurs par défaut
+        }
+    }
+    const emojis = {
+        microbe: '🦠', spore: '🍄', seed: '🌱', flower: '🌸', nectar: '🍯', anonymous: '👤'
+    };
+    const tierEmoji = emojis[tier] || '❓';
+    if (hasKey) {
+        return `${t('connect_response.title_key', { name, mode })}
+
+> **Your Tiers:** ${tierEmoji} ${tier.toUpperCase()}
+
+---
+
+${t('connect_response.tools_intro')}
+
+---
+
+${t('connect_response.terminal_cmds')}
+---
+
+${t('connect_response.resources')}`;
+    }
+    let freeModelsText = `Modèles gratuits disponibles : \`openai-fast\`, \`gemini-fast\`, \`mistral\`, \`qwen-coder\`, \`nova-fast\``;
+    try {
+        const freeRes = await fetch('https://text.pollinations.ai/models', { signal: AbortSignal.timeout(4000) });
+        if (freeRes.ok) {
+            const freeData = await freeRes.json();
+            const modelsList = freeData.slice(0, 15).map((m) => `\`${m.name}\``).join(', ');
+            freeModelsText = t('connect_response.free_models_success', { models: modelsList });
+        }
+        else {
+            freeModelsText = t('connect_response.free_models_error');
+        }
+    }
+    catch (e) {
+        freeModelsText = t('connect_response.free_models_error');
+    }
+    return t('connect_response.onboarding', { freeText: freeModelsText });
+}

package/dist/server/generate-config.d.ts

@@ -1,34 +1,8 @@
-/**
- * generate-config.ts - v6.0 Simplified
- *
- * Single endpoint: gen.pollinations.ai/text/models
- * No more Free tier, no cache ETag, no prefixes
- */
-export interface PollinationsModel {
-    name: string;
-    description?: string;
-    type?: string;
-    tools?: boolean;
-    reasoning?: boolean;
-    context?: number;
-    context_window?: number;
-    input_modalities?: string[];
-    output_modalities?: string[];
-    paid_only?: boolean;
-    vision?: boolean;
-    audio?: boolean;
-    pricing?: {
-        promptTextTokens?: number;
-        completionTextTokens?: number;
-        promptImageTokens?: number;
-        promptAudioTokens?: number;
-        completionAudioTokens?: number;
-    };
-    [key: string]: any;
-}
 interface OpenCodeModel {
     id: string;
     name: string;
+    object: string;
+    variants?: any;
     options?: any;
     limit?: {
         context?: number;
@@ -38,7 +12,6 @@ interface OpenCodeModel {
         input?: string[];
         output?: string[];
     };
-    tool_call?: boolean;
 }
-export declare function generatePollinationsConfig(forceApiKey?: string): Promise<OpenCodeModel[]>;
+export declare function generatePollinationsConfig(forceApiKey?: string, forceStrict?: boolean): Promise<OpenCodeModel[]>;
 export {};