@dyyz1993/agent-browser 0.13.2 → 0.24.0

package/dist/actions.js

@@ -7,6 +7,10 @@ import { getViewerUrl, getViewerWsUrl, getViewerPort, getMessageBridgeUrl, getEx
 import { detectMainContent, generateContentTips } from './content-detection.js';
 import { humanClick, humanType, humanMoveTo, humanWander, getHumanConfigFromEnv, } from './human-mouse.js';
 import { successResponse, errorResponse } from './protocol.js';
+import { parseYamlSiteFile, loadSitesFromDirectory, loadAllSites, findFlow, validateYamlFile, } from './flow/yaml-parser.js';
+import { recorderToFlowFromFile, siteToYamlString } from './flow/recorder-to-flow.js';
+import { FlowExecutor } from './flow/flow-executor.js';
+import { PlaywrightExporter, PythonExporter, CypressExporter, SeleniumExporter, } from './flow/exporters/index.js';
 // Callback for screencast frames - will be set by the daemon when streaming is active
 let screencastFrameCallback = null;
 /**
@@ -98,6 +102,9 @@ export function toAIFriendlyError(error, selector) {
  */
 export async function executeCommand(command, browser) {
     try {
+        if (command.action === 'flow') {
+            return await handleFlowAction(command, browser);
+        }
         const cmd = command;
         switch (cmd.action) {
             case 'launch':
@@ -366,6 +373,12 @@ export async function executeCommand(command, browser) {
                 return handleConfig(cmd);
             case 'history':
                 return await handleHistory(cmd, browser);
+            case 'selector-for':
+                return await handleSelectorFor(cmd, browser);
+            case 'selectors-of':
+                return await handleSelectorsOf(cmd, browser);
+            case 'validate':
+                return await handleValidate(cmd, browser);
             default: {
                 const unknownCommand = cmd;
                 return errorResponse(unknownCommand.id, `Unknown action: ${unknownCommand.action}`);
@@ -661,10 +674,15 @@ async function handleEvaluate(command, browser) {
     try {
         let script;
         if (command.file) {
-            if (!existsSync(command.file)) {
-                throw new Error(`Script file not found: ${command.file}`);
+            const resolvedPath = path.resolve(command.file);
+            const cwd = process.cwd();
+            if (!resolvedPath.startsWith(cwd)) {
+                throw new Error(`Security: file path must be within project directory. Got: ${resolvedPath}`);
+            }
+            if (!existsSync(resolvedPath)) {
+                throw new Error(`Script file not found: ${resolvedPath}`);
             }
-            script = readFileSync(command.file, 'utf-8');
+            script = readFileSync(resolvedPath, 'utf-8');
         }
         else if (command.script) {
             script = command.script;
@@ -765,7 +783,12 @@ async function handleScroll(command, browser) {
                     break;
             }
         }
-        await page.evaluate(`window.scrollBy(${deltaX}, ${deltaY})`);
+        const safeDeltaX = Number(deltaX) || 0;
+        const safeDeltaY = Number(deltaY) || 0;
+        await page.evaluate(({ dx, dy }) => window.scrollBy(dx, dy), {
+            dx: safeDeltaX,
+            dy: safeDeltaY,
+        });
     }
     return successResponse(command.id, { scrolled: true });
 }
@@ -1508,14 +1531,14 @@ async function handleStyles(command, browser) {
     if (browser.isRef(command.selector)) {
         const locator = browser.getLocator(command.selector);
         const element = (await locator.evaluate((el, script) => {
-            const fn = eval(script);
+            const fn = new Function('return ' + script)();
             return fn(el);
         }, extractStylesScript));
         return successResponse(command.id, { elements: [element] });
     }
     // CSS selector - can match multiple elements
     const elements = (await frame.locator(command.selector).evaluateAll((els, script) => {
-        const fn = eval(script);
+        const fn = new Function('return ' + script)();
         return els.map((el) => fn(el));
     }, extractStylesScript));
     return successResponse(command.id, { elements });
@@ -2182,14 +2205,23 @@ async function handleRecorderReplay(command, browser) {
     // Filter out env-only lines (keep them for env setup but not as commands)
     const envLines = cliCommands.filter((l) => l.startsWith('AGENT_BROWSER_'));
     const cmdLines = cliCommands.filter((l) => l.startsWith('agent-browser '));
-    // Set env vars from recording
+    // Set env vars from recording (skip AGENT_BROWSER_HUMAN to avoid
+    // human-mode coordinate issues during replay where elements may be
+    // scrolled off-screen)
     const originalEnv = {};
     for (const envLine of envLines) {
         const eqIdx = envLine.indexOf('=');
         if (eqIdx > 0) {
             const key = envLine.substring(0, eqIdx);
+            if (key === 'AGENT_BROWSER_HUMAN')
+                continue;
+            let value = envLine.substring(eqIdx + 1);
+            const spaceIdx = value.indexOf(' ');
+            if (spaceIdx > 0) {
+                value = value.substring(0, spaceIdx);
+            }
             originalEnv[key] = process.env[key];
-            process.env[key] = envLine.substring(eqIdx + 1);
+            process.env[key] = value;
         }
     }
     function parseCommandLine(line) {
@@ -2316,7 +2348,6 @@ function handleConfig(command) {
         userAgent: process.env.AGENT_BROWSER_USER_AGENT || null,
         provider: process.env.AGENT_BROWSER_PROVIDER || null,
         allowFileAccess: process.env.AGENT_BROWSER_ALLOW_FILE_ACCESS === '1',
-        iosDevice: process.env.AGENT_BROWSER_IOS_DEVICE || null,
         streamPort: getViewerPort(),
         headed: process.env.AGENT_BROWSER_HEADED === '1',
         human: humanConfig,
@@ -2370,4 +2401,262 @@ async function handleHistory(command, browser) {
     const history = browser.getHistory(command.filter);
     return successResponse(command.id, { history });
 }
+async function handleSelectorFor(command, browser) {
+    const store = browser.getSnapshotStore();
+    const colonIndex = command.target.indexOf(':');
+    if (colonIndex === -1) {
+        return errorResponse(command.id, `Invalid target format: "${command.target}". Expected "snapshotId:refOrIndex" (e.g., "snap_3:@e1" or "snap_3:1").`);
+    }
+    const snapshotId = command.target.substring(0, colonIndex);
+    const refOrIndex = command.target.substring(colonIndex + 1);
+    await browser.ensureSelectorsGenerated(snapshotId);
+    const element = store.getElement(snapshotId, refOrIndex);
+    if (!element) {
+        return errorResponse(command.id, `Element not found: "${refOrIndex}" in snapshot "${snapshotId}". Run 'snapshot' to get fresh snapshot data.`);
+    }
+    return successResponse(command.id, {
+        snapshotId,
+        ref: element.ref,
+        index: element.index,
+        role: element.role,
+        name: element.name,
+        cssSelector: element.cssSelector,
+        xpath: element.xpath,
+    });
+}
+async function handleSelectorsOf(command, browser) {
+    const store = browser.getSnapshotStore();
+    await browser.ensureSelectorsGenerated(command.target);
+    const elements = store.getElements(command.target);
+    if (!elements) {
+        return errorResponse(command.id, `Snapshot "${command.target}" not found. Run 'snapshot' to create a new snapshot.`);
+    }
+    return successResponse(command.id, {
+        snapshotId: command.target,
+        elements: elements.map((el) => ({
+            ref: el.ref,
+            index: el.index,
+            role: el.role,
+            name: el.name,
+            cssSelector: el.cssSelector,
+            xpath: el.xpath,
+        })),
+    });
+}
+async function handleValidate(command, browser) {
+    const store = browser.getSnapshotStore();
+    await browser.ensureSelectorsGenerated(command.target);
+    const elements = store.getElements(command.target);
+    if (!elements) {
+        return errorResponse(command.id, `Snapshot "${command.target}" not found. Run 'snapshot' to create a new snapshot.`);
+    }
+    const page = browser.getPage();
+    const selectors = elements.map((el) => el.cssSelector);
+    const matchCounts = await page.evaluate((sels) => {
+        return sels.map((sel) => {
+            try {
+                return document.querySelectorAll(sel).length;
+            }
+            catch {
+                return -1;
+            }
+        });
+    }, selectors);
+    const results = elements.map((el, i) => {
+        const matchCount = matchCounts[i];
+        let status;
+        if (matchCount === -1) {
+            status = 'invalid_selector';
+        }
+        else if (matchCount === 0) {
+            status = 'not_found';
+        }
+        else if (matchCount === 1) {
+            status = 'valid';
+        }
+        else {
+            status = 'ambiguous';
+        }
+        return {
+            ref: el.ref,
+            index: el.index,
+            cssSelector: el.cssSelector,
+            status,
+            matchCount,
+        };
+    });
+    const failedCount = results.filter((r) => r.status === 'not_found' || r.status === 'invalid_selector').length;
+    let newSnapshotId;
+    if (failedCount > 0) {
+        const newSnapshot = await browser.getSnapshot({ interactive: true });
+        newSnapshotId = newSnapshot.snapshotId;
+    }
+    return successResponse(command.id, {
+        snapshotId: command.target,
+        results,
+        newSnapshotId,
+    });
+}
+async function handleFlowAction(command, browser) {
+    const cmd = command;
+    const subcommand = cmd.subcommand;
+    switch (subcommand) {
+        case 'run':
+            return await handleFlowRun(cmd, browser);
+        case 'list':
+            return handleFlowList(cmd);
+        case 'show':
+            return handleFlowShow(cmd);
+        case 'validate':
+            return handleFlowValidate(cmd);
+        case 'from-recorder':
+            return handleFlowFromRecorder(cmd);
+        case 'export':
+            return handleFlowExport(cmd);
+        default:
+            return errorResponse(command.id, `Unknown flow subcommand: ${subcommand}`);
+    }
+}
+function handleFlowList(command) {
+    const sites = command.sitesDir ? loadSitesFromDirectory(command.sitesDir) : loadAllSites();
+    const siteList = [];
+    for (const [name, site] of sites) {
+        siteList.push({
+            name,
+            description: site.description,
+            flows: Object.keys(site.flows),
+        });
+    }
+    return successResponse(command.id, { sites: siteList });
+}
+function handleFlowShow(command) {
+    const sites = command.sitesDir ? loadSitesFromDirectory(command.sitesDir) : loadAllSites();
+    const ref = command.siteFlow || '';
+    const result = findFlow(sites, ref);
+    if (!result) {
+        return errorResponse(command.id, `Flow "${ref}" not found`);
+    }
+    return successResponse(command.id, {
+        site: {
+            name: result.site.name,
+            description: result.site.description,
+            baseUrl: result.site.baseUrl,
+        },
+        flow: result.flow,
+    });
+}
+function handleFlowValidate(command) {
+    const filePath = command.filePath || '';
+    if (!filePath) {
+        return errorResponse(command.id, 'Missing file path for validate');
+    }
+    const result = validateYamlFile(filePath);
+    return successResponse(command.id, result);
+}
+function handleFlowFromRecorder(command) {
+    const recorderFile = command.recorderFile;
+    if (!recorderFile) {
+        return errorResponse(command.id, 'Missing recorder YAML file path');
+    }
+    try {
+        const result = recorderToFlowFromFile(recorderFile, {
+            flowId: command.flowId,
+            description: command.description,
+            baseUrl: command.baseUrl,
+            siteName: command.siteName,
+            maxPaginateIterations: command.maxPaginateIterations,
+        });
+        const yamlString = siteToYamlString(result.site);
+        if (command.outputFile) {
+            writeFileSync(path.resolve(command.outputFile), yamlString, 'utf-8');
+            return successResponse(command.id, {
+                siteName: result.site.name,
+                flowId: Object.keys(result.site.flows)[0],
+                outputFile: command.outputFile,
+                warnings: result.warnings,
+            });
+        }
+        return successResponse(command.id, {
+            siteName: result.site.name,
+            flowId: Object.keys(result.site.flows)[0],
+            yaml: yamlString,
+            warnings: result.warnings,
+        });
+    }
+    catch (e) {
+        return errorResponse(command.id, `Failed to convert recorder YAML: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+async function handleFlowRun(command, browser) {
+    const ref = command.siteFlow || '';
+    const sites = command.sitesDir ? loadSitesFromDirectory(command.sitesDir) : loadAllSites();
+    const result = findFlow(sites, ref);
+    if (!result) {
+        return errorResponse(command.id, `Flow "${ref}" not found. Available sites: ${[...sites.keys()].join(', ')}`);
+    }
+    const typedParams = {};
+    if (result.flow.params) {
+        for (const param of result.flow.params) {
+            const raw = command.params?.[param.name];
+            if (raw !== undefined) {
+                switch (param.type) {
+                    case 'number':
+                        typedParams[param.name] = Number(raw);
+                        break;
+                    case 'boolean':
+                        typedParams[param.name] = raw === 'true' || raw === '1';
+                        break;
+                    default:
+                        typedParams[param.name] = raw;
+                }
+            }
+        }
+    }
+    const executor = new FlowExecutor(browser);
+    const flowResult = await executor.execute(result.site, result.flowName, typedParams);
+    return successResponse(command.id, flowResult);
+}
+function handleFlowExport(command) {
+    const filePath = command.filePath;
+    if (!filePath) {
+        return errorResponse(command.id, 'Missing file path for export');
+    }
+    let site;
+    try {
+        site = parseYamlSiteFile(filePath);
+    }
+    catch (e) {
+        return errorResponse(command.id, `Failed to parse YAML file: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const flowEntries = Object.entries(site.flows);
+    if (flowEntries.length === 0) {
+        return errorResponse(command.id, 'No flows found in YAML file');
+    }
+    const flow = flowEntries[0][1];
+    const format = command.format || 'playwright';
+    const exporterMap = {
+        playwright: new PlaywrightExporter(),
+        python: new PythonExporter(),
+        cypress: new CypressExporter(),
+        selenium: new SeleniumExporter(),
+    };
+    const exporter = exporterMap[format];
+    if (!exporter) {
+        return errorResponse(command.id, `Unknown export format: "${format}". Available: ${Object.keys(exporterMap).join(', ')}`);
+    }
+    try {
+        const script = exporter.export(flow.steps, {
+            baseUrl: command.baseUrl || site.baseUrl,
+            headless: command.headless,
+        });
+        return successResponse(command.id, {
+            format: exporter.format,
+            extension: exporter.extension,
+            script,
+        });
+    }
+    catch (e) {
+        return errorResponse(command.id, `Export failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
 //# sourceMappingURL=actions.js.map