@web-auto/camo 0.1.24 → 0.1.26

package/README.md

@@ -473,6 +473,7 @@ Condition types:
 
 ### Environment Variables
 
+- `CAMO_INPUT_MODE` - Input mode: `playwright` (default) or `cdp`. CDP mode uses `Input.dispatchMouseEvent` via Chrome DevTools Protocol, bypassing OS-level input system. Does not require window foreground. See [CDP Input Mode](#cdp-input-mode) below.
 - `CAMO_BROWSER_URL` - Browser service URL (default: `http://127.0.0.1:7704`)
 - `CAMO_INSTALL_DIR` - `@web-auto/camo` 安装目录（可选，首次安装兜底）
 - `CAMO_REPO_ROOT` - Camo repository root (optional, dev mode)
@@ -484,6 +485,51 @@ Condition types:
 - `CAMO_PROGRESS_WS_HOST` / `CAMO_PROGRESS_WS_PORT` - Progress websocket daemon bind address (default: `127.0.0.1:7788`)
 - `CAMO_DEFAULT_WINDOW_VERTICAL_RESERVE` - Reserved vertical pixels for default headful auto-size
 
+### CDP Input Mode
+
+By default, Camo uses Playwright's high-level input API (`page.mouse.click`), which goes through the OS input system and requires the browser window to be in the foreground. This can cause hangs (up to 30s timeout) on Windows when the window loses focus.
+
+CDP mode sends mouse events directly via the Chrome DevTools Protocol (`Input.dispatchMouseEvent`), which:
+
+- **Does not require window foreground** — works with minimized, background, or headless windows
+- **Does not depend on OS input system** — no `bringToFront`, no `ensureInputReady`
+- **Bypasses input pipeline checks** — no 30s timeout risk from `ensureInputReady` hanging
+
+#### How to enable
+
+```bash
+# Environment variable (recommended)
+CAMO_INPUT_MODE=cdp camo start xhs-qa-1 --url https://www.xiaohongshu.com
+
+# Or set in shell profile
+export CAMO_INPUT_MODE=cdp
+```
+
+#### Behavior differences
+
+| Feature | Playwright (default) | CDP mode |
+|---------|---------------------|----------|
+| Window foreground required | Yes | No |
+| OS input system | Yes | No |
+| Auto-scroll to element | Yes (via Playwright) | No (caller must ensure element in viewport) |
+| `ensureInputReady` check | Yes (can hang 30s) | Skipped |
+| `bringToFront` | Yes (default) | Skipped |
+| Nudge/recovery on timeout | Yes | No (fast fail) |
+| Input coordinate system | Viewport-relative | Viewport-relative (same) |
+
+#### Limitations
+
+- **Element must be in viewport**: CDP clicks at coordinates only. If the target element is scrolled out of view, the click will miss. Callers (like webauto's `clickPoint`) already resolve viewport-relative coordinates via `getBoundingClientRect`.
+- **No auto-scroll**: Unlike Playwright's `page.click(selector)`, CDP mode does not scroll to bring elements into view.
+- **keyboard operations still use Playwright**: `keyboard:press` and `keyboard:type` are not affected by CDP mode (they already work reliably in background via Playwright's keyboard API).
+
+#### Related environment variables
+
+- `CAMO_INPUT_ACTION_TIMEOUT_MS` — Max wait for input action (default: 30000)
+- `CAMO_INPUT_ACTION_MAX_ATTEMPTS` — Retry count on failure (default: 2)
+- `CAMO_INPUT_READY_SETTLE_MS` — Settle time after input ready (default: 80)
+- `CAMO_BRING_TO_FRONT_MODE` — `never` (skip) or `auto` (default, bring window to front)
+
 ## Session Persistence
 
 Camo CLI persists session information locally:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/camo",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Camoufox Browser CLI - Cross-platform browser automation",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -33,6 +33,7 @@ import {
 import { handleSessionWatchdogCommand } from './lifecycle/session-watchdog.mjs';
 import { safeAppendProgressEvent } from './events/progress-log.mjs';
 import { ensureProgressEventDaemon } from './events/daemon.mjs';
+import { appendCommandLog, buildCommandSenderMeta } from './utils/command-log.mjs';
 
 const CURRENT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_JSON_PATH = path.resolve(CURRENT_DIR, '..', 'package.json');
@@ -119,6 +120,14 @@ function inferProfileId(cmd, args) {
 async function runTrackedCommand(cmd, args, fn) {
   const startedAt = Date.now();
   const profileId = inferProfileId(cmd, args);
+  appendCommandLog({
+    action: cmd,
+    command: cmd,
+    profileId,
+    args: args.slice(1),
+    payload: { mode: 'cli' },
+    meta: buildCommandSenderMeta({ source: 'cli', cwd: process.cwd(), argv: process.argv.slice() }),
+  });
   safeAppendProgressEvent({
     source: 'cli.command',
     mode: cmd === 'autoscript' ? 'autoscript' : 'normal',

package/src/commands/browser.mjs

@@ -496,6 +496,7 @@ export async function handleStartCommand(args) {
   const alias = validateAlias(readFlagValue(args, ['--alias']));
   const idleTimeoutRaw = readFlagValue(args, ['--idle-timeout']);
   const parsedIdleTimeoutMs = parseDurationMs(idleTimeoutRaw, DEFAULT_HEADLESS_IDLE_TIMEOUT_MS);
+  const maxTabs = Math.max(1, Math.floor(Number(readFlagValue(args, ['--max-tabs']) || 1) || 1));
   const wantsDevtools = args.includes('--devtools');
   const wantsRecord = args.includes('--record');
   const recordName = readFlagValue(args, ['--record-name']);
@@ -506,7 +507,7 @@ export async function handleStartCommand(args) {
       ? true
       : null;
   if (hasExplicitWidth !== hasExplicitHeight) {
-    throw new Error('Usage: camo start [profileId] [--url <url>] [--headless] [--devtools] [--record] [--record-name <name>] [--record-output <path>] [--record-overlay|--no-record-overlay] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]');
+    throw new Error('Usage: camo start [profileId] [--url <url>] [--no-headless|--visible] [--devtools] [--record] [--record-name <name>] [--record-output <path>] [--record-overlay|--no-record-overlay] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h> --max-tabs <n>]');
   }
   if ((hasExplicitWidth && explicitWidth < START_WINDOW_MIN_WIDTH) || (hasExplicitHeight && explicitHeight < START_WINDOW_MIN_HEIGHT)) {
     throw new Error(`Window size too small. Minimum is ${START_WINDOW_MIN_WIDTH}x${START_WINDOW_MIN_HEIGHT}`);
@@ -527,8 +528,8 @@ export async function handleStartCommand(args) {
     const arg = args[i];
     if (arg === '--url') { i++; continue; }
     if (arg === '--width' || arg === '--height') { i++; continue; }
-    if (arg === '--alias' || arg === '--idle-timeout' || arg === '--record-name' || arg === '--record-output') { i++; continue; }
-    if (arg === '--headless') continue;
+    if (arg === '--alias' || arg === '--idle-timeout' || arg === '--record-name' || arg === '--record-output' || arg === '--max-tabs') { i++; continue; }
+    if (arg === '--headless' || arg === '--no-headless' || arg === '--visible') continue;
     if (arg === '--record' || arg === '--record-overlay' || arg === '--no-record-overlay') continue;
     if (arg.startsWith('--')) continue;
 
@@ -615,9 +616,9 @@ export async function handleStartCommand(args) {
     releaseLock(profileId);
   }
 
-  const headless = args.includes('--headless');
+  const headless = !args.includes('--no-headless') && !args.includes('--visible');
   if (wantsDevtools && headless) {
-    throw new Error('--devtools is not supported with --headless');
+    throw new Error('--devtools requires --no-headless or --visible mode');
   }
   const idleTimeoutMs = headless ? parsedIdleTimeoutMs : 0;
   const targetUrl = explicitUrl || implicitUrl;
@@ -627,6 +628,7 @@ export async function handleStartCommand(args) {
     headless,
     devtools: wantsDevtools,
     ...(wantsRecord ? { record: true } : {}),
+    ...(Number.isFinite(maxTabs) ? { maxTabs } : {}),
     ...(recordName ? { recordName } : {}),
     ...(recordOutput ? { recordOutput } : {}),
     ...(recordOverlay !== null ? { recordOverlay } : {}),
@@ -655,8 +657,8 @@ export async function handleStartCommand(args) {
       all: 'camo close all',
     };
     result.message = headless
-      ? `Started headless session. Idle timeout: ${formatDurationMs(idleTimeoutMs)}`
-      : 'Started session. Remember to stop it when finished.';
+      ? `Started session. Idle timeout: ${formatDurationMs(idleTimeoutMs)}`
+      : 'Started visible session. Remember to stop it when finished.';
 
     if (!headless) {
       let windowTarget = null;

package/src/container/change-notifier.mjs

@@ -26,30 +26,43 @@ function parseCssSelector(css) {
   const raw = typeof css === 'string' ? css.trim() : '';
   if (!raw) return [];
   const attrRegex = /\[\s*([^\s~|^$*=\]]+)\s*(\*=|\^=|\$=|=)?\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+))?\s*\]/g;
+  const parseSegment = (item) => {
+    const tagMatch = item.match(/^[a-zA-Z][\w-]*/);
+    const idMatch = item.match(/#([\w-]+)/);
+    const classMatches = item.match(/\.([\w-]+)/g) || [];
+    const attrs = [];
+    let attrMatch = attrRegex.exec(item);
+    while (attrMatch) {
+      attrs.push({
+        name: String(attrMatch[1] || '').toLowerCase(),
+        op: attrMatch[2] || 'exists',
+        value: attrMatch[3] ?? attrMatch[4] ?? attrMatch[5] ?? '',
+      });
+      attrMatch = attrRegex.exec(item);
+    }
+    attrRegex.lastIndex = 0;
+    return {
+      raw: item,
+      tag: tagMatch ? tagMatch[0].toLowerCase() : null,
+      id: idMatch ? idMatch[1] : null,
+      classes: classMatches.map((token) => token.slice(1)),
+      attrs,
+    };
+  };
   return raw
     .split(',')
     .map((item) => item.trim())
     .filter(Boolean)
     .map((item) => {
-      const tagMatch = item.match(/^[a-zA-Z][\w-]*/);
-      const idMatch = item.match(/#([\w-]+)/);
-      const classMatches = item.match(/\.([\w-]+)/g) || [];
-      const attrs = [];
-      let attrMatch = attrRegex.exec(item);
-      while (attrMatch) {
-        attrs.push({
-          name: String(attrMatch[1] || '').toLowerCase(),
-          op: attrMatch[2] || 'exists',
-          value: attrMatch[3] ?? attrMatch[4] ?? attrMatch[5] ?? '',
-        });
-        attrMatch = attrRegex.exec(item);
-      }
-      attrRegex.lastIndex = 0;
+      const segments = item
+        .split(/\s+/)
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .map((segment) => parseSegment(segment));
       return {
-        tag: tagMatch ? tagMatch[0].toLowerCase() : null,
-        id: idMatch ? idMatch[1] : null,
-        classes: classMatches.map((token) => token.slice(1)),
-        attrs,
+        raw: item,
+        segments,
+        ...parseSegment(item),
       };
     });
 }
@@ -82,6 +95,50 @@ function matchAttribute(node, attrSpec, nodeId, nodeClasses) {
   return false;
 }
 
+function nodeMatchesCssSegment(node, cssSegment) {
+  const nodeTag = typeof node?.tag === 'string' ? node.tag.toLowerCase() : null;
+  const nodeId = typeof node?.id === 'string' ? node.id : null;
+  const nodeClasses = new Set(Array.isArray(node?.classes) ? node.classes : []);
+
+  const hasConstraints = Boolean(
+    cssSegment?.tag
+      || cssSegment?.id
+      || (cssSegment?.classes && cssSegment.classes.length > 0)
+      || (cssSegment?.attrs && cssSegment.attrs.length > 0),
+  );
+  if (!hasConstraints) return false;
+
+  let matched = true;
+  if (cssSegment.tag && nodeTag !== cssSegment.tag) matched = false;
+  if (cssSegment.id && nodeId !== cssSegment.id) matched = false;
+  if (matched && cssSegment.classes.length > 0) {
+    matched = cssSegment.classes.every((className) => nodeClasses.has(className));
+  }
+  if (matched && cssSegment.attrs.length > 0) {
+    matched = cssSegment.attrs.every((attrSpec) => matchAttribute(node, attrSpec, nodeId, nodeClasses));
+  }
+  return matched;
+}
+
+function matchesAncestorChain(ancestors, segments) {
+  if (!Array.isArray(segments) || segments.length === 0) return true;
+  if (!Array.isArray(ancestors) || ancestors.length === 0) return false;
+  let ancestorIndex = ancestors.length - 1;
+  for (let segmentIndex = segments.length - 1; segmentIndex >= 0; segmentIndex -= 1) {
+    let found = false;
+    while (ancestorIndex >= 0) {
+      if (nodeMatchesCssSegment(ancestors[ancestorIndex], segments[segmentIndex])) {
+        found = true;
+        ancestorIndex -= 1;
+        break;
+      }
+      ancestorIndex -= 1;
+    }
+    if (!found) return false;
+  }
+  return true;
+}
+
 export class ChangeNotifier {
   constructor() {
     this.subscriptions = new Map(); // topic -> Set<callback>
@@ -214,17 +271,22 @@ export class ChangeNotifier {
     const normalized = normalizeSelector(selector);
     const runtimeContext = context || {
       viewport: node?.__viewport || null,
+      ancestors: [],
     };
 
     // Check if current node matches
-    if (this.nodeMatchesSelector(node, normalized) && this.nodePassesVisibility(node, normalized, runtimeContext.viewport)) {
+    if (this.nodeMatchesSelector(node, normalized, runtimeContext.ancestors) && this.nodePassesVisibility(node, normalized, runtimeContext.viewport)) {
       results.push({ ...node, path });
     }
 
     // Recurse into children
     if (node.children) {
+      const childContext = {
+        ...runtimeContext,
+        ancestors: [...runtimeContext.ancestors, node],
+      };
       for (let i = 0; i < node.children.length; i++) {
-        const childResults = this.findElements(node.children[i], normalized, `${path}/${i}`, runtimeContext);
+        const childResults = this.findElements(node.children[i], normalized, `${path}/${i}`, childContext);
         results.push(...childResults);
       }
     }
@@ -233,7 +295,7 @@ export class ChangeNotifier {
   }
 
   // Check if node matches selector
-  nodeMatchesSelector(node, selector) {
+  nodeMatchesSelector(node, selector, ancestors = []) {
     if (!node) return false;
     const normalized = normalizeSelector(selector);
     if (!normalized || typeof normalized !== 'object') return false;
@@ -248,24 +310,13 @@ export class ChangeNotifier {
     const cssVariants = parseCssSelector(normalized.css);
     if (cssVariants.length > 0) {
       for (const cssVariant of cssVariants) {
-        const hasConstraints = Boolean(
-          cssVariant.tag
-            || cssVariant.id
-            || (cssVariant.classes && cssVariant.classes.length > 0)
-            || (cssVariant.attrs && cssVariant.attrs.length > 0),
-        );
-        if (!hasConstraints) continue;
-
-        let matched = true;
-        if (cssVariant.tag && nodeTag !== cssVariant.tag) matched = false;
-        if (cssVariant.id && nodeId !== cssVariant.id) matched = false;
-        if (matched && cssVariant.classes.length > 0) {
-          matched = cssVariant.classes.every((className) => nodeClasses.has(className));
-        }
-        if (matched && cssVariant.attrs.length > 0) {
-          matched = cssVariant.attrs.every((attrSpec) => matchAttribute(node, attrSpec, nodeId, nodeClasses));
-        }
-        if (matched) return true;
+        const segments = Array.isArray(cssVariant.segments) && cssVariant.segments.length > 0
+          ? cssVariant.segments
+          : [cssVariant];
+        const targetSegment = segments[segments.length - 1];
+        if (!nodeMatchesCssSegment(node, targetSegment)) continue;
+        if (segments.length === 1) return true;
+        if (matchesAncestorChain(ancestors, segments.slice(0, -1))) return true;
       }
     }
 

package/src/container/runtime-core/operations/index.mjs

@@ -94,6 +94,17 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function pageScroll(profileId, deltaY, delayMs = 80) {
+  const raw = Number(deltaY) || 0;
+  if (!Number.isFinite(raw) || raw === 0) return;
+  const key = raw >= 0 ? 'PageDown' : 'PageUp';
+  const steps = Math.max(1, Math.min(8, Math.round(Math.abs(raw) / 420) || 1));
+  for (let step = 0; step < steps; step += 1) {
+    await callAPI('keyboard:press', { profileId, key });
+    if (delayMs > 0) await sleep(delayMs);
+  }
+}
+
 function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
@@ -281,7 +292,8 @@ async function scrollTargetIntoViewport(profileId, selector, initialTarget, para
     if (isTargetFullyInViewport(target, visibilityMargin)) break;
     const delta = resolveViewportScrollDelta(target, visibilityMargin);
     if (Math.abs(delta.deltaX) < 1 && Math.abs(delta.deltaY) < 1) break;
-    await callAPI('mouse:wheel', { profileId, deltaX: delta.deltaX, deltaY: delta.deltaY });
+    const deltaY = delta.deltaY !== 0 ? delta.deltaY : (delta.deltaX !== 0 ? delta.deltaX : 0);
+    await pageScroll(profileId, deltaY);
     if (settleMs > 0) await sleep(settleMs);
     target = await resolveSelectorTarget(profileId, selector, options);
   }
@@ -468,6 +480,56 @@ async function executeVerifySubscriptions({ profileId, params }) {
 
   const acrossPages = params.acrossPages === true;
   const settleMs = Math.max(0, Number(params.settleMs ?? 280) || 280);
+  const pageUrlIncludes = normalizeArray(params.pageUrlIncludes)
+    .map((item) => String(item || '').trim())
+    .filter(Boolean);
+  const pageUrlExcludes = normalizeArray(params.pageUrlExcludes)
+    .map((item) => String(item || '').trim())
+    .filter(Boolean);
+  const pageUrlRegex = String(params.pageUrlRegex || '').trim();
+  const pageUrlNotRegex = String(params.pageUrlNotRegex || '').trim();
+  const requireMatchedPages = params.requireMatchedPages !== false;
+
+  let includeRegex = null;
+  if (pageUrlRegex) {
+    try {
+      includeRegex = new RegExp(pageUrlRegex);
+    } catch {
+      return asErrorPayload('OPERATION_FAILED', `invalid pageUrlRegex: ${pageUrlRegex}`);
+    }
+  }
+  let excludeRegex = null;
+  if (pageUrlNotRegex) {
+    try {
+      excludeRegex = new RegExp(pageUrlNotRegex);
+    } catch {
+      return asErrorPayload('OPERATION_FAILED', `invalid pageUrlNotRegex: ${pageUrlNotRegex}`);
+    }
+  }
+
+  const hasPageFilter = (
+    pageUrlIncludes.length > 0
+    || pageUrlExcludes.length > 0
+    || Boolean(includeRegex)
+    || Boolean(excludeRegex)
+  );
+
+  const shouldVerifyPage = (rawUrl) => {
+    const url = String(rawUrl || '').trim();
+    if (pageUrlIncludes.length > 0 && !pageUrlIncludes.some((part) => url.includes(part))) {
+      return false;
+    }
+    if (pageUrlExcludes.length > 0 && pageUrlExcludes.some((part) => url.includes(part))) {
+      return false;
+    }
+    if (includeRegex && !includeRegex.test(url)) {
+      return false;
+    }
+    if (excludeRegex && excludeRegex.test(url)) {
+      return false;
+    }
+    return true;
+  };
 
   const collectForCurrentPage = async () => {
     const snapshot = await getDomSnapshotByProfile(profileId);
@@ -487,6 +549,8 @@ async function executeVerifySubscriptions({ profileId, params }) {
 
   let pagesResult = [];
   let overallOk = true;
+  let matchedPageCount = 0;
+  let activePageIndex = null;
   if (!acrossPages) {
     const current = await collectForCurrentPage();
     overallOk = current.matches.every((item) => item.count >= item.minCount);
@@ -494,8 +558,19 @@ async function executeVerifySubscriptions({ profileId, params }) {
   } else {
     const listed = await callAPI('page:list', { profileId });
     const { pages, activeIndex } = extractPageList(listed);
+    activePageIndex = Number.isFinite(activeIndex) ? activeIndex : null;
     for (const page of pages) {
       const pageIndex = Number(page.index);
+      const listedUrl = String(page.url || '');
+      if (!shouldVerifyPage(listedUrl)) {
+        pagesResult.push({
+          index: pageIndex,
+          url: listedUrl,
+          skipped: true,
+          ok: true,
+        });
+        continue;
+      }
       if (Number.isFinite(activeIndex) && activeIndex !== pageIndex) {
         await callAPI('page:switch', { profileId, index: pageIndex });
         if (settleMs > 0) await new Promise((resolve) => setTimeout(resolve, settleMs));
@@ -504,15 +579,43 @@ async function executeVerifySubscriptions({ profileId, params }) {
       const pageOk = current.matches.every((item) => item.count >= item.minCount);
       overallOk = overallOk && pageOk;
       pagesResult.push({ index: pageIndex, ...current, ok: pageOk });
+      matchedPageCount += 1;
     }
     if (Number.isFinite(activeIndex)) {
       await callAPI('page:switch', { profileId, index: activeIndex });
     }
   }
 
+  if (acrossPages && hasPageFilter && requireMatchedPages && matchedPageCount === 0) {
+    const fallback = await collectForCurrentPage();
+    const fallbackOk = fallback.matches.every((item) => item.count >= item.minCount);
+    if (fallbackOk) {
+      matchedPageCount = 1;
+      overallOk = true;
+      pagesResult.push({
+        index: Number.isFinite(activePageIndex) ? activePageIndex : null,
+        urlMatched: false,
+        fallback: 'dom_match',
+        ok: true,
+        ...fallback,
+      });
+    } else {
+      return asErrorPayload('SUBSCRIPTION_MISMATCH', 'no page matched verify_subscriptions pageUrl filter', {
+        acrossPages,
+        pageUrlIncludes,
+        pageUrlExcludes,
+        pageUrlRegex: pageUrlRegex || null,
+        pageUrlNotRegex: pageUrlNotRegex || null,
+        pages: pagesResult,
+        fallback,
+      });
+    }
+  }
+
   if (!overallOk) {
     return asErrorPayload('SUBSCRIPTION_MISMATCH', 'subscription selectors missing on one or more pages', {
       acrossPages,
+      matchedPageCount,
       pages: pagesResult,
     });
   }
@@ -521,7 +624,7 @@ async function executeVerifySubscriptions({ profileId, params }) {
     ok: true,
     code: 'OPERATION_DONE',
     message: 'verify_subscriptions done',
-    data: { acrossPages, pages: pagesResult },
+    data: { acrossPages, matchedPageCount, pages: pagesResult },
   };
 }
 
@@ -617,48 +720,12 @@ export async function executeOperation({ profileId, operation, context = {} }) {
         deltaX = amount;
         deltaY = 0;
       }
-      const anchorSelector = maybeSelector({
-        profileId: resolvedProfile,
-        containerId: params.containerId || operation?.containerId || null,
-        selector: params.selector || operation?.selector || null,
-      });
-      const anchor = await resolveScrollAnchor(resolvedProfile, {
-        selector: anchorSelector,
-        filterMode,
-      });
-      if (!anchor?.ok || !anchor?.center) {
-        return asErrorPayload('OPERATION_FAILED', 'visible scroll container not found');
-      }
-      await callAPI('mouse:click', {
-        profileId: resolvedProfile,
-        x: anchor.center.x,
-        y: anchor.center.y,
-        button: 'left',
-        clicks: 1,
-        delay: 30,
-      });
-      const result = await callAPI('mouse:wheel', {
-        profileId: resolvedProfile,
-        deltaX,
-        deltaY,
-        anchorX: anchor.center.x,
-        anchorY: anchor.center.y,
-      });
+      const result = await pageScroll(resolvedProfile, deltaY);
       return {
         ok: true,
         code: 'OPERATION_DONE',
         message: 'scroll done',
-        data: {
-          direction,
-          amount,
-          deltaX,
-          deltaY,
-          filterMode,
-          anchorSource: String(anchor?.source || 'document'),
-          anchorCenter: anchor?.center || null,
-          modalLocked: anchor?.modalLocked === true,
-          result,
-        },
+        data: { direction, amount, deltaX, deltaY, result },
       };
     }
 
@@ -679,13 +746,7 @@ export async function executeOperation({ profileId, operation, context = {} }) {
     }
 
     if (action === 'evaluate') {
-      if (!isJsExecutionEnabled()) {
-        return asErrorPayload('JS_DISABLED', 'evaluate is disabled by default. Re-run camo command with --js.');
-      }
-      const script = String(params.script || '').trim();
-      if (!script) return asErrorPayload('OPERATION_FAILED', 'evaluate requires params.script');
-      const result = await callAPI('evaluate', { profileId: resolvedProfile, script });
-      return { ok: true, code: 'OPERATION_DONE', message: 'evaluate done', data: result };
+      return asErrorPayload('JS_DISABLED', 'evaluate is disabled in camo runtime');
     }
 
     if (action === 'click' || action === 'type' || action === 'scroll_into_view') {
@@ -694,7 +755,6 @@ export async function executeOperation({ profileId, operation, context = {} }) {
         action,
         operation,
         params,
-        filterMode,
       });
     }