@web-auto/webauto 0.1.1 → 0.1.3

package/dist/modules/workflow/blocks/ExtractDetailBlock.js

@@ -0,0 +1,310 @@
+/**
+ * Workflow Block: ExtractDetailBlock
+ *
+ * 提取详情页内容（header/content/gallery）
+ */
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './helpers/operationLogger.js';
+/**
+ * 提取详情页内容
+ *
+ * @param input - 输入参数
+ * @returns Promise<ExtractDetailOutput>
+ */
+export async function execute(input) {
+    const { sessionId, serviceUrl = 'http://127.0.0.1:7701' } = input;
+    const profile = sessionId;
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    async function controllerAction(action, payload = {}) {
+        const opId = logControllerActionStart(action, payload, { source: 'ExtractDetailBlock' });
+        try {
+            const response = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+                // 防御性超时，避免 containers:match / operation 长时间挂起
+                signal: AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+            }
+            const data = await response.json();
+            const result = data.data || data;
+            logControllerActionResult(opId, action, result, { source: 'ExtractDetailBlock' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'ExtractDetailBlock' });
+            throw error;
+        }
+    }
+    async function extractContainer(containerId) {
+        const result = await controllerAction('container:operation', {
+            containerId,
+            operationId: 'extract',
+            config: {},
+            sessionId: profile
+        });
+        return result.data?.extracted?.[0] || result.extracted?.[0] || {};
+    }
+    async function extractGalleryImagesFromDom(rootSelectors = []) {
+        try {
+            const result = await controllerAction('browser:execute', {
+                profile,
+                script: `(() => {
+          const urls = new Set();
+
+          const rootSelectors = ${JSON.stringify(rootSelectors)};
+          const fallbackSelectors = [
+            ".media-container img",
+            ".note-slider-list img",
+            ".note-img img",
+            ".note-scroller img",
+            "img[src*='sns-img']",
+            "img[data-src*='sns-img']"
+          ];
+
+          const selectors = [];
+
+          // 优先：基于 gallery 容器 selector 的 root 内部查找 IMG
+          if (Array.isArray(rootSelectors) && rootSelectors.length > 0) {
+            for (const sel of rootSelectors) {
+              if (typeof sel !== 'string' || !sel.trim()) continue;
+              selectors.push(sel + " img");
+            }
+          }
+
+          // 兜底：保留原有的一组全局 IMG selectors
+          selectors.push(...fallbackSelectors);
+
+          // 辅助函数：从单个节点提取 src / data-src / background-image
+          const addUrlFromNode = (node) => {
+            if (!node) return;
+
+            // 1) IMG / SOURCE 类节点
+            let src =
+              node.currentSrc ||
+              node.src ||
+              (typeof node.getAttribute === "function" &&
+                (node.getAttribute("src") || node.getAttribute("data-src")));
+
+            // 2) 背景图：检查 inline style 与 computed style 的 background-image
+            if (!src && typeof window !== "undefined") {
+              try {
+                const style = window.getComputedStyle(node);
+                const bg = style && (style.backgroundImage || style.background);
+                if (bg && bg.includes("url(")) {
+                  // 解析 url("...") / url('...') / url(...)
+                  const match = bg.match(/url\\(([^)]+)\\)/);
+                  if (match && match[1]) {
+                    src = match[1].trim().replace(/^['"]|['"]$/g, "");
+                  }
+                }
+              } catch (_) {
+                // ignore style errors
+              }
+            }
+
+            if (typeof src === "string") {
+              const trimmed = src.trim();
+              if (trimmed) {
+                urls.add(trimmed);
+              }
+            }
+          };
+
+          // 先扫 IMG
+          for (const sel of selectors) {
+            try {
+              document.querySelectorAll(sel).forEach((node) => {
+                addUrlFromNode(node);
+              });
+            } catch (_) {
+              // 单个 selector 出错不影响整体
+            }
+          }
+
+          // 再在 gallery root 内扫描可能只用背景图渲染的节点（基于 computedStyle.backgroundImage）
+          const roots = [];
+          if (Array.isArray(rootSelectors) && rootSelectors.length > 0) {
+            for (const sel of rootSelectors) {
+              try {
+                const el = document.querySelector(sel);
+                if (el) roots.push(el);
+              } catch (_) {}
+            }
+          }
+          if (!roots.length && document.body) {
+            roots.push(document.body);
+          }
+
+          const MAX_BG_NODES = 400;
+          for (const root of roots) {
+            try {
+              const nodes = root.querySelectorAll('*');
+              const len = Math.min(nodes.length, MAX_BG_NODES);
+              for (let i = 0; i < len; i++) {
+                addUrlFromNode(nodes[i]);
+              }
+            } catch (_) {
+              // ignore
+            }
+          }
+
+          return Array.from(urls);
+        })()`
+            });
+            const payload = result.result || result.data?.result || result;
+            if (Array.isArray(payload)) {
+                return payload.filter((v) => typeof v === 'string' && v.trim().length > 0);
+            }
+            if (payload && Array.isArray(payload.urls)) {
+                return payload.urls.filter((v) => typeof v === 'string' && v.trim().length > 0);
+            }
+            return [];
+        }
+        catch (e) {
+            console.warn(`[ExtractDetail] fallback DOM image extraction error: ${e?.message || e}`);
+            return [];
+        }
+    }
+    try {
+        const { verifyAnchorByContainerId, getPrimarySelectorByContainerId } = await import('./helpers/containerAnchors.js');
+        // 1. 直接使用固定的详情子容器 ID（避免依赖 containers:match）
+        const headerNode = { id: 'xiaohongshu_detail.header' };
+        const contentNode = { id: 'xiaohongshu_detail.content' };
+        const galleryNode = { id: 'xiaohongshu_detail.gallery' };
+        // 3. 提取数据
+        const detail = {};
+        let headerRect;
+        let contentRect;
+        let galleryRect;
+        // 3.1 header：高亮 + Rect + 数据
+        if (headerNode?.id) {
+            try {
+                const anchor = await verifyAnchorByContainerId(headerNode.id, profile, serviceUrl, '2px solid #ff8800', 1500);
+                if (anchor.found && anchor.rect) {
+                    headerRect = anchor.rect;
+                    console.log(`[ExtractDetail] header rect: ${JSON.stringify(anchor.rect)}`);
+                }
+                else {
+                    console.warn(`[ExtractDetail] header anchor verify failed: ${anchor.error || 'not found'}`);
+                }
+            }
+            catch (e) {
+                console.warn(`[ExtractDetail] header anchor verify error: ${e.message}`);
+            }
+            detail.header = await extractContainer(headerNode.id);
+        }
+        // 3.2 content：高亮 + Rect + 数据
+        if (contentNode?.id) {
+            try {
+                const anchor = await verifyAnchorByContainerId(contentNode.id, profile, serviceUrl, '2px solid #00aa00', 1500);
+                if (anchor.found && anchor.rect) {
+                    contentRect = anchor.rect;
+                    console.log(`[ExtractDetail] content rect: ${JSON.stringify(anchor.rect)}`);
+                }
+                else {
+                    console.warn(`[ExtractDetail] content anchor verify failed: ${anchor.error || 'not found'}`);
+                }
+            }
+            catch (e) {
+                console.warn(`[ExtractDetail] content anchor verify error: ${e.message}`);
+            }
+            detail.content = await extractContainer(contentNode.id);
+        }
+        // 3.3 gallery：高亮 + Rect + 数据
+        if (galleryNode?.id) {
+            let galleryAnchorOk = false;
+            try {
+                const anchor = await verifyAnchorByContainerId(galleryNode.id, profile, serviceUrl, '2px solid #0088ff', 1500);
+                if (anchor.found && anchor.rect) {
+                    galleryRect = anchor.rect;
+                    galleryAnchorOk = true;
+                    console.log(`[ExtractDetail] gallery rect: ${JSON.stringify(anchor.rect)}`);
+                }
+                else {
+                    console.warn(`[ExtractDetail] gallery anchor verify failed: ${anchor.error || 'not found'}`);
+                }
+            }
+            catch (e) {
+                console.warn(`[ExtractDetail] gallery anchor verify error: ${e.message}`);
+            }
+            // 「无锚不动」：如果 gallery 容器锚点未命中，则不做任何图片提取，避免误采头像 / 推荐流图片。
+            if (!galleryAnchorOk) {
+                console.warn('[ExtractDetail] gallery anchor not found, skip gallery extraction entirely');
+            }
+            else {
+                const galleryData = (await extractContainer(galleryNode.id)) || {};
+                // 处理图片字段：兼容字符串 / 对象数组，并在为空时用 DOM 兜底
+                let images = [];
+                const rawImages = galleryData.images;
+                if (Array.isArray(rawImages)) {
+                    images = rawImages
+                        .map((item) => {
+                        if (!item)
+                            return '';
+                        if (typeof item === 'string')
+                            return item;
+                        if (typeof item === 'object') {
+                            return (item.src || item.url || item.href || '').trim();
+                        }
+                        return '';
+                    })
+                        .filter((v) => v.length > 0);
+                }
+                else if (typeof rawImages === 'string') {
+                    const v = rawImages.trim();
+                    if (v)
+                        images.push(v);
+                }
+                // 若容器未返回图片，则尝试直接从 DOM 中聚合一次（优先基于 gallery 容器 selector 作为 root）
+                if (images.length === 0) {
+                    const gallerySelector = (await getPrimarySelectorByContainerId(galleryNode.id)) || '';
+                    const domImages = await extractGalleryImagesFromDom(gallerySelector ? [gallerySelector] : []);
+                    if (domImages.length > 0) {
+                        images = domImages;
+                    }
+                }
+                if (images.length > 0) {
+                    // 去重，避免 swiper 结构中的 duplicate slide 导致重复图片
+                    images = Array.from(new Set(images));
+                    console.log(`[ExtractDetail] gallery images count after dedupe: ${images.length}`);
+                    galleryData.images = images;
+                }
+                else {
+                    console.warn('[ExtractDetail] gallery images still empty after DOM fallback');
+                }
+                detail.gallery = galleryData;
+            }
+        }
+        // 4. Rect 规则验证：header 在顶部，content 在中部，gallery 在下方
+        let verified = false;
+        if (headerRect && contentRect && galleryRect) {
+            const headerOk = headerRect.y < 300 && headerRect.height > 0;
+            const contentOk = contentRect.y > headerRect.y && contentRect.height > 0;
+            const galleryOk = galleryRect.y > contentRect.y && galleryRect.height > 0;
+            verified = headerOk && contentOk && galleryOk;
+            console.log(`[ExtractDetail] Rect validation: header=${headerOk}, content=${contentOk}, gallery=${galleryOk}`);
+        }
+        return {
+            success: true,
+            detail,
+            anchor: {
+                headerContainerId: headerNode?.id,
+                headerRect,
+                contentContainerId: contentNode?.id,
+                contentRect,
+                galleryContainerId: galleryNode?.id,
+                galleryRect,
+                verified
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `ExtractDetail failed: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=ExtractDetailBlock.js.map

package/dist/modules/workflow/blocks/ExtractPostFields.js

@@ -0,0 +1,88 @@
+/**
+ * Workflow Block: ExtractPostFields
+ *
+ * 抽取单条帖子字段数据，包含链接过滤
+ */
+/**
+ * 抽取字段
+ *
+ * @param input - 输入参数
+ * @returns Promise<ExtractPostFieldsOutput>
+ */
+export async function execute(input) {
+    const { sessionId, containerSelector, index = 0, serviceUrl = 'http://127.0.0.1:7704' } = input;
+    const commandUrl = `${serviceUrl}/command`;
+    try {
+        const evalRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'evaluate',
+                args: {
+                    profileId: sessionId,
+                    script: `
+            (() => {
+              const containers = document.querySelectorAll('${containerSelector}');
+              if (!containers || containers.length === 0) {
+                return { error: 'No containers found' };
+              }
+              const index = ${index};
+              if (index >= containers.length) {
+                return { error: 'Index out of range' };
+              }
+              const element = containers[index];
+
+              const getText = (selector) => {
+                const node = element.querySelector(selector);
+                return node ? node.textContent?.trim() : '';
+              };
+
+              // 过滤链接：只保留帖子链接
+              const isPostUrl = (url) => {
+                if (!url) return false;
+                // 帖子URL: weibo.com/数字/帖子ID，其中帖子ID长度>4位
+                return /^https?:\\/\\/(?:www\\.)?weibo\\.com\\/\\d+\\/[a-zA-Z0-9]{5,}/.test(url) ||
+                       /^https?:\\/\\/(?:m\\.)?weibo\\.com\\/detail\\/[a-zA-Z0-9]{5,}/.test(url);
+              };
+
+              const isProfileUrl = (url) => {
+                if (!url) return false;
+                // 用户主页: /u/数字ID 或 单段用户名
+                return /^https?:\\/\\/(?:www\\.)?weibo\\.com\\/u\\/\\d+/.test(url) ||
+                       /^https?:\\/\\/(?:www\\.)?weibo\\.com\\/[a-zA-Z0-9_-]{1,16}\\/?$/.test(url);
+              };
+
+              const links = Array.from(element.querySelectorAll('a'))
+                .map(a => a.href)
+                .filter(url => isPostUrl(url) && !isProfileUrl(url));
+
+              return {
+                author: getText('.woo-font.woo-font--headline'),
+                content: getText('.detail_wbtext_4CRf9, .detail_wbtext_4CRf9 *'),
+                time: getText('time, .wb_time'),
+                postLinks: links
+              };
+            })()
+          `
+                }
+            })
+        });
+        const evalData = await evalRes.json();
+        if (!evalData.success || evalData.data?.error) {
+            return {
+                fields: {},
+                error: evalData.data?.error || 'Failed to extract fields'
+            };
+        }
+        return {
+            fields: evalData.data
+        };
+    }
+    catch (error) {
+        return {
+            fields: {},
+            error: `Extract error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=ExtractPostFields.js.map

package/dist/modules/workflow/blocks/GenerateSmartReplyBlock.js

@@ -0,0 +1,68 @@
+/**
+ * Block: GenerateSmartReply
+ *
+ * 职责：
+ * - 构造 prompt（<note> + <comment>）
+ * - 调用 OpenAI-compatible Chat API 生成 <= N 字回复
+ *
+ * Dev 模式：
+ * - 默认返回 mock 回复（避免误触发真实外部请求/成本）
+ */
+import { buildSmartReplyUserPrompt, mockSmartReply, sanitizeSmartReply } from './helpers/smartReply.js';
+function resolveBaseUrl(baseUrl) {
+    const s = String(baseUrl || '').trim();
+    if (!s)
+        return '';
+    return s.endsWith('/') ? s.slice(0, -1) : s;
+}
+export async function execute(input) {
+    const maxChars = typeof input.maxChars === 'number' ? input.maxChars : 20;
+    const dev = input.dev === true;
+    const dryRun = input.dryRun === true;
+    const note = String(input.note || '');
+    const comment = String(input.comment || '');
+    const apiKey = String(input.apiKey || process.env.WEBAUTO_CHAT_API_KEY || '').trim();
+    const model = String(input.model || process.env.WEBAUTO_CHAT_MODEL || 'gpt-4o-mini').trim();
+    const baseUrl = resolveBaseUrl(String(input.baseUrl || process.env.WEBAUTO_CHAT_BASE_URL || 'https://api.openai.com'));
+    if (dryRun || dev || !apiKey || !baseUrl) {
+        return { success: true, reply: mockSmartReply(note, comment, maxChars), usedMock: true };
+    }
+    try {
+        const userPrompt = buildSmartReplyUserPrompt({ note, comment, maxChars });
+        const systemPrompt = '你是一个真实的小红书用户，擅长用自然、简短、拟人的口吻互动。';
+        const body = {
+            model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: userPrompt },
+            ],
+            temperature: typeof input.temperature === 'number' ? input.temperature : 0.7,
+            max_tokens: 80,
+        };
+        const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(25000),
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            const msg = json?.error?.message || `HTTP ${res.status}`;
+            throw new Error(msg);
+        }
+        const content = json?.choices?.[0]?.message?.content ??
+            json?.choices?.[0]?.text ??
+            '';
+        const reply = sanitizeSmartReply(String(content || ''), maxChars);
+        if (!reply)
+            throw new Error('empty reply');
+        return { success: true, reply, usedMock: false };
+    }
+    catch (e) {
+        return { success: false, reply: '', usedMock: false, error: e?.message || String(e) };
+    }
+}
+//# sourceMappingURL=GenerateSmartReplyBlock.js.map