opencode-pollinations-plugin 5.1.3

package/dist/server/index.js

@@ -0,0 +1,120 @@
+import * as http from 'http';
+import * as fs from 'fs';
+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');
+// Simple file logger
+function log(msg) {
+    const ts = new Date().toISOString();
+    try {
+        if (!fs.existsSync(path.dirname(LOG_FILE))) {
+            fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+        }
+        fs.appendFileSync(LOG_FILE, `[${ts}] ${msg}\n`);
+    }
+    catch (e) {
+        // silent fail
+    }
+}
+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();
+        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" }));
+                }
+                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) }));
+            }
+        });
+        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));
+        }
+        catch (e) {
+            log(`Error fetching models: ${e}`);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: "Failed to fetch models" }));
+        }
+        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 () => {
+            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");
+});
+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) { }
+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}`);
+    console.log(`POLLINATIONS_V3_URL=${url}`);
+});

package/dist/server/pollinations-api.d.ts

@@ -0,0 +1,48 @@
+interface OpenAIModel {
+    id: string;
+    name: string;
+    object: "model";
+    created: number;
+    owned_by: string;
+    permission: any[];
+    capabilities: {
+        failure?: boolean;
+        completion?: boolean;
+        chat: boolean;
+        tools?: boolean;
+    };
+    context_window?: number;
+    description?: string;
+    modalities?: {
+        input: string[];
+        output: string[];
+    };
+}
+export interface DetailedUsageEntry {
+    timestamp: string;
+    type: string;
+    model: string;
+    api_key: string;
+    api_key_type: string;
+    meter_source: 'tier' | 'pack';
+    input_text_tokens: number;
+    input_cached_tokens: number;
+    input_audio_tokens: number;
+    input_image_tokens: number;
+    output_text_tokens: number;
+    output_reasoning_tokens: number;
+    output_audio_tokens: number;
+    output_image_tokens: number;
+    cost_usd: number;
+    response_time_ms: number;
+}
+export interface DetailedUsageResponse {
+    usage: DetailedUsageEntry[];
+    count: number;
+}
+export declare function getDetailedUsage(apiKey: string): Promise<DetailedUsageResponse | null>;
+export declare function getAggregatedModels(): Promise<{
+    object: string;
+    data: OpenAIModel[];
+}>;
+export {};

package/dist/server/pollinations-api.js

@@ -0,0 +1,147 @@
+import { loadConfig } from './config.js';
+import * as fs from 'fs';
+// Debug Helper
+function logDebug(msg) {
+    try {
+        fs.appendFileSync('/tmp/pollinations-api-debug.log', `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch (e) { }
+}
+const HEADERS = {
+    'User-Agent': 'curl/8.5.0',
+    'Origin': '',
+    'Referer': ''
+};
+function formatName(name, censored) {
+    let clean = name.replace(/^pollinations\//, '').replace(/-/g, ' ');
+    clean = clean.replace(/\b\w/g, l => l.toUpperCase());
+    if (!censored)
+        clean += " (Uncensored)";
+    return clean;
+}
+// Helper to guess context window if not provided by API
+function getContextWindow(id) {
+    const n = id.toLowerCase();
+    if (n.includes('128k') || n.includes('gpt-4') || n.includes('turbo'))
+        return 128000;
+    if (n.includes('gemini') || n.includes('flash') || n.includes('pro'))
+        return 1048576;
+    return 32768; // Default
+}
+// Fetch Free Models (Public API)
+async function fetchFreeModels() {
+    try {
+        logDebug("Fetching Free Models (Dynamic Inspection)...");
+        const response = await fetch('https://text.pollinations.ai/models', { headers: HEADERS });
+        if (!response.ok)
+            throw new Error(`${response.status}`);
+        const data = await response.json();
+        const models = Array.isArray(data) ? data : (data.data || []);
+        // Log sample for verification
+        if (models.length > 0)
+            logDebug(`Sample Free: ${JSON.stringify(models[0])}`);
+        return models
+            .filter((m) => m.tools === true) // FILTER: Tools Only
+            .map((m) => {
+            const id = m.name || m.id;
+            // Use Description if available, else generated name
+            const desc = m.description ? m.description : formatName(id, m.censored);
+            const displayName = `Pollinations Free: ${desc}`;
+            return {
+                id: `pollinations/free/${id}`,
+                name: displayName,
+                object: "model",
+                created: 1700000000,
+                owned_by: "pollinations-free",
+                permission: [],
+                capabilities: { chat: true, completion: true, tools: true },
+                context_window: m.context_window || getContextWindow(id),
+                description: m.description,
+                modalities: { input: ['text'], output: ['text'] } // Improve if 'vision' flag exists in API
+            };
+        });
+    }
+    catch (e) {
+        logDebug(`Error Free: ${e}`);
+        return [];
+    }
+}
+// Fetch Enterprise Models
+async function fetchEnterpriseModels(apiKey) {
+    if (!apiKey || apiKey === 'dummy' || apiKey.length < 5)
+        return [];
+    try {
+        logDebug(`Fetching Enter Models...`);
+        const response = await fetch('https://gen.pollinations.ai/models', {
+            headers: { 'Authorization': `Bearer ${apiKey}` }
+        });
+        if (!response.ok) {
+            logDebug(`Enter API Error: ${response.status}`);
+            return [];
+        }
+        const rawData = await response.json();
+        const rawModels = Array.isArray(rawData) ? rawData : (rawData.data || []);
+        logDebug(`Fetched ${rawModels.length} Enter models.`);
+        if (rawModels.length > 0)
+            logDebug(`Sample Enter: ${JSON.stringify(rawModels[0])}`);
+        return rawModels
+            .filter((m) => {
+            if (typeof m === 'string')
+                return true; // Strings = pass (cant check tools)
+            return m.tools === true; // Objects = check tools
+        })
+            .map((m) => {
+            // Enter models might be strings or objects. 
+            // If string, we can't extract description dynamically -> Fallback formatted name
+            const isObj = typeof m === 'object';
+            const id = isObj ? (m.id || m.name) : m;
+            const desc = (isObj && m.description) ? m.description : formatName(id, true);
+            const displayName = `Pollinations Pro: ${desc}`;
+            return {
+                id: `pollinations/enter/${id}`,
+                name: displayName,
+                object: "model",
+                created: 1700000000,
+                owned_by: "pollinations-enter",
+                permission: [],
+                capabilities: { chat: true, completion: true, tools: true },
+                context_window: (isObj && m.context_window) ? m.context_window : getContextWindow(id),
+                modalities: { input: ['text'], output: ['text'] }
+            };
+        });
+    }
+    catch (e) {
+        logDebug(`Error Enter: ${e}`);
+        return [];
+    }
+}
+export async function getDetailedUsage(apiKey) {
+    if (!apiKey || apiKey.length < 10)
+        return null;
+    try {
+        logDebug("Fetching Detailed Usage...");
+        const response = await fetch('https://gen.pollinations.ai/account/usage', {
+            headers: { 'Authorization': `Bearer ${apiKey}` }
+        });
+        if (!response.ok) {
+            logDebug(`Usage API Error: ${response.status}`);
+            return null;
+        }
+        const data = await response.json();
+        // Handle varying response structures if necessary -> Assuming { usage: [...] }
+        return data;
+    }
+    catch (e) {
+        logDebug(`Error Usage: ${e}`);
+        return null;
+    }
+}
+export async function getAggregatedModels() {
+    const config = loadConfig();
+    const [free, enter] = await Promise.all([
+        fetchFreeModels(),
+        fetchEnterpriseModels(config.apiKey || '')
+    ]);
+    // Merge: Enter first
+    return { object: "list", data: [...enter, ...free] };
+}

package/dist/server/proxy.d.ts

@@ -0,0 +1,2 @@
+import * as http from 'http';
+export declare function handleChatCompletion(req: http.IncomingMessage, res: http.ServerResponse, bodyRaw: string): Promise<void>;