granclaw 0.0.1-beta.32 → 0.0.1-beta.34

package/dist/backend/agent/process.js

@@ -169,6 +169,20 @@ function main() {
                         telegramAdapter.appendChunk(job.channelId, chunk.text);
                     }
                 }
+                if (chunk.type === 'takeover_requested') {
+                    const takeoverUrl = chunk.takeoverUrl;
+                    if (isTelegramJob) {
+                        telegramAdapter.notifyTakeover(job.channelId, takeoverUrl);
+                    }
+                    else {
+                        // For UI/WebSocket channels inject the URL as a text chunk so it
+                        // appears inline in the streaming response.
+                        broadcastToChannel(job.channelId, {
+                            type: 'chunk',
+                            chunk: { type: 'text', text: `\n\n🔗 **Takeover link:** ${takeoverUrl}` },
+                        });
+                    }
+                }
                 if (chunk.type === 'tool_call') {
                     const tcString = `${chunk.tool}(${JSON.stringify(chunk.input)})`;
                     toolCallCount++;

package/dist/backend/agent/runner-pi.js

@@ -26,6 +26,19 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const util_1 = require("util");
+const node_html_markdown_1 = require("node-html-markdown");
+const undici_1 = require("undici");
+// Cache ProxyAgent instances by URL so the same connection pool (and exit IP)
+// is reused across all fetch_website calls for the same proxy.
+const proxyAgentCache = new Map();
+function getProxyAgent(proxyUrl) {
+    let agent = proxyAgentCache.get(proxyUrl);
+    if (!agent) {
+        agent = new undici_1.ProxyAgent(proxyUrl);
+        proxyAgentCache.set(proxyUrl, agent);
+    }
+    return agent;
+}
 const os_1 = require("os");
 const crypto_1 = require("crypto");
 const takeover_state_js_1 = require("../takeover-state.js");
@@ -255,6 +268,37 @@ function getLanIp() {
     }
     return 'localhost';
 }
+/**
+ * Stable hash of an agent ID string → non-negative integer.
+ * Used so proxy assignment is deterministic by agent ID, not config order.
+ */
+function hashAgentId(id) {
+    let h = 0;
+    for (const c of id)
+        h = (Math.imul(31, h) + c.charCodeAt(0)) | 0;
+    return Math.abs(h);
+}
+/**
+ * Resolve the proxy for an agent.
+ * Priority: agent.proxy config → GRANCLAW_PROXY_LIST (stable hash by agent ID) → undefined.
+ * Hash-based assignment means the same agent always gets the same proxy even if
+ * agents.config.json is reordered or new agents are added — so the Chrome daemon
+ * always restarts on the same IP.
+ * Only applies when GRANCLAW_PROXY_ENABLE=true or agent.proxy is explicitly set.
+ */
+function resolveAgentProxy(agentId, configProxy) {
+    if (configProxy)
+        return configProxy;
+    if (process.env.GRANCLAW_PROXY_ENABLE !== 'true')
+        return undefined;
+    const proxyList = process.env.GRANCLAW_PROXY_LIST;
+    if (!proxyList)
+        return undefined;
+    const proxies = proxyList.split(',').map(p => p.trim()).filter(Boolean);
+    if (proxies.length === 0)
+        return undefined;
+    return proxies[hashAgentId(agentId) % proxies.length];
+}
 async function runAgent(agent, message, onChunk, options) {
     const workspaceDir = path_1.default.resolve(config_js_1.REPO_ROOT, agent.workspaceDir);
     const channelId = options?.channelId ?? 'ui';
@@ -638,6 +682,50 @@ async function runAgent(agent, message, onChunk, options) {
         //
         // Privileged commands (record, close, tab close for session 0,
         // session management) are rejected — the runtime owns those.
+        /**
+         * After a navigation command, check if a CAPTCHA is blocking the page.
+         * Waits up to 30s for the CapMonster extension to auto-solve it.
+         * Returns 'clear' (no captcha / solved), 'unsolved' (still blocked after timeout).
+         */
+        async function waitForCaptchaResolution(bin, sessionId) {
+            const CAPTCHA_JS = `(function() {
+        var patterns = [
+          'iframe[src*="captcha-delivery"]',
+          'iframe[src*="geo.captcha"]',
+          'iframe[src*="recaptcha"]',
+          'iframe[src*="hcaptcha"]',
+          'iframe[src*="challenges.cloudflare"]',
+          '.g-recaptcha',
+          '.h-captcha',
+          '[class*="captcha"]',
+        ];
+        return patterns.some(function(s) {
+          return !!document.querySelector(s);
+        }) ? 'captcha' : 'clear';
+      })()`;
+            const evalArgv = (id) => ['--session', id, 'eval', CAPTCHA_JS];
+            const check = async () => {
+                try {
+                    const { stdout } = await execFileAsync(bin, evalArgv(sessionId), { timeout: 8_000 });
+                    return stdout.includes('"captcha"') || stdout.includes("'captcha'") || stdout.trim() === 'captcha';
+                }
+                catch {
+                    return false;
+                }
+            };
+            // Initial check — short delay to let page settle
+            await new Promise(r => setTimeout(r, 1500));
+            if (!await check())
+                return 'clear';
+            // CAPTCHA detected — wait up to 30s for auto-solve
+            const deadline = Date.now() + 30_000;
+            while (Date.now() < deadline) {
+                await new Promise(r => setTimeout(r, 2_000));
+                if (!await check())
+                    return 'clear';
+            }
+            return 'unsolved';
+        }
         extensionFactories.push((pi) => {
             const agentBrowserBin = process.env.AGENT_BROWSER_BIN ?? 'agent-browser';
             const profileDir = path_1.default.join(workspaceDir, '.browser-profile');
@@ -660,12 +748,15 @@ async function runAgent(agent, message, onChunk, options) {
                     'or `session`, they are rejected. Every turn is recorded as a single WebM video visible in the dashboard Browser view.',
                 promptSnippet: 'Control a headless browser — navigate, click, fill, snapshot, extract data',
                 promptGuidelines: [
+                    'Use browser for: real-time navigation, login flows, write/post/update operations (LinkedIn, Reddit, social media), pages requiring JS interaction, and multi-step forms.',
+                    'Do NOT use browser to just read a webpage — use fetch_website instead (faster, lighter, no screenshot overhead).',
                     'Core loop: open → snapshot → interact → re-snapshot. Refs from snapshot are invalidated by navigation.',
                     'For visual reasoning use `snapshot --annotate -i` (annotated screenshot with numbered refs).',
                     'For data extraction use `snapshot` (plain accessibility tree) or `text --ref <ref>`.',
                     'Do not call `record start`, `record stop`, `close`, or `session` — the runtime manages those.',
                     'You do not need to screenshot for audit — the whole session is recorded as video automatically.',
                     'Saved logins persist automatically when the user has set up a profile via the dashboard Browser view.',
+                    'CAPTCHA handling: if a page returns a CAPTCHA, wait — the browser has an automatic solver extension. If it is not resolved after ~30 seconds, use request_human_browser_takeover to let the user solve it.',
                     'Examples: {"command":"open","args":["https://example.com"]}, {"command":"click","args":["--ref","e12"]}, {"command":"fill","args":["--ref","e5","Alice"]}',
                 ],
                 parameters: {
@@ -718,7 +809,11 @@ async function runAgent(agent, message, onChunk, options) {
                     if (fs_1.default.existsSync(profileDir)) {
                         argv.push('--profile', profileDir);
                     }
-                    argv.push(...(0, stealth_js_1.stealthArgv)());
+                    const stealthOpts = {
+                        proxy: resolveAgentProxy(agent.id, agent.proxy),
+                        capmonsterKey: agent.capmonsterKey,
+                    };
+                    argv.push(...(0, stealth_js_1.stealthArgv)(stealthOpts));
                     argv.push(command, ...args);
                     try {
                         const { stdout, stderr } = await execFileAsync(agentBrowserBin, argv, {
@@ -728,6 +823,20 @@ async function runAgent(agent, message, onChunk, options) {
                         });
                         (0, session_manager_js_1.appendCommand)(browserState.handle, `${command} ${args.join(' ')}`.trim());
                         const out = stdout.trim() || stderr.trim() || 'ok';
+                        // After navigation, check for CAPTCHA and wait up to 30s for the
+                        // CapMonster extension to auto-solve it before returning to the agent.
+                        if (command === 'open' || command === 'reload') {
+                            const captchaResult = await waitForCaptchaResolution(agentBrowserBin, agent.id);
+                            if (captchaResult === 'unsolved') {
+                                return {
+                                    content: [{
+                                            type: 'text',
+                                            text: out + '\n\n⚠️ CAPTCHA detected and not auto-solved after 30s. ' +
+                                                'Use request_human_browser_takeover to let the user solve it, or try a different URL.',
+                                        }],
+                                };
+                            }
+                        }
                         return { content: [{ type: 'text', text: out }] };
                     }
                     catch (err) {
@@ -826,6 +935,7 @@ async function runAgent(agent, message, onChunk, options) {
                         'Use for any question about recent events, current prices, live data, or information past your training cutoff.',
                         'Prefer specific, focused queries over vague ones.',
                         'You can call this tool multiple times to refine results.',
+                        'After getting results, verify URLs with fetch_website before sharing with the user — confirms the page loads and is not paywalled or broken.',
                     ],
                     parameters: {
                         type: 'object',
@@ -862,6 +972,108 @@ async function runAgent(agent, message, onChunk, options) {
                 });
             });
         }
+        // fetch_website tool: fetches a URL and returns clean trimmed markdown.
+        // Normal mode: plain HTTP GET. Unblocker mode: Bright Data Web Unlocker API.
+        // Always registered — no key required for basic usage.
+        extensionFactories.push((pi) => {
+            const nhm = new node_html_markdown_1.NodeHtmlMarkdown();
+            function htmlToMarkdown(html, maxChars = 4000) {
+                let md = nhm.translate(html).replace(/\n{3,}/g, '\n\n').trim();
+                if (md.length > maxChars) {
+                    md = md.slice(0, maxChars) + `\n\n[...truncated at ${maxChars} chars]`;
+                }
+                return md;
+            }
+            pi.registerTool({
+                name: 'fetch_website',
+                label: 'Fetch Website',
+                description: 'Fetch a webpage and return its content as trimmed markdown. ' +
+                    'Use to read web pages, verify URLs from search results, or scrape public content. ' +
+                    'Set unblocker=true if the site blocks normal requests (bot-detection, Cloudflare, DataDome). ' +
+                    'Prefer this over browser for read-only operations — it is faster and uses less context.',
+                promptSnippet: 'Fetch and read a webpage as markdown',
+                promptGuidelines: [
+                    'Use fetch_website (not browser) when you only need to read a page — faster and no screenshot overhead.',
+                    'Use fetch_website to verify URLs from web_search results before sharing with the user.',
+                    'Set unblocker=true only after being blocked (captcha/403) on the same domain with unblocker=false.',
+                    'Output is truncated at 4000 chars. For interactive or login-gated pages, use browser instead.',
+                ],
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        url: { type: 'string', description: 'The URL to fetch' },
+                        unblocker: {
+                            type: 'boolean',
+                            description: 'Route through Bright Data Web Unlocker to bypass bot protection (default: false)',
+                        },
+                    },
+                    required: ['url'],
+                },
+                async execute(_toolCallId, params) {
+                    const useUnblocker = !!params.unblocker;
+                    if (useUnblocker) {
+                        const unblockerKey = process.env.BRIGHTDATA_UNBLOCKER_KEY;
+                        const unblockerEnabled = process.env.BRIGHTDATA_UNBLOCKER_ENABLED !== 'false';
+                        if (!unblockerKey || !unblockerEnabled) {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: 'fetch_website: Bright Data unblocker not configured. Set BRIGHTDATA_UNBLOCKER_KEY and BRIGHTDATA_UNBLOCKER_ENABLED=true.',
+                                    }],
+                            };
+                        }
+                        try {
+                            const res = await fetch('https://api.brightdata.com/request', {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                    'Authorization': `Bearer ${unblockerKey}`,
+                                },
+                                body: JSON.stringify({ zone: 'web_unlocker1', url: params.url, format: 'raw' }),
+                                signal: AbortSignal.timeout(30_000),
+                            });
+                            if (!res.ok) {
+                                return { content: [{ type: 'text', text: `fetch_website (unblocker): HTTP ${res.status} ${res.statusText}` }] };
+                            }
+                            const html = await res.text();
+                            const md = htmlToMarkdown(html);
+                            return { content: [{ type: 'text', text: md }] };
+                        }
+                        catch (err) {
+                            return { content: [{ type: 'text', text: `fetch_website (unblocker) error: ${err instanceof Error ? err.message : String(err)}` }] };
+                        }
+                    }
+                    // Plain HTTP fetch — route through proxy if configured
+                    try {
+                        const agentProxy = resolveAgentProxy(agent.id, agent.proxy);
+                        const fetchOpts = {
+                            headers: {
+                                'User-Agent': 'Mozilla/5.0 (compatible; GranClaw/1.0; +https://granclaw.com)',
+                                'Accept': 'text/html,application/xhtml+xml,*/*;q=0.9',
+                            },
+                            signal: AbortSignal.timeout(15_000),
+                            redirect: 'follow',
+                            ...(agentProxy ? { dispatcher: getProxyAgent(agentProxy) } : {}),
+                        };
+                        const res = await (0, undici_1.fetch)(params.url, fetchOpts);
+                        if (!res.ok) {
+                            return { content: [{ type: 'text', text: `fetch_website: HTTP ${res.status} ${res.statusText}. Try unblocker=true if blocked.` }] };
+                        }
+                        const contentType = res.headers.get('content-type') ?? '';
+                        const body = await res.text();
+                        if (!contentType.includes('html')) {
+                            const out = body.length > 4000 ? body.slice(0, 4000) + '\n\n[...truncated]' : body;
+                            return { content: [{ type: 'text', text: out }] };
+                        }
+                        const md = htmlToMarkdown(body);
+                        return { content: [{ type: 'text', text: md }] };
+                    }
+                    catch (err) {
+                        return { content: [{ type: 'text', text: `fetch_website error: ${err instanceof Error ? err.message : String(err)}` }] };
+                    }
+                },
+            });
+        });
         // Build resource loader. Must call reload() before passing to createAgentSession —
         // when the sdk receives a pre-built resourceLoader it skips reload().
         const resourceLoader = new DefaultResourceLoader({

package/dist/backend/agent/telegram-adapter.js

@@ -22,8 +22,12 @@
  * stay under Telegram's per-chat rate limit. Periodic typing indicators are
  * re-sent every 4 s while the job is running.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelegramAdapter = void 0;
+const telegramify_markdown_1 = __importDefault(require("telegramify-markdown"));
 const telegram_http_client_js_1 = require("./telegram-http-client.js");
 const agent_db_js_1 = require("../agent-db.js");
 const i18n_telegram_js_1 = require("../lib/i18n-telegram.js");
@@ -181,6 +185,17 @@ class TelegramAdapter {
             return;
         state.responseBuffer += text;
     }
+    /** Called from process.ts when the agent emits a takeover_requested chunk. */
+    notifyTakeover(channelId, takeoverUrl) {
+        const state = this.chats.get(channelId);
+        if (!state)
+            return;
+        this.bot
+            .sendMessage(state.chatId, `Takeover link: ${takeoverUrl}`)
+            .catch((err) => {
+            console.warn(`[agent:${this.agentId}] Telegram takeover notify failed:`, err.message);
+        });
+    }
     // ── Finalize + flush ─────────────────────────────────────────────────────
     /**
      * Edit the live status message one last time with a "Done" footer, then
@@ -235,15 +250,30 @@ class TelegramAdapter {
     }
     async sendReply(chatId, text) {
         const MAX = 4000;
-        if (text.length <= MAX) {
-            await this.bot.sendMessage(chatId, text, { parse_mode: 'Markdown' }).catch(() => this.bot.sendMessage(chatId, text));
+        // Convert standard markdown → Telegram MarkdownV2. Fall back to plain
+        // text if conversion throws (e.g. deeply malformed LLM output).
+        let body;
+        let parseMode;
+        try {
+            body = (0, telegramify_markdown_1.default)(text, 'escape');
+            parseMode = 'MarkdownV2';
+        }
+        catch {
+            body = text;
+            parseMode = undefined;
+        }
+        const send = (chunk) => this.bot
+            .sendMessage(chatId, chunk, parseMode ? { parse_mode: parseMode } : undefined)
+            .catch(() => this.bot.sendMessage(chatId, chunk, {})); // plain-text fallback
+        if (body.length <= MAX) {
+            await send(body);
             return;
         }
-        let remaining = text;
+        let remaining = body;
         while (remaining.length > 0) {
-            const chunk = remaining.slice(0, MAX);
-            const splitAt = chunk.lastIndexOf('\n') > MAX / 2 ? chunk.lastIndexOf('\n') : MAX;
-            await this.bot.sendMessage(chatId, remaining.slice(0, splitAt)).catch(() => { });
+            const slice = remaining.slice(0, MAX);
+            const splitAt = slice.lastIndexOf('\n') > MAX / 2 ? slice.lastIndexOf('\n') : MAX;
+            await send(remaining.slice(0, splitAt));
             remaining = remaining.slice(splitAt).trimStart();
         }
     }

package/dist/backend/assets/capmonster-extension/_locales/en/messages.json

@@ -0,0 +1,226 @@
+{
+    "extName": {
+        "message": "CapMonster Cloud — automated captcha solver",
+        "description": "The title of the application, displayed in the web store."
+    },
+    "extDesc": {
+        "message": "Online service for automated captcha solving",
+        "description": "The description of the application, displayed in the web store."
+    },
+    "extNameFirefox": {
+        "message": "CapMonster Cloud — automated captcha solver",
+        "description": "The title of the application, displayed in the web store."
+    },
+    "extDescFirefox": {
+        "message": "Online service for automated captcha solving",
+        "description": "The description of the application, displayed in the web store."
+    },
+    "extShortName": {
+        "message": "CapMonster Cloud",
+        "description": ""
+    },
+    "on": {
+        "message": "On",
+        "description": ""
+    },
+    "off": {
+        "message": "Off",
+        "description": ""
+    },
+    "support": {
+        "message": "Support",
+        "description": ""
+    },
+    "apiKeyPlaceholder": {
+        "message": "Enter API key",
+        "description": ""
+    },
+    "getKey": {
+        "message": "Get a key",
+        "description": ""
+    },
+    "balance": {
+        "message": "Balance",
+        "description": ""
+    },
+    "topUp": {
+        "message": "Add funds",
+        "description": ""
+    },
+    "wrongKey": {
+        "message": "Wrong key",
+        "description": ""
+    },
+    "emptyKey": {
+        "message": "Empty key",
+        "description": ""
+    },
+    "automaticCaptchaSolving": {
+        "message": "Automated captcha solving",
+        "description": ""
+    },
+    "settings": {
+        "message": "Settings",
+        "description": ""
+    },
+    "repeatSolveAttempts": {
+        "message": "Repeat captcha solving in case of an error, attempts",
+        "description": ""
+    },
+    "proxy": {
+        "message": "Proxy",
+        "description": ""
+    },
+    "proxyType": {
+        "message": "Proxy type",
+        "description": ""
+    },
+    "port": {
+        "message": "Port",
+        "description": ""
+    },
+    "login": {
+        "message": "Login",
+        "description": ""
+    },
+    "password": {
+        "message": "Password",
+        "description": ""
+    },
+    "blacklistControl": {
+        "message": "Blacklist control",
+        "description": ""
+    },
+    "blacklistDescription": {
+        "message": "Captcha solving on added websites will be disabled",
+        "description": ""
+    },
+    "add": {
+        "message": "Add",
+        "description": ""
+    },
+    "manualRecognition": {
+        "message": "Manual recognition",
+        "description": ""
+    },
+    "textCaptcha": {
+        "message": "Text captcha",
+        "description": ""
+    },
+    "textCaptchaHelpLink": {
+        "message": "https://docs.capmonster.cloud/docs/captchas/image-to-text",
+        "description": ""
+    },
+    "markImageAsCaptcha": {
+        "message": "Mark image as captcha",
+        "description": ""
+    },
+    "selectForSubmit": {
+        "message": "Select element for submit",
+        "description": ""
+    },
+    "selectInputForCaptchaResult": {
+        "message": "Select an input for the captcha result",
+        "description": ""
+    },
+    "help": {
+        "message": "Help",
+        "description": ""
+    },
+    "rcInfoText": {
+        "message": "Only click",
+        "description": ""
+    },
+    "close_button": {
+        "message": "Close",
+        "description": ""
+    },
+    "delayStartCount": {
+        "message": "Delay between start solve captcha clicks",
+        "description": ""
+    },
+    "textCaptchaSaveOnSite": {
+        "message": "Save selected captcha position for sites",
+        "description": ""
+    },
+    "delayAfterLoadPage": {
+        "message": "Delay before start solve saved captcha",
+        "description": ""
+    },
+    "autoClick": {
+        "message": "Auto click",
+        "description": ""
+    },
+    "autoSolve": {
+        "message": "Auto solve",
+        "description": ""
+    },
+    "globalVariableSetting": {
+        "message": "Global variable",
+        "description": ""
+    },
+    "manualRecognitionDescription": {
+        "message": "This feature allows starting captcha solving using the \"Token\" method not automatically but by clicking the \"Solve\" button.",
+        "description": ""
+    },
+    "textCaptchaModule": {
+        "message": "Text module",
+        "description": ""
+    },
+    "enterModuleName": {
+        "message": "Enter text module",
+        "description": ""
+    },
+    "addModuleText": {
+        "message": "Add module",
+        "description": ""
+    },
+    "autoModule": {
+        "message": "Auto",
+        "description": ""
+    },
+    "delayBetweenClickValue": {
+        "message": "Delay between click (ms)",
+        "description": ""
+    },
+    "delayBetweenClickEnabled": {
+        "message": "Delay between click",
+        "description": ""
+    },
+    "apiKeyTitle": {
+        "message": "API-key",
+        "description": ""
+    },
+    "globalObjectDescription": {
+        "message": "Name of the field for interaction with the extension via a global object. More information about the extension settings can be found",
+        "description": ""
+    },
+    "globalObjectDescriptionLink": {
+        "message": "in the article",
+        "description": ""
+    },
+    "autoSubmitText": {
+        "message": "Element for auto submit",
+        "description": ""
+    },
+    "removeAutoSubmit": {
+        "message": "Remove",
+        "description": ""
+    },
+    "emptyDetectedCaptchaMessage": {
+        "message": "CAPTCHA may require activation - simply refreshing the page might not be enough. Please complete the CAPTCHA manually to load all necessary parameters.",
+        "description": ""
+    },
+    "detectedCaptchas": {
+        "message": "Captchas detected",
+        "description": ""
+    },
+    "copySuccessMessage": {
+        "message": "Copied to clipboard!",
+        "description": ""
+    },
+    "copyFailedMessage": {
+        "message": "Failed to copy",
+        "description": ""
+    }
+}