@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/server/routes/extract.js

@@ -0,0 +1,325 @@
+/**
+ * POST /v1/extract — Structured JSON Schema extraction endpoint.
+ *
+ * Firecrawl-compatible: pass a URL + JSON schema, get structured data back.
+ *
+ * Auth: API key required (full or read scope)
+ * Body: { url, schema, prompt?, llm?, render? }
+ *
+ * Also exposes:
+ *   GET  /v1/extract/auto  — Auto-extract known structured types from a URL
+ *   POST /v1/extract/auto  — Same but via POST body
+ */
+import { Router } from 'express';
+import crypto from 'crypto';
+import { peel } from '../../index.js';
+import { extractStructured, } from '../../core/structured-extract.js';
+import { getDefaultLLMConfig, isFreeTierLimitError, } from '../../core/llm-provider.js';
+const VALID_PROVIDERS = [
+    'cloudflare',
+    'openai',
+    'anthropic',
+    'google',
+    'ollama',
+    'cerebras',
+];
+function reqId(req) {
+    return req.requestId || crypto.randomUUID();
+}
+export function createExtractRouter() {
+    const router = Router();
+    // ── POST /v1/extract ─────────────────────────────────────────────────────
+    router.post('/v1/extract', async (req, res) => {
+        try {
+            const { url, schema: schemaRaw, prompt, llm: llmRaw, render, 
+            // Legacy fields for backward compat
+            llmApiKey, llmProvider, model: legacyModel, } = req.body;
+            // ── Validate URL ────────────────────────────────────────────────────
+            if (!url || typeof url !== 'string') {
+                res.status(400).json({
+                    success: false,
+                    error: {
+                        type: 'invalid_request',
+                        message: 'Missing or invalid "url" field in request body.',
+                        hint: 'Pass a URL: { "url": "https://example.com", "schema": { ... } }',
+                        docs: 'https://webpeel.dev/docs/errors#invalid-request',
+                    },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            if (url.length > 2048) {
+                res.status(400).json({
+                    success: false,
+                    error: {
+                        type: 'invalid_url',
+                        message: 'URL too long (max 2048 characters)',
+                        docs: 'https://webpeel.dev/docs/errors#invalid-url',
+                    },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            try {
+                const parsed = new URL(url);
+                if (!['http:', 'https:'].includes(parsed.protocol)) {
+                    res.status(400).json({
+                        success: false,
+                        error: {
+                            type: 'invalid_url',
+                            message: 'Only HTTP and HTTPS URLs are supported',
+                            docs: 'https://webpeel.dev/docs/errors#invalid-url',
+                        },
+                        requestId: reqId(req),
+                    });
+                    return;
+                }
+            }
+            catch {
+                res.status(400).json({
+                    success: false,
+                    error: {
+                        type: 'invalid_url',
+                        message: `Invalid URL format: ${url}`,
+                        hint: 'Ensure the URL is well-formed: https://example.com',
+                        docs: 'https://webpeel.dev/docs/errors#invalid-url',
+                    },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            // ── Validate schema ─────────────────────────────────────────────────
+            if (!schemaRaw && !prompt) {
+                res.status(400).json({
+                    success: false,
+                    error: {
+                        type: 'invalid_request',
+                        message: 'Either "schema" or "prompt" is required for structured extraction.',
+                        hint: 'Include a JSON schema in the request body: { "schema": { "type": "object", "properties": { ... } } }',
+                        docs: 'https://webpeel.dev/docs/errors#invalid-request',
+                    },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            // Build or validate schema
+            let schema;
+            if (schemaRaw) {
+                if (typeof schemaRaw !== 'object' || schemaRaw === null || Array.isArray(schemaRaw)) {
+                    res.status(400).json({
+                        success: false,
+                        error: {
+                            type: 'invalid_request',
+                            message: '"schema" must be a JSON object',
+                            hint: '{ "type": "object", "properties": { "field": { "type": "string" } } }',
+                            docs: 'https://webpeel.dev/docs/errors#invalid-request',
+                        },
+                        requestId: reqId(req),
+                    });
+                    return;
+                }
+                const schemaObj = schemaRaw;
+                // Accept both full JSON Schema and shorthand { field: "type" }
+                if (schemaObj.type === 'object' && schemaObj.properties) {
+                    schema = schemaObj;
+                }
+                else {
+                    // Shorthand: { "company_mission": "string", "is_open_source": "boolean" }
+                    const props = {};
+                    for (const [k, v] of Object.entries(schemaObj)) {
+                        props[k] = { type: typeof v === 'string' ? v : 'string' };
+                    }
+                    schema = { type: 'object', properties: props };
+                }
+            }
+            else {
+                // No schema provided but prompt is — create a minimal schema
+                schema = { type: 'object', properties: { result: { type: 'string', description: prompt } } };
+            }
+            // ── Resolve LLM config ──────────────────────────────────────────────
+            let llmConfig;
+            if (llmRaw && typeof llmRaw === 'object' && !Array.isArray(llmRaw)) {
+                // New format: { "provider": "openai", "apiKey": "sk-...", "model": "..." }
+                const llmObj = llmRaw;
+                const provider = typeof llmObj.provider === 'string' ? llmObj.provider : 'openai';
+                if (!VALID_PROVIDERS.includes(provider)) {
+                    res.status(400).json({
+                        success: false,
+                        error: {
+                            type: 'invalid_request',
+                            message: `Invalid "llm.provider". Must be one of: ${VALID_PROVIDERS.join(', ')}`,
+                            docs: 'https://webpeel.dev/docs/errors#invalid-request',
+                        },
+                        requestId: reqId(req),
+                    });
+                    return;
+                }
+                llmConfig = {
+                    provider: provider,
+                    apiKey: typeof llmObj.apiKey === 'string' ? llmObj.apiKey : undefined,
+                    model: typeof llmObj.model === 'string' ? llmObj.model : undefined,
+                    endpoint: typeof llmObj.endpoint === 'string' ? llmObj.endpoint : undefined,
+                };
+            }
+            else if (typeof llmApiKey === 'string' && llmApiKey) {
+                // Legacy format: llmApiKey + llmProvider at top level
+                const provider = (typeof llmProvider === 'string' && VALID_PROVIDERS.includes(llmProvider))
+                    ? llmProvider
+                    : 'openai';
+                llmConfig = {
+                    provider,
+                    apiKey: llmApiKey,
+                    model: typeof legacyModel === 'string' ? legacyModel : undefined,
+                };
+            }
+            else {
+                // Try server-side default (env vars)
+                const defaultCfg = getDefaultLLMConfig();
+                // Only use server default if it has a real key (not bare cloudflare)
+                if (defaultCfg.provider !== 'cloudflare' || (process.env.CLOUDFLARE_ACCOUNT_ID && process.env.CLOUDFLARE_API_TOKEN)) {
+                    llmConfig = defaultCfg;
+                }
+                // If still no config, we'll use heuristic extraction
+            }
+            // ── Fetch page content ──────────────────────────────────────────────
+            const useRender = render === true || render === 'true';
+            const peelResult = await peel(url, {
+                format: 'markdown',
+                render: useRender,
+                noEscalate: !useRender, // prevent OOM: only browser when render=true explicitly
+                timeout: 30000,
+                readable: true,
+            });
+            const content = peelResult.content || '';
+            // ── Extract structured data ─────────────────────────────────────────
+            // Seed hints from domain-api structured data (GitHub stars/language, etc.)
+            // This lets heuristic extraction use pre-parsed structured fields as ground truth.
+            const domainHints = {};
+            const rawDomainData = peelResult.domainData?.structured;
+            if (rawDomainData && typeof rawDomainData === 'object') {
+                for (const [k, v] of Object.entries(rawDomainData)) {
+                    if (v !== null && v !== undefined && v !== '') {
+                        domainHints[k] = v;
+                    }
+                }
+            }
+            const extractResult = await extractStructured(content, schema, llmConfig, typeof prompt === 'string' ? prompt : undefined, Object.keys(domainHints).length > 0 ? domainHints : undefined);
+            const method = llmConfig ? 'llm' : 'heuristic';
+            res.json({
+                success: true,
+                data: {
+                    url: peelResult.url || url,
+                    extracted: extractResult.data,
+                    confidence: extractResult.confidence,
+                    tokensUsed: extractResult.tokensUsed,
+                    method,
+                },
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error('[/v1/extract] Error:', msg);
+            if (isFreeTierLimitError(error)) {
+                res.status(429).json({
+                    success: false,
+                    error: {
+                        type: 'free_tier_limit',
+                        message: error.message,
+                        hint: 'Provide your own API key in the "llm" config object for unlimited use.',
+                        docs: 'https://webpeel.dev/docs/extract#free-tier',
+                    },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            if (msg.includes('401') || msg.includes('Unauthorized') || msg.includes('authentication failed')) {
+                res.status(401).json({
+                    success: false,
+                    error: { type: 'llm_auth_failed', message: msg },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            if (msg.includes('429') || msg.includes('rate limit')) {
+                res.status(429).json({
+                    success: false,
+                    error: {
+                        type: 'llm_rate_limited',
+                        message: msg,
+                        hint: 'Try again in a moment or use a different LLM provider.',
+                        docs: 'https://webpeel.dev/docs/errors#llm-rate-limited',
+                    },
+                    requestId: reqId(req),
+                });
+                return;
+            }
+            res.status(500).json({
+                success: false,
+                error: {
+                    type: 'extraction_failed',
+                    message: msg,
+                    docs: 'https://webpeel.dev/docs/errors#extraction-failed',
+                },
+                requestId: reqId(req),
+            });
+        }
+    });
+    // ── GET /v1/extract/auto ─────────────────────────────────────────────────
+    router.get('/v1/extract/auto', async (req, res) => {
+        const url = req.query.url;
+        if (!url) {
+            res.status(400).json({
+                success: false,
+                error: {
+                    type: 'missing_url',
+                    message: 'Missing url parameter',
+                    hint: 'Pass a URL: GET /v1/extract/auto?url=https://example.com',
+                    docs: 'https://webpeel.dev/docs/errors#missing-url',
+                },
+                requestId: reqId(req),
+            });
+            return;
+        }
+        const { autoExtract } = await import('../../core/auto-extract.js');
+        const result = await peel(url, { format: 'html' });
+        const extracted = autoExtract(result.content || '', url);
+        res.json({ url, pageType: extracted.type, structured: extracted });
+    });
+    // ── POST /v1/extract/auto ────────────────────────────────────────────────
+    router.post('/v1/extract/auto', async (req, res) => {
+        const { url, ...rest } = req.body;
+        if (!url || typeof url !== 'string') {
+            res.status(400).json({
+                success: false,
+                error: {
+                    type: 'missing_url',
+                    message: 'Missing or invalid url field in request body',
+                    hint: 'Pass a URL in the request body: { "url": "https://example.com" }',
+                    docs: 'https://webpeel.dev/docs/errors#missing-url',
+                },
+                requestId: reqId(req),
+            });
+            return;
+        }
+        try {
+            const { autoExtract } = await import('../../core/auto-extract.js');
+            const result = await peel(url, { format: 'html', ...rest });
+            const extracted = autoExtract(result.content || '', url);
+            res.json({ url, pageType: extracted.type, structured: extracted });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            console.error('[/v1/extract/auto POST] Error:', msg);
+            res.status(500).json({
+                success: false,
+                error: {
+                    type: 'extraction_failed',
+                    message: msg,
+                    docs: 'https://webpeel.dev/docs/errors#extraction-failed',
+                },
+                requestId: reqId(req),
+            });
+        }
+    });
+    return router;
+}

package/dist/server/routes/feed.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Feed discovery and parsing endpoint — GET /v1/feed
+ *
+ * Discovers and fetches RSS/Atom feeds for any website URL.
+ * Supports direct feed URLs as well as HTML pages (auto-discovers via <link> tags
+ * or probes common feed paths like /feed, /rss.xml, etc.).
+ *
+ * Query params:
+ *   - url     (required) — website URL or direct feed URL
+ *   - limit   (optional) — max items to return (default 20, max 100)
+ *   - format  (optional) — "json" (default) or "markdown"
+ */
+import { Router } from 'express';
+import { AuthStore } from '../auth-store.js';
+export declare function createFeedRouter(_authStore: AuthStore): Router;

package/dist/server/routes/feed.js

@@ -0,0 +1,311 @@
+/**
+ * Feed discovery and parsing endpoint — GET /v1/feed
+ *
+ * Discovers and fetches RSS/Atom feeds for any website URL.
+ * Supports direct feed URLs as well as HTML pages (auto-discovers via <link> tags
+ * or probes common feed paths like /feed, /rss.xml, etc.).
+ *
+ * Query params:
+ *   - url     (required) — website URL or direct feed URL
+ *   - limit   (optional) — max items to return (default 20, max 100)
+ *   - format  (optional) — "json" (default) or "markdown"
+ */
+import { Router } from 'express';
+import { validateUrlForSSRF, SSRFError } from '../middleware/url-validator.js';
+// ── Helpers: XML text extraction ──────────────────────────────────────────────
+/** Extract the inner text of the first matching XML tag. */
+function extractTag(xml, tag) {
+    // Try with namespace prefix first (e.g. dc:creator), then plain
+    const patterns = [
+        new RegExp(`<${tag}[^>]*><!\\[CDATA\\[([\\s\\S]*?)\\]\\]></${tag}>`, 'i'),
+        new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'i'),
+    ];
+    for (const re of patterns) {
+        const m = xml.match(re);
+        if (m)
+            return m[1].trim();
+    }
+    return '';
+}
+/** Extract an attribute value from an XML/HTML tag. */
+function extractAttr(tag, attr) {
+    const re = new RegExp(`${attr}=["']([^"']+)["']`, 'i');
+    const m = tag.match(re);
+    return m ? m[1].trim() : '';
+}
+/** Strip HTML tags from a string (for description cleanup). */
+function stripHtml(html) {
+    return html.replace(/<[^>]+>/g, '').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').replace(/&quot;/g, '"').replace(/&#39;/g, "'").trim();
+}
+// ── RSS/Atom parser ───────────────────────────────────────────────────────────
+/**
+ * Parse an RSS 2.0 or Atom feed XML string into a flat array of FeedItem objects.
+ * Uses regex — no external dependencies.
+ */
+function parseRSSFeed(xml) {
+    const items = [];
+    // Detect feed type
+    const isAtom = /<feed[\s>]/i.test(xml);
+    if (isAtom) {
+        // ── Atom ───────────────────────────────────────────────────────────────
+        const entryRe = /<entry[\s>]([\s\S]*?)<\/entry>/gi;
+        let m;
+        while ((m = entryRe.exec(xml)) !== null) {
+            const entry = m[1];
+            // title
+            const title = stripHtml(extractTag(entry, 'title') || '');
+            // link — prefer <link rel="alternate" href="..."> else <link href="...">
+            let link = '';
+            const linkTagRe = /<link([^>]*)\/?>/gi;
+            let lt;
+            while ((lt = linkTagRe.exec(entry)) !== null) {
+                const attrs = lt[1];
+                const rel = extractAttr(attrs, 'rel') || 'alternate';
+                const href = extractAttr(attrs, 'href');
+                if (href && (rel === 'alternate' || rel === '')) {
+                    link = href;
+                    break;
+                }
+                if (href && !link)
+                    link = href; // fallback
+            }
+            // description — prefer <content>, fallback <summary>
+            const content = extractTag(entry, 'content') || extractTag(entry, 'summary') || '';
+            const description = stripHtml(content).substring(0, 500);
+            // date — prefer <published>, fallback <updated>
+            const pubDate = extractTag(entry, 'published') || extractTag(entry, 'updated') || '';
+            // author
+            const authorBlock = entry.match(/<author[\s>]([\s\S]*?)<\/author>/i);
+            const author = authorBlock ? (extractTag(authorBlock[1], 'name') || '') : '';
+            // id
+            const guid = extractTag(entry, 'id') || link;
+            items.push({ title, link, description, pubDate, author, guid });
+        }
+    }
+    else {
+        // ── RSS 2.0 ────────────────────────────────────────────────────────────
+        const itemRe = /<item[\s>]([\s\S]*?)<\/item>/gi;
+        let m;
+        while ((m = itemRe.exec(xml)) !== null) {
+            const item = m[1];
+            const title = stripHtml(extractTag(item, 'title') || '');
+            const link = extractTag(item, 'link') || extractTag(item, 'feedburner:origLink') || '';
+            const rawDesc = extractTag(item, 'description') || extractTag(item, 'content:encoded') || '';
+            const description = stripHtml(rawDesc).substring(0, 500);
+            const pubDate = extractTag(item, 'pubDate') || extractTag(item, 'dc:date') || '';
+            const author = extractTag(item, 'author') || extractTag(item, 'dc:creator') || '';
+            const guid = extractTag(item, 'guid') || link;
+            items.push({ title, link, description, pubDate, author, guid });
+        }
+    }
+    return items;
+}
+// ── HTML feed discovery ───────────────────────────────────────────────────────
+/**
+ * Scan an HTML document for <link rel="alternate" type="application/rss+xml"> tags
+ * and similar, returning discovered feed URLs resolved against the page URL.
+ */
+function discoverFeeds(html, pageUrl) {
+    const feeds = [];
+    const seen = new Set();
+    // Match all <link ...> tags in the <head>
+    const linkRe = /<link([^>]+)>/gi;
+    let m;
+    while ((m = linkRe.exec(html)) !== null) {
+        const attrs = m[1];
+        const rel = extractAttr(attrs, 'rel').toLowerCase();
+        const type = extractAttr(attrs, 'type').toLowerCase();
+        const href = extractAttr(attrs, 'href');
+        if (rel !== 'alternate' || !href)
+            continue;
+        // Accept RSS, Atom, and generic XML feed types
+        const isFeed = type.includes('rss') ||
+            type.includes('atom') ||
+            type.includes('application/xml') ||
+            type.includes('text/xml');
+        if (!isFeed)
+            continue;
+        // Resolve relative URLs
+        let resolvedUrl;
+        try {
+            resolvedUrl = new URL(href, pageUrl).toString();
+        }
+        catch {
+            continue;
+        }
+        if (seen.has(resolvedUrl))
+            continue;
+        seen.add(resolvedUrl);
+        const title = extractAttr(attrs, 'title') || 'Feed';
+        feeds.push({ url: resolvedUrl, type, title });
+    }
+    return feeds;
+}
+// ── Router factory ────────────────────────────────────────────────────────────
+export function createFeedRouter(_authStore) {
+    const router = Router();
+    router.get('/v1/feed', async (req, res) => {
+        try {
+            const url = req.query.url;
+            const limitRaw = parseInt(req.query.limit || '20', 10);
+            const limit = isNaN(limitRaw) ? 20 : Math.min(limitRaw, 100);
+            const format = req.query.format || 'json';
+            // ── Validate required param ──────────────────────────────────────────
+            if (!url) {
+                res.status(400).json({
+                    success: false,
+                    error: { type: 'invalid_request', message: 'Missing required parameter: "url"' },
+                });
+                return;
+            }
+            // ── SSRF guard ───────────────────────────────────────────────────────
+            try {
+                validateUrlForSSRF(url);
+            }
+            catch (e) {
+                if (e instanceof SSRFError) {
+                    res.status(400).json({
+                        success: false,
+                        error: { type: 'invalid_request', message: e.message },
+                    });
+                    return;
+                }
+                throw e;
+            }
+            let feedUrl = url;
+            let feedItems = [];
+            // ── Fetch the URL ────────────────────────────────────────────────────
+            const response = await fetch(url, {
+                headers: {
+                    'User-Agent': 'WebPeel/0.21 (+https://webpeel.dev/bot)',
+                    'Accept': 'application/rss+xml, application/atom+xml, application/xml, text/xml, text/html, */*',
+                },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!response.ok) {
+                res.status(502).json({
+                    success: false,
+                    error: { type: 'fetch_error', message: `Failed to fetch URL: HTTP ${response.status}` },
+                });
+                return;
+            }
+            const contentType = response.headers.get('content-type') || '';
+            const text = await response.text();
+            const trimmed = text.trimStart();
+            const looksLikeFeed = contentType.includes('xml') ||
+                contentType.includes('rss') ||
+                contentType.includes('atom') ||
+                trimmed.startsWith('<?xml') ||
+                trimmed.startsWith('<rss') ||
+                trimmed.startsWith('<feed');
+            if (looksLikeFeed) {
+                // ── Direct feed URL ────────────────────────────────────────────────
+                feedItems = parseRSSFeed(text);
+            }
+            else {
+                // ── HTML page — discover feeds ─────────────────────────────────────
+                const feedLinks = discoverFeeds(text, url);
+                if (feedLinks.length > 0) {
+                    // Fetch the first (highest-priority) discovered feed
+                    feedUrl = feedLinks[0].url;
+                    try {
+                        validateUrlForSSRF(feedUrl);
+                    }
+                    catch {
+                        // If discovered feed URL is blocked, fall through to probe paths
+                        feedUrl = url;
+                    }
+                    if (feedUrl !== url) {
+                        const feedRes = await fetch(feedUrl, {
+                            headers: { 'User-Agent': 'WebPeel/0.21 (+https://webpeel.dev/bot)' },
+                            signal: AbortSignal.timeout(10000),
+                        });
+                        if (feedRes.ok) {
+                            const feedText = await feedRes.text();
+                            feedItems = parseRSSFeed(feedText);
+                        }
+                    }
+                }
+                // If still no items, probe common feed paths
+                if (feedItems.length === 0) {
+                    const baseUrl = new URL(url).origin;
+                    const commonPaths = [
+                        '/feed',
+                        '/rss',
+                        '/rss.xml',
+                        '/feed.xml',
+                        '/atom.xml',
+                        '/feed/rss',
+                        '/blog/feed',
+                        '/blog/rss',
+                        '/index.xml',
+                    ];
+                    for (const path of commonPaths) {
+                        const candidateUrl = baseUrl + path;
+                        try {
+                            validateUrlForSSRF(candidateUrl);
+                        }
+                        catch {
+                            continue;
+                        }
+                        try {
+                            const probeRes = await fetch(candidateUrl, {
+                                headers: { 'User-Agent': 'WebPeel/0.21 (+https://webpeel.dev/bot)' },
+                                signal: AbortSignal.timeout(3000),
+                            });
+                            if (!probeRes.ok)
+                                continue;
+                            const probeText = await probeRes.text();
+                            const probeTrimmed = probeText.trimStart();
+                            if (probeTrimmed.startsWith('<?xml') ||
+                                probeTrimmed.startsWith('<rss') ||
+                                probeTrimmed.startsWith('<feed')) {
+                                feedItems = parseRSSFeed(probeText);
+                                feedUrl = candidateUrl;
+                                break;
+                            }
+                        }
+                        catch {
+                            // Continue to next candidate
+                        }
+                    }
+                }
+            }
+            // ── Trim to limit ────────────────────────────────────────────────────
+            feedItems = feedItems.slice(0, limit);
+            // ── Format response ──────────────────────────────────────────────────
+            if (format === 'markdown') {
+                const md = feedItems
+                    .map((item, i) => `${i + 1}. **${item.title || '(no title)'}**\n   ${item.link || ''}\n   ${item.pubDate || ''}\n   ${item.description?.substring(0, 200) || ''}`)
+                    .join('\n\n');
+                res.json({
+                    success: true,
+                    data: {
+                        feedUrl,
+                        format: 'markdown',
+                        content: md,
+                        itemCount: feedItems.length,
+                    },
+                });
+            }
+            else {
+                res.json({
+                    success: true,
+                    data: {
+                        feedUrl,
+                        items: feedItems,
+                        itemCount: feedItems.length,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({
+                success: false,
+                error: { type: 'internal', message },
+            });
+        }
+    });
+    return router;
+}

package/dist/server/routes/fetch-queue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Queue-backed /v1/fetch and /v1/render endpoints.
+ *
+ * Used when API_MODE=queue (microservices mode).
+ * Instead of calling peel() directly, jobs are enqueued in Bull
+ * and results are polled from Redis via GET /v1/jobs/:id.
+ *
+ * POST /v1/fetch  → enqueue in webpeel:fetch queue  → return { jobId, status }
+ * POST /v1/render → enqueue in webpeel:render queue → return { jobId, status }
+ * GET  /v1/jobs/:id → return job status + result from Redis
+ */
+import { Router } from 'express';
+export declare function createQueueFetchRouter(): Router;