@web-auto/webauto 0.1.4 → 0.1.6

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/utils/checkpoints.js

@@ -0,0 +1,222 @@
+import { execute as detectPageState } from '../../../../workflow/blocks/DetectPageStateBlock.js';
+import { execute as anchorVerify } from '../../../../workflow/blocks/AnchorVerificationBlock.js';
+import { execute as errorRecovery } from '../../../../workflow/blocks/ErrorRecoveryBlock.js';
+function hasAny(matchIds, ids) {
+    const set = new Set(matchIds || []);
+    return ids.some((x) => set.has(x));
+}
+function hasAll(matchIds, ids) {
+    const set = new Set(matchIds || []);
+    return ids.every((x) => set.has(x));
+}
+export async function detectXhsCheckpoint(input) {
+    const { sessionId, serviceUrl = 'http://127.0.0.1:7701' } = input;
+    const state = await detectPageState({ sessionId, platform: 'xiaohongshu', serviceUrl });
+    const url = String(state?.url || '').trim();
+    const stage = String(state?.stage || 'unknown');
+    const rootId = state?.rootId ?? null;
+    const matchIds = Array.isArray(state?.matchIds) ? state.matchIds : [];
+    const dom = {
+        hasDetailMask: typeof state?.dom?.hasDetailMask === 'boolean' ? state.dom.hasDetailMask : undefined,
+        hasSearchInput: typeof state?.dom?.hasSearchInput === 'boolean' ? state.dom.hasSearchInput : undefined,
+        readyState: typeof state?.dom?.readyState === 'string' ? state.dom.readyState : undefined,
+        title: typeof state?.dom?.title === 'string' ? state.dom.title : undefined,
+    };
+    const signals = [];
+    const allIds = [String(rootId || ''), ...matchIds].filter(Boolean);
+    // Priority 0 (DOM-first): XHS may keep /explore/<id> in the URL even after closing the detail modal.
+    // In that case URL-based assumptions are wrong; prefer DOM signals.
+    if (dom.hasDetailMask === false && dom.hasSearchInput === true) {
+        const isInSearch = url.includes('/search_result') || url.includes('keyword=');
+        const checkpoint = isInSearch ? 'search_ready' : 'home_ready';
+        return {
+            success: true,
+            checkpoint,
+            stage,
+            url,
+            rootId,
+            matchIds,
+            signals: ['no_detail_mask', 'has_search_input', checkpoint],
+            dom,
+            error: state?.error,
+        };
+    }
+    // Risk-control / captcha URL patterns are hard stops (even if container match fails).
+    // We must avoid any automated retries here to reduce further risk-control triggers.
+    const lowerUrl = url.toLowerCase();
+    if (lowerUrl.includes('/website-login/captcha') ||
+        lowerUrl.includes('verifyuuid=') ||
+        lowerUrl.includes('verifytype=') ||
+        lowerUrl.includes('verifybiz=') ||
+        lowerUrl.includes('/website-login/verify') ||
+        lowerUrl.includes('/website-login/security')) {
+        return {
+            success: true,
+            checkpoint: 'risk_control',
+            stage,
+            url,
+            rootId,
+            matchIds,
+            signals: ['risk_control_url'],
+            dom,
+            error: state?.error,
+        };
+    }
+    // offsite is a hard stop
+    if (!url || !url.includes('xiaohongshu.com')) {
+        return { success: false, checkpoint: 'offsite', stage, url, rootId, matchIds, signals: ['offsite'], dom, error: state?.error };
+    }
+    // login guard
+    if (hasAny(allIds, ['xiaohongshu_login.login_guard'])) {
+        return { success: true, checkpoint: 'login_guard', stage, url, rootId, matchIds, signals: ['login_guard'], dom };
+    }
+    // risk control (placeholder ids; extend as container library grows)
+    if (hasAny(allIds, ['xiaohongshu_login.qrcode_guard', 'xiaohongshu_login.captcha_guard'])) {
+        return { success: true, checkpoint: 'risk_control', stage, url, rootId, matchIds, signals: ['risk_control'], dom };
+    }
+    // comments_ready
+    if (hasAny(allIds, [
+        'xiaohongshu_detail.comment_section',
+        'xiaohongshu_detail.comment_section.comment_item',
+        'xiaohongshu_detail.end_marker',
+    ])) {
+        return { success: true, checkpoint: 'comments_ready', stage, url, rootId, matchIds, signals: ['comments_anchor'], dom };
+    }
+    // detail_ready
+    if (hasAll(allIds, ['xiaohongshu_detail.modal_shell', 'xiaohongshu_detail.content_anchor'])) {
+        return { success: true, checkpoint: 'detail_ready', stage, url, rootId, matchIds, signals: ['detail_shell', 'content_anchor'], dom };
+    }
+    // search_ready
+    if (hasAll(allIds, ['xiaohongshu_search.search_bar', 'xiaohongshu_search.search_result_list'])) {
+        return { success: true, checkpoint: 'search_ready', stage, url, rootId, matchIds, signals: ['search_bar', 'search_result_list'], dom };
+    }
+    // home_ready
+    if (hasAny(allIds, ['xiaohongshu_home.search_input', 'xiaohongshu_home'])) {
+        // IMPORTANT:
+        // On XHS, the URL may still contain /explore/<noteId>?xsec_token=... even after the detail modal is closed.
+        // We must prefer DOM/container evidence over URL.
+        // If detail mask is absent and home/search anchors are present, treat as home_ready.
+        return { success: true, checkpoint: 'home_ready', stage, url, rootId, matchIds, signals: ['home'], dom };
+    }
+    return {
+        success: stage !== 'unknown',
+        checkpoint: 'unknown',
+        stage,
+        url,
+        rootId,
+        matchIds,
+        signals,
+        dom,
+        error: state?.error,
+    };
+}
+async function highlightAnchors(sessionId, serviceUrl, ids, ms) {
+    for (const id of ids) {
+        try {
+            await anchorVerify({ sessionId, containerId: id, operation: 'enter', serviceUrl });
+            return;
+        }
+        catch {
+            // try next
+        }
+    }
+}
+function fallbackTarget(target) {
+    // one-level-up policy
+    if (target === 'search_ready')
+        return 'home_ready';
+    if (target === 'comments_ready')
+        return 'detail_ready';
+    if (target === 'detail_ready')
+        return 'search_ready';
+    return null;
+}
+export async function ensureXhsCheckpoint(input) {
+    const { sessionId, target, serviceUrl = 'http://127.0.0.1:7701', timeoutMs = 15000, allowOneLevelUpFallback = true, evidence = { highlightMs: 1200 }, } = input;
+    const start = Date.now();
+    const attempts = [];
+    const det0 = await detectXhsCheckpoint({ sessionId, serviceUrl });
+    const from = det0.checkpoint;
+    let last = det0;
+    // quick success
+    if (from === target) {
+        return { success: true, from, to: target, reached: target, url: det0.url, stage: det0.stage, attempts, signals: det0.signals };
+    }
+    while (Date.now() - start < timeoutMs) {
+        last = await detectXhsCheckpoint({ sessionId, serviceUrl });
+        if (last.checkpoint === target) {
+            return { success: true, from, to: target, reached: target, url: last.url, stage: last.stage, attempts, signals: last.signals };
+        }
+        // Always highlight best-effort so user sees where we are.
+        const hm = Math.max(200, Math.min(2000, Number(evidence.highlightMs || 1200)));
+        if (last.checkpoint === 'detail_ready' || last.checkpoint === 'comments_ready') {
+            await highlightAnchors(sessionId, serviceUrl, ['xiaohongshu_detail.modal_shell', 'xiaohongshu_detail.content_anchor'], hm);
+        }
+        else if (last.checkpoint === 'search_ready') {
+            await highlightAnchors(sessionId, serviceUrl, ['xiaohongshu_search.search_bar', 'xiaohongshu_search.search_result_list'], hm);
+        }
+        else if (last.checkpoint === 'home_ready') {
+            await highlightAnchors(sessionId, serviceUrl, ['xiaohongshu_home.search_input'], hm);
+        }
+        // Recovery actions: conservative (ESC-based).
+        if ((target === 'search_ready' || target === 'home_ready') &&
+            (last.checkpoint === 'detail_ready' || last.checkpoint === 'comments_ready')) {
+            try {
+                await errorRecovery({
+                    sessionId,
+                    fromStage: 'detail',
+                    targetStage: target === 'home_ready' ? 'home' : 'search',
+                    recoveryMode: 'esc',
+                    serviceUrl,
+                    maxRetries: 3,
+                });
+                attempts.push({ action: 'esc', ok: true });
+            }
+            catch (e) {
+                attempts.push({ action: 'esc', ok: false, reason: e?.message || String(e) });
+            }
+            continue;
+        }
+        // No safe automated path; break to fallback or fail.
+        break;
+    }
+    // one-level-up fallback
+    if (allowOneLevelUpFallback) {
+        const up = fallbackTarget(target);
+        if (up && up !== target) {
+            const res = await ensureXhsCheckpoint({
+                sessionId,
+                target: up,
+                serviceUrl,
+                timeoutMs,
+                allowOneLevelUpFallback: false,
+                evidence,
+            });
+            if (res.success) {
+                return {
+                    success: false,
+                    from,
+                    to: target,
+                    reached: up,
+                    url: res.url,
+                    stage: res.stage,
+                    attempts: [...attempts, ...res.attempts, { action: 'need_user_action', ok: false, reason: `need to reach ${target}` }],
+                    signals: res.signals,
+                    error: `fallback_reached_${up}_need_${target}`,
+                };
+            }
+        }
+    }
+    return {
+        success: false,
+        from,
+        to: target,
+        reached: last.checkpoint,
+        url: last.url,
+        stage: last.stage,
+        attempts,
+        signals: last.signals,
+        error: `ensure_checkpoint_failed target=${target} reached=${last.checkpoint}`,
+    };
+}
+//# sourceMappingURL=checkpoints.js.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/utils/controllerAction.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Controller Action 工具函数
+ */
+export declare function controllerAction(action: string, payload: any, apiUrl: string): Promise<any>;
+export declare function delay(ms: number): Promise<void>;
+export declare function expandHome(p: string): string;
+export declare function ensureDir(dir: string): Promise<void>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function downloadImage(url: string, destPath: string): Promise<void>;
+//# sourceMappingURL=controllerAction.d.ts.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/utils/controllerAction.js

@@ -0,0 +1,43 @@
+/**
+ * Controller Action 工具函数
+ */
+export async function controllerAction(action, payload, apiUrl) {
+    const timeoutMs = typeof payload?.timeoutMs === 'number' && Number.isFinite(payload.timeoutMs) && payload.timeoutMs > 0
+        ? Math.floor(payload.timeoutMs)
+        : 60000;
+    const res = await fetch(`${apiUrl}/v1/controller/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        // Unified API expects payload nested under `payload`.
+        body: JSON.stringify({ action, payload: payload || {} }),
+        // 截图/容器操作在某些页面会更慢，允许调用方覆盖超时。
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const data = await res.json().catch(() => ({}));
+    return data.data || data;
+}
+export function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function expandHome(p) {
+    if (!p)
+        return p;
+    if (p.startsWith('~/'))
+        return `${process.env.HOME}/${p.slice(2)}`;
+    return p;
+}
+export async function ensureDir(dir) {
+    const { mkdir } = await import('node:fs/promises');
+    await mkdir(dir, { recursive: true });
+}
+export async function writeFile(filePath, content) {
+    const { writeFile: wf } = await import('node:fs/promises');
+    await wf(filePath, content, 'utf8');
+}
+export async function downloadImage(url, destPath) {
+    const response = await fetch(url);
+    const buffer = await response.arrayBuffer();
+    const { writeFile: wf } = await import('node:fs/promises');
+    await wf(destPath, Buffer.from(buffer));
+}
+//# sourceMappingURL=controllerAction.js.map

package/dist/services/shared/serviceProcessLogger.js

@@ -14,7 +14,7 @@ function ensureLogDir() {
 }
 function safeAppend(filePath, line) {
     try {
-        fs.appendFileSync(filePath, line);
+        fs.appendFileSync(filePath, line, 'utf8');
     }
     catch {
         // ignore

package/dist/services/unified-api/server.js

@@ -251,17 +251,119 @@ class UnifiedApiServer {
         server.on('request', (req, res) => {
             void (async () => {
                 const url = new URL(req.url, `http://${req.headers.host}`);
+                const normalizeTaskPhase = (value) => {
+                    const text = String(value || '').trim().toLowerCase();
+                    if (text === 'phase1' || text === 'phase2' || text === 'phase3' || text === 'phase4' || text === 'unified' || text === 'orchestrate') {
+                        return text;
+                    }
+                    return 'unknown';
+                };
+                const normalizeTaskStatus = (value) => {
+                    const text = String(value || '').trim().toLowerCase();
+                    if (text === 'starting' || text === 'running' || text === 'paused' || text === 'completed' || text === 'failed' || text === 'aborted') {
+                        return text;
+                    }
+                    return '';
+                };
+                const ensureTask = (runId, seed = {}) => {
+                    const normalizedRunId = String(runId || '').trim();
+                    if (!normalizedRunId)
+                        return null;
+                    const existing = this.taskRegistry.getTask(normalizedRunId);
+                    if (existing)
+                        return existing;
+                    const profileId = String(seed?.profileId || 'unknown').trim() || 'unknown';
+                    const keyword = String(seed?.keyword || '').trim();
+                    const phase = normalizeTaskPhase(seed?.phase);
+                    return this.taskRegistry.createTask({
+                        runId: normalizedRunId,
+                        profileId,
+                        keyword,
+                        phase,
+                    });
+                };
+                const applyTaskPatch = (runId, payload = {}) => {
+                    const normalizedRunId = String(runId || '').trim();
+                    if (!normalizedRunId)
+                        return;
+                    ensureTask(normalizedRunId, payload);
+                    const phase = normalizeTaskPhase(payload?.phase);
+                    const profileId = String(payload?.profileId || '').trim();
+                    const keyword = String(payload?.keyword || '').trim();
+                    const details = payload?.details && typeof payload.details === 'object' ? payload.details : undefined;
+                    const patch = {};
+                    if (phase !== 'unknown')
+                        patch.phase = phase;
+                    if (profileId)
+                        patch.profileId = profileId;
+                    if (keyword)
+                        patch.keyword = keyword;
+                    if (details)
+                        patch.details = details;
+                    if (Object.keys(patch).length > 0) {
+                        this.taskRegistry.updateTask(normalizedRunId, patch);
+                    }
+                    if (payload?.progress && typeof payload.progress === 'object') {
+                        this.taskRegistry.updateProgress(normalizedRunId, payload.progress);
+                    }
+                    if (payload?.stats && typeof payload.stats === 'object') {
+                        this.taskRegistry.updateStats(normalizedRunId, payload.stats);
+                    }
+                    const status = normalizeTaskStatus(payload?.status);
+                    if (status) {
+                        this.taskRegistry.setStatus(normalizedRunId, status);
+                    }
+                    const errorPayload = payload?.error && typeof payload.error === 'object'
+                        ? payload.error
+                        : (payload?.lastError && typeof payload.lastError === 'object' ? payload.lastError : null);
+                    if (errorPayload) {
+                        this.taskRegistry.setError(normalizedRunId, {
+                            message: String(errorPayload.message || 'task_error'),
+                            code: String(errorPayload.code || 'TASK_ERROR'),
+                            timestamp: Number(errorPayload.timestamp || Date.now()),
+                            recoverable: Boolean(errorPayload.recoverable),
+                        });
+                    }
+                };
                 // Container operations endpoints
                 const containerHandled = await handleContainerOperations(req, res, sessionManager, this.containerExecutor);
                 if (containerHandled)
                     return;
                 // Task state API endpoints
+                if (req.method === 'POST' && url.pathname === '/api/v1/tasks') {
+                    try {
+                        const payload = await this.readJsonBody(req);
+                        const runId = String(payload?.runId || payload?.id || '').trim();
+                        if (!runId)
+                            throw new Error('runId is required');
+                        ensureTask(runId, payload);
+                        applyTaskPatch(runId, payload);
+                        const task = this.taskRegistry.getTask(runId);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: true, data: task }));
+                    }
+                    catch (err) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: err?.message || String(err) }));
+                    }
+                    return;
+                }
                 if (req.method === 'GET' && url.pathname === '/api/v1/tasks') {
                     const tasks = this.taskRegistry.getAllTasks();
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ success: true, data: tasks }));
                     return;
                 }
+                if (req.method === 'GET' && url.pathname.includes('/api/v1/tasks/') && url.pathname.includes('/events')) {
+                    const parts = url.pathname.split('/');
+                    const tasksIndex = parts.indexOf('tasks');
+                    const runId = parts[tasksIndex + 1];
+                    const since = url.searchParams.get('since');
+                    const events = this.taskRegistry.getEvents(runId, since ? Number(since) : undefined);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true, data: events }));
+                    return;
+                }
                 if (req.method === 'GET' && url.pathname.startsWith('/api/v1/tasks/')) {
                     const parts = url.pathname.split('/');
                     const runId = parts[parts.length - 1];
@@ -275,23 +377,13 @@ class UnifiedApiServer {
                     res.end(JSON.stringify({ success: true, data: task }));
                     return;
                 }
-                if (req.method === 'GET' && url.pathname.includes('/api/v1/tasks/') && url.pathname.includes('/events')) {
-                    const parts = url.pathname.split('/');
-                    const tasksIndex = parts.indexOf('tasks');
-                    const runId = parts[tasksIndex + 1];
-                    const since = url.searchParams.get('since');
-                    const events = this.taskRegistry.getEvents(runId, since ? Number(since) : undefined);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ success: true, data: events }));
-                    return;
-                }
                 if (req.method === 'POST' && url.pathname.includes('/api/v1/tasks/') && url.pathname.includes('/update')) {
                     const parts = url.pathname.split('/');
                     const tasksIndex = parts.indexOf('tasks');
                     const runId = parts[tasksIndex + 1];
                     try {
                         const payload = await this.readJsonBody(req);
-                        this.taskRegistry.updateTask(runId, payload);
+                        applyTaskPatch(runId, payload);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ success: true }));
                     }
@@ -307,6 +399,7 @@ class UnifiedApiServer {
                     const runId = parts[tasksIndex + 1];
                     try {
                         const event = await this.readJsonBody(req);
+                        ensureTask(runId, event?.data || {});
                         this.taskRegistry.pushEvent(runId, event.type, event.data);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ success: true }));
@@ -323,6 +416,7 @@ class UnifiedApiServer {
                     const runId = parts[tasksIndex + 1];
                     const action = url.searchParams.get('action');
                     try {
+                        ensureTask(runId, {});
                         if (action === 'pause') {
                             this.taskRegistry.setStatus(runId, 'paused');
                         }

package/modules/camo-backend/src/index.ts

@@ -308,9 +308,29 @@ async function handleCommand(
         ...(args.ownerPid ? { ownerPid: args.ownerPid } : {}),
       };
       const res = await manager.createSession(opts);
+      const session = manager.getSession(opts.profileId);
+      if (!session) {
+        throw new Error(`session for profile ${opts.profileId} not started`);
+      }
+      let recording = null;
+      if (args.record === true || args.recording === true) {
+        recording = await session.startRecording({
+          name: args.recordName || args.recordingName,
+          outputPath: args.recordOutput || args.recordingOutput || args.recordOutputPath,
+          overlay: typeof args.recordOverlay === 'boolean' ? args.recordOverlay : undefined,
+        });
+      }
       options.onSessionStart?.();
       broadcast('browser:started', { profileId: opts.profileId, sessionId: res.sessionId });
-      return { ok: true, body: { ok: true, sessionId: res.sessionId, profileId: opts.profileId } };
+      return {
+        ok: true,
+        body: {
+          ok: true,
+          sessionId: res.sessionId,
+          profileId: opts.profileId,
+          ...(recording ? { recording } : {}),
+        },
+      };
     }
     case 'goto': {
       const profileId = args.profileId || 'default';
@@ -354,6 +374,31 @@ async function handleCommand(
     case 'getStatus': {
       return { ok: true, body: { ok: true, sessions: manager.listSessions() } };
     }
+    case 'record:start': {
+      const profileId = args.profileId || 'default';
+      const session = manager.getSession(profileId);
+      if (!session) throw new Error(`session for profile ${profileId} not started`);
+      const recording = await session.startRecording({
+        name: args.name || args.recordName,
+        outputPath: args.outputPath || args.output || args.recordOutput,
+        overlay: typeof args.overlay === 'boolean' ? args.overlay : undefined,
+      });
+      return { ok: true, body: { ok: true, profileId, recording } };
+    }
+    case 'record:stop': {
+      const profileId = args.profileId || 'default';
+      const session = manager.getSession(profileId);
+      if (!session) throw new Error(`session for profile ${profileId} not started`);
+      const recording = await session.stopRecording({ reason: String(args.reason || 'manual') });
+      return { ok: true, body: { ok: true, profileId, recording } };
+    }
+    case 'record:status': {
+      const profileId = args.profileId || 'default';
+      const session = manager.getSession(profileId);
+      if (!session) throw new Error(`session for profile ${profileId} not started`);
+      const recording = session.getRecordingStatus();
+      return { ok: true, body: { ok: true, profileId, recording } };
+    }
     case 'system:display': {
       const metrics = getDisplayMetrics();
       return { ok: true, body: { ok: true, metrics: metrics || null } };