opencode-pollinations-plugin 5.2.3 → 5.3.0

package/dist/index.js

@@ -1,6 +1,5 @@
 import * as http from 'http';
 import * as fs from 'fs';
-import { execSync } from 'child_process';
 import { generatePollinationsConfig } from './server/generate-config.js';
 import { loadConfig } from './server/config.js';
 import { handleChatCompletion } from './server/proxy.js';
@@ -15,19 +14,43 @@ function log(msg) {
     catch (e) { }
 }
 const TRACKING_PORT = 10001;
-// === ANTI-ZOMBIE ATOMIC CLEANUP ===
-try {
-    log(`[Init] Checking port ${TRACKING_PORT} for zombies...`);
-    execSync(`fuser -k ${TRACKING_PORT}/tcp || true`);
-    log(`[Init] Port ${TRACKING_PORT} cleaned.`);
-}
-catch (e) {
-    log(`[Init] Zombie cleanup warning: ${e}`);
-}
+// === ANTI-ZOMBIE / PORT MANAGMENT (CROSS-PLATFORM) ===
+// Instead of killing specific PIDs (which requires OS-specific commands like fuser/taskkill),
+// we use a "Try to Listen" approach. If the port is busy, we assume it's a previous instance
+// of ourselves (or another plugin instance) and we try to reuse it or fail gracefully.
+// This works on Windows, Linux, and macOS without external dependencies.
+const tryListen = (server, port, retries = 3) => {
+    return new Promise((resolve, reject) => {
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                if (retries > 0) {
+                    log(`[Init] Port ${port} busy. Retrying in 500ms... (${retries} left)`);
+                    setTimeout(() => {
+                        server.close();
+                        server.listen(port, '127.0.0.1'); // Retry listen
+                    }, 500);
+                }
+                else {
+                    log(`[Init] Port ${port} still busy. Assuming persistent instance.`);
+                    resolve(); // Resolve anyway, assuming existing instance will handle requests
+                }
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.once('listening', () => {
+            log(`[Init] Proxy successfully bound to port ${port}`);
+            resolve();
+        });
+        server.listen(port, '127.0.0.1');
+    });
+};
 // === GESTION DU CYCLE DE VIE PROXY ===
 const startProxy = () => {
-    return new Promise((resolve) => {
+    return new Promise(async (resolve) => {
         const server = http.createServer(async (req, res) => {
+            // ... (Request Handling - Unchanged) ...
             log(`[Proxy] Request: ${req.method} ${req.url}`);
             res.setHeader('Access-Control-Allow-Origin', '*');
             res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
@@ -42,7 +65,7 @@ const startProxy = () => {
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
                     status: "ok",
-                    version: "v5.2.0",
+                    version: "v5.3.0",
                     mode: config.mode
                 }));
                 return;
@@ -69,14 +92,15 @@ const startProxy = () => {
             res.writeHead(404);
             res.end("Not Found");
         });
-        server.listen(TRACKING_PORT, '127.0.0.1', () => {
-            log(`[Proxy] Started V5.2 on port ${TRACKING_PORT}`);
+        // Robust Startup Logic
+        try {
+            await tryListen(server, TRACKING_PORT, 3);
             resolve(TRACKING_PORT);
-        });
-        server.on('error', (e) => {
-            log(`[Proxy] Fatal Error: ${e}`);
-            resolve(0);
-        });
+        }
+        catch (e) {
+            log(`[Proxy] Fatal Bind Error: ${e}`);
+            resolve(0); // Should handle gracefully upper in stack
+        }
     });
 };
 // === PLUGIN EXPORT ===

package/dist/server/proxy.js

@@ -249,12 +249,20 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                     isFallbackActive = true;
                     fallbackReason = "Quota Unreachable (Safety)";
                 }
-                else if (quota.walletBalance < config.thresholds.wallet && quota.tierRemaining <= 0.1) { // Tier is loose here, wallet is primary
-                    log(`[SafetyNet] Pro Mode: Wallet Critical (<$${config.thresholds.wallet}). Switching to Free Fallback.`);
-                    actualModel = config.fallbacks.free.main.replace('free/', '');
-                    isEnterprise = false;
-                    isFallbackActive = true;
-                    fallbackReason = `Wallet < $${config.thresholds.wallet}`;
+                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/', '');
+                        isEnterprise = false;
+                        isFallbackActive = true;
+                        fallbackReason = `Wallet & Tier Critical`;
+                    }
                 }
             }
         }

package/package.json

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