@web-auto/camo 0.1.14 → 0.1.16

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

@@ -1,10 +1,6 @@
 import { callAPI, getDomSnapshotByProfile } from '../../../utils/browser-service.mjs';
+import { isJsExecutionEnabled } from '../../../utils/js-policy.mjs';
 import { executeTabPoolOperation } from './tab-pool.mjs';
-import {
-  buildSelectorClickScript,
-  buildSelectorScrollIntoViewScript,
-  buildSelectorTypeScript,
-} from './selector-scripts.mjs';
 import { executeViewportOperation } from './viewport.mjs';
 import {
   asErrorPayload,
@@ -27,6 +23,23 @@ const VIEWPORT_ACTIONS = new Set([
   'get_current_url',
 ]);
 
+const DEFAULT_MODAL_SELECTORS = [
+  '[aria-modal="true"]',
+  '[role="dialog"]',
+  '.modal',
+  '.dialog',
+  '.note-detail-mask',
+  '.note-detail-page',
+  '.note-detail-dialog',
+];
+
+function resolveFilterMode(input) {
+  const text = String(input || process.env.CAMO_FILTER_MODE || 'strict').trim().toLowerCase();
+  if (!text) return 'strict';
+  if (text === 'legacy') return 'legacy';
+  return 'strict';
+}
+
 async function executeExternalOperationIfAny({
   profileId,
   action,
@@ -54,6 +67,7 @@ async function executeExternalOperationIfAny({
 }
 
 async function flashOperationViewport(profileId, params = {}) {
+  if (!isJsExecutionEnabled()) return;
   if (params.highlight === false) return;
   try {
     await callAPI('evaluate', {
@@ -77,7 +91,272 @@ async function flashOperationViewport(profileId, params = {}) {
   }
 }
 
-async function executeSelectorOperation({ profileId, action, operation, params }) {
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function isTargetFullyInViewport(target, margin = 6) {
+  const rect = target?.rect && typeof target.rect === 'object' ? target.rect : null;
+  const viewport = target?.viewport && typeof target.viewport === 'object' ? target.viewport : null;
+  if (!rect || !viewport) return true;
+  const vw = Number(viewport.width || 0);
+  const vh = Number(viewport.height || 0);
+  if (!Number.isFinite(vw) || !Number.isFinite(vh) || vw <= 0 || vh <= 0) return true;
+  const left = Number(rect.left || 0);
+  const top = Number(rect.top || 0);
+  const width = Math.max(0, Number(rect.width || 0));
+  const height = Math.max(0, Number(rect.height || 0));
+  const right = left + width;
+  const bottom = top + height;
+  const m = Math.max(0, Number(margin) || 0);
+  return left >= m && top >= m && right <= (vw - m) && bottom <= (vh - m);
+}
+
+function resolveViewportScrollDelta(target, margin = 6) {
+  const rect = target?.rect && typeof target.rect === 'object' ? target.rect : null;
+  const viewport = target?.viewport && typeof target.viewport === 'object' ? target.viewport : null;
+  if (!rect || !viewport) return { deltaX: 0, deltaY: 0 };
+  const vw = Number(viewport.width || 0);
+  const vh = Number(viewport.height || 0);
+  if (!Number.isFinite(vw) || !Number.isFinite(vh) || vw <= 0 || vh <= 0) return { deltaX: 0, deltaY: 0 };
+  const left = Number(rect.left || 0);
+  const top = Number(rect.top || 0);
+  const width = Math.max(0, Number(rect.width || 0));
+  const height = Math.max(0, Number(rect.height || 0));
+  const right = left + width;
+  const bottom = top + height;
+  const m = Math.max(0, Number(margin) || 0);
+
+  let deltaX = 0;
+  let deltaY = 0;
+
+  if (left < m) {
+    deltaX = Math.round(left - m);
+  } else if (right > (vw - m)) {
+    deltaX = Math.round(right - (vw - m));
+  }
+
+  if (top < m) {
+    deltaY = Math.round(top - m);
+  } else if (bottom > (vh - m)) {
+    deltaY = Math.round(bottom - (vh - m));
+  }
+
+  if (Math.abs(deltaY) < 80 && !isTargetFullyInViewport(target, m)) {
+    deltaY = deltaY >= 0 ? 120 : -120;
+  }
+  if (Math.abs(deltaX) < 40 && (left < m || right > (vw - m))) {
+    deltaX = deltaX >= 0 ? 60 : -60;
+  }
+
+  return {
+    deltaX: clamp(deltaX, -900, 900),
+    deltaY: clamp(deltaY, -900, 900),
+  };
+}
+
+function normalizeRect(node) {
+  const rect = node?.rect && typeof node.rect === 'object' ? node.rect : null;
+  if (!rect) return null;
+  const left = Number(rect.left ?? rect.x ?? 0);
+  const top = Number(rect.top ?? rect.y ?? 0);
+  const width = Number(rect.width ?? 0);
+  const height = Number(rect.height ?? 0);
+  if (!Number.isFinite(left) || !Number.isFinite(top) || !Number.isFinite(width) || !Number.isFinite(height)) {
+    return null;
+  }
+  if (width <= 0 || height <= 0) return null;
+  return { left, top, width, height };
+}
+
+function nodeArea(node) {
+  const rect = normalizeRect(node);
+  if (!rect) return 0;
+  return Number(rect.width || 0) * Number(rect.height || 0);
+}
+
+function nodeCenter(node, viewport = null) {
+  const rect = normalizeRect(node);
+  const vw = Number(viewport?.width || 0);
+  const vh = Number(viewport?.height || 0);
+  if (!rect) return null;
+  const rawX = rect.left + Math.max(1, rect.width / 2);
+  const rawY = rect.top + Math.max(1, rect.height / 2);
+  const centerX = vw > 1
+    ? clamp(Math.round(rawX), 1, Math.max(1, vw - 1))
+    : Math.max(1, Math.round(rawX));
+  const centerY = vh > 1
+    ? clamp(Math.round(rawY), 1, Math.max(1, vh - 1))
+    : Math.max(1, Math.round(rawY));
+  return {
+    center: { x: centerX, y: centerY },
+    rawCenter: { x: rawX, y: rawY },
+    rect,
+  };
+}
+
+function getSnapshotViewport(snapshot) {
+  const width = Number(snapshot?.__viewport?.width || 0);
+  const height = Number(snapshot?.__viewport?.height || 0);
+  return { width, height };
+}
+
+function isPathWithin(path, parentPath) {
+  const child = String(path || '').trim();
+  const parent = String(parentPath || '').trim();
+  if (!child || !parent) return false;
+  return child === parent || child.startsWith(`${parent}/`);
+}
+
+function resolveActiveModal(snapshot) {
+  if (!snapshot) return null;
+  const rows = [];
+  for (const selector of DEFAULT_MODAL_SELECTORS) {
+    const matches = buildSelectorCheck(snapshot, { css: selector, visible: true });
+    for (const node of matches) {
+      if (nodeArea(node) <= 1) continue;
+      rows.push({
+        selector,
+        path: String(node.path || ''),
+        node,
+        area: nodeArea(node),
+      });
+    }
+  }
+  rows.sort((a, b) => b.area - a.area);
+  return rows[0] || null;
+}
+
+async function resolveSelectorTarget(profileId, selector, options = {}) {
+  const filterMode = resolveFilterMode(options.filterMode);
+  const strictFilter = filterMode !== 'legacy';
+  const normalizedSelector = String(selector || '').trim();
+  const snapshot = await getDomSnapshotByProfile(profileId);
+  const viewport = getSnapshotViewport(snapshot);
+  const modal = strictFilter ? resolveActiveModal(snapshot) : null;
+  const visibleMatches = buildSelectorCheck(snapshot, { css: normalizedSelector, visible: true });
+  const allMatches = strictFilter
+    ? visibleMatches
+    : buildSelectorCheck(snapshot, { css: normalizedSelector, visible: false });
+  const scopedVisible = modal
+    ? visibleMatches.filter((item) => isPathWithin(item.path, modal.path))
+    : visibleMatches;
+  const scopedAll = modal
+    ? allMatches.filter((item) => isPathWithin(item.path, modal.path))
+    : allMatches;
+  const candidate = strictFilter
+    ? (scopedVisible[0] || null)
+    : (scopedVisible[0] || scopedAll[0] || null);
+  if (!candidate) {
+    if (modal) {
+      throw new Error(`Modal focus locked for selector: ${normalizedSelector}`);
+    }
+    throw new Error(`Element not found: ${normalizedSelector}`);
+  }
+  const center = nodeCenter(candidate, viewport);
+  if (!center) {
+    throw new Error(`Element not found: ${normalizedSelector}`);
+  }
+  return {
+    ok: true,
+    selector: normalizedSelector,
+    matchedIndex: Math.max(0, scopedAll.indexOf(candidate)),
+    center: center.center,
+    rawCenter: center.rawCenter,
+    rect: center.rect,
+    viewport,
+    modalLocked: Boolean(modal),
+  };
+}
+
+async function scrollTargetIntoViewport(profileId, selector, initialTarget, params = {}, options = {}) {
+  let target = initialTarget;
+  const maxSteps = Math.max(0, Math.min(24, Number(params.maxScrollSteps ?? 8) || 8));
+  const settleMs = Math.max(0, Number(params.scrollSettleMs ?? 140) || 140);
+  const visibilityMargin = Math.max(0, Number(params.visibilityMargin ?? params.viewportMargin ?? 6) || 6);
+  for (let i = 0; i < maxSteps; i += 1) {
+    if (isTargetFullyInViewport(target, visibilityMargin)) break;
+    const delta = resolveViewportScrollDelta(target, visibilityMargin);
+    if (Math.abs(delta.deltaX) < 1 && Math.abs(delta.deltaY) < 1) break;
+    const anchorX = clamp(Math.round(Number(target?.center?.x || 0) || 1), 1, Math.max(1, Number(target?.viewport?.width || 1) - 1));
+    const anchorY = clamp(Math.round(Number(target?.center?.y || 0) || 1), 1, Math.max(1, Number(target?.viewport?.height || 1) - 1));
+    await callAPI('mouse:move', { profileId, x: anchorX, y: anchorY, steps: 1 });
+    await callAPI('mouse:wheel', { profileId, deltaX: delta.deltaX, deltaY: delta.deltaY });
+    if (settleMs > 0) await sleep(settleMs);
+    target = await resolveSelectorTarget(profileId, selector, options);
+  }
+  return target;
+}
+
+async function resolveScrollAnchor(profileId, options = {}) {
+  const filterMode = resolveFilterMode(options.filterMode);
+  const strictFilter = filterMode !== 'legacy';
+  const selector = String(options.selector || '').trim();
+  const snapshot = await getDomSnapshotByProfile(profileId);
+  const viewport = getSnapshotViewport(snapshot);
+  const modal = strictFilter ? resolveActiveModal(snapshot) : null;
+
+  if (selector) {
+    const visibleMatches = buildSelectorCheck(snapshot, { css: selector, visible: true });
+    const target = visibleMatches[0] || null;
+    if (target) {
+      if (modal && !isPathWithin(target.path, modal.path)) {
+        const modalCenter = nodeCenter(modal.node, viewport);
+        if (modalCenter) {
+          return {
+            ok: true,
+            source: 'modal',
+            center: modalCenter.center,
+            modalLocked: true,
+            modalSelector: modal.selector,
+            selectorRejectedByModalLock: true,
+          };
+        }
+      } else {
+        const targetCenter = nodeCenter(target, viewport);
+        if (targetCenter) {
+          return {
+            ok: true,
+            source: 'selector',
+            center: targetCenter.center,
+            modalLocked: Boolean(modal),
+          };
+        }
+      }
+    }
+  }
+
+  if (modal) {
+    const modalCenter = nodeCenter(modal.node, viewport);
+    if (modalCenter) {
+      return {
+        ok: true,
+        source: 'modal',
+        center: modalCenter.center,
+        modalLocked: true,
+        modalSelector: modal.selector,
+      };
+    }
+  }
+
+  const width = Number(viewport.width || 0);
+  const height = Number(viewport.height || 0);
+  return {
+    ok: true,
+    source: 'document',
+    center: {
+      x: width > 1 ? Math.round(width / 2) : 1,
+      y: height > 1 ? Math.round(height / 2) : 1,
+    },
+    modalLocked: false,
+  };
+}
+
+async function executeSelectorOperation({ profileId, action, operation, params, filterMode }) {
   const selector = maybeSelector({
     profileId,
     containerId: params.containerId || operation?.containerId || null,
@@ -85,22 +364,75 @@ async function executeSelectorOperation({ profileId, action, operation, params }
   });
   if (!selector) return asErrorPayload('CONTAINER_NOT_FOUND', `${action} requires selector/containerId`);
 
-  const highlight = params.highlight !== false;
+  let target = await resolveSelectorTarget(profileId, selector, { filterMode });
+  target = await scrollTargetIntoViewport(profileId, selector, target, params, { filterMode });
+  const visibilityMargin = Math.max(0, Number(params.visibilityMargin ?? params.viewportMargin ?? 6) || 6);
+  const targetFullyVisible = isTargetFullyInViewport(target, visibilityMargin);
+  if (action === 'click' && !targetFullyVisible) {
+    return asErrorPayload('TARGET_NOT_FULLY_VISIBLE', 'click target is not fully visible after auto scroll', {
+      selector,
+      target,
+      visibilityMargin,
+    });
+  }
+
+  await callAPI('mouse:move', { profileId, x: target.center.x, y: target.center.y, steps: 2 });
+
   if (action === 'scroll_into_view') {
-    const script = buildSelectorScrollIntoViewScript({ selector, highlight });
-    const result = await callAPI('evaluate', {
+    return {
+      ok: true,
+      code: 'OPERATION_DONE',
+      message: 'scroll_into_view done',
+      data: { selector, target, targetFullyVisible, visibilityMargin },
+    };
+  }
+
+  if (action === 'click') {
+    const button = String(params.button || 'left').trim() || 'left';
+    const clicks = Math.max(1, Number(params.clicks ?? 1) || 1);
+    const delay = Number(params.delay);
+    const result = await callAPI('mouse:click', {
       profileId,
-      script,
+      x: target.center.x,
+      y: target.center.y,
+      button,
+      clicks,
+      ...(Number.isFinite(delay) && delay >= 0 ? { delay } : {}),
     });
-    return { ok: true, code: 'OPERATION_DONE', message: 'scroll_into_view done', data: result };
+    return { ok: true, code: 'OPERATION_DONE', message: 'click done', data: { selector, target, result, targetFullyVisible, visibilityMargin } };
   }
 
-  const typeText = String(params.text ?? params.value ?? '');
-  const script = action === 'click'
-    ? buildSelectorClickScript({ selector, highlight })
-    : buildSelectorTypeScript({ selector, highlight, text: typeText });
-  const result = await callAPI('evaluate', { profileId, script });
-  return { ok: true, code: 'OPERATION_DONE', message: `${action} done`, data: result };
+  const text = String(params.text ?? params.value ?? '');
+  await callAPI('mouse:click', {
+    profileId,
+    x: target.center.x,
+    y: target.center.y,
+    button: 'left',
+    clicks: 1,
+  });
+  const clearBeforeType = params.clear !== false;
+  if (clearBeforeType) {
+    await callAPI('keyboard:press', {
+      profileId,
+      key: process.platform === 'darwin' ? 'Meta+A' : 'Control+A',
+    });
+    await callAPI('keyboard:press', { profileId, key: 'Backspace' });
+  }
+  const delay = Number(params.keyDelayMs ?? params.delay);
+  await callAPI('keyboard:type', {
+    profileId,
+    text,
+    ...(Number.isFinite(delay) && delay >= 0 ? { delay } : {}),
+  });
+  if (params.pressEnter === true) {
+    await callAPI('keyboard:press', { profileId, key: 'Enter' });
+  }
+  return {
+    ok: true,
+    code: 'OPERATION_DONE',
+    message: 'type done',
+    data: { selector, target, length: text.length },
+  };
 }
 
 async function executeVerifySubscriptions({ profileId, params }) {
@@ -200,6 +532,13 @@ export async function executeOperation({ profileId, operation, context = {} }) {
     const resolvedProfile = session.profileId || profileId;
     const action = String(operation?.action || '').trim();
     const params = operation?.params || operation?.config || {};
+    const filterMode = resolveFilterMode(
+      params.filterMode
+      || operation?.filterMode
+      || context?.filterMode
+      || context?.runtime?.filterMode
+      || null,
+    );
 
     if (!action) {
       return asErrorPayload('OPERATION_FAILED', 'operation.action is required');
@@ -279,38 +618,49 @@ 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?.center?.x && anchor?.center?.y) {
+        await callAPI('mouse:move', {
+          profileId: resolvedProfile,
+          x: Math.max(1, Math.round(Number(anchor.center.x) || 1)),
+          y: Math.max(1, Math.round(Number(anchor.center.y) || 1)),
+          steps: 2,
+        });
+      }
       const result = await callAPI('mouse:wheel', { profileId: resolvedProfile, deltaX, deltaY });
       return {
         ok: true,
         code: 'OPERATION_DONE',
         message: 'scroll done',
-        data: { direction, amount, deltaX, deltaY, result },
+        data: {
+          direction,
+          amount,
+          deltaX,
+          deltaY,
+          filterMode,
+          anchorSource: String(anchor?.source || 'document'),
+          modalLocked: anchor?.modalLocked === true,
+          result,
+        },
       };
     }
 
     if (action === 'press_key') {
       const key = String(params.key || params.value || '').trim();
       if (!key) return asErrorPayload('OPERATION_FAILED', 'press_key requires params.key');
-      const result = await callAPI('evaluate', {
+      const delay = Number(params.delay);
+      const result = await callAPI('keyboard:press', {
         profileId: resolvedProfile,
-        script: `(async () => {
-          const target = document.activeElement || document.body || document.documentElement;
-          const key = ${JSON.stringify(key)};
-          const code = key.length === 1 ? 'Key' + key.toUpperCase() : key;
-          const opts = { key, code, bubbles: true, cancelable: true };
-          target.dispatchEvent(new KeyboardEvent('keydown', opts));
-          target.dispatchEvent(new KeyboardEvent('keypress', opts));
-          target.dispatchEvent(new KeyboardEvent('keyup', opts));
-          if (key === 'Escape') {
-            const closeButton = document.querySelector('.note-detail-mask .close-box, .note-detail-mask .close-circle');
-            if (closeButton instanceof HTMLElement) closeButton.click();
-          }
-          if (key === 'Enter' && target instanceof HTMLInputElement && target.form) {
-            if (typeof target.form.requestSubmit === 'function') target.form.requestSubmit();
-            else target.form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
-          }
-          return { key, targetTag: target?.tagName || null };
-        })()`,
+        key,
+        ...(Number.isFinite(delay) && delay >= 0 ? { delay } : {}),
       });
       return { ok: true, code: 'OPERATION_DONE', message: 'press_key done', data: result };
     }
@@ -320,6 +670,9 @@ 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 });
@@ -327,11 +680,12 @@ export async function executeOperation({ profileId, operation, context = {} }) {
     }
 
     if (action === 'click' || action === 'type' || action === 'scroll_into_view') {
-      return executeSelectorOperation({
+      return await executeSelectorOperation({
         profileId: resolvedProfile,
         action,
         operation,
         params,
+        filterMode,
       });
     }
 

package/src/container/runtime-core/subscription.mjs

@@ -1,17 +1,36 @@
 import { getDomSnapshotByProfile } from '../../utils/browser-service.mjs';
 import { ChangeNotifier } from '../change-notifier.mjs';
-import { ensureActiveSession, normalizeArray } from './utils.mjs';
+import { ensureActiveSession, getCurrentUrl, normalizeArray } from './utils.mjs';
+
+function resolveFilterMode(input) {
+  const text = String(input || process.env.CAMO_FILTER_MODE || 'strict').trim().toLowerCase();
+  if (!text) return 'strict';
+  if (text === 'legacy') return 'legacy';
+  return 'strict';
+}
+
+function urlMatchesFilter(url, item) {
+  const href = String(url || '').trim();
+  const includes = normalizeArray(item?.pageUrlIncludes).map((token) => String(token || '').trim()).filter(Boolean);
+  const excludes = normalizeArray(item?.pageUrlExcludes).map((token) => String(token || '').trim()).filter(Boolean);
+  if (includes.length > 0 && !includes.every((token) => href.includes(token))) return false;
+  if (excludes.length > 0 && excludes.some((token) => href.includes(token))) return false;
+  return true;
+}
 
 export async function watchSubscriptions({
   profileId,
   subscriptions,
   throttle = 500,
+  filterMode = 'strict',
   onEvent = () => {},
   onError = () => {},
 }) {
   const session = await ensureActiveSession(profileId);
   const resolvedProfile = session.profileId || profileId;
   const notifier = new ChangeNotifier();
+  const effectiveFilterMode = resolveFilterMode(filterMode);
+  const strictFilter = effectiveFilterMode === 'strict';
   const items = normalizeArray(subscriptions)
     .map((item, index) => {
       if (!item || typeof item !== 'object') return null;
@@ -19,7 +38,16 @@ export async function watchSubscriptions({
       const selector = String(item.selector || '').trim();
       if (!selector) return null;
       const events = normalizeArray(item.events).map((name) => String(name).trim()).filter(Boolean);
-      return { id, selector, events: events.length > 0 ? new Set(events) : null };
+      const pageUrlIncludes = normalizeArray(item.pageUrlIncludes).map((token) => String(token || '').trim()).filter(Boolean);
+      const pageUrlExcludes = normalizeArray(item.pageUrlExcludes).map((token) => String(token || '').trim()).filter(Boolean);
+      return {
+        id,
+        selector,
+        visible: strictFilter ? true : (item.visible !== false),
+        pageUrlIncludes,
+        pageUrlExcludes,
+        events: events.length > 0 ? new Set(events) : null,
+      };
     })
     .filter(Boolean);
 
@@ -39,10 +67,14 @@ export async function watchSubscriptions({
     if (stopped) return;
     try {
       const snapshot = await getDomSnapshotByProfile(resolvedProfile);
+      const currentUrl = await getCurrentUrl(resolvedProfile).catch(() => '');
       const ts = new Date().toISOString();
       for (const item of items) {
         const prev = state.get(item.id) || { exists: false, stateSig: '', appearCount: 0 };
-        const elements = notifier.findElements(snapshot, { css: item.selector });
+        const urlMatched = urlMatchesFilter(currentUrl, item);
+        const elements = urlMatched
+          ? notifier.findElements(snapshot, { css: item.selector, visible: item.visible })
+          : [];
         const exists = elements.length > 0;
         const stateSig = elements.map((node) => node.path).sort().join(',');
         const changed = stateSig !== prev.stateSig;
@@ -55,16 +87,56 @@ export async function watchSubscriptions({
 
         const shouldEmit = (type) => !item.events || item.events.has(type);
         if (exists && !prev.exists && shouldEmit('appear')) {
-          await emit({ type: 'appear', profileId: resolvedProfile, subscriptionId: item.id, selector: item.selector, count: elements.length, elements, timestamp: ts });
+          await emit({
+            type: 'appear',
+            profileId: resolvedProfile,
+            subscriptionId: item.id,
+            selector: item.selector,
+            count: elements.length,
+            elements,
+            pageUrl: currentUrl,
+            filterMode: effectiveFilterMode,
+            timestamp: ts,
+          });
         }
         if (!exists && prev.exists && shouldEmit('disappear')) {
-          await emit({ type: 'disappear', profileId: resolvedProfile, subscriptionId: item.id, selector: item.selector, count: 0, elements: [], timestamp: ts });
+          await emit({
+            type: 'disappear',
+            profileId: resolvedProfile,
+            subscriptionId: item.id,
+            selector: item.selector,
+            count: 0,
+            elements: [],
+            pageUrl: currentUrl,
+            filterMode: effectiveFilterMode,
+            timestamp: ts,
+          });
         }
         if (exists && shouldEmit('exist')) {
-          await emit({ type: 'exist', profileId: resolvedProfile, subscriptionId: item.id, selector: item.selector, count: elements.length, elements, timestamp: ts });
+          await emit({
+            type: 'exist',
+            profileId: resolvedProfile,
+            subscriptionId: item.id,
+            selector: item.selector,
+            count: elements.length,
+            elements,
+            pageUrl: currentUrl,
+            filterMode: effectiveFilterMode,
+            timestamp: ts,
+          });
         }
         if (changed && shouldEmit('change')) {
-          await emit({ type: 'change', profileId: resolvedProfile, subscriptionId: item.id, selector: item.selector, count: elements.length, elements, timestamp: ts });
+          await emit({
+            type: 'change',
+            profileId: resolvedProfile,
+            subscriptionId: item.id,
+            selector: item.selector,
+            count: elements.length,
+            elements,
+            pageUrl: currentUrl,
+            filterMode: effectiveFilterMode,
+            timestamp: ts,
+          });
         }
       }
       await emit({ type: 'tick', profileId: resolvedProfile, timestamp: ts });

package/src/container/runtime-core/validation.mjs

@@ -9,7 +9,7 @@ import {
   normalizeArray,
 } from './utils.mjs';
 
-async function validatePage(profileId, spec = {}, platform = 'xiaohongshu') {
+async function validatePage(profileId, spec = {}, platform = 'generic') {
   const url = await getCurrentUrl(profileId);
   const includes = normalizeArray(spec.urlIncludes || []);
   const excludes = normalizeArray(spec.urlExcludes || []);
@@ -74,7 +74,7 @@ export async function validateOperation({
   validationSpec = {},
   phase = 'pre',
   context = {},
-  platform = 'xiaohongshu',
+  platform = 'generic',
 }) {
   try {
     const mode = String(validationSpec.mode || 'none').toLowerCase();