@web-auto/camo 0.1.24 → 0.1.25

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

@@ -41,6 +41,7 @@ export async function executeViewportOperation({ profileId, action, params = {}
     const width = hasTargetViewport ? Math.max(320, rawWidth) : null;
     const height = hasTargetViewport ? Math.max(240, rawHeight) : null;
     const followWindow = params.followWindow !== false;
+    const fitDisplayWindow = params.fitDisplayWindow !== false;
     const settleMs = Math.max(0, Number(params.settleMs ?? 180) || 180);
     const attempts = Math.max(1, Number(params.attempts ?? 3) || 3);
     const tolerance = Math.max(0, Number(params.tolerancePx ?? 3) || 3);
@@ -56,6 +57,49 @@ export async function executeViewportOperation({ profileId, action, params = {}
 
     let measured = await probeWindow();
     if (followWindow && !hasTargetViewport) {
+      let resizedWindow = false;
+      let windowTarget = null;
+      if (fitDisplayWindow) {
+        try {
+          const displayPayload = await callWithTimeout('system:display', {}, apiTimeoutMs);
+          const display = displayPayload?.metrics || displayPayload || {};
+          const reserveFromEnv = Number(process.env.CAMO_DEFAULT_WINDOW_VERTICAL_RESERVE ?? 0);
+          const reservePx = Number.isFinite(reserveFromEnv) ? Math.max(0, Math.min(240, Math.floor(reserveFromEnv))) : 0;
+          const workWidth = Number(display.workWidth || 0);
+          const workHeight = Number(display.workHeight || 0);
+          const displayWidth = Number(display.width || 0);
+          const displayHeight = Number(display.height || 0);
+          const baseW = Math.floor(workWidth > 0 ? workWidth : displayWidth);
+          const baseH = Math.floor(workHeight > 0 ? workHeight : displayHeight);
+          if (baseW > 0 && baseH > 0) {
+            windowTarget = {
+              width: Math.max(960, baseW),
+              height: Math.max(700, baseH - reservePx),
+            };
+            const currentOuterWidth = Number(measured.outerWidth || 0);
+            const currentOuterHeight = Number(measured.outerHeight || 0);
+            const shouldResize = (
+              !Number.isFinite(currentOuterWidth)
+              || !Number.isFinite(currentOuterHeight)
+              || currentOuterWidth < Math.floor(windowTarget.width * 0.92)
+              || currentOuterHeight < Math.floor(windowTarget.height * 0.92)
+            );
+            if (shouldResize) {
+              await callWithTimeout('window:resize', {
+                profileId,
+                width: windowTarget.width,
+                height: windowTarget.height,
+              }, apiTimeoutMs);
+              if (settleMs > 0) await new Promise((resolve) => setTimeout(resolve, settleMs));
+              measured = await probeWindow();
+              resizedWindow = true;
+            }
+          }
+        } catch {
+          // display probing is best-effort and must not block follow-window sync
+        }
+      }
+
       const innerWidth = Math.max(320, Number(measured.innerWidth || 0) || 1280);
       const innerHeight = Math.max(240, Number(measured.innerHeight || 0) || 720);
       const outerWidth = Math.max(320, Number(measured.outerWidth || 0) || innerWidth);
@@ -77,6 +121,8 @@ export async function executeViewportOperation({ profileId, action, params = {}
           followWindow: true,
           viewport: { width: followWidth, height: followHeight },
           frame: { width: frameW, height: frameH },
+          resizedWindow,
+          windowTarget,
           measured: synced,
         },
       };

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

@@ -2,6 +2,30 @@ import { getDomSnapshotByProfile } from '../../utils/browser-service.mjs';
 import { ChangeNotifier } from '../change-notifier.mjs';
 import { ensureActiveSession, getCurrentUrl, normalizeArray } from './utils.mjs';
 
+function normalizeElementKeys(elements) {
+  return (Array.isArray(elements) ? elements : [])
+    .map((node) => String(node?.path || '').trim())
+    .filter(Boolean)
+    .sort();
+}
+
+function joinElementKeys(keys) {
+  return Array.isArray(keys) && keys.length > 0 ? keys.join('|') : 'none';
+}
+
+function buildEventKey(subscriptionId, type, presenceVersion, keys) {
+  return `${subscriptionId}:${type}:p${Math.max(0, Number(presenceVersion) || 0)}:k${joinElementKeys(keys)}`;
+}
+
+export function isTransientSubscriptionError(error) {
+  const message = String(error?.message || error || '').trim().toLowerCase();
+  if (!message) return false;
+  return message.includes('execution context was destroyed')
+    || message.includes('most likely because of a navigation')
+    || message.includes('cannot find context with specified id')
+    || message.includes('target closed');
+}
+
 function resolveFilterMode(input) {
   const text = String(input || process.env.CAMO_FILTER_MODE || 'strict').trim().toLowerCase();
   if (!text) return 'strict';
@@ -11,9 +35,9 @@ function resolveFilterMode(input) {
 
 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;
+  const includes = normalizeArray(item?.pageUrlIncludes || item?.urlIncludes).map((token) => String(token || '').trim()).filter(Boolean);
+  const excludes = normalizeArray(item?.pageUrlExcludes || item?.urlExcludes).map((token) => String(token || '').trim()).filter(Boolean);
+  if (includes.length > 0 && !includes.some((token) => href.includes(token))) return false;
   if (excludes.length > 0 && excludes.some((token) => href.includes(token))) return false;
   return true;
 }
@@ -51,7 +75,13 @@ export async function watchSubscriptions({
     })
     .filter(Boolean);
 
-  const state = new Map(items.map((item) => [item.id, { exists: false, stateSig: '', appearCount: 0 }]));
+  const state = new Map(items.map((item) => [item.id, {
+    exists: false,
+    stateSig: '',
+    appearCount: 0,
+    presenceVersion: 0,
+    elementKeys: [],
+  }]));
   const intervalMs = Math.max(100, Number(throttle) || 500);
   let stopped = false;
 
@@ -67,21 +97,36 @@ export async function watchSubscriptions({
     if (stopped) return;
     try {
       const snapshot = await getDomSnapshotByProfile(resolvedProfile);
-      const currentUrl = await getCurrentUrl(resolvedProfile).catch(() => '');
+      const currentUrl = String(snapshot?.__url || '') || 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 prev = state.get(item.id) || {
+          exists: false,
+          stateSig: '',
+          appearCount: 0,
+          presenceVersion: 0,
+          elementKeys: [],
+        };
         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 elementKeys = normalizeElementKeys(elements);
+        const prevElementKeys = Array.isArray(prev.elementKeys) ? prev.elementKeys : [];
+        const prevElementKeySet = new Set(prevElementKeys);
+        const elementKeySet = new Set(elementKeys);
+        const appearedKeys = elementKeys.filter((key) => !prevElementKeySet.has(key));
+        const disappearedKeys = prevElementKeys.filter((key) => !elementKeySet.has(key));
+        const stateSig = elementKeys.join(',');
         const changed = stateSig !== prev.stateSig;
+        const presenceVersion = prev.presenceVersion + (exists && !prev.exists ? 1 : 0);
         const next = {
           exists,
           stateSig,
           appearCount: prev.appearCount + (exists && !prev.exists ? 1 : 0),
+          presenceVersion,
+          elementKeys,
         };
         state.set(item.id, next);
 
@@ -96,6 +141,10 @@ export async function watchSubscriptions({
             elements,
             pageUrl: currentUrl,
             filterMode: effectiveFilterMode,
+            elementKeys,
+            presenceVersion,
+            stateKey: stateSig,
+            eventKey: buildEventKey(item.id, 'appear', presenceVersion, appearedKeys.length > 0 ? appearedKeys : elementKeys),
             timestamp: ts,
           });
         }
@@ -109,6 +158,11 @@ export async function watchSubscriptions({
             elements: [],
             pageUrl: currentUrl,
             filterMode: effectiveFilterMode,
+            elementKeys: [],
+            departedElementKeys: disappearedKeys,
+            presenceVersion: prev.presenceVersion,
+            stateKey: '',
+            eventKey: buildEventKey(item.id, 'disappear', prev.presenceVersion, disappearedKeys),
             timestamp: ts,
           });
         }
@@ -122,6 +176,10 @@ export async function watchSubscriptions({
             elements,
             pageUrl: currentUrl,
             filterMode: effectiveFilterMode,
+            elementKeys,
+            presenceVersion,
+            stateKey: stateSig,
+            eventKey: buildEventKey(item.id, 'exist', presenceVersion, elementKeys),
             timestamp: ts,
           });
         }
@@ -135,12 +193,19 @@ export async function watchSubscriptions({
             elements,
             pageUrl: currentUrl,
             filterMode: effectiveFilterMode,
+            elementKeys,
+            appearedElementKeys: appearedKeys,
+            departedElementKeys: disappearedKeys,
+            presenceVersion,
+            stateKey: stateSig,
+            eventKey: buildEventKey(item.id, 'change', presenceVersion, elementKeys),
             timestamp: ts,
           });
         }
       }
       await emit({ type: 'tick', profileId: resolvedProfile, timestamp: ts });
     } catch (err) {
+      if (isTransientSubscriptionError(err)) return;
       onError(err);
     }
   };

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

@@ -26,13 +26,21 @@ async function validatePage(profileId, spec = {}, platform = 'generic') {
     errors.push(`url host mismatch, expected one of: ${hostIncludes.join(',')}`);
   }
 
+  // 锚点驱动的 checkpoint 检查
   const checkpoints = normalizeArray(spec.checkpointIn || []);
   let checkpoint = null;
   if (checkpoints.length > 0) {
-    const detected = await detectCheckpoint({ profileId, platform });
-    checkpoint = detected?.data?.checkpoint || null;
-    if (!checkpoints.includes(checkpoint)) {
-      errors.push(`checkpoint mismatch: got ${checkpoint}, expect one of ${checkpoints.join(',')}`);
+    // 使用锚点轮询，而非 evaluate
+    const checkpointSelectors = getCheckpointSelectors(checkpoints, platform);
+    const anchorResult = await validateAnchors(profileId, checkpointSelectors, {
+      timeoutMs: 15000,  // 15秒最大等待
+      intervalMs: 500,
+    });
+    
+    if (anchorResult.found) {
+      checkpoint = checkpoints[0];  // 锚点存在，使用第一个 checkpoint
+    } else {
+      errors.push(`anchor not found within ${anchorResult.elapsed}ms, expected one of: ${checkpoints.join(',')}`);
     }
   }
 
@@ -42,8 +50,29 @@ async function validatePage(profileId, spec = {}, platform = 'generic') {
     checkpoint,
     errors,
   };
+};
+
+// 添加 getCheckpointSelectors 辅助函数
+function getCheckpointSelectors(checkpoints, platform = 'generic') {
+  const XHS_CHECKPOINTS = {
+    search_ready: ['#search-input', 'input.search-input', '.search-result-list'],
+    home_ready: ['.note-item', '.note-item a', 'a[href*="/explore/"]', '[class*="note-item"]'],
+    detail_ready: ['.note-scroller', '.note-content', '.interaction-container'],
+    comments_ready: ['.comments-container', '.comment-item'],
+    login_guard: ['.login-container', '.login-dialog', '#login-container'],
+    risk_control: ['.qrcode-box', '.captcha-container', '[class*="captcha"]'],
+  };
+
+  const selectors = [];
+  for (const cp of checkpoints) {
+    if (platform === 'xiaohongshu' && XHS_CHECKPOINTS[cp]) {
+      selectors.push(...XHS_CHECKPOINTS[cp]);
+    }
+  }
+  return selectors.length > 0 ? selectors : checkpoints;
 }
 
+
 async function validateContainer(profileId, spec = {}) {
   const snapshot = await getDomSnapshotByProfile(profileId);
   const selector = maybeSelector({
@@ -125,3 +154,31 @@ export async function validateOperation({
     return asErrorPayload('VALIDATION_FAILED', err?.message || String(err), { phase, context });
   }
 }
+
+// 锚点驱动的验证：轮询容器 selector，而非 evaluate
+async function validateAnchors(profileId, selectors = [], options = {}) {
+  const maxMs = Math.max(1000, Number(options.timeoutMs || 30000));
+  const intervalMs = Math.max(200, Number(options.intervalMs || 500));
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < maxMs) {
+    try {
+      const snapshot = await getDomSnapshotByProfile(profileId, { maxDepth: 5, maxChildren: 50 });
+      for (const selector of selectors) {
+        const matched = buildSelectorCheck(snapshot, selector);
+        if (matched.length > 0) {
+          return { ok: true, found: true, selector, count: matched.length, elapsed: Date.now() - startTime };
+        }
+      }
+    } catch (err) {
+      // 忽略 snapshot 错误，继续轮询
+    }
+    
+    // 等待下次检查
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  
+  return { ok: false, found: false, elapsed: maxMs };
+}
+
+export { validateAnchors };

package/src/core/utils.mjs

@@ -48,6 +48,10 @@ export async function withTimeout(promise, ms, message = 'Timeout') {
 export function ensureUrlScheme(url) {
   if (!url) return url;
   if (url.startsWith('http://') || url.startsWith('https://')) return url;
+  // Skip special browser URLs that don't need scheme
+  if (url.startsWith('about:') || url.startsWith('chrome:') || url.startsWith('file:')) {
+    return url;
+  }
   if (url.startsWith('localhost') || url.match(/^\\d+\\.\\d+/)) {
     return `http://${url}`;
   }

package/src/services/browser-service/index.js

@@ -7,6 +7,7 @@ import { BrowserWsServer } from './internal/ws-server.js';
 import { logDebug } from './internal/logging.js';
 import { installServiceProcessLogger } from './internal/service-process-logger.js';
 import { startHeartbeatWriter } from './internal/heartbeat.js';
+import { appendCommandLog } from '../../utils/command-log.mjs';
 const clients = new Set();
 const autoLoops = new Map();
 function readNumber(value) {
@@ -215,6 +216,18 @@ export async function startBrowserService(opts = {}) {
                         const t0 = Date.now();
                         const action = String(payload?.action || '');
                         const profileId = String(payload?.args?.profileId || payload?.args?.profile || payload?.args?.sessionId || '');
+                        appendCommandLog({
+                            action,
+                            profileId,
+                            payload: payload?.args ?? {},
+                            meta: {
+                                source: 'browser-service',
+                                cwd: process.cwd(),
+                                pid: process.pid,
+                                ppid: process.ppid,
+                                sender: payload?.meta?.sender && typeof payload.meta.sender === 'object' ? payload.meta.sender : {},
+                            },
+                        });
                         logEvent('browser.command.start', { action, profileId });
                         const result = await handleCommand(payload, sessionManager, wsServer, { onSessionStart: markSessionStarted });
                         logEvent('browser.command.done', { action, profileId, ok: result.ok, ms: Date.now() - t0 });
@@ -292,16 +305,19 @@ async function handleCommand(payload, manager, wsServer, options = {}) {
     switch (action) {
         case 'start': {
             const startViewport = resolveStartViewport(args);
-            const opts = {
-                profileId: args.profileId || 'default',
-                sessionName: args.profileId || 'default',
-                headless: !!args.headless,
-                initialUrl: args.url,
-                engine: args.engine || 'camoufox',
-                fingerprintPlatform: args.fingerprintPlatform || null,
-                ...(startViewport ? { viewport: startViewport } : {}),
-                ...(args.ownerPid ? { ownerPid: args.ownerPid } : {}),
-            };
+      const opts = {
+        profileId: args.profileId || 'default',
+        sessionName: args.profileId || 'default',
+        headless: !!args.headless,
+        initialUrl: args.url,
+        engine: args.engine || 'camoufox',
+        fingerprintPlatform: args.fingerprintPlatform || null,
+        ...(startViewport ? { viewport: startViewport } : {}),
+        ...(args.ownerPid ? { ownerPid: args.ownerPid } : {}),
+      };
+      if (Number.isFinite(args.maxTabs) && args.maxTabs >= 1) {
+        opts.maxTabs = Math.floor(args.maxTabs);
+      }
             const res = await manager.createSession(opts);
             const session = manager.getSession(opts.profileId);
             if (!session) {
@@ -479,6 +495,7 @@ async function handleCommand(payload, manager, wsServer, options = {}) {
             const activeIndex = pages.find((p) => p.active)?.index ?? 0;
             return { ok: true, body: { ok: true, pages, activeIndex } };
         }
+        case 'newTab':
         case 'page:new':
         case 'newPage': {
             const profileId = args.profileId || 'default';