@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/workflow/blocks/helpers/macosVisionOcrPlugin.js

@@ -0,0 +1,116 @@
+import { execFile } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const execFileAsync = promisify(execFile);
+export function isImageFile(name) {
+    const lower = String(name || '').toLowerCase();
+    return lower.endsWith('.png') || lower.endsWith('.jpg') || lower.endsWith('.jpeg') || lower.endsWith('.webp');
+}
+function findUp(startDir, fileName) {
+    let cur = startDir;
+    for (let i = 0; i < 12; i += 1) {
+        const candidate = path.join(cur, fileName);
+        if (fs.existsSync(candidate))
+            return cur;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return null;
+}
+function resolveDefaultBinaryCandidates() {
+    const candidates = [];
+    const homeBin = path.join(os.homedir(), '.webauto', 'bin', 'webauto-ocr-macos');
+    candidates.push(homeBin);
+    // Try relative to repo root (dev + built dist)
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const repoRoot = findUp(here, 'package.json');
+    if (repoRoot) {
+        candidates.push(path.join(repoRoot, 'dist', 'plugins', 'ocr-macos', 'webauto-ocr-macos'));
+        candidates.push(path.join(repoRoot, 'plugins', 'ocr-macos', '.build', 'release', 'webauto-ocr-macos'));
+    }
+    return candidates;
+}
+export function resolveMacOcrBinary() {
+    const tried = [];
+    const envPath = process.env.WEBAUTO_OCR_BIN;
+    if (envPath && envPath.trim()) {
+        const p = envPath.trim();
+        tried.push(p);
+        if (fs.existsSync(p))
+            return { binPath: p, tried };
+    }
+    for (const candidate of resolveDefaultBinaryCandidates()) {
+        tried.push(candidate);
+        if (fs.existsSync(candidate))
+            return { binPath: candidate, tried };
+    }
+    return { binPath: '', tried };
+}
+function normalizeLanguages(raw) {
+    const v = typeof raw === 'string' ? raw.trim() : '';
+    const desired = v || 'chi_sim+eng';
+    const parts = desired.includes('+')
+        ? desired.split('+')
+        : desired.includes(',')
+            ? desired.split(',')
+            : [desired];
+    const mapped = parts
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((s) => {
+        switch (s) {
+            case 'chi_sim':
+                return 'zh-Hans';
+            case 'chi_tra':
+                return 'zh-Hant';
+            case 'eng':
+                return 'en-US';
+            case 'jpn':
+                return 'ja-JP';
+            default:
+                return s;
+        }
+    });
+    // stable & readable
+    return Array.from(new Set(mapped)).join(',');
+}
+export function pickMacOcrLanguages(requested) {
+    return { languages: normalizeLanguages(requested) };
+}
+export async function ocrImagesWithMacPlugin(imagePaths, config = {}) {
+    if (process.platform !== 'darwin') {
+        throw new Error(`macOS OCR plugin only supported on darwin (platform=${process.platform})`);
+    }
+    const { binPath, tried } = resolveMacOcrBinary();
+    if (!binPath) {
+        const msg = [
+            `macOS OCR binary not found.`,
+            `Tried:`,
+            ...tried.map((p) => `- ${p}`),
+            `Build it via: node scripts/build/build-ocr-macos.mjs --install`,
+            `Or set WEBAUTO_OCR_BIN=/absolute/path/to/webauto-ocr-macos`,
+        ].join('\n');
+        throw new Error(msg);
+    }
+    const languagesUsed = normalizeLanguages(config.languages);
+    const timeoutMs = typeof config.timeoutMs === 'number' ? config.timeoutMs : 120_000;
+    if (!imagePaths.length) {
+        return { languagesUsed, results: [], binPath };
+    }
+    // Batch size guard to avoid "argument list too long" in pathological cases.
+    const batchSize = 32;
+    const all = [];
+    for (let i = 0; i < imagePaths.length; i += batchSize) {
+        const batch = imagePaths.slice(i, i + batchSize);
+        const { stdout } = await execFileAsync(binPath, ['--json', '--langs', languagesUsed, ...batch], { timeout: timeoutMs, maxBuffer: 20 * 1024 * 1024 });
+        const parsed = JSON.parse(String(stdout || '[]'));
+        all.push(...(Array.isArray(parsed) ? parsed : []));
+    }
+    return { languagesUsed, results: all, binPath };
+}
+//# sourceMappingURL=macosVisionOcrPlugin.js.map

package/dist/modules/workflow/blocks/helpers/mergeXhsMarkdown.js

@@ -0,0 +1,109 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { resolveKeywordDir } from './downloadPaths.js';
+function shouldSkipDir(name) {
+    return name.startsWith('.') || name.startsWith('_') || name.toLowerCase() === 'macosx';
+}
+async function pathExists(filepath) {
+    try {
+        await fs.access(filepath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function rewriteRelativeImagePath(rawPath, noteId) {
+    const trimmed = String(rawPath || '').trim();
+    if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(trimmed))
+        return rawPath;
+    if (/^[a-z]+:/i.test(trimmed))
+        return rawPath;
+    if (trimmed.startsWith('/') || trimmed.startsWith('#'))
+        return rawPath;
+    const cleaned = trimmed.replace(/^\.?\//, '');
+    return `./${noteId}/${cleaned}`;
+}
+function rewriteMarkdownImages(markdown, noteId) {
+    const pattern = /!\[([^\]]*)\]\(([^)\s]+)(\s+"[^"]*")?\)/g;
+    return markdown.replace(pattern, (_match, altText, rawPath, titlePart) => {
+        const nextPath = rewriteRelativeImagePath(rawPath, noteId);
+        const title = titlePart || '';
+        return `![${altText}](${nextPath}${title})`;
+    });
+}
+export async function mergeNotesMarkdown(input) {
+    const { platform = 'xiaohongshu', env, keyword, homeDir, downloadRoot, outputFileName = 'merged.md', noteFileCandidates = ['content.md', 'README.md'], includeComments = true, commentsFileName = 'comments.md', } = input;
+    const keywordDir = resolveKeywordDir({ platform, env, keyword, homeDir, downloadRoot });
+    const outputPath = path.join(keywordDir, outputFileName);
+    if (!(await pathExists(keywordDir))) {
+        return {
+            success: false,
+            keywordDir,
+            outputPath,
+            totalNotes: 0,
+            mergedNotes: 0,
+            skippedNotes: [],
+            error: `keyword_dir_missing: ${keywordDir}`,
+        };
+    }
+    const entries = await fs.readdir(keywordDir, { withFileTypes: true }).catch(() => []);
+    const noteDirs = entries.filter((ent) => ent?.isDirectory?.() && !shouldSkipDir(ent.name));
+    const sections = [];
+    const skippedNotes = [];
+    for (const ent of noteDirs) {
+        const noteId = ent.name;
+        let contentPath = '';
+        for (const candidate of noteFileCandidates) {
+            const candidatePath = path.join(keywordDir, noteId, candidate);
+            if (await pathExists(candidatePath)) {
+                contentPath = candidatePath;
+                break;
+            }
+        }
+        if (!contentPath) {
+            skippedNotes.push(noteId);
+            continue;
+        }
+        const raw = await fs.readFile(contentPath, 'utf-8').catch(() => '');
+        const content = rewriteMarkdownImages(raw, noteId).trim();
+        const lines = [];
+        lines.push(`## ${noteId}`);
+        lines.push('');
+        if (content) {
+            lines.push(content);
+        }
+        if (includeComments) {
+            const commentsPath = path.join(keywordDir, noteId, commentsFileName);
+            if (await pathExists(commentsPath)) {
+                const commentsRaw = await fs.readFile(commentsPath, 'utf-8').catch(() => '');
+                const comments = commentsRaw.trim();
+                if (comments) {
+                    lines.push('');
+                    lines.push('### Comments');
+                    lines.push('');
+                    lines.push(comments);
+                }
+            }
+        }
+        sections.push(lines.join('\n'));
+    }
+    const header = [];
+    header.push(`# ${keyword}`);
+    header.push('');
+    header.push(`- keyword: ${keyword}`);
+    header.push(`- generatedAt: ${new Date().toISOString()}`);
+    header.push(`- notes: ${sections.length}`);
+    header.push('');
+    const merged = header.join('\n') + (sections.length > 0 ? sections.join('\n\n---\n\n') : '');
+    await fs.writeFile(outputPath, merged, 'utf-8');
+    return {
+        success: true,
+        keywordDir,
+        outputPath,
+        totalNotes: noteDirs.length,
+        mergedNotes: sections.length,
+        skippedNotes,
+    };
+}
+//# sourceMappingURL=mergeXhsMarkdown.js.map

package/dist/modules/workflow/blocks/helpers/openDetailController.js

@@ -0,0 +1,56 @@
+/**
+ * OpenDetailBlock Controller Helper
+ *
+ * 封装 OpenDetail 专用的 controller 调用
+ */
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './operationLogger.js';
+/**
+ * 创建 OpenDetail Controller 客户端
+ */
+export function createOpenDetailControllerClient(config) {
+    const { profile, controllerUrl } = config;
+    async function controllerAction(action, payload = {}) {
+        // OpenDetail 的 debug 截图可能较慢（页面重、资源多），这里对 screenshot 单独放宽超时。
+        const timeoutMs = action === 'browser:screenshot'
+            ? 45000
+            : action === 'containers:match'
+                ? 20000
+                : 10000;
+        const opId = logControllerActionStart(action, payload, { source: 'openDetailController' });
+        try {
+            const response = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+                // 防御性超时，避免 containers:match / container:operation 长时间挂起
+                signal: AbortSignal.timeout ? AbortSignal.timeout(timeoutMs) : 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: 'openDetailController' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'openDetailController' });
+            throw error;
+        }
+    }
+    async function getCurrentUrl() {
+        const response = await fetch(controllerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: { profile, script: 'location.href' }
+            }),
+            signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined
+        });
+        const data = await response.json().catch(() => ({}));
+        return data?.data?.result || data?.result || '';
+    }
+    return { controllerAction, getCurrentUrl };
+}
+//# sourceMappingURL=openDetailController.js.map

package/dist/modules/workflow/blocks/helpers/openDetailTypes.js

@@ -0,0 +1,7 @@
+/**
+ * openDetailTypes.ts
+ *
+ * OpenDetailBlock 相关类型定义（供 helper 模块共享）
+ */
+export {};
+//# sourceMappingURL=openDetailTypes.js.map