@web-auto/camo 0.1.2 → 0.1.4

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

@@ -0,0 +1,87 @@
+import { getDomSnapshotByProfile } from '../../utils/browser-service.mjs';
+import { ChangeNotifier } from '../change-notifier.mjs';
+import { ensureActiveSession, normalizeArray } from './utils.mjs';
+
+export async function watchSubscriptions({
+  profileId,
+  subscriptions,
+  throttle = 500,
+  onEvent = () => {},
+  onError = () => {},
+}) {
+  const session = await ensureActiveSession(profileId);
+  const resolvedProfile = session.profileId || profileId;
+  const notifier = new ChangeNotifier();
+  const items = normalizeArray(subscriptions)
+    .map((item, index) => {
+      if (!item || typeof item !== 'object') return null;
+      const id = String(item.id || `sub_${index + 1}`);
+      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 };
+    })
+    .filter(Boolean);
+
+  const state = new Map(items.map((item) => [item.id, { exists: false, stateSig: '', appearCount: 0 }]));
+  const intervalMs = Math.max(100, Number(throttle) || 500);
+  let stopped = false;
+
+  const emit = async (payload) => {
+    try {
+      await onEvent(payload);
+    } catch (err) {
+      onError(err);
+    }
+  };
+
+  const poll = async () => {
+    if (stopped) return;
+    try {
+      const snapshot = await getDomSnapshotByProfile(resolvedProfile);
+      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 exists = elements.length > 0;
+        const stateSig = elements.map((node) => node.path).sort().join(',');
+        const changed = stateSig !== prev.stateSig;
+        const next = {
+          exists,
+          stateSig,
+          appearCount: prev.appearCount + (exists && !prev.exists ? 1 : 0),
+        };
+        state.set(item.id, next);
+
+        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 });
+        }
+        if (!exists && prev.exists && shouldEmit('disappear')) {
+          await emit({ type: 'disappear', profileId: resolvedProfile, subscriptionId: item.id, selector: item.selector, count: 0, elements: [], timestamp: ts });
+        }
+        if (exists && shouldEmit('exist')) {
+          await emit({ type: 'exist', profileId: resolvedProfile, subscriptionId: item.id, selector: item.selector, count: elements.length, elements, 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: 'tick', profileId: resolvedProfile, timestamp: ts });
+    } catch (err) {
+      onError(err);
+    }
+  };
+
+  const interval = setInterval(poll, intervalMs);
+  await poll();
+
+  return {
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(interval);
+    },
+    profileId: resolvedProfile,
+  };
+}

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

@@ -0,0 +1,94 @@
+import { callAPI, getSessionByProfile } from '../../utils/browser-service.mjs';
+import { getDefaultProfile } from '../../utils/config.mjs';
+import { ChangeNotifier } from '../change-notifier.mjs';
+import { getRegisteredTargets } from '../subscription-registry.mjs';
+
+export function asErrorPayload(code, message, data = {}) {
+  return { ok: false, code, message, data };
+}
+
+export function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+export function extractPageList(payload) {
+  const pages = normalizeArray(payload?.pages || payload?.data?.pages)
+    .map((item, idx) => {
+      const rawIndex = Number(item?.index);
+      return {
+        ...item,
+        index: Number.isFinite(rawIndex) ? rawIndex : idx,
+      };
+    })
+    .sort((a, b) => Number(a.index) - Number(b.index));
+  const activeIndex = Number(payload?.activeIndex ?? payload?.data?.activeIndex);
+  return {
+    pages,
+    activeIndex: Number.isFinite(activeIndex) ? activeIndex : null,
+  };
+}
+
+export async function getCurrentUrl(profileId) {
+  const res = await callAPI('evaluate', {
+    profileId,
+    script: 'window.location.href',
+  });
+  return String(res?.result || res?.data?.result || '');
+}
+
+function firstSelectorForContainer(profileId, containerId) {
+  const targets = getRegisteredTargets(profileId)?.profile;
+  const selectors = normalizeArray(targets?.selectors);
+  const direct = selectors.find((item) => item?.setId === containerId && typeof item?.css === 'string');
+  if (direct?.css) return direct.css;
+
+  const fallbackTarget = normalizeArray(targets?.targets).find(
+    (item) => item?.containerId === containerId && item?.markerType === 'url_dom' && item?.dom?.css,
+  );
+  if (fallbackTarget?.dom?.css) return fallbackTarget.dom.css;
+  return null;
+}
+
+export function maybeSelector({ profileId, containerId, selector }) {
+  if (selector && typeof selector === 'string') return selector;
+  if (containerId && typeof containerId === 'string') {
+    return firstSelectorForContainer(profileId, containerId);
+  }
+  return null;
+}
+
+export function buildSelectorCheck(snapshot, selector) {
+  if (!snapshot || !selector) return [];
+  const notifier = new ChangeNotifier();
+  if (typeof selector === 'string') {
+    return notifier.findElements(snapshot, { css: selector });
+  }
+  if (selector && typeof selector === 'object') {
+    return notifier.findElements(snapshot, selector);
+  }
+  return [];
+}
+
+export function isCheckpointRiskUrl(url) {
+  const lower = String(url || '').toLowerCase();
+  return (
+    lower.includes('/website-login/captcha')
+    || lower.includes('verifyuuid=')
+    || lower.includes('verifytype=')
+    || lower.includes('verifybiz=')
+    || lower.includes('/website-login/verify')
+    || lower.includes('/website-login/security')
+  );
+}
+
+export async function ensureActiveSession(profileId) {
+  const targetProfile = profileId || getDefaultProfile();
+  if (!targetProfile) {
+    throw new Error('profileId is required');
+  }
+  const session = await getSessionByProfile(targetProfile);
+  if (!session) {
+    throw new Error(`No active session for profile: ${targetProfile}`);
+  }
+  return session;
+}

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

@@ -0,0 +1,127 @@
+import { getDomSnapshotByProfile } from '../../utils/browser-service.mjs';
+import { detectCheckpoint } from './checkpoint.mjs';
+import {
+  asErrorPayload,
+  buildSelectorCheck,
+  ensureActiveSession,
+  getCurrentUrl,
+  maybeSelector,
+  normalizeArray,
+} from './utils.mjs';
+
+async function validatePage(profileId, spec = {}, platform = 'xiaohongshu') {
+  const url = await getCurrentUrl(profileId);
+  const includes = normalizeArray(spec.urlIncludes || []);
+  const excludes = normalizeArray(spec.urlExcludes || []);
+  const hostIncludes = normalizeArray(spec.hostIncludes || []);
+  const errors = [];
+
+  for (const token of includes) {
+    if (!url.includes(String(token))) errors.push(`url missing token: ${token}`);
+  }
+  for (const token of excludes) {
+    if (url.includes(String(token))) errors.push(`url contains forbidden token: ${token}`);
+  }
+  if (hostIncludes.length > 0 && !hostIncludes.some((token) => url.includes(String(token)))) {
+    errors.push(`url host mismatch, expected one of: ${hostIncludes.join(',')}`);
+  }
+
+  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(',')}`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    url,
+    checkpoint,
+    errors,
+  };
+}
+
+async function validateContainer(profileId, spec = {}) {
+  const snapshot = await getDomSnapshotByProfile(profileId);
+  const selector = maybeSelector({
+    profileId,
+    containerId: spec.containerId || null,
+    selector: spec.selector || null,
+  });
+  if (!selector) {
+    return { ok: false, selector: null, count: 0, errors: ['container selector not resolved'] };
+  }
+  const matched = buildSelectorCheck(snapshot, selector);
+  const count = matched.length;
+  const mustExist = spec.mustExist !== false;
+  const minCount = Number.isFinite(Number(spec.minCount)) ? Number(spec.minCount) : (mustExist ? 1 : 0);
+  const maxCount = Number.isFinite(Number(spec.maxCount)) ? Number(spec.maxCount) : null;
+  const errors = [];
+
+  if (count < minCount) errors.push(`container count too small: ${count} < ${minCount}`);
+  if (maxCount !== null && count > maxCount) errors.push(`container count too large: ${count} > ${maxCount}`);
+  if (!mustExist && minCount === 0) {
+    return { ok: true, selector, count, errors: [] };
+  }
+  return { ok: errors.length === 0, selector, count, errors };
+}
+
+export async function validateOperation({
+  profileId,
+  validationSpec = {},
+  phase = 'pre',
+  context = {},
+  platform = 'xiaohongshu',
+}) {
+  try {
+    const mode = String(validationSpec.mode || 'none').toLowerCase();
+    if (mode === 'none') {
+      return { ok: true, code: 'VALIDATION_SKIPPED', message: 'Validation skipped', data: { phase, mode } };
+    }
+    if (phase === 'pre' && mode === 'post') {
+      return { ok: true, code: 'VALIDATION_SKIPPED', message: 'Pre validation skipped by mode=post', data: { phase, mode } };
+    }
+    if (phase === 'post' && mode === 'pre') {
+      return { ok: true, code: 'VALIDATION_SKIPPED', message: 'Post validation skipped by mode=pre', data: { phase, mode } };
+    }
+
+    const effective = validationSpec[phase] || {};
+    const resolvedProfile = (await ensureActiveSession(profileId)).profileId || profileId;
+    const pageResult = effective.page
+      ? await validatePage(resolvedProfile, effective.page, platform)
+      : { ok: true, errors: [] };
+    const containerResult = effective.container
+      ? await validateContainer(resolvedProfile, effective.container)
+      : { ok: true, errors: [] };
+    const allErrors = [...normalizeArray(pageResult.errors), ...normalizeArray(containerResult.errors)];
+
+    if (allErrors.length > 0) {
+      return asErrorPayload('VALIDATION_FAILED', `Validation failed at phase=${phase}`, {
+        phase,
+        mode,
+        errors: allErrors,
+        page: pageResult,
+        container: containerResult,
+        context,
+      });
+    }
+
+    return {
+      ok: true,
+      code: 'VALIDATION_PASSED',
+      message: `Validation passed at phase=${phase}`,
+      data: {
+        phase,
+        mode,
+        page: pageResult,
+        container: containerResult,
+        context,
+      },
+    };
+  } catch (err) {
+    return asErrorPayload('VALIDATION_FAILED', err?.message || String(err), { phase, context });
+  }
+}

package/src/container/runtime-core.mjs

@@ -0,0 +1 @@
+export * from './runtime-core/index.mjs';