@web-auto/webauto 0.1.3 → 0.1.6

package/dist/modules/xiaohongshu/app/src/workflow/blocks/helpers/operationLogger.js

@@ -0,0 +1,195 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const LOG_ROOT = path.join(os.homedir(), '.webauto', 'logs');
+const OPS_LOG_FILE = path.join(LOG_ROOT, 'ops.jsonl');
+const ERR_LOG_FILE = path.join(LOG_ROOT, 'ops-errors.jsonl');
+const MAX_RECENT = 50;
+let seq = 0;
+const recentOps = [];
+let logReady = false;
+function ensureLogDir() {
+    if (logReady)
+        return;
+    try {
+        fs.mkdirSync(LOG_ROOT, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    logReady = true;
+}
+function nextId() {
+    seq += 1;
+    return seq;
+}
+function truncateString(value, maxLen = 400) {
+    if (value.length <= maxLen)
+        return value;
+    return `${value.slice(0, maxLen)}...[len=${value.length}]`;
+}
+function shouldOmitKey(key) {
+    const k = key.toLowerCase();
+    return (k.includes('script') ||
+        k.includes('html') ||
+        k.includes('cookie') ||
+        k.includes('buffer') ||
+        k.includes('base64') ||
+        k.includes('screenshot') ||
+        k.includes('image'));
+}
+function summarizeValue(value, depth = 0) {
+    if (depth > 3)
+        return '[max-depth]';
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string')
+        return truncateString(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (Array.isArray(value)) {
+        const len = value.length;
+        if (len === 0)
+            return [];
+        if (len <= 5)
+            return value.map((v) => summarizeValue(v, depth + 1));
+        return {
+            _type: 'array',
+            length: len,
+            sample: value.slice(0, 2).map((v) => summarizeValue(v, depth + 1)),
+        };
+    }
+    if (typeof value === 'object') {
+        const out = {};
+        const keys = Object.keys(value);
+        let count = 0;
+        for (const key of keys) {
+            if (count >= 20)
+                break;
+            count += 1;
+            if (shouldOmitKey(key)) {
+                out[key] = '[omitted]';
+                continue;
+            }
+            out[key] = summarizeValue(value[key], depth + 1);
+        }
+        if (keys.length > count)
+            out._more = keys.length - count;
+        return out;
+    }
+    return String(value);
+}
+function summarizeRecent(entry) {
+    return {
+        opId: entry.opId,
+        kind: entry.kind,
+        action: entry.action,
+        sessionId: entry.sessionId,
+        context: entry.context,
+        reason: entry.reason,
+    };
+}
+function pushRecent(entry) {
+    recentOps.push(entry);
+    if (recentOps.length > MAX_RECENT) {
+        recentOps.splice(0, recentOps.length - MAX_RECENT);
+    }
+}
+export function logOperation(entry) {
+    ensureLogDir();
+    const opId = entry.opId ?? nextId();
+    const record = {
+        ts: new Date().toISOString(),
+        opId,
+        kind: entry.kind,
+        action: entry.action || null,
+        sessionId: entry.sessionId || null,
+        context: entry.context || null,
+        reason: entry.reason || null,
+        payload: entry.payload ? summarizeValue(entry.payload) : null,
+        result: entry.result ? summarizeValue(entry.result) : null,
+        target: entry.target ? summarizeValue(entry.target) : null,
+        meta: entry.meta ? summarizeValue(entry.meta) : null,
+    };
+    try {
+        fs.appendFileSync(OPS_LOG_FILE, `${JSON.stringify(record)}\n`);
+    }
+    catch {
+        // ignore
+    }
+    pushRecent(record);
+    return opId;
+}
+export function logError(entry) {
+    ensureLogDir();
+    const opId = entry.opId ?? nextId();
+    const record = {
+        ts: new Date().toISOString(),
+        opId,
+        kind: entry.kind,
+        action: entry.action || null,
+        sessionId: entry.sessionId || null,
+        context: entry.context || null,
+        reason: entry.reason || null,
+        error: entry.error || null,
+        payload: entry.payload ? summarizeValue(entry.payload) : null,
+        meta: entry.meta ? summarizeValue(entry.meta) : null,
+        recent: recentOps.map(summarizeRecent),
+    };
+    try {
+        fs.appendFileSync(ERR_LOG_FILE, `${JSON.stringify(record)}\n`);
+    }
+    catch {
+        // ignore
+    }
+    return opId;
+}
+export function logControllerActionStart(action, payload, meta = {}) {
+    const sessionId = payload?.profileId || payload?.profile || payload?.sessionId || null;
+    const reason = payload?.reason ||
+        payload?.context ||
+        payload?.operationId ||
+        payload?.actionId ||
+        null;
+    const target = payload?.containerId
+        ? {
+            containerId: payload.containerId,
+            operationId: payload?.operationId || null,
+            index: payload?.index ?? null,
+        }
+        : payload?.x !== undefined && payload?.y !== undefined
+            ? { x: payload.x, y: payload.y }
+            : payload?.coordinates
+                ? { coordinates: payload.coordinates }
+                : null;
+    return logOperation({
+        kind: 'controller_action',
+        action,
+        sessionId,
+        reason,
+        target,
+        payload,
+        meta,
+    });
+}
+export function logControllerActionResult(opId, action, result, meta = {}) {
+    logOperation({
+        kind: 'controller_result',
+        action,
+        opId,
+        result,
+        meta,
+    });
+}
+export function logControllerActionError(opId, action, error, payload, meta = {}) {
+    const err = error instanceof Error ? error.message : String(error);
+    logError({
+        kind: 'controller_error',
+        action,
+        opId,
+        error: err,
+        payload,
+        meta,
+    });
+}
+//# sourceMappingURL=operationLogger.js.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/helpers/searchPageState.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SearchPageState helper
+ *
+ * 处理搜索页面状态验证和 URL 关键词校验
+ */
+export interface PageStateConfig {
+    profile: string;
+    controllerUrl: string;
+}
+export interface EnsureHomePageResult {
+    success: boolean;
+    url: string;
+    onSearchPage: boolean;
+    hasDetailOverlay?: boolean;
+    onCaptchaPage?: boolean;
+}
+export interface ProbeSearchPageStateResult {
+    hasItems: boolean;
+    hasNoResultText: boolean;
+}
+export declare function urlKeywordEquals(url: string, keyword: string): boolean;
+export declare function getCurrentUrl(config: PageStateConfig): Promise<string>;
+export declare function ensureHomePage(config: PageStateConfig): Promise<EnsureHomePageResult>;
+export declare function probeSearchPageState(config: PageStateConfig): Promise<ProbeSearchPageStateResult>;
+//# sourceMappingURL=searchPageState.d.ts.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/helpers/searchPageState.js

@@ -0,0 +1,164 @@
+/**
+ * SearchPageState helper
+ *
+ * 处理搜索页面状态验证和 URL 关键词校验
+ */
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+export function urlKeywordEquals(url, keyword) {
+    const raw = url || '';
+    if (!raw.includes('/search_result'))
+        return false;
+    try {
+        const u = new URL(raw);
+        const kw = u.searchParams.get('keyword');
+        if (!kw)
+            return false;
+        const decoded = safeDecodeURIComponent(safeDecodeURIComponent(kw)).trim();
+        return decoded === String(keyword || '').trim();
+    }
+    catch {
+        const decodedUrl = safeDecodeURIComponent(safeDecodeURIComponent(raw));
+        if (!decodedUrl.includes('/search_result'))
+            return false;
+        try {
+            const u2 = new URL(decodedUrl);
+            const kw2 = u2.searchParams.get('keyword');
+            if (!kw2)
+                return false;
+            const decoded2 = safeDecodeURIComponent(safeDecodeURIComponent(kw2)).trim();
+            return decoded2 === String(keyword || '').trim();
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export async function getCurrentUrl(config) {
+    const { profile, controllerUrl } = config;
+    const response = await fetch(controllerUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'browser:execute',
+            payload: {
+                profile,
+                script: 'location.href'
+            }
+        })
+    });
+    const data = await response.json();
+    return data.data?.result || '';
+}
+export async function ensureHomePage(config) {
+    const { profile, controllerUrl } = config;
+    const url = await getCurrentUrl({ profile, controllerUrl });
+    if (!url.includes('xiaohongshu.com')) {
+        throw new Error(`Not on xiaohongshu.com (current url=${url || 'unknown'}), please navigate manually before searching.`);
+    }
+    try {
+        const detailState = await fetch(controllerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: {
+                    profile,
+                    script: `(() => {
+            const selectors = [
+              '.note-detail-mask',
+              '.note-detail-page',
+              '.note-detail-dialog',
+              '.note-detail',
+              '.detail-container',
+              '.media-container'
+            ];
+            const isVisible = (el) => {
+              if (!el) return false;
+              const style = window.getComputedStyle(el);
+              if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+              const r = el.getBoundingClientRect();
+              if (!r.width || !r.height) return false;
+              if (r.bottom <= 0 || r.top >= window.innerHeight) return false;
+              return true;
+            };
+            let visibleOverlay = null;
+            for (const sel of selectors) {
+              const el = document.querySelector(sel);
+              if (el && isVisible(el)) {
+                visibleOverlay = el;
+                break;
+              }
+            }
+            return { hasDetailOverlayVisible: !!visibleOverlay };
+          })()`
+                },
+            }),
+        }).then((r) => r.json());
+        const payload = detailState.data?.result ?? detailState.result ?? {};
+        if (payload.hasDetailOverlayVisible) {
+            throw new Error('Currently in visible detail overlay, please exit detail before searching.');
+        }
+    }
+    catch (err) {
+        if (err?.message?.includes('Currently in detail overlay')) {
+            throw err;
+        }
+        console.warn('[SearchPageState] Detail-overlay check failed:', err?.message || err);
+    }
+    const onSearchPage = url.includes('/search_result');
+    const onCaptchaPage = url.includes('captcha') || url.includes('verify');
+    if (onCaptchaPage) {
+        throw new Error('Detected CAPTCHA page, please solve it manually.');
+    }
+    return {
+        success: true,
+        url,
+        onSearchPage,
+        onCaptchaPage
+    };
+}
+export async function probeSearchPageState(config) {
+    const { profile, controllerUrl } = config;
+    try {
+        const response = await fetch(controllerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: {
+                    profile,
+                    script: `(() => {
+            const cards = document.querySelectorAll('.note-item').length;
+            const emptyEl =
+              document.querySelector('[class*="no-result"], [class*="noResult"], [class*="empty"], .search-empty, .empty') ||
+              null;
+            const emptyText = (emptyEl ? (emptyEl.textContent || '') : '').trim();
+            const bodyText = (document.body && document.body.innerText ? document.body.innerText.slice(0, 1200) : '');
+            const hasNoResultText =
+              emptyText.includes('没找到相关内容') ||
+              emptyText.includes('换个词试试') ||
+              bodyText.includes('没找到相关内容') ||
+              bodyText.includes('换个词试试');
+            return { cards, hasNoResultText };
+          })()`
+                },
+            }),
+            signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined,
+        });
+        const data = await response.json().catch(() => ({}));
+        const payload = data.data?.result ?? data.result ?? {};
+        const cards = Number(payload.cards || 0);
+        return { hasItems: cards > 0, hasNoResultText: Boolean(payload.hasNoResultText) };
+    }
+    catch {
+        return { hasItems: false, hasNoResultText: false };
+    }
+}
+//# sourceMappingURL=searchPageState.js.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/MatchCommentsBlock.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Block: 评论命中（MatchComments）
+ *
+ * 职责：
+ * - 基于容器提取“视口内评论”
+ * - 按可配置规则匹配关键字（任意一个/任意两个/必选过滤/排除词等）
+ * - 命中后高亮 + 截图留证（可选）
+ *
+ * 说明：
+ * - 不负责导航（safeUrl 由上层负责）
+ * - 不做 DOM click，所有交互均通过 container:operation / 系统能力
+ */
+import { type CommentKeywordMatchRule } from './helpers/commentMatcher.js';
+import { type CommentMatchDslRule } from './helpers/commentMatchDsl.js';
+export interface MatchCommentsInput {
+    sessionId: string;
+    /**
+     * Rule can be:
+     * - legacy keyword rule (any/must/mustNot/should/minAnyMatches...)
+     * - DSL rule (require/exclude/prefer with boolean expr)
+     */
+    rule: CommentKeywordMatchRule | CommentMatchDslRule;
+    unifiedApiUrl?: string;
+    maxScrolls?: number;
+    maxItems?: number;
+    maxMatches?: number;
+    openComments?: boolean;
+    highlightOnFirstMatch?: boolean;
+    screenshotOnFirstMatch?: boolean;
+    noteId?: string;
+    env?: string;
+    keyword?: string;
+}
+export interface MatchCommentsOutput {
+    success: boolean;
+    rounds: number;
+    reachedBottom: boolean;
+    matches: Array<{
+        index: number;
+        userId: string;
+        userName: string;
+        content: string;
+        timestamp: string;
+        matched: {
+            hits: string[];
+            score: number;
+            legacy?: {
+                anyHits: string[];
+                mustHits: string[];
+                shouldHits: string[];
+                anyCount: number;
+                shouldCount: number;
+            };
+            dsl?: {
+                requireHits: string[];
+                preferHits: string[];
+            };
+        };
+    }>;
+    evidence?: {
+        firstMatchScreenshot?: string | null;
+    };
+    error?: string;
+}
+export declare function execute(input: MatchCommentsInput): Promise<MatchCommentsOutput>;
+//# sourceMappingURL=MatchCommentsBlock.d.ts.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/MatchCommentsBlock.js

@@ -0,0 +1,139 @@
+/**
+ * Block: 评论命中（MatchComments）
+ *
+ * 职责：
+ * - 基于容器提取“视口内评论”
+ * - 按可配置规则匹配关键字（任意一个/任意两个/必选过滤/排除词等）
+ * - 命中后高亮 + 截图留证（可选）
+ *
+ * 说明：
+ * - 不负责导航（safeUrl 由上层负责）
+ * - 不做 DOM click，所有交互均通过 container:operation / 系统能力
+ */
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { controllerAction, delay } from '../utils/controllerAction.js';
+import { isLegacyKeywordRule, matchCommentText } from './helpers/commentMatcher.js';
+import { matchCommentTextDsl } from './helpers/commentMatchDsl.js';
+import { ensureCommentsOpened, extractVisibleComments, highlightCommentRow, isCommentEnd, scrollComments, } from './helpers/xhsComments.js';
+import { resolveDownloadRoot, savePngBase64, takeScreenshotBase64 } from './helpers/evidence.js';
+export async function execute(input) {
+    const { sessionId, rule, unifiedApiUrl = 'http://127.0.0.1:7701', maxScrolls = 12, maxItems = 60, maxMatches = 3, openComments = true, highlightOnFirstMatch = true, screenshotOnFirstMatch = true, noteId = `unknown-${Date.now()}`, env = 'debug', keyword = 'unknown', } = input;
+    const matches = [];
+    const seen = new Set();
+    let rounds = 0;
+    let reachedBottom = false;
+    let firstMatchScreenshot = null;
+    try {
+        if (openComments) {
+            await ensureCommentsOpened(sessionId, unifiedApiUrl);
+        }
+        const outDir = path.join(resolveDownloadRoot(), 'xiaohongshu', env, keyword, 'comment-match', noteId);
+        for (let round = 0; round < maxScrolls; round += 1) {
+            rounds = round + 1;
+            const rows = await extractVisibleComments(sessionId, unifiedApiUrl, maxItems);
+            for (let i = 0; i < rows.length; i += 1) {
+                if (matches.length >= maxMatches)
+                    break;
+                const r = rows[i] || {};
+                const text = String(r.text || '').trim();
+                if (!text)
+                    continue;
+                const key = `${String(r.user_id || '')}:${text}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const matched = isLegacyKeywordRule(rule)
+                    ? (() => {
+                        const m = matchCommentText(text, rule);
+                        if (!m.ok)
+                            return null;
+                        return {
+                            ok: true,
+                            hits: Array.from(new Set([...m.anyHits, ...m.mustHits, ...m.shouldHits])),
+                            score: m.shouldCount * 100 + m.anyCount + m.mustHits.length,
+                            legacy: {
+                                anyHits: m.anyHits,
+                                mustHits: m.mustHits,
+                                shouldHits: m.shouldHits,
+                                anyCount: m.anyCount,
+                                shouldCount: m.shouldCount,
+                            },
+                        };
+                    })()
+                    : (() => {
+                        const d = matchCommentTextDsl(text, rule);
+                        if (!d.ok)
+                            return null;
+                        return {
+                            ok: true,
+                            hits: d.hits,
+                            score: d.score,
+                            dsl: { requireHits: d.requireHits, preferHits: d.preferHits },
+                        };
+                    })();
+                if (!matched)
+                    continue;
+                matches.push({
+                    index: i,
+                    userId: String(r.user_id || ''),
+                    userName: String(r.user_name || ''),
+                    content: text,
+                    timestamp: String(r.timestamp || ''),
+                    matched: {
+                        hits: matched.hits,
+                        score: matched.score,
+                        legacy: Object.prototype.hasOwnProperty.call(matched, 'legacy') ? matched.legacy : undefined,
+                        dsl: Object.prototype.hasOwnProperty.call(matched, 'dsl') ? matched.dsl : undefined,
+                    },
+                });
+                if (matches.length === 1 && highlightOnFirstMatch) {
+                    const hl = await highlightCommentRow(sessionId, i, unifiedApiUrl, 'comment-match-first').catch(() => null);
+                    await delay(450);
+                    if (screenshotOnFirstMatch && hl?.inViewport === true && !firstMatchScreenshot) {
+                        const base64 = await takeScreenshotBase64(sessionId, unifiedApiUrl);
+                        if (base64) {
+                            await fs.mkdir(outDir, { recursive: true });
+                            firstMatchScreenshot = await savePngBase64(base64, path.join(outDir, `match-first-${Date.now()}.png`));
+                        }
+                    }
+                }
+            }
+            if (matches.length >= maxMatches)
+                break;
+            reachedBottom = await isCommentEnd(sessionId, unifiedApiUrl);
+            if (reachedBottom)
+                break;
+            await scrollComments(sessionId, unifiedApiUrl, 650).catch(() => { });
+            await delay(900);
+        }
+        return {
+            success: true,
+            rounds,
+            reachedBottom,
+            matches,
+            evidence: { firstMatchScreenshot },
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            rounds,
+            reachedBottom,
+            matches,
+            evidence: { firstMatchScreenshot },
+            error: e?.message || String(e),
+        };
+    }
+    finally {
+        // 尽量不破坏会话，仅清理一次高亮 channel（不强制）
+        await controllerAction('browser:execute', {
+            profile: sessionId,
+            script: `(() => {
+          try { window.__webautoRuntime?.highlight?.clear?.('comment-match-first'); } catch {}
+          return true;
+        })()`,
+        }, unifiedApiUrl).catch(() => null);
+    }
+}
+//# sourceMappingURL=MatchCommentsBlock.js.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/Phase1EnsureServicesBlock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase 1 Block: 确保基础服务就绪
+ */
+export interface EnsureServicesInput {
+    unifiedApiUrl?: string;
+    browserServiceUrl?: string;
+    timeout?: number;
+}
+export interface EnsureServicesOutput {
+    unifiedApiOk: boolean;
+    browserServiceOk: boolean;
+    unifiedApiUrl: string;
+    browserServiceUrl: string;
+}
+export declare function execute(input?: EnsureServicesInput): Promise<EnsureServicesOutput>;
+//# sourceMappingURL=Phase1EnsureServicesBlock.d.ts.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/Phase1EnsureServicesBlock.js

@@ -0,0 +1,36 @@
+/**
+ * Phase 1 Block: 确保基础服务就绪
+ */
+export async function execute(input = {}) {
+    const { unifiedApiUrl = 'http://127.0.0.1:7701', browserServiceUrl = 'http://127.0.0.1:7704', timeout = 5000, } = input;
+    console.log('[Phase1EnsureServices] 检查服务状态...');
+    let unifiedApiOk = false;
+    try {
+        const res = await fetch(`${unifiedApiUrl}/health`, {
+            signal: AbortSignal.timeout(timeout),
+        });
+        unifiedApiOk = res.ok;
+        console.log(`[Phase1] Unified API: ${unifiedApiOk ? '✅' : '❌'}`);
+    }
+    catch (err) {
+        console.warn(`[Phase1] Unified API 不可达: ${err?.message || String(err)}`);
+    }
+    let browserServiceOk = false;
+    try {
+        const res = await fetch(`${browserServiceUrl}/health`, {
+            signal: AbortSignal.timeout(timeout),
+        });
+        browserServiceOk = res.ok;
+        console.log(`[Phase1] Browser Service: ${browserServiceOk ? '✅' : '❌'}`);
+    }
+    catch (err) {
+        console.warn(`[Phase1] Browser Service 不可达: ${err?.message || String(err)}`);
+    }
+    return {
+        unifiedApiOk,
+        browserServiceOk,
+        unifiedApiUrl,
+        browserServiceUrl,
+    };
+}
+//# sourceMappingURL=Phase1EnsureServicesBlock.js.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/Phase1MonitorCookieBlock.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Phase 1 Block: Cookie 监控与稳定保存
+ *
+ * 规则：
+ * - 不论是否登录成功，都要每 15 秒扫描一次 cookie
+ * - 只有在“登录锚点确认成功”后：cookie 发生变化并且稳定（连续 stableCount 次一致）才保存
+ * - 保存走 Browser Service 的 saveCookiesIfStable（避免自己造格式）
+ */
+export interface Phase1MonitorCookieInput {
+    profile: string;
+    unifiedApiUrl?: string;
+    browserServiceUrl?: string;
+    scanIntervalMs?: number;
+    stableCount?: number;
+    cookiePath?: string;
+}
+export interface Phase1MonitorCookieOutput {
+    success: boolean;
+    profile: string;
+    loggedIn: boolean;
+    saved: boolean;
+    cookiePath: string;
+    scanRounds: number;
+    autoCookiesStarted: boolean;
+}
+export declare function execute(input: Phase1MonitorCookieInput): Promise<Phase1MonitorCookieOutput>;
+//# sourceMappingURL=Phase1MonitorCookieBlock.d.ts.map