granclaw 0.0.1-beta.96 → 0.0.1-beta.98

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

@@ -1,25 +1,120 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerBrowserProvider = registerBrowserProvider;
+exports.registerBrowserKiller = registerBrowserKiller;
+exports.killBrowser = killBrowser;
 exports._resetBrowserProvidersForTests = _resetBrowserProvidersForTests;
 exports.buildArgv = buildArgv;
+exports.cdpNavigate = cdpNavigate;
 exports.resolveBrowserBinary = resolveBrowserBinary;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const ws_1 = require("ws");
 const stealth_js_1 = require("../browser/stealth.js");
 const providers = [];
 function registerBrowserProvider(provider) {
     providers.push(provider);
 }
+const killers = [];
+function registerBrowserKiller(killer) {
+    killers.push(killer);
+}
+async function killBrowser(agentId) {
+    for (const killer of killers) {
+        try {
+            await killer(agentId);
+        }
+        catch { }
+    }
+    try {
+        fs_1.default.unlinkSync(`/tmp/granclaw-cdp-${agentId}.url`);
+    }
+    catch { }
+    try {
+        const { execFileSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const bin = process.env.AGENT_BROWSER_BIN ?? 'agent-browser';
+        execFileSync(bin, ['--session', agentId, 'close'], { timeout: 5000, stdio: 'pipe' });
+    }
+    catch { }
+}
 function _resetBrowserProvidersForTests() {
     providers.length = 0;
+    killers.length = 0;
 }
 function buildArgv(res, command, args) {
     return [...res.preCommandArgs, command, ...args, ...res.postCommandArgs];
 }
+function cdpNavigate(port, url) {
+    return new Promise(async (resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('cdpNavigate: timeout')), 15_000);
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/json`);
+            const targets = (await res.json());
+            const page = targets.find(t => t.type === 'page');
+            if (!page) {
+                clearTimeout(timer);
+                reject(new Error('cdpNavigate: no page target'));
+                return;
+            }
+            const ws = new ws_1.WebSocket(page.webSocketDebuggerUrl);
+            ws.on('open', () => {
+                ws.send(JSON.stringify({ id: 1, method: 'Page.navigate', params: { url } }));
+            });
+            ws.on('message', (data) => {
+                const msg = JSON.parse(data.toString());
+                if (msg.id === 1) {
+                    clearTimeout(timer);
+                    ws.close();
+                    if (msg.error)
+                        reject(new Error(`cdpNavigate: ${msg.error.message}`));
+                    else
+                        resolve(url);
+                }
+            });
+            ws.on('error', (err) => { clearTimeout(timer); reject(err); });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            reject(err);
+        }
+    });
+}
 async function resolveBrowserBinary(agentId, workspaceDir) {
     for (const provider of providers) {
         const resolution = await provider(agentId, workspaceDir);
@@ -39,6 +134,7 @@ async function resolveBrowserBinary(agentId, workspaceDir) {
                     env: {},
                     isRemote: false,
                     recordingSupported: true,
+                    cdpPort: port,
                 };
             }
         }

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

@@ -413,7 +413,7 @@ async function runAgent(agent, message, onChunk, options) {
                     },
                 },
                 async execute(_toolCallId, params) {
-                    const apiUrl = process.env.GRANCLAW_API_URL ?? 'http://localhost:3001';
+                    const apiUrl = process.env.GRANCLAW_API_URL ?? `http://localhost:${process.env.PORT ?? 3001}`;
                     const url = new URL(`${apiUrl}/agents/${agent.id}/messages`);
                     if (params.contains)
                         url.searchParams.set('contains', params.contains);
@@ -564,7 +564,7 @@ async function runAgent(agent, message, onChunk, options) {
         });
         extensionFactories.push((pi) => {
             const taskBase = () => {
-                const apiUrl = process.env.GRANCLAW_API_URL ?? 'http://localhost:3001';
+                const apiUrl = process.env.GRANCLAW_API_URL ?? `http://localhost:${process.env.PORT ?? 3001}`;
                 return `${apiUrl}/agents/${agent.id}/tasks`;
             };
             const fetchJson = async (url, init) => {
@@ -585,7 +585,7 @@ async function runAgent(agent, message, onChunk, options) {
                 parameters: {
                     type: 'object',
                     properties: {
-                        status: { type: 'string', enum: ['backlog', 'in_progress', 'scheduled', 'to_review', 'done'], description: 'Filter by status (omit for all tasks)' },
+                        status: { type: 'string', enum: ['backlog', 'in_progress', 'scheduled', 'to_review', 'done', 'cancelled'], description: 'Filter by status (omit for all tasks)' },
                     },
                 },
                 async execute(_id, params) {
@@ -788,6 +788,17 @@ async function runAgent(agent, message, onChunk, options) {
                     if (browser.recordingSupported && !browserState.handle.recordingStarted) {
                         await (0, session_manager_js_1.startRecording)(browserState.handle, browser);
                     }
+                    if (command === 'open' && browser.cdpPort && args.length > 0) {
+                        try {
+                            await (0, browser_bin_js_1.cdpNavigate)(browser.cdpPort, args[0]);
+                            (0, session_manager_js_1.appendCommand)(browserState.handle, `${command} ${args.join(' ')}`.trim());
+                            return { content: [{ type: 'text', text: `Navigated to ${args[0]}` }] };
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            return { content: [{ type: 'text', text: `browser open failed (CDP navigate): ${msg}` }] };
+                        }
+                    }
                     const argv = (0, browser_bin_js_1.buildArgv)(browser, command, args);
                     try {
                         const { stdout, stderr } = await execFileAsync(browser.bin, argv, {
@@ -827,6 +838,41 @@ async function runAgent(agent, message, onChunk, options) {
                 },
             });
         });
+        extensionFactories.push((pi) => {
+            pi.registerTool({
+                name: 'browser_restart',
+                label: 'Restart Browser',
+                description: 'Kill the browser process and force a fresh start on the next browser command. ' +
+                    'Cookies, logins, and profile data are preserved — only the process is restarted. ' +
+                    'Use when the browser is hung, unresponsive, showing stale state, or after a proxy change.',
+                promptSnippet: 'Kill and respawn the browser daemon (cookies survive)',
+                promptGuidelines: [
+                    'Use when browser commands timeout repeatedly or the browser appears hung.',
+                    'Use after you receive BROWSER_BLOCKED if you want a clean process before retrying.',
+                    'Cookies and saved logins persist — only the process is restarted.',
+                    'The next browser command after this will spawn a fresh browser automatically.',
+                ],
+                parameters: { type: 'object', properties: {} },
+                async execute() {
+                    try {
+                        if (browserState.handle) {
+                            try {
+                                await (0, session_manager_js_1.finalizeSession)(browserState.handle, 'closed');
+                            }
+                            catch { }
+                            browserState.handle = null;
+                        }
+                        await (0, browser_bin_js_1.killBrowser)(agent.id);
+                        return { content: [{ type: 'text', text: 'Browser killed. Cookies and logins are preserved. The next browser command will spawn a fresh instance.' }] };
+                    }
+                    catch (err) {
+                        browserState.handle = null;
+                        const msg = err instanceof Error ? err.message : String(err);
+                        return { content: [{ type: 'text', text: `browser_restart partial: ${msg} — next browser call will still spawn fresh.` }] };
+                    }
+                },
+            });
+        });
         extensionFactories.push((pi) => {
             pi.registerTool({
                 name: 'request_human_browser_takeover',
@@ -943,7 +989,7 @@ async function runAgent(agent, message, onChunk, options) {
                         required: ['query'],
                     },
                     async execute(_toolCallId, params) {
-                        const apiUrl = process.env.GRANCLAW_API_URL ?? 'http://localhost:3001';
+                        const apiUrl = process.env.GRANCLAW_API_URL ?? `http://localhost:${process.env.PORT ?? 3001}`;
                         const url = `${apiUrl}/search?q=${encodeURIComponent(params.query)}`;
                         try {
                             const res = await fetch(url);

package/dist/backend/orchestrator/server.js

@@ -1203,6 +1203,19 @@ function createServer() {
         }
         res.json(run);
     });
+    app.post('/agents/:id/workflows/:wfId/runs/:runId/cancel', (req, res) => {
+        const managed = (0, agent_manager_js_1.getManagedAgent)(req.params.id);
+        if (!managed) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        const cancelled = (0, runner_js_1.cancelWorkflowRun)(req.params.id, req.params.runId);
+        if (!cancelled) {
+            res.status(404).json({ error: 'Run not active or not found' });
+            return;
+        }
+        res.json({ ok: true });
+    });
     app.get('/agents/:id/schedules', (req, res) => {
         const managed = (0, agent_manager_js_1.getManagedAgent)(req.params.id);
         if (!managed) {
@@ -1517,6 +1530,7 @@ function createServer() {
     (0, loader_js_1.loadExtensions)({
         app,
         registerBrowserProvider: browser_bin_js_1.registerBrowserProvider,
+        registerBrowserKiller: browser_bin_js_1.registerBrowserKiller,
         registerCdpSession: browser_live_js_1.registerExternalCdpSession,
         removeCdpSession: browser_live_js_1.removeExternalCdpSession,
         registerTakeoverResolvedListener: takeover_listeners_js_1.registerTakeoverResolvedListener,

package/dist/backend/workflows/runner.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelWorkflowRun = cancelWorkflowRun;
+exports.getActiveRunIds = getActiveRunIds;
 exports.executeWorkflow = executeWorkflow;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
@@ -15,6 +17,18 @@ const runner_pi_js_1 = require("../agent/runner-pi.js");
 const crypto_1 = require("crypto");
 const messages_db_js_1 = require("../messages-db.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const activeRuns = new Map();
+function cancelWorkflowRun(agentId, runId) {
+    const key = `${agentId}:${runId}`;
+    const ctrl = activeRuns.get(key);
+    if (!ctrl)
+        return false;
+    ctrl.abort();
+    return true;
+}
+function getActiveRunIds() {
+    return Array.from(activeRuns.keys());
+}
 function resolveTemplates(prompt, prevOutput, allResults) {
     let resolved = prompt;
     resolved = resolved.replace(/\{\{prev\.output\}\}/g, prevOutput !== null ? JSON.stringify(prevOutput) : 'null');
@@ -170,6 +184,9 @@ async function executeWorkflow(agentId, workflowId, trigger) {
     const workspaceDir = path_1.default.resolve(config_js_1.REPO_ROOT, agent.workspaceDir);
     const run = (0, workflows_db_js_1.createRun)(agentId, workflowId, trigger);
     const allResults = [];
+    const abortCtrl = new AbortController();
+    const runKey = `${agentId}:${run.id}`;
+    activeRuns.set(runKey, abortCtrl);
     const runStepMap = new Map();
     for (const step of workflow.steps) {
         const runStep = (0, workflows_db_js_1.createRunStep)(agentId, { runId: run.id, stepId: step.id });
@@ -178,6 +195,17 @@ async function executeWorkflow(agentId, workflowId, trigger) {
     let currentStep = workflow.steps[0];
     let prevOutput = null;
     while (currentStep) {
+        if (abortCtrl.signal.aborted) {
+            for (const step of workflow.steps) {
+                const rsId = runStepMap.get(step.id);
+                if (!allResults.some(r => r.stepId === step.id)) {
+                    (0, workflows_db_js_1.updateRunStep)(agentId, rsId, { status: 'skipped' });
+                }
+            }
+            (0, workflows_db_js_1.updateRun)(agentId, run.id, { status: 'cancelled', finishedAt: Date.now() });
+            activeRuns.delete(runKey);
+            return run.id;
+        }
         const runStepId = runStepMap.get(currentStep.id);
         const startedAt = Date.now();
         (0, workflows_db_js_1.updateRunStep)(agentId, runStepId, { status: 'running', startedAt });
@@ -266,12 +294,14 @@ async function executeWorkflow(agentId, workflowId, trigger) {
                 }
             }
             (0, workflows_db_js_1.updateRun)(agentId, run.id, { status: 'failed', finishedAt });
+            activeRuns.delete(runKey);
             console.error(`[workflow-runner] step "${currentStep?.name}" failed:`, message);
             const failSummary = `**Workflow "${workflow.name}" failed** at step "${currentStep?.name}"\n\nError: ${message}`;
             (0, messages_db_js_1.saveMessage)({ id: (0, crypto_1.randomUUID)(), agentId, channelId: 'ui', role: 'assistant', content: failSummary });
             return run.id;
         }
     }
+    activeRuns.delete(runKey);
     (0, workflows_db_js_1.updateRun)(agentId, run.id, { status: 'completed', finishedAt: Date.now() });
     const lastOutput = allResults[allResults.length - 1];
     const outputPreview = typeof lastOutput?.output === 'string'