opencode-pollinations-plugin 6.4.5 → 6.4.7

package/dist/server/toast.d.ts

@@ -2,6 +2,7 @@ export declare function setGlobalClient(client: any): void;
 export declare function emitLogToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string): void;
 export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string, metadata?: {
     filePath?: string;
+    freeTool?: boolean;
     params?: Record<string, any>;
 }): void;
 export declare function createToastHooks(client: any): {

package/dist/server/toast.js

@@ -31,9 +31,14 @@ export function emitStatusToast(type, message, title, metadata) {
         finalMessage += `\n📁 ${metadata.filePath}`;
     }
     if (type === 'success' || type === 'error') {
-        // En arrière-plan, essaye de récupérer le quota localement sans bloquer l'appel
+        // Skip quota display for non-polli tools (free tools)
+        if (metadata?.freeTool === true) {
+            dispatchToast('status', type, finalMessage, title || 'Pollinations Status');
+            return;
+        }
+        // En arrière-plan, récupère le quota EN LIVE (pas de cache)
         import('./quota.js').then(({ getQuotaStatus, formatQuotaForToast }) => {
-            getQuotaStatus(false).then(quota => {
+            getQuotaStatus(true).then(quota => {
                 const quotaMsg = formatQuotaForToast
                     ? formatQuotaForToast(quota)
                     : `🌻 Freetier: ${quota.tierRemaining.toFixed(2)}/${quota.tierLimit} | Wallet: $${quota.walletBalance.toFixed(2)}`;

package/dist/tools/index.js

@@ -20,6 +20,10 @@ import { rmbgKeysTool } from './power/rmbg_keys.js';
 import { genEditImageFreeTool } from './pollinations/gen_edit_image_free.js';
 import { genVideoFreeTool } from './pollinations/gen_video_free.js';
 import { polliLoginTool } from './pollinations/polli_login.js';
+// === FREE BONUS: standalone image processing tools (no key, no API, direct calls) ===
+import { objectRemoverTool } from './pollinations/object_remover.js';
+import { imageUpscalerTool } from './pollinations/image_upscaler.js';
+import { imageEnhancerTool } from './pollinations/image_enhancer.js';
 // === ENTER TOOLS (Require API key) ===
 import { polliGenImageTool } from './pollinations/gen_image.js';
 import { polliGenVideoTool } from './pollinations/gen_video.js';
@@ -65,6 +69,10 @@ export function createToolRegistry() {
     tools['gen_video_free'] = genVideoFreeTool;
     // Login tool: device-flow login, callable by any model (no key needed to run)
     tools['polli_login'] = polliLoginTool;
+    // Standalone image processing tools (no key, no API, direct calls from user IP)
+    tools['object_remover'] = objectRemoverTool;
+    tools['image_upscaler'] = imageUpscalerTool;
+    tools['image_enhancer'] = imageEnhancerTool;
     log(`Free tools injected: ${Object.keys(tools).length}`);
     // === ENTER UNIVERSE: Only with valid API key (+6 tools) ===
     if (keyPresent) {

package/dist/tools/pollinations/gen_edit_image_free.js

@@ -99,7 +99,7 @@ export const genEditImageFreeTool = tool({
             }
             if (!apiResp || !apiResp.success || !apiResp.imageUrl) {
                 const reason = apiResp?.error || 'unknown';
-                emitStatusToast('error', t('tools.gen_edit_image_free.failed', { error: String(reason).substring(0, 60) }), '🆓 gen_edit_image_free');
+                emitStatusToast('error', t('tools.gen_edit_image_free.failed', { error: String(reason).substring(0, 60) }), '🆓 gen_edit_image_free', { freeTool: true });
                 return t('tools.gen_edit_image_free.api_error', { error: String(reason) });
             }
             // 3. Download the produced image and save it locally
@@ -133,12 +133,13 @@ export const genEditImageFreeTool = tool({
             }
             lines.push('');
             lines.push(t('tools.gen_edit_image_free.res_note'));
-            emitStatusToast('success', t('tools.gen_edit_image_free.success', { mode }), '🆓 gen_edit_image_free', { filePath });
+            const quotaMsg = after ? ` | ${after.remaining}/${after.max}/j` : '';
+            emitStatusToast('success', t('tools.gen_edit_image_free.success', { mode }) + quotaMsg, '🆓 gen_edit_image_free', { filePath, freeTool: true });
             return lines.join('\n');
         }
         catch (err) {
             const msg = err.message || String(err);
-            emitStatusToast('error', t('tools.gen_edit_image_free.failed', { error: msg.substring(0, 60) }), '🆓 gen_edit_image_free');
+            emitStatusToast('error', t('tools.gen_edit_image_free.failed', { error: msg.substring(0, 60) }), '🆓 gen_edit_image_free', { freeTool: true });
             // Graceful degradation: explicitly point to Pollinations models
             return t('tools.gen_edit_image_free.degraded', { error: msg.substring(0, 150) });
         }

package/dist/tools/pollinations/gen_video_free.js

@@ -234,12 +234,13 @@ export const genVideoFreeTool = tool({
                 lines.push(t('tools.gen_video_free.res_quota', { remaining: after.remaining, max: after.max }));
             lines.push('');
             lines.push(t('tools.gen_video_free.res_note'));
-            emitStatusToast('success', t('tools.gen_video_free.success'), '🆓 gen_video_free', { filePath });
+            const quotaMsg = after ? ` | ${after.remaining}/${after.max}/j` : '';
+            emitStatusToast('success', t('tools.gen_video_free.success') + quotaMsg, '🆓 gen_video_free', { filePath, freeTool: true });
             return lines.join('\n');
         }
         catch (err) {
             const msg = err.message || String(err);
-            emitStatusToast('error', t('tools.gen_video_free.failed', { error: msg.substring(0, 60) }), '🆓 gen_video_free');
+            emitStatusToast('error', t('tools.gen_video_free.failed', { error: msg.substring(0, 60) }), '🆓 gen_video_free', { freeTool: true });
             return t('tools.gen_video_free.degraded', { error: msg.substring(0, 150) });
         }
     },

package/dist/tools/pollinations/image_enhancer.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const imageEnhancerTool: ToolDefinition;

package/dist/tools/pollinations/image_enhancer.js

@@ -0,0 +1,62 @@
+// image_enhancer — Amélioration IA (débruitage, netteté) via imgupscaler.com
+// Standalone : appel direct depuis l'IP utilisateur, pas d'API, pas de clé
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ensureDir, generateFilename, getDefaultOutputDir, formatFileSize, sanitizeFilename, httpsGet, } from './shared.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+import { processTool } from './imgtools/clients.js';
+export const imageEnhancerTool = tool({
+    description: `Améliore la qualité d'une image : réduction du bruit, netteté, restauration des détails (gratuit, appel direct).
+Résolutions : 1K (1024px), 2K (2048px), 4K (4096px). Défaut : 2K.
+Temps de traitement : 30-120s. Pas de clé requise.`,
+    args: {
+        file: tool.schema.string().describe('Chemin local de l\'image à améliorer'),
+        target_longest_side: tool.schema.enum(['1024', '2048', '4096']).optional().describe('Résolution cible (1K=1024, 2K=2048, 4K=4096). Défaut: 2048'),
+        save_to: tool.schema.string().optional().describe('Dossier de sortie'),
+        filename: tool.schema.string().optional().describe('Nom du fichier de sortie (sans extension)'),
+    },
+    async execute(args, context) {
+        const imagePath = args.file;
+        if (!fs.existsSync(imagePath)) {
+            return t('tools.image_enhancer.file_not_found', { path: imagePath }) || `❌ Fichier introuvable : ${imagePath}`;
+        }
+        const ext = path.extname(imagePath).toLowerCase();
+        const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
+        const imageData = fs.readFileSync(imagePath);
+        const targetLongestSide = parseInt(args.target_longest_side || '2048');
+        const resLabel = targetLongestSide >= 4096 ? '4K' : targetLongestSide >= 2048 ? '2K' : '1K';
+        context.metadata({ title: '✨ image_enhancer', metadata: { type: 'info', message: `Amélioration ${resLabel}...` } });
+        try {
+            const result = await processTool('enhance', {
+                data: imageData,
+                contentType: mimeType,
+                filename: path.basename(imagePath),
+                options: { targetLongestSide },
+            });
+            if (!result.imageUrl) {
+                return t('tools.image_enhancer.no_result') || '❌ Aucun résultat reçu.';
+            }
+            const dl = await httpsGet(result.imageUrl);
+            const outputDir = args.save_to ? args.save_to : getDefaultOutputDir('image_enhancer');
+            const outputFilename = (args.filename ? sanitizeFilename(args.filename) : generateFilename('enhance', 'imgupscaler', 'png'));
+            const filePath = path.join(outputDir, outputFilename.includes('.') ? outputFilename : `${outputFilename}.png`);
+            ensureDir(outputDir);
+            fs.writeFileSync(filePath, dl.data);
+            emitStatusToast("success", "✨ Enhancement terminé", "image_enhancer", { filePath, freeTool: true });
+            const fileSize = fs.statSync(filePath).size;
+            const lines = [];
+            lines.push('✨ **Image Améliorée**');
+            lines.push('━━━━━━━━━━━━━━━━━━');
+            lines.push(`Fichier      : \`${filePath}\``);
+            lines.push(`Taille       : ${formatFileSize(fileSize)}`);
+            lines.push(`Résolution   : ${resLabel}`);
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast("warning", "❌ " + (err.message?.substring(0, 80) || ""), "image_enhancer", { freeTool: true });
+            return "❌ Erreur : " + err.message;
+        }
+    },
+});

package/dist/tools/pollinations/image_upscaler.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const imageUpscalerTool: ToolDefinition;

package/dist/tools/pollinations/image_upscaler.js

@@ -0,0 +1,61 @@
+// image_upscaler — Agrandissement 2x/4x via imgupscaler.com
+// Standalone : appel direct depuis l'IP utilisateur, pas d'API, pas de clé
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ensureDir, generateFilename, getDefaultOutputDir, formatFileSize, sanitizeFilename, httpsGet, } from './shared.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+import { processTool } from './imgtools/clients.js';
+export const imageUpscalerTool = tool({
+    description: `Agrandit une image 2x ou 4x (gratuit, appel direct).
+Temps de traitement : 30-120s. Pas de clé requise.`,
+    args: {
+        file: tool.schema.string().describe('Chemin local de l\'image à agrandir'),
+        ratio: tool.schema.enum(['2', '4']).optional().describe('Facteur d\'agrandissement (2=2x, 4=4x). Défaut: 2'),
+        save_to: tool.schema.string().optional().describe('Dossier de sortie'),
+        filename: tool.schema.string().optional().describe('Nom du fichier de sortie (sans extension)'),
+    },
+    async execute(args, context) {
+        const imagePath = args.file;
+        if (!fs.existsSync(imagePath)) {
+            return t('tools.image_upscaler.file_not_found', { path: imagePath }) || `❌ Fichier introuvable : ${imagePath}`;
+        }
+        const ext = path.extname(imagePath).toLowerCase();
+        const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
+        const imageData = fs.readFileSync(imagePath);
+        const ratio = args.ratio === '4' ? '400' : '200';
+        const ratioLabel = args.ratio === '4' ? '4x' : '2x';
+        context.metadata({ title: '📐 image_upscaler', metadata: { type: 'info', message: `Agrandissement ${ratioLabel}...` } });
+        try {
+            const result = await processTool('upscale', {
+                data: imageData,
+                contentType: mimeType,
+                filename: path.basename(imagePath),
+                options: { ratio },
+            });
+            if (!result.imageUrl) {
+                return t('tools.image_upscaler.no_result') || '❌ Aucun résultat reçu.';
+            }
+            const dl = await httpsGet(result.imageUrl);
+            const outputDir = args.save_to ? args.save_to : getDefaultOutputDir('image_upscaler');
+            const outputFilename = (args.filename ? sanitizeFilename(args.filename) : generateFilename('upscale', 'imgupscaler', 'png'));
+            const filePath = path.join(outputDir, outputFilename.includes('.') ? outputFilename : `${outputFilename}.png`);
+            ensureDir(outputDir);
+            fs.writeFileSync(filePath, dl.data);
+            emitStatusToast("success", "📐 Upscale terminé", "image_upscaler", { filePath, freeTool: true });
+            const fileSize = fs.statSync(filePath).size;
+            const lines = [];
+            lines.push('📐 **Image Agrandie**');
+            lines.push('━━━━━━━━━━━━━━━━━━');
+            lines.push(`Fichier : \`${filePath}\``);
+            lines.push(`Taille  : ${formatFileSize(fileSize)}`);
+            lines.push(`Ratio   : ${ratioLabel}`);
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast("warning", "❌ " + (err.message?.substring(0, 80) || ""), "image_upscaler", { freeTool: true });
+            return "❌ Erreur : " + err.message;
+        }
+    },
+});

package/dist/tools/pollinations/imgtools/clients.d.ts

@@ -0,0 +1,11 @@
+export interface ToolInput {
+    data: Buffer;
+    contentType: string;
+    filename: string;
+    options?: Record<string, string | number>;
+}
+export interface ToolResult {
+    imageUrl: string;
+    downloadUrls: string[];
+}
+export declare function processTool(toolName: string, input: ToolInput): Promise<ToolResult>;

package/dist/tools/pollinations/imgtools/clients.js

@@ -0,0 +1,182 @@
+// imgtools/clients.ts — orchestration upload → poll → download pour les 4 outils
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/clients.js
+// Mode standalone : appels directs depuis l'IP utilisateur, pas de queue, pas d'API
+import { TOOLS, UA } from './config.js';
+import { getKey, encrypt, decrypt } from './crypto.js';
+import { buildMultipart, httpsPost, getDims, aspectRatio } from './helpers.js';
+const BASE_HEADERS = {
+    'User-Agent': UA,
+    'Accept': '*/*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+function headersFor(t, contentType) {
+    return {
+        ...BASE_HEADERS,
+        'Origin': `https://${t.host}`,
+        'Referer': t.page,
+        ...(contentType ? { 'Content-Type': contentType } : {}),
+    };
+}
+function normalizeUrls(dUrls) {
+    if (Array.isArray(dUrls))
+        return dUrls.filter(u => u && String(u).trim()).map(u => String(u).trim());
+    if (dUrls && typeof dUrls === 'object') {
+        return Object.values(dUrls).filter(u => u && String(u).trim()).map(u => String(u).trim());
+    }
+    return [];
+}
+function hasUrls(dUrls) {
+    return normalizeUrls(dUrls).length > 0;
+}
+function resolveUrls(t, urls) {
+    const resolved = urls.map(u => {
+        if (String(u).startsWith('http'))
+            return String(u);
+        if (t.resultBase) {
+            const fn = String(u).split('/').pop() || '';
+            return `${t.resultBase}/${fn}`;
+        }
+        return String(u);
+    });
+    return { imageUrl: resolved[0] || '', downloadUrls: resolved };
+}
+// ─── Legacy (rmbg, upscale) ──────────────────────────────────────────
+async function uploadLegacy(t, file) {
+    const mpFields = [
+        { name: 'file', value: file.data, filename: file.filename || 'image.jpg', contentType: file.contentType || 'image/jpeg' },
+    ];
+    if (t.uploadFields) {
+        for (const [k, v] of Object.entries(t.uploadFields)) {
+            let val = v;
+            if (k === 'ratio' && file.options?.ratio)
+                val = String(file.options.ratio);
+            mpFields.push({ name: k, value: val });
+        }
+    }
+    const { boundary, body } = buildMultipart(mpFields);
+    const hdrs = headersFor(t, `multipart/form-data; boundary=${boundary}`);
+    const res = await httpsPost(t.host, t.uploadPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Upload ${t.name} failed: ${res.status} ${res.body.toString('utf8').slice(0, 200)}`);
+    let json;
+    try {
+        json = JSON.parse(res.body.toString('utf8'));
+    }
+    catch {
+        throw new Error(`Upload ${t.name} non-JSON: ${res.body.toString('utf8').slice(0, 200)}`);
+    }
+    if (json.downloadUrls && hasUrls(json.downloadUrls)) {
+        return { code: null, directUrls: normalizeUrls(json.downloadUrls) };
+    }
+    const code = json.code || json.taskId || json.taskCode || (json.data && (json.data.code || json.data.taskId));
+    if (!code)
+        throw new Error(`Upload ${t.name}: no code in ${JSON.stringify(json).slice(0, 300)}`);
+    return { code: String(code), directUrls: [] };
+}
+async function pollLegacy(t, code) {
+    const codes = Array.isArray(code) ? code : [code];
+    const bodyObj = t.statusBodyBuilder ? t.statusBodyBuilder(codes) : { type: t.statusType, [t.statusField]: codes };
+    const body = JSON.stringify(bodyObj);
+    const hdrs = headersFor(t, 'application/json');
+    const res = await httpsPost(t.host, t.statusPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Status ${t.name} failed: ${res.status}`);
+    try {
+        return JSON.parse(res.body.toString('utf8'));
+    }
+    catch {
+        throw new Error(`Status ${t.name} non-JSON`);
+    }
+}
+// ─── Encrypted (ruo, enhance) ────────────────────────────────────────
+function buildUploadParams(t, file, dims, extra) {
+    const ratio = aspectRatio(dims.width, dims.height);
+    if (t.name === 'ruo') {
+        const p = String(extra.prompt || 'remove unwanted objects');
+        return {
+            type: t.statusType, selected_model: t.selectedModel, model_name: t.modelName,
+            user_id: 'anonymous', tool: t.tool,
+            positive_prompts: p, resolved_prompt: p, raw_prompt: p,
+            aspect_ratio: ratio, prompt_image_refs: ['primary'], image_order_map: ['primary'],
+        };
+    }
+    if (t.name === 'enhance') {
+        const prompt = t.prompt;
+        const tls = Number(extra.targetLongestSide || 1024);
+        return {
+            positive_prompts: prompt, resolved_prompt: prompt, aspect_ratio: ratio,
+            selected_model: t.selectedModel, model_name: t.modelName,
+            user_id: 'anonymous', type: t.statusType, target_longest_side: tls,
+        };
+    }
+    throw new Error(`Unknown encrypted tool: ${t.name}`);
+}
+async function uploadEncrypted(t, file) {
+    const key = getKey(t.crypto.salt);
+    const dims = getDims(file.data) || { width: 0, height: 0 };
+    const params = buildUploadParams(t, file, dims, file.options || {});
+    const enc = encrypt(params, key);
+    const { boundary, body } = buildMultipart([
+        { name: 'params', value: enc },
+        { name: 'file', value: file.data, filename: file.filename || 'image.jpg', contentType: file.contentType || 'image/jpeg' },
+        { name: 'selected_model', value: t.selectedModel },
+    ]);
+    const hdrs = headersFor(t, `multipart/form-data; boundary=${boundary}`);
+    const res = await httpsPost(t.host, t.uploadPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Upload ${t.name} failed: ${res.status}`);
+    const json = JSON.parse(res.body.toString('utf8'));
+    if (!json.data_enc)
+        throw new Error(`Upload ${t.name}: no data_enc in ${JSON.stringify(json).slice(0, 200)}`);
+    const dec = decrypt(json.data_enc, key);
+    if (!dec.code)
+        throw new Error(`Upload ${t.name}: no code in decrypted ${JSON.stringify(dec).slice(0, 200)}`);
+    return { code: String(dec.code) };
+}
+async function pollEncrypted(t, code) {
+    const key = getKey(t.crypto.salt);
+    const statusPayload = { type: t.statusType, code, user_id: 'anonymous' };
+    const enc = encrypt(statusPayload, key);
+    const body = JSON.stringify({ params: enc });
+    const hdrs = headersFor(t, 'application/json');
+    const res = await httpsPost(t.host, t.statusPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Status ${t.name} failed: ${res.status}`);
+    const json = JSON.parse(res.body.toString('utf8'));
+    if (!json.data_enc)
+        throw new Error(`Status ${t.name}: no data_enc`);
+    return decrypt(json.data_enc, key);
+}
+// ─── Orchestrateur principal ─────────────────────────────────────────
+export async function processTool(toolName, input) {
+    const t = TOOLS[toolName];
+    if (!t)
+        throw new Error(`Unknown tool: ${toolName}`);
+    const isEncrypted = !!t.crypto;
+    const upRes = isEncrypted
+        ? await uploadEncrypted(t, input)
+        : await uploadLegacy(t, input);
+    if ('directUrls' in upRes && upRes.directUrls && upRes.directUrls.length > 0) {
+        return resolveUrls(t, upRes.directUrls);
+    }
+    const code = 'code' in upRes ? upRes.code : upRes.code;
+    let status;
+    for (let i = 0; i < t.maxPolls; i++) {
+        if (i > 0)
+            await new Promise(r => setTimeout(r, t.pollInterval));
+        status = isEncrypted
+            ? await pollEncrypted(t, code)
+            : await pollLegacy(t, code);
+        if (status.status === 'success' || hasUrls(status.downloadUrls))
+            break;
+        if (status.status === 'failed')
+            throw new Error(`Status ${t.name} failed: ${status.message || JSON.stringify(status).slice(0, 200)}`);
+        if (status.status && !['processing', 'pending', 'queued', 'waiting'].includes(status.status)) {
+            throw new Error(`Status ${t.name} unexpected: ${JSON.stringify(status).slice(0, 300)}`);
+        }
+    }
+    const urls = status ? normalizeUrls(status.downloadUrls) : [];
+    if (!urls.length)
+        throw new Error(`Polling ${t.name} timeout: no downloadUrls after ${t.maxPolls} attempts`);
+    return resolveUrls(t, urls);
+}

package/dist/tools/pollinations/imgtools/config.d.ts

@@ -0,0 +1,42 @@
+export declare const UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/150.0.0.0 Safari/537.36";
+export declare const CRYPTO: {
+    PBKDF2: {
+        iterations: number;
+        hash: string;
+        keylen: number;
+    };
+    AES_GCM: {
+        ivLen: number;
+        tagLen: number;
+    };
+    password: string;
+};
+export interface ToolConfig {
+    name: string;
+    label: string;
+    host: string;
+    uploadPath: string;
+    statusPath: string;
+    crypto: typeof CRYPTO & {
+        salt: string;
+    } | null;
+    statusType: number;
+    statusField: string;
+    maxPolls: number;
+    pollInterval: number;
+    downloadUrlsFormat?: string;
+    page: string;
+    uploadFields?: Record<string, string>;
+    statusBodyBuilder?: (codes: string[]) => Record<string, unknown>;
+    selectedModel?: string;
+    modelName?: string;
+    tool?: string;
+    resultBase?: string;
+    ratios?: string[];
+    targetLongestSides?: Array<{
+        label: string;
+        value: number;
+    }>;
+    prompt?: string;
+}
+export declare const TOOLS: Record<string, ToolConfig>;

package/dist/tools/pollinations/imgtools/config.js

@@ -0,0 +1,81 @@
+// imgtools/config.ts — endpoints, crypto params, headers des 4 outils
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/config.js
+export const UA = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/150.0.0.0 Safari/537.36';
+export const CRYPTO = {
+    PBKDF2: { iterations: 10000, hash: 'sha256', keylen: 32 },
+    AES_GCM: { ivLen: 12, tagLen: 16 },
+    password: 'vH33r_2025_AES_GCM_S3cur3_K3y_9X7mP4qR8nT2wE5yU1oI6aS3dF7gH0jK9lZ',
+};
+export const TOOLS = {
+    rmbg: {
+        name: 'rmbg',
+        label: 'Background Removal',
+        host: 'bgeraser.com',
+        uploadPath: '/api/bgeraser/legacy/upload',
+        statusPath: '/api/bgeraser/legacy/status',
+        crypto: null,
+        statusType: 4,
+        statusField: 'codes',
+        uploadFields: { type: '4', mattValue: '0' },
+        maxPolls: 30,
+        pollInterval: 5000,
+        downloadUrlsFormat: 'object',
+        page: 'https://bgeraser.com',
+    },
+    ruo: {
+        name: 'ruo',
+        label: 'Remove Unwanted Objects',
+        host: 'objectremover.com',
+        uploadPath: '/api/u2/upload',
+        statusPath: '/api/u2/status',
+        crypto: { ...CRYPTO, salt: 'objectremover-salt-2026' },
+        statusType: 7,
+        statusField: 'code',
+        maxPolls: 40,
+        pollInterval: 3000,
+        selectedModel: 'flux_klein/edit',
+        modelName: 'Flux Klein Edit',
+        tool: 'object-remover',
+        page: 'https://objectremover.com',
+        resultBase: 'https://access.vheer.com/results',
+    },
+    upscale: {
+        name: 'upscale',
+        label: 'Image Upscaler',
+        host: 'imgupscaler.com',
+        uploadPath: '/api/legacy/upload',
+        statusPath: '/api/legacy/status',
+        crypto: null,
+        statusType: 4,
+        statusField: 'codes',
+        statusBodyBuilder: (codes) => ({ taskId: codes[0] }),
+        uploadFields: { type: '4' },
+        maxPolls: 30,
+        pollInterval: 5000,
+        downloadUrlsFormat: 'array',
+        page: 'https://imgupscaler.com',
+        ratios: ['200', '400'],
+    },
+    enhance: {
+        name: 'enhance',
+        label: 'AI Image Enhancer',
+        host: 'imgupscaler.com',
+        uploadPath: '/api/u2/upload',
+        statusPath: '/api/u2/status',
+        crypto: { ...CRYPTO, salt: 'imgupscaler-salt-2026' },
+        statusType: 7,
+        statusField: 'code',
+        maxPolls: 40,
+        pollInterval: 3000,
+        selectedModel: 'hypir',
+        modelName: 'Hypir Enhancer',
+        page: 'https://imgupscaler.com/enhancer',
+        resultBase: 'https://access.vheer.com/results',
+        prompt: 'preserve facial identity, preserve facial geometry, restore image clarity, enhance natural details, reduce blur and noise, preserve original colors and structure',
+        targetLongestSides: [
+            { label: '1K', value: 1024 },
+            { label: '2K', value: 2048 },
+            { label: '4K', value: 4096 },
+        ],
+    },
+};

package/dist/tools/pollinations/imgtools/crypto.d.ts

@@ -0,0 +1,4 @@
+export declare function deriveKey(password: string, salt: string): Buffer;
+export declare function encrypt(data: Record<string, unknown>, key: Buffer): string;
+export declare function decrypt(encoded: string, key: Buffer): any;
+export declare function getKey(salt: string): Buffer;

package/dist/tools/pollinations/imgtools/crypto.js

@@ -0,0 +1,34 @@
+// imgtools/crypto.ts — AES-GCM + PBKDF2 pour ruo/enhance
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/crypto.js
+import * as crypto from 'crypto';
+const PBKDF2 = { iterations: 10000, hash: 'sha256', keylen: 32 };
+const AES_GCM = { ivLen: 12, tagLen: 16 };
+export function deriveKey(password, salt) {
+    return crypto.pbkdf2Sync(Buffer.from(password, 'utf8'), Buffer.from(salt, 'utf8'), PBKDF2.iterations, PBKDF2.keylen, PBKDF2.hash);
+}
+export function encrypt(data, key) {
+    const iv = crypto.randomBytes(AES_GCM.ivLen);
+    const plaintext = Buffer.from(JSON.stringify(data), 'utf8');
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, ciphertext, tag]).toString('base64');
+}
+export function decrypt(encoded, key) {
+    const buf = Buffer.from(encoded, 'base64');
+    const iv = buf.subarray(0, 12);
+    const ciphertext = buf.subarray(12, -16);
+    const tag = buf.subarray(-16);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return JSON.parse(plaintext.toString('utf8'));
+}
+const _keyCache = {};
+export function getKey(salt) {
+    if (_keyCache[salt])
+        return _keyCache[salt];
+    const key = deriveKey('vH33r_2025_AES_GCM_S3cur3_K3y_9X7mP4qR8nT2wE5yU1oI6aS3dF7gH0jK9lZ', salt);
+    _keyCache[salt] = key;
+    return key;
+}

package/dist/tools/pollinations/imgtools/helpers.d.ts

@@ -0,0 +1,24 @@
+export declare function sleep(ms: number): Promise<void>;
+export declare function buildMultipart(fields: Array<{
+    name: string;
+    value: Buffer | string;
+    filename?: string;
+    contentType?: string;
+}>): {
+    boundary: string;
+    body: Buffer;
+};
+export declare function httpsPost(host: string, path: string, headers: Record<string, string>, body: Buffer | string): Promise<{
+    status: number;
+    body: Buffer;
+    headers: Record<string, string>;
+}>;
+export declare function getDims(buf: Buffer): {
+    width: number;
+    height: number;
+} | null;
+export declare function aspectRatio(w: number, h: number): string;
+export declare function dlImage(url: string): Promise<{
+    body: Buffer;
+    contentType: string;
+}>;