@web-auto/webauto 0.1.4 → 0.1.6

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

@@ -0,0 +1,213 @@
+import path from 'node:path';
+async function controllerAction(action, payload, apiUrl) {
+    const res = await fetch(`${apiUrl}/v1/controller/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action, payload }),
+        signal: AbortSignal.timeout(20000),
+    });
+    const data = await res.json().catch(() => ({}));
+    return data.data || data;
+}
+async function browserServiceCommand(action, args, serviceUrl) {
+    const res = await fetch(`${serviceUrl}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action, args }),
+        signal: AbortSignal.timeout(20000),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok || data?.ok === false)
+        throw new Error(data?.error || 'browser-service error');
+    return data;
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function resolveDefaultCookiePath(profile) {
+    const envRoot = String(process.env.WEBAUTO_PATHS_COOKIES || '').trim();
+    if (envRoot)
+        return path.join(envRoot, `${profile}.json`);
+    const portableRoot = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
+    if (portableRoot)
+        return path.join(portableRoot, '.webauto', 'cookies', `${profile}.json`);
+    const homeDir = process.platform === 'win32'
+        ? String(process.env.USERPROFILE || '').trim()
+        : String(process.env.HOME || '').trim();
+    if (homeDir)
+        return path.join(homeDir, '.webauto', 'cookies', `${profile}.json`);
+    return path.join('.webauto', 'cookies', `${profile}.json`);
+}
+function hashCookiePairs(pairs) {
+    const normalized = pairs
+        .map((c) => `${c.name}=${c.value}`)
+        .sort()
+        .join('|');
+    // cheap hash; only used for change detection
+    let h = 0;
+    for (let i = 0; i < normalized.length; i++) {
+        h = (h * 31 + normalized.charCodeAt(i)) >>> 0;
+    }
+    return h.toString(16);
+}
+function extractSessions(payload) {
+    if (!payload)
+        return [];
+    if (Array.isArray(payload.sessions))
+        return payload.sessions;
+    if (Array.isArray(payload.data?.sessions))
+        return payload.data.sessions;
+    if (Array.isArray(payload.result?.sessions))
+        return payload.result.sessions;
+    if (payload.data)
+        return extractSessions(payload.data);
+    return [];
+}
+async function listSessions(apiUrl) {
+    const raw = await controllerAction('session:list', {}, apiUrl);
+    return extractSessions(raw);
+}
+function hasSession(sessions, profile) {
+    return sessions.some((s) => s?.profileId === profile || s?.session_id === profile);
+}
+async function getDocumentCookiePairs(apiUrl, profile) {
+    // 只读扫描：使用 document.cookie 的可见部分做“变化检测”即可。
+    const raw = await controllerAction('browser:execute', {
+        profile,
+        script: `(() => document.cookie.split(';').map(s => s.trim()).filter(Boolean))()`,
+    }, apiUrl);
+    const arr = raw?.result || raw?.data?.result;
+    const list = Array.isArray(arr) ? arr : [];
+    const pairs = [];
+    for (const item of list) {
+        const idx = String(item).indexOf('=');
+        if (idx <= 0)
+            continue;
+        pairs.push({ name: String(item).slice(0, idx), value: String(item).slice(idx + 1) });
+    }
+    return pairs;
+}
+async function fetchContainerTree(apiUrl, profile) {
+    let currentUrl = '';
+    try {
+        const urlRes = await controllerAction('browser:execute', { profile, script: 'location.href' }, apiUrl);
+        currentUrl = urlRes?.result || urlRes?.data?.result || '';
+    }
+    catch {
+        currentUrl = '';
+    }
+    try {
+        const res = await controllerAction('containers:match', {
+            profile,
+            ...(currentUrl ? { url: currentUrl } : {}),
+            maxDepth: 2,
+            maxChildren: 5,
+        }, apiUrl);
+        return res?.snapshot?.container_tree || res?.container_tree || res?.data?.snapshot?.container_tree || null;
+    }
+    catch {
+        return null;
+    }
+}
+function findContainer(node, pattern) {
+    if (!node)
+        return null;
+    if (pattern.test(node.id || node.defId || ''))
+        return node;
+    if (Array.isArray(node.children)) {
+        for (const child of node.children) {
+            const found = findContainer(child, pattern);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+async function isLoggedIn(apiUrl, profile) {
+    const tree = await fetchContainerTree(apiUrl, profile);
+    if (!tree)
+        return false;
+    const loginAnchor = findContainer(tree, /\.login_anchor$/);
+    if (loginAnchor)
+        return true;
+    const loginGuard = findContainer(tree, /xiaohongshu_login\.login_guard$/);
+    if (loginGuard)
+        return false;
+    return false;
+}
+export async function execute(input) {
+    const { profile, unifiedApiUrl = 'http://127.0.0.1:7701', browserServiceUrl = 'http://127.0.0.1:7704', scanIntervalMs = 15000, stableCount = 3, cookiePath, } = input;
+    const resolvedCookiePath = cookiePath || resolveDefaultCookiePath(profile);
+    let lastHash = '';
+    let stableRounds = 0;
+    let scanRounds = 0;
+    let lastLoggedIn = false;
+    let autoCookiesStarted = false;
+    while (true) {
+        scanRounds += 1;
+        const sessions = await listSessions(unifiedApiUrl).catch(() => []);
+        if (!hasSession(sessions, profile)) {
+            throw new Error(`[Phase1MonitorCookie] session closed: ${profile}`);
+        }
+        const loggedIn = await isLoggedIn(unifiedApiUrl, profile);
+        lastLoggedIn = loggedIn;
+        const pairs = await getDocumentCookiePairs(unifiedApiUrl, profile);
+        const currentHash = hashCookiePairs(pairs);
+        console.log(`[Phase1MonitorCookie] round=${scanRounds} loggedIn=${loggedIn} cookieCount=${pairs.length} hash=${currentHash}`);
+        if (currentHash === lastHash) {
+            stableRounds += 1;
+        }
+        else {
+            stableRounds = 0;
+            lastHash = currentHash;
+        }
+        // 只有登录成功时才保存，并且必须“变化后稳定”
+        if (loggedIn && stableRounds >= stableCount) {
+            console.log('[Phase1MonitorCookie] Cookie stable, saving...');
+            let saveResult = null;
+            try {
+                saveResult = await browserServiceCommand('saveCookiesIfStable', { profileId: profile, path: resolvedCookiePath, minDelayMs: 2000 }, browserServiceUrl);
+            }
+            catch (err) {
+                console.warn(`[Phase1MonitorCookie] saveCookiesIfStable failed: ${err?.message || String(err)}`);
+            }
+            if (!Boolean(saveResult?.saved)) {
+                // Fallback: force save once so downstream checks can find explicit cookie file.
+                let forced = null;
+                try {
+                    forced = await browserServiceCommand('saveCookies', { profileId: profile, path: resolvedCookiePath }, browserServiceUrl);
+                }
+                catch {
+                    forced = null;
+                }
+                const forcedCount = Number(forced?.count ?? forced?.body?.count ?? -1);
+                if (forcedCount >= 0) {
+                    saveResult = { ...(saveResult || {}), saved: true, count: forcedCount };
+                    console.log(`[Phase1MonitorCookie] saveCookies fallback count=${forcedCount}`);
+                }
+            }
+            if (!Boolean(saveResult?.saved)) {
+                console.warn('[Phase1MonitorCookie] cookie not saved yet, continue scanning');
+                await delay(scanIntervalMs);
+                continue;
+            }
+            // 进入常驻模式：开启 Browser Service 自动保存 cookie，不阻塞后续 Phase2
+            if (!autoCookiesStarted) {
+                await browserServiceCommand('autoCookies:start', { profileId: profile, intervalMs: scanIntervalMs }, browserServiceUrl);
+                autoCookiesStarted = true;
+                console.log(`[Phase1MonitorCookie] autoCookies:start enabled intervalMs=${scanIntervalMs}`);
+            }
+            return {
+                success: true,
+                profile,
+                loggedIn: true,
+                saved: true,
+                cookiePath: resolvedCookiePath,
+                scanRounds,
+                autoCookiesStarted,
+            };
+        }
+        await delay(scanIntervalMs);
+    }
+}
+//# sourceMappingURL=Phase1MonitorCookieBlock.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Phase 1 Block: 启动/复用 Profile 会话
+ */
+export interface StartProfileInput {
+    profile: string;
+    url?: string;
+    headless?: boolean;
+    browserServiceUrl?: string;
+    ownerPid?: number;
+}
+export interface StartProfileOutput {
+    started: boolean;
+    profile: string;
+    url: string;
+    headless: boolean;
+}
+export declare function execute(input: StartProfileInput): Promise<StartProfileOutput>;
+//# sourceMappingURL=Phase1StartProfileBlock.d.ts.map

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

@@ -0,0 +1,121 @@
+/**
+ * Phase 1 Block: 启动/复用 Profile 会话
+ */
+const DEFAULT_TIMEOUT_MS = process.platform === 'win32' ? 60000 : 20000;
+async function browserServiceCommand(action, args, serviceUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const res = await fetch(`${serviceUrl}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action, args }),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok || data?.error)
+        throw new Error(data?.error || 'browser-service error');
+    return data;
+}
+export async function execute(input) {
+    const { profile, url = 'https://www.xiaohongshu.com', headless = false, browserServiceUrl = 'http://127.0.0.1:7704', ownerPid = process.pid, } = input;
+    console.log(`[Phase1StartProfile] 启动 profile=${profile} headless=${headless}`);
+    function clamp(n, min, max) {
+        if (!Number.isFinite(n))
+            return min;
+        return Math.min(Math.max(n, min), max);
+    }
+    function pickFirstPositive(...values) {
+        for (const value of values) {
+            const parsed = Number(value ?? 0);
+            if (Number.isFinite(parsed) && parsed > 0)
+                return parsed;
+        }
+        return 0;
+    }
+    function resolveEffectiveMax(displayValue, browserValue) {
+        if (displayValue > 0 && browserValue > 0) {
+            return Math.min(displayValue, browserValue);
+        }
+        return displayValue > 0 ? displayValue : browserValue;
+    }
+    async function resolveViewportSize() {
+        try {
+            const displayRes = await browserServiceCommand('system:display', {}, browserServiceUrl);
+            const res = await browserServiceCommand('evaluate', {
+                profileId: profile,
+                script: `(() => ({
+            innerWidth: window.innerWidth,
+            innerHeight: window.innerHeight,
+            screenWidth: window.screen?.width,
+            screenHeight: window.screen?.height,
+            availWidth: window.screen?.availWidth,
+            availHeight: window.screen?.availHeight
+          }))()`,
+            }, browserServiceUrl);
+            const payload = res?.body || res?.data || res;
+            const metrics = payload?.result || payload?.data?.result || null;
+            const displayPayload = displayRes?.body || displayRes?.data || displayRes;
+            const display = displayPayload?.metrics || displayPayload?.data?.metrics || null;
+            // These reflect *browser* idea of available size (can be scaled / not equal to physical pixels).
+            const maxW = Number(metrics?.availWidth || metrics?.screenWidth || 0);
+            const maxH = Number(metrics?.availHeight || metrics?.screenHeight || 0);
+            const innerW = Number(metrics?.innerWidth || 0);
+            const innerH = Number(metrics?.innerHeight || 0);
+            // Prefer OS work area (excludes taskbar/dock), fall back to total screen size.
+            // IMPORTANT: do not let browser metrics override OS metrics when present.
+            const displayW = pickFirstPositive(display?.workWidth, display?.width, display?.nativeWidth);
+            const displayH = pickFirstPositive(display?.workHeight, display?.height, display?.nativeHeight);
+            // Use inner dimensions as the floor - browser cannot render smaller than its inner window
+            const innerFloorW = Math.max(innerW, 900);
+            const innerFloorH = Math.max(innerH, 720);
+            const effectiveMaxW = resolveEffectiveMax(displayW, maxW);
+            const effectiveMaxH = resolveEffectiveMax(displayH, maxH);
+            // Hard requirement: do not exceed browser-reported max size to avoid oversized window
+            // that ends up partially off-screen (causing non-centered viewport).
+            const targetW = maxW > 0 ? maxW : (effectiveMaxW > 0 ? effectiveMaxW : (displayW > 0 ? displayW : 1920));
+            const targetH = maxH > 0 ? maxH : (effectiveMaxH > 0 ? effectiveMaxH : (displayH > 0 ? displayH : 1400));
+            // Keep a reasonable minimum, but do NOT clamp max height/width; use real screen size.
+            const width = Math.max(innerFloorW, Math.floor(targetW));
+            const height = Math.max(innerFloorH, Math.floor(targetH));
+            console.log(`[Phase1StartProfile] display metrics: browser=${maxW}x${maxH} display=${displayW}x${displayH} ` +
+                `effective=${effectiveMaxW}x${effectiveMaxH} inner=${innerW}x${innerH} ` +
+                `target=${targetW}x${targetH} finalViewport=${width}x${height}`);
+            return { width, height };
+        }
+        catch {
+            return { width: 1440, height: 1080 };
+        }
+    }
+    await browserServiceCommand('start', {
+        profileId: profile,
+        headless,
+        url,
+        ownerPid,
+    }, browserServiceUrl);
+    const viewport = await resolveViewportSize();
+    await browserServiceCommand('page:setViewport', {
+        profileId: profile,
+        width: viewport.width,
+        height: viewport.height,
+    }, browserServiceUrl);
+    // Ensure window centered on screen to keep viewport in expected position
+    try {
+        await browserServiceCommand('window:move', {
+            profileId: profile,
+            x: 0,
+            y: 0,
+            width: viewport.width,
+            height: viewport.height,
+        }, browserServiceUrl);
+        console.log('[Phase1StartProfile] window positioned at (0,0)');
+    }
+    catch (err) {
+        console.warn('[Phase1StartProfile] window move failed:', err?.message || String(err));
+    }
+    console.log(`[Phase1StartProfile] viewport set: ${viewport.width}x${viewport.height}`);
+    return {
+        started: true,
+        profile,
+        url,
+        headless,
+    };
+}
+//# sourceMappingURL=Phase1StartProfileBlock.js.map

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

@@ -0,0 +1,34 @@
+/**
+ * Phase 2 Block: 采集安全链接
+ *
+ * 职责：通过容器点击进入详情，获取带 xsec_token 的安全 URL
+ */
+export interface CollectLinksInput {
+    keyword: string;
+    targetCount: number;
+    profile?: string;
+    unifiedApiUrl?: string;
+    env?: string;
+    alreadyCollectedNoteIds?: string[];
+    onLink?: (link: {
+        noteId: string;
+        safeUrl: string;
+        searchUrl: string;
+        ts: string;
+    }, meta: {
+        collected: number;
+        targetCount: number;
+    }) => Promise<void> | void;
+}
+export interface CollectLinksOutput {
+    links: Array<{
+        noteId: string;
+        safeUrl: string;
+        searchUrl: string;
+        ts: string;
+    }>;
+    totalCollected: number;
+    termination?: 'reached_target' | 'no_progress_after_3_retries';
+}
+export declare function execute(input: CollectLinksInput): Promise<CollectLinksOutput>;
+//# sourceMappingURL=Phase2CollectLinksBlock.d.ts.map