opencode-pollinations-plugin 5.3.0 → 5.3.1

package/dist/index.js

@@ -1,5 +1,6 @@
 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';
@@ -14,37 +15,55 @@ function log(msg) {
     catch (e) { }
 }
 const TRACKING_PORT = 10001;
-// === 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);
+// === PORT MANAGEMENT (CROSS-PLATFORM) ===
+// We MUST kill the previous instance to ensure a fresh state.
+// Sticky ports = Zombies = Buggy Behavior.
+const freePort = (port) => {
+    try {
+        if (process.platform === 'win32') {
+            // Windows: Find PID -> TaskKing
+            try {
+                const output = execSync(`netstat -ano | findstr :${port}`).toString();
+                const lines = output.trim().split('\n');
+                for (const line of lines) {
+                    const parts = line.trim().split(/\s+/);
+                    const pid = parts[parts.length - 1];
+                    if (pid && /^\d+$/.test(pid) && pid !== '0') {
+                        try {
+                            execSync(`taskkill /PID ${pid} /F`);
+                            log(`[Init] Killed Windows PID ${pid} on port ${port}`);
+                        }
+                        catch (e) { }
+                    }
                 }
-                else {
-                    log(`[Init] Port ${port} still busy. Assuming persistent instance.`);
-                    resolve(); // Resolve anyway, assuming existing instance will handle requests
+            }
+            catch (e) { }
+        }
+        else {
+            // Linux / macOS: lsof or fuser
+            try {
+                // Try lsof first (Cleaner)
+                const pid = execSync(`lsof -t -i:${port}`).toString().trim();
+                if (pid) {
+                    execSync(`kill -9 ${pid}`);
+                    log(`[Init] Killed PID ${pid} via lsof`);
                 }
             }
-            else {
-                reject(err);
+            catch (e) {
+                // Fallback to fuser (Linux specific but very effective)
+                if (process.platform === 'linux') {
+                    try {
+                        execSync(`fuser -k ${port}/tcp`);
+                        log(`[Init] Cleaned port ${port} via fuser`);
+                    }
+                    catch (e2) { }
+                }
             }
-        });
-        server.once('listening', () => {
-            log(`[Init] Proxy successfully bound to port ${port}`);
-            resolve();
-        });
-        server.listen(port, '127.0.0.1');
-    });
+        }
+    }
+    catch (e) {
+        // Ignored: Port likely already free
+    }
 };
 // === GESTION DU CYCLE DE VIE PROXY ===
 const startProxy = () => {
@@ -94,12 +113,17 @@ const startProxy = () => {
         });
         // Robust Startup Logic
         try {
-            await tryListen(server, TRACKING_PORT, 3);
-            resolve(TRACKING_PORT);
+            server.listen(TRACKING_PORT, '127.0.0.1', () => {
+                log(`[Proxy] Started V5.3.1 on port ${TRACKING_PORT}`);
+                resolve(TRACKING_PORT);
+            });
+            server.on('error', (e) => {
+                log(`[Proxy] Fatal Bind Error: ${e}`);
+                resolve(0);
+            });
         }
         catch (e) {
-            log(`[Proxy] Fatal Bind Error: ${e}`);
-            resolve(0); // Should handle gracefully upper in stack
+            resolve(0);
         }
     });
 };
@@ -107,6 +131,9 @@ const startProxy = () => {
 export const PollinationsPlugin = async (ctx) => {
     log("Plugin Initializing V5.2.0 (Stable)...");
     // START PROXY
+    // 1. Force Clean Port
+    freePort(TRACKING_PORT);
+    // 2. Start
     const port = await startProxy();
     const localBaseUrl = `http://127.0.0.1:${port}/v1`;
     setGlobalClient(ctx.client);

package/package.json

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