@dyyz1993/agent-browser 0.13.2 → 0.23.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 } 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}`);
@@ -2370,4 +2383,260 @@ 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(),
+    };
+    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