@web-auto/camo 0.1.24 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/camo",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "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,
       });
     }