granclaw 0.0.1-beta.6 → 0.0.1-beta.60

package/dist/backend/agent/browser-bin.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBrowserProvider = registerBrowserProvider;
+exports._resetBrowserProvidersForTests = _resetBrowserProvidersForTests;
+exports.buildArgv = buildArgv;
+exports.resolveBrowserBinary = resolveBrowserBinary;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const stealth_js_1 = require("../browser/stealth.js");
+const providers = [];
+function registerBrowserProvider(provider) {
+    providers.push(provider);
+}
+function _resetBrowserProvidersForTests() {
+    providers.length = 0;
+}
+function buildArgv(res, command, args) {
+    return [...res.preCommandArgs, command, ...args, ...res.postCommandArgs];
+}
+function resolveBrowserBinary(agentId, workspaceDir) {
+    for (const provider of providers) {
+        const resolution = provider(agentId, workspaceDir);
+        if (resolution)
+            return resolution;
+    }
+    const bin = process.env.AGENT_BROWSER_BIN ?? 'agent-browser';
+    const profileDir = path_1.default.join(workspaceDir, '.browser-profile');
+    const preCommandArgs = ['--session', agentId];
+    if (fs_1.default.existsSync(profileDir)) {
+        preCommandArgs.push('--profile', profileDir);
+    }
+    preCommandArgs.push(...(0, stealth_js_1.stealthArgv)());
+    return {
+        bin,
+        preCommandArgs,
+        postCommandArgs: [],
+        env: {},
+        isRemote: false,
+        recordingSupported: true,
+    };
+}

package/dist/backend/agent/captcha-detect.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPTCHA_DETECT_JS = void 0;
+exports.CAPTCHA_DETECT_JS = `(function() {
+  var title = (document.title || '').toLowerCase();
+
+  // Cloudflare JS interstitials — the stealth extension can clear these.
+  var cfTitlePatterns = [
+    'just a moment',           // Cloudflare interstitial (EN)
+    'un momento',              // CF Spanish
+    'un instant',              // CF French
+    'einen moment',            // CF German
+    'checking your browser',   // CF older / generic anti-bot
+    'please wait',             // generic "please wait while we check"
+  ];
+  var cfSelectors = [
+    '#challenge-stage',
+    '#challenge-running',
+    '#cf-challenge-running',
+    '.cf-browser-verification',
+    '.cf-im-under-attack',
+  ];
+  for (var i = 0; i < cfTitlePatterns.length; i++) {
+    if (title.indexOf(cfTitlePatterns[i]) !== -1) return 'interstitial';
+  }
+  for (var j = 0; j < cfSelectors.length; j++) {
+    if (document.querySelector(cfSelectors[j])) return 'interstitial';
+  }
+
+  // Actual captcha widgets — need human intervention.
+  var captchaSelectors = [
+    'iframe[src*="captcha-delivery"]',        // DataDome
+    'iframe[src*="geo.captcha"]',             // DataDome geo
+    'iframe[src*="recaptcha"]',               // reCaptcha v2/v3
+    'iframe[src*="hcaptcha"]',                // hCaptcha
+    'iframe[src*="challenges.cloudflare"]',   // Cloudflare Turnstile
+    'iframe[src*="arkoselabs"]',              // Arkose FunCaptcha
+    'iframe[src*="funcaptcha"]',
+    '.g-recaptcha',
+    '.h-captcha',
+    '[class*="captcha"]',
+    '#px-captcha',                            // PerimeterX / HUMAN
+  ];
+  // "Attention Required" is a CF WAF block — not a JS interstitial, needs human.
+  if (title.indexOf('attention required') !== -1) return 'captcha';
+  for (var k = 0; k < captchaSelectors.length; k++) {
+    if (document.querySelector(captchaSelectors[k])) return 'captcha';
+  }
+  return 'clear';
+})()`;

package/dist/backend/agent/process.js

@@ -1,20 +1,4 @@
 "use strict";
-/**
- * agent/process.ts
- *
- * Standalone agent process — spawned by the orchestrator, one per agent.
- *
- * Architecture:
- *   WS server  →  receives messages  →  [BB evaluate]  →  enqueue()
- *   Queue worker (poll loop)          →  dequeueNext() → runAgent() → broadcastToChannel chunks
- *
- * WebSocket protocol:
- *   Client → Agent:  { type: 'message', text: string, channelId?: string }
- *   Agent  → Client: { type: 'queued' }
- *                    { type: 'chunk', chunk: StreamChunk }
- *                    { type: 'error', message: string }
- *                    { type: 'blocked', reason: string }
- */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -37,7 +21,6 @@ if (!agentId || !port) {
     console.error('[agent/process] AGENT_ID and AGENT_PORT env vars are required');
     process.exit(1);
 }
-// ── Main ───────────────────────────────────────────────────────────────────────
 function main() {
     const agent = (0, config_js_1.getAgent)(agentId);
     if (!agent) {
@@ -45,13 +28,11 @@ function main() {
         process.exit(1);
     }
     const workspaceDir = path_1.default.resolve(config_js_1.REPO_ROOT, agent.workspaceDir);
-    // Clean up stale 'processing' jobs from previous crashes/restarts
+    (0, runner_pi_js_1.bootstrapWorkspace)(workspaceDir, agentId);
     const cleaned = (0, agent_db_js_1.cleanupStaleJobs)(workspaceDir);
     if (cleaned > 0)
         console.log(`[agent:${agentId}] cleaned up ${cleaned} stale processing jobs`);
-    // ── WebSocket server ───────────────────────────────────────────────────────
     const wss = new ws_1.WebSocketServer({ port });
-    // Map from channelId → set of WS clients subscribed to that channel
     const channelClients = new Map();
     function getChannelClients(channelId) {
         if (!channelClients.has(channelId))
@@ -59,7 +40,7 @@ function main() {
         return channelClients.get(channelId);
     }
     wss.on('connection', (ws) => {
-        let clientChannelId = 'ui'; // default until client sends a message with channelId
+        let clientChannelId = 'ui';
         console.log(`[agent:${agentId}] client connected`);
         ws.on('message', (raw) => {
             let msg;
@@ -76,8 +57,6 @@ function main() {
                 ws.send(JSON.stringify({ type: 'stopped', killed: stopped }));
             }
             else if (msg.type === 'subscribe' && msg.channelId) {
-                // Subscribe this WS client to a channel without sending a message.
-                // Used by the frontend to receive live chunks from scheduled runs.
                 clientChannelId = msg.channelId;
                 getChannelClients(clientChannelId).add(ws);
             }
@@ -89,7 +68,6 @@ function main() {
             }
         });
         ws.on('close', () => {
-            // Remove from whichever channel set it was in
             for (const [id, set] of channelClients.entries()) {
                 set.delete(ws);
                 if (set.size === 0)
@@ -99,16 +77,11 @@ function main() {
         });
     });
     console.log(`[agent:${agentId}] WS listening on ws://localhost:${port}`);
-    // ── Telegram adapter ───────────────────────────────────────────────────────
-    // Started automatically if TELEGRAM_BOT_TOKEN is set (via Secrets in the UI).
-    // The user adds TELEGRAM_BOT_TOKEN as a secret → orchestrator injects it as
-    // an env var when spawning this process → adapter picks it up here.
     let telegramAdapter = null;
     const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN;
     if (telegramBotToken) {
         telegramAdapter = new telegram_adapter_js_1.TelegramAdapter(agentId, telegramBotToken, workspaceDir);
     }
-    // ── Queue worker ───────────────────────────────────────────────────────────
     function broadcastToChannel(channelId, data) {
         const json = JSON.stringify(data);
         const targets = channelClients.get(channelId);
@@ -119,14 +92,13 @@ function main() {
                 ws.send(json);
         }
     }
-    // Track busy state per channel type so UI chat can run while workflows/schedules execute
     const busyChannels = new Set();
     function channelType(channelId) {
         if (channelId.startsWith('wf-'))
             return 'workflow';
         if (channelId === 'schedule')
             return 'schedule';
-        return channelId; // 'ui', 'telegram:xxx' — each is its own lane
+        return channelId;
     }
     async function processNext() {
         const job = (0, agent_db_js_1.dequeueNext)(workspaceDir, agentId, busyChannels);
@@ -136,27 +108,15 @@ function main() {
         busyChannels.add(lane);
         try {
             const isTelegramJob = telegramAdapter !== null && job.channelId.startsWith('telegram:');
-            // Save the prompt so it's visible in run history immediately
             try {
                 (0, messages_db_js_1.saveMessage)({ id: (0, crypto_1.randomUUID)(), agentId: agentId, channelId: job.channelId, role: 'user', content: job.message });
             }
-            catch { /* non-fatal */ }
-            // Stream chunks directly to channel clients.
-            //
-            // tool_call rows are persisted to the DB the moment they arrive
-            // (not batched at turn end). Reason: if a user leaves the chat view
-            // mid-turn and navigates to /dashboard, ChatPage unmounts and loses
-            // its in-memory streaming state. On return, it refetches history
-            // from the DB — if tool_calls were still buffered in memory, the
-            // user would see an empty chat while the agent was clearly still
-            // working. Persisting as-they-happen makes the live state
-            // refetchable. See regression A (view-switch-state.spec.ts).
+            catch { }
             let fullResponse = '';
             let toolCallCount = 0;
-            // Inject context message if a human takeover was pending
             let messageText = job.message;
             if ((0, takeover_state_js_1.hasTakeover)(agentId)) {
-                (0, takeover_state_js_1.cancelTakeoverTimer)(agentId); // stop 10min timeout — entry stays for runner-pi to restore handle
+                (0, takeover_state_js_1.cancelTakeoverTimer)(agentId);
                 messageText =
                     `[User completed browser interaction]\n` +
                         `User said: "${job.message}"`;
@@ -169,6 +129,18 @@ 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 {
+                        broadcastToChannel(job.channelId, {
+                            type: 'chunk',
+                            chunk: { type: 'text', text: `\n\n🔗 **Takeover link:** ${takeoverUrl}\n\n` },
+                        });
+                    }
+                }
                 if (chunk.type === 'tool_call') {
                     const tcString = `${chunk.tool}(${JSON.stringify(chunk.input)})`;
                     toolCallCount++;
@@ -181,16 +153,12 @@ function main() {
                             content: tcString,
                         });
                     }
-                    catch { /* non-fatal — WAL/locking can fail under parallel writes */ }
+                    catch { }
                     if (isTelegramJob) {
-                        // Live status update — appears in the user's chat as the
-                        // acknowledgment message gets edited to show progress.
                         void telegramAdapter.appendToolStep(job.channelId, chunk.tool);
                     }
                 }
             }, { channelId: job.channelId });
-            // Persist the final assistant message. tool_call rows were already
-            // saved one-by-one above, so no batch here.
             try {
                 if (fullResponse) {
                     (0, messages_db_js_1.saveMessage)({
@@ -199,13 +167,12 @@ function main() {
                         channelId: job.channelId,
                         role: 'assistant',
                         content: fullResponse,
-                        createdAt: Date.now() + toolCallCount, // ordered after the last tool_call
+                        createdAt: Date.now() + toolCallCount,
                     });
                 }
             }
-            catch { /* non-fatal */ }
+            catch { }
             (0, agent_db_js_1.markDone)(workspaceDir, job.id);
-            // Arm 10-minute timeout if the agent registered a takeover during this run
             if ((0, takeover_state_js_1.hasTakeover)(agentId)) {
                 const timer = setTimeout(() => {
                     (0, takeover_timeout_js_1.handleTakeoverTimeout)(agentId, workspaceDir).catch((err) => {
@@ -214,14 +181,9 @@ function main() {
                 }, takeover_state_js_1.TAKEOVER_TIMEOUT_MS);
                 (0, takeover_state_js_1.updateTakeoverTimer)(agentId, timer);
             }
-            // Belt-and-suspenders: if the agent left a browser session open (e.g.
-            // forgot to call close), finalize it so recordings don't stay "active"
-            // forever and stream subscribers detach cleanly.
-            // Skip if a human takeover is pending — browser session must stay alive
             if (!(0, takeover_state_js_1.hasTakeover)(agentId)) {
                 (0, browser_sessions_js_1.forceCloseActiveSession)(agentId);
             }
-            // Send the full reply back to Telegram once the turn is complete
             if (isTelegramJob) {
                 await telegramAdapter.flushReply(job.channelId);
             }