@sovovs/bycli 2.1.0 → 2.1.2

package/dist/src/download/article-download.js

@@ -11,12 +11,29 @@ import TurndownService from 'turndown';
 import { gfm } from 'turndown-plugin-gfm';
 import { httpDownload, sanitizeFilename } from './index.js';
 import { formatBytes } from './progress.js';
+export { extractWechatArticleHtml } from './wechat-article.js';
 const IMAGE_CONCURRENCY = 5;
 const DEFAULT_LABELS = {
     author: '作者',
     publishTime: '发布时间',
     sourceUrl: '原文链接',
 };
+function escapeMarkdownText(value) {
+    return value.replace(/\s+/g, ' ').trim()
+        .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;').replace(/'/g, '&#39;')
+        .replace(/([\\`*_[\]{}()#+.!|>~-])/g, '\\$1');
+}
+function safeHttpUrl(value) {
+    const normalized = value.trim().startsWith('//') ? `https:${value.trim()}` : value.trim();
+    try {
+        const url = new URL(normalized);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : '';
+    }
+    catch {
+        return '';
+    }
+}
 // ============================================================
 // Markdown Conversion
 // ============================================================
@@ -36,13 +53,48 @@ const STRIPPED_TAGS = [
     'form', 'button', 'dialog',
     'header', 'footer', 'nav', 'aside',
 ];
-function createTurndown(configure, cleanSelectors) {
+function createTurndown(configure, cleanSelectors, secureMarkdown = false) {
     const td = new TurndownService({
         headingStyle: 'atx',
         codeBlockStyle: 'fenced',
         bulletListMarker: '-',
     });
     td.use(gfm);
+    if (secureMarkdown) {
+        const escapeDestination = (value) => value.replace(/([\\()])/g, '\\$1');
+        td.addRule('safeFencedCodeBlock', {
+            filter: 'pre',
+            replacement: (_content, node) => {
+                const element = node;
+                const code = element.textContent || '';
+                const longest = Math.max(0, ...[...code.matchAll(/`+/g)].map(match => match[0].length));
+                const fence = '`'.repeat(Math.max(3, longest + 1));
+                const className = element.querySelector('code')?.getAttribute('class') || '';
+                const language = element.getAttribute('data-lang')
+                    || /(?:^|\s)language-([^\s]+)/.exec(className)?.[1]
+                    || '';
+                return `\n${fence}${language}\n${code.replace(/\n$/, '')}\n${fence}\n`;
+            },
+        });
+        td.addRule('safeImage', {
+            filter: 'img',
+            replacement: (_content, node) => {
+                const element = node;
+                const alt = escapeMarkdownText(element.getAttribute('alt') || '');
+                const src = element.getAttribute('src') || '';
+                return src ? `![${alt}](${escapeDestination(src)})` : alt;
+            },
+        });
+        td.addRule('safeLink', {
+            filter: 'a',
+            replacement: (_content, node) => {
+                const element = node;
+                const label = escapeMarkdownText(element.textContent || '');
+                const href = element.getAttribute('href') || '';
+                return href ? `[${label}](${escapeDestination(href)})` : label;
+            },
+        });
+    }
     td.remove(STRIPPED_TAGS);
     // turndown-plugin-gfm@1.0.2 emits single-tilde strikethrough (`~x~`), which
     // is not the canonical GFM form. Override it so exported markdown is
@@ -104,11 +156,14 @@ function createTurndown(configure, cleanSelectors) {
         filter: (node) => node.nodeName === 'IFRAME',
         replacement: (_content, node) => {
             const el = node;
-            const src = el.getAttribute('src') || '';
+            const rawSrc = el.getAttribute('src') || '';
+            const src = secureMarkdown ? safeHttpUrl(rawSrc) : rawSrc;
             if (!src)
                 return '';
-            const title = el.getAttribute('title') || 'Embedded content';
-            return `\n[${title}](${src})\n`;
+            const rawTitle = el.getAttribute('title') || 'Embedded content';
+            const title = secureMarkdown ? escapeMarkdownText(rawTitle) : rawTitle;
+            const destination = secureMarkdown ? src.replace(/([\\()])/g, '\\$1') : src;
+            return `\n[${title}](${destination})\n`;
         },
     });
     // Per-adapter dirty-node removal. Adapters know their site's specific noise
@@ -139,14 +194,16 @@ function createTurndown(configure, cleanSelectors) {
         configure(td);
     return td;
 }
-function convertToMarkdown(contentHtml, codeBlocks, configure, cleanSelectors) {
-    const td = createTurndown(configure, cleanSelectors);
+function convertToMarkdown(contentHtml, codeBlocks, configure, cleanSelectors, secureMarkdown = false) {
+    const td = createTurndown(configure, cleanSelectors, secureMarkdown);
     let md = td.turndown(contentHtml);
-    // Restore code block placeholders
-    codeBlocks.forEach((block, i) => {
-        const placeholder = `CODEBLOCK-PLACEHOLDER-${i}`;
-        const fenced = `\n\`\`\`${block.lang}\n${block.code}\n\`\`\`\n`;
-        md = md.replace(placeholder, fenced);
+    // Legacy callers may still supply extracted blocks. New callers preserve
+    // real <pre>/<code> nodes so Turndown owns fencing without collision-prone
+    // magic text; legacy blocks are appended with safe dynamic fences.
+    codeBlocks.forEach((block) => {
+        const longest = Math.max(0, ...[...block.code.matchAll(/`+/g)].map(match => match[0].length));
+        const fence = '`'.repeat(Math.max(3, longest + 1));
+        md += `\n\n${fence}${block.lang}\n${block.code}\n${fence}`;
     });
     // Clean up
     md = md.replace(/\u00a0/g, ' ');
@@ -158,6 +215,9 @@ function convertToMarkdown(contentHtml, codeBlocks, configure, cleanSelectors) {
     md = md.replace(/\n{3,}/g, '\n\n');
     return md;
 }
+export function convertArticleHtmlToMarkdown(contentHtml, options = {}) {
+    return convertToMarkdown(contentHtml, [], undefined, undefined, options.safeFencedCodeBlocks === true);
+}
 function replaceImageUrls(md, urlMap) {
     return md.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match, alt, imgUrl) => {
         const local = urlMap[imgUrl];
@@ -230,7 +290,7 @@ async function downloadImages(imgUrls, imgDir, headers, detectExt) {
  * 6. File write
  */
 export async function downloadArticle(data, options) {
-    const { output, downloadImages: shouldDownloadImages = true, imageHeaders, maxTitleLength = 80, configureTurndown, detectImageExt, frontmatterLabels, cleanSelectors, stdout = false, } = options;
+    const { output, downloadImages: shouldDownloadImages = true, imageHeaders, maxTitleLength = 80, configureTurndown, detectImageExt, frontmatterLabels, cleanSelectors, stdout = false, secureMarkdown = false, } = options;
     const labels = { ...DEFAULT_LABELS, ...frontmatterLabels };
     if (!data.title) {
         return [{
@@ -253,7 +313,7 @@ export async function downloadArticle(data, options) {
             }];
     }
     // Convert HTML to Markdown
-    let markdown = convertToMarkdown(data.contentHtml, data.codeBlocks || [], configureTurndown, cleanSelectors);
+    let markdown = convertToMarkdown(data.contentHtml, data.codeBlocks || [], configureTurndown, cleanSelectors, secureMarkdown);
     const safeTitle = sanitizeFilename(data.title, maxTitleLength);
     // Download images only when writing to disk. In stdout mode remote URLs
     // stay intact so the piped output is self-contained.
@@ -268,13 +328,14 @@ export async function downloadArticle(data, options) {
     // Build frontmatter with customizable labels.
     // Shape: `# Title\n[> meta\n...]\n---\n\n<markdown>` — exactly one blank
     // line separates every section, so we never produce ≥3 consecutive newlines.
-    const headerLines = [`# ${data.title}`];
+    const headerValue = (value) => secureMarkdown ? escapeMarkdownText(value) : value;
+    const headerLines = [`# ${headerValue(data.title)}`];
     if (data.author)
-        headerLines.push(`> ${labels.author}: ${data.author}`);
+        headerLines.push(`> ${labels.author}: ${headerValue(data.author)}`);
     if (data.publishTime)
-        headerLines.push(`> ${labels.publishTime}: ${data.publishTime}`);
+        headerLines.push(`> ${labels.publishTime}: ${headerValue(data.publishTime)}`);
     if (data.sourceUrl)
-        headerLines.push(`> ${labels.sourceUrl}: ${data.sourceUrl}`);
+        headerLines.push(`> ${labels.sourceUrl}: ${headerValue(data.sourceUrl)}`);
     const frontmatter = headerLines.join('\n') + '\n\n---\n\n';
     const fullContent = frontmatter + markdown;
     const size = Buffer.byteLength(fullContent, 'utf-8');

package/dist/src/download/wechat-article.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_WECHAT_HTML_BYTES: number;
+export declare const MAX_WECHAT_NODES = 100000;
+export declare const MAX_WECHAT_CODE_BLOCKS = 1000;
+export interface ExtractedWechatArticle {
+    contentHtml: string;
+    imageUrls: string[];
+}
+export declare function extractWechatArticleHtml(html: string): ExtractedWechatArticle;

package/dist/src/download/wechat-article.js

@@ -0,0 +1,137 @@
+import { parse, serialize } from 'parse5';
+import { CommandExecutionError } from '../errors.js';
+export const MAX_WECHAT_HTML_BYTES = 10 * 1024 * 1024;
+export const MAX_WECHAT_NODES = 100_000;
+export const MAX_WECHAT_CODE_BLOCKS = 1_000;
+function isElement(node) {
+    return 'tagName' in node;
+}
+function attr(node, name) {
+    return node.attrs.find(item => item.name === name)?.value;
+}
+function hasClass(node, name) {
+    return (attr(node, 'class') || '').split(/\s+/).includes(name);
+}
+function safeUrl(value) {
+    const normalized = value.trim().startsWith('//') ? `https:${value.trim()}` : value.trim();
+    try {
+        const url = new URL(normalized);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function textContent(node) {
+    if ('value' in node)
+        return node.value;
+    if (!('childNodes' in node))
+        return '';
+    return node.childNodes.map(textContent).join('');
+}
+export function extractWechatArticleHtml(html) {
+    if (Buffer.byteLength(html, 'utf8') > MAX_WECHAT_HTML_BYTES) {
+        throw new CommandExecutionError('WeChat article HTML exceeds the 10 MiB limit');
+    }
+    const document = parse(html);
+    let content;
+    let nodes = 0;
+    let codeBlocks = 0;
+    const stack = [document];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        nodes += 1;
+        if (nodes > MAX_WECHAT_NODES)
+            throw new CommandExecutionError('WeChat article HTML exceeds the DOM node limit');
+        if (isElement(node)) {
+            if (attr(node, 'id') === 'js_content')
+                content = node;
+            if (node.tagName === 'pre') {
+                codeBlocks += 1;
+                if (codeBlocks > MAX_WECHAT_CODE_BLOCKS)
+                    throw new CommandExecutionError('WeChat article HTML exceeds the code block limit');
+            }
+        }
+        if ('childNodes' in node) {
+            for (let i = node.childNodes.length - 1; i >= 0; i -= 1)
+                stack.push(node.childNodes[i]);
+        }
+    }
+    if (!content)
+        throw new CommandExecutionError('WeChat article has no #js_content');
+    const parents = [content];
+    while (parents.length > 0) {
+        const parent = parents.pop();
+        parent.childNodes = parent.childNodes.filter(node => {
+            if (!isElement(node))
+                return true;
+            return !['script', 'style'].includes(node.tagName)
+                && !hasClass(node, 'qr_code_pc') && !hasClass(node, 'reward_area')
+                && !hasClass(node, 'code-snippet__line-index');
+        });
+        for (const node of parent.childNodes) {
+            if (isElement(node)) {
+                node.attrs = node.attrs.flatMap(item => {
+                    if (!['href', 'src', 'poster', 'data-src'].includes(item.name))
+                        return [item];
+                    const value = safeUrl(item.value);
+                    return value ? [{ ...item, value }] : [];
+                });
+                if (node.tagName === 'img') {
+                    const lazy = attr(node, 'data-src');
+                    if (lazy) {
+                        node.attrs = node.attrs.filter(item => !['src', 'data-src'].includes(item.name));
+                        node.attrs.push({ name: 'src', value: lazy });
+                    }
+                }
+                if (hasClass(node, 'code-snippet__fix')) {
+                    const descendants = [...node.childNodes].reverse();
+                    let pre;
+                    const lines = [];
+                    while (descendants.length > 0) {
+                        const descendant = descendants.pop();
+                        if (isElement(descendant)) {
+                            if (descendant.tagName === 'pre')
+                                pre = descendant;
+                            if (descendant.tagName === 'code') {
+                                const line = textContent(descendant);
+                                if (!/^[ce]?ounter\(line/.test(line))
+                                    lines.push(line);
+                                continue;
+                            }
+                        }
+                        if ('childNodes' in descendant) {
+                            for (let i = descendant.childNodes.length - 1; i >= 0; i -= 1)
+                                descendants.push(descendant.childNodes[i]);
+                        }
+                    }
+                    if (pre && lines.length > 0) {
+                        pre.childNodes = [{ nodeName: '#text', value: lines.join('\n'), parentNode: pre }];
+                    }
+                }
+                parents.push(node);
+            }
+        }
+    }
+    const imageUrls = [];
+    const seenImages = new Set();
+    const imageStack = [content];
+    while (imageStack.length > 0) {
+        const node = imageStack.pop();
+        if (isElement(node) && node.tagName === 'img') {
+            const src = attr(node, 'src');
+            if (src && !seenImages.has(src)) {
+                seenImages.add(src);
+                imageUrls.push(src);
+            }
+        }
+        if ('childNodes' in node) {
+            for (let i = node.childNodes.length - 1; i >= 0; i -= 1)
+                imageStack.push(node.childNodes[i]);
+        }
+    }
+    const fragment = {
+        nodeName: '#document-fragment', childNodes: content.childNodes,
+    };
+    return { contentHtml: serialize(fragment), imageUrls };
+}

package/dist/src/download/wechat-article.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/recorder/highlevel/verify.d.ts

@@ -29,6 +29,8 @@ export interface VerifyInput {
     trace?: 'off' | 'retain-on-failure' | 'always';
     /** N3:显式 adapter 路径 override —— verify 录制器 LLM 生成的临时草稿(不在 clis/),缺省按 name 派生。 */
     adapterPath?: string;
+    /** Optional lowercase SHA-256 expected for the exact adapter bytes the runner will execute. */
+    expectedSourceSha256?: string;
 }
 /** The runner boundary (08). M6 provides the real child-process implementation. */
 export interface RunnerPort {
@@ -42,6 +44,7 @@ export interface RunnerPort {
         trace: string;
         /** N3: explicit adapter path override (recorder draft verify); default = name→clis path. */
         adapterPath?: string;
+        expectedSourceSha256?: string;
     }): Promise<{
         requestId: string;
     }>;

package/dist/src/recorder/highlevel/verify.js

@@ -49,6 +49,9 @@ export async function verifyAdapter(input, sessionHmacKey, runner) {
         }
         adapterPath = abs;
     }
+    if (input.expectedSourceSha256 !== undefined && !/^[0-9a-f]{64}$/.test(input.expectedSourceSha256)) {
+        return { ok: false, errorCode: 'validation_failed', reason: 'expectedSourceSha256 must be 64 lowercase hex characters' };
+    }
     const port = runner ?? defaultRunnerPort();
     const rawSeedArgs = input.executionSeedArgs ?? {};
     const evidenceSeedArgs = deriveEvidenceSeedArgs(rawSeedArgs, sessionHmacKey);
@@ -61,6 +64,7 @@ export async function verifyAdapter(input, sessionHmacKey, runner) {
             fixture: input.fixture ?? 'ignore',
             trace: input.trace ?? 'retain-on-failure',
             adapterPath, // N3: validated draft path override (undefined → name→clis)
+            expectedSourceSha256: input.expectedSourceSha256,
         });
         return { ok: true, requestId };
     }

package/dist/src/recorder/highlevel/verify.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/recorder/http/handlers.js

@@ -142,7 +142,33 @@ export async function handleVerify(ctx, body) {
     const executionSeedArgs = body.executionSeedArgs && typeof body.executionSeedArgs === 'object' && !Array.isArray(body.executionSeedArgs)
         ? body.executionSeedArgs
         : undefined;
-    const input = { name, requestId, sessionId, executionSeedArgs, fixture, trace };
+    const adapterPathRaw = body.adapterPath;
+    const expectedSourceSha256Raw = body.expectedSourceSha256;
+    const invalidAdapterPath = adapterPathRaw !== undefined
+        && (typeof adapterPathRaw !== 'string' || adapterPathRaw.trim().length === 0);
+    const invalidExpectedSourceHash = expectedSourceSha256Raw !== undefined
+        && (typeof expectedSourceSha256Raw !== 'string' || !/^[0-9a-f]{64}$/.test(expectedSourceSha256Raw));
+    if (invalidAdapterPath || invalidExpectedSourceHash) {
+        ctx.registry.finalizeRequest(requestId, {
+            status: 'failed',
+            error: errorBody('validation_failed', 'adapterPath or expectedSourceSha256 is invalid'),
+        });
+        return { status: 202, body: accepted(requestId) };
+    }
+    const adapterPath = typeof adapterPathRaw === 'string' ? adapterPathRaw : undefined;
+    const expectedSourceSha256 = typeof expectedSourceSha256Raw === 'string'
+        ? expectedSourceSha256Raw
+        : undefined;
+    const input = {
+        name,
+        requestId,
+        sessionId,
+        executionSeedArgs,
+        fixture,
+        trace,
+        adapterPath,
+        expectedSourceSha256,
+    };
     const result = await verifyAdapter(input, sessionHmacKey, ctx.runner);
     if (!result.ok) {
         ctx.registry.finalizeRequest(requestId, { status: 'failed', error: errorBody(result.errorCode, result.reason) });

package/dist/src/recorder/runner/runner-port.js

@@ -252,6 +252,7 @@ export function createRunnerPort(opts = {}) {
                 requestId,
                 name: input.name,
                 adapterPath: input.adapterPath ?? resolveAdapterPath(input.name),
+                expectedSourceSha256: input.expectedSourceSha256,
                 executionSeedArgs: input.rawSeedArgs, // raw → input.json only
                 fixture: input.fixture,
                 trace: input.trace,

package/dist/src/recorder/runner/verify-runner-main.d.ts

@@ -23,6 +23,8 @@ export interface RunnerInput {
     name: string;
     /** Resolved adapter module file to import. */
     adapterPath: string;
+    /** Expected hash supplied by the caller; mismatch means the captured module is never loaded. */
+    expectedSourceSha256?: string;
     /** Browser profile contextId for browser adapters (M6b). Omitted → daemon default profile. */
     contextId?: string;
     /** Raw seed args — prepared before resolver/adapter calls and never echoed into events. */
@@ -47,7 +49,20 @@ export declare function installRunnerBackstops(maxRuntimeMs: number): void;
  * Load an adapter by importing its module (which registers via `cli()`), then look it up
  * in the registry by name. Mirrors execution.ts's lazy-import pattern (118-135).
  */
-export declare function loadAdapterByName(adapterPath: string, name: string): Promise<CliCommand | undefined>;
+export interface AdapterSourceSnapshot {
+    canonicalUrl: string;
+    source: ArrayBuffer;
+    sourceSha256: string;
+}
+/** Read the main module once. The same exact bytes are hashed and transferred to the ESM loader. */
+export declare function captureAdapterSource(adapterPath: string): AdapterSourceSnapshot;
+/** Import exactly the captured main-module bytes while preserving its canonical URL as import base. */
+export declare function loadAdapterSnapshot(snapshot: AdapterSourceSnapshot, name: string): Promise<CliCommand | undefined>;
+export interface VerifyRunnerDependencies {
+    capture?: (adapterPath: string) => AdapterSourceSnapshot | Promise<AdapterSourceSnapshot>;
+    load?: (snapshot: AdapterSourceSnapshot, name: string) => Promise<CliCommand | undefined>;
+    browserRunner?: BrowserAdapterRunner;
+}
 /**
  * The browser-adapter execution seam (M6b). A browser adapter's `func` needs an IPage; the
  * default implementation connects BACK to the running daemon for one. Injectable so unit
@@ -85,7 +100,7 @@ export declare function executeAdapterForVerify(command: CliCommand | undefined,
  * tests); `load` is injected so unit tests can supply an in-memory command. Never throws —
  * any failure becomes a terminal result so the parent always sees one and only one.
  */
-export declare function runVerifyRunner(input: RunnerInput, emit: (event: RunnerEvent) => void, load?: (adapterPath: string, name: string) => Promise<CliCommand | undefined>, browserRunner?: BrowserAdapterRunner): Promise<void>;
+export declare function runVerifyRunner(input: RunnerInput, emit: (event: RunnerEvent) => void, dependencies?: VerifyRunnerDependencies): Promise<void>;
 /**
  * Entry point for `bycli internal verify-runner --jsonl --request-id … --name … --input …`.
  * Writes JSONL events to the dedicated protocol fd (`--protocol-fd`, set by the parent RunnerPort

package/dist/src/recorder/runner/verify-runner-main.js

@@ -16,7 +16,8 @@
  * are echoed into the emitted result/started events.
  */
 import * as fs from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { register } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { getRegistry, } from '../../registry.js';
 import { prepareCommandArgsOrThrowArgumentError } from '../../execution.js';
@@ -78,14 +79,48 @@ function fieldCountOf(rows) {
     }
     return undefined;
 }
-/**
- * Load an adapter by importing its module (which registers via `cli()`), then look it up
- * in the registry by name. Mirrors execution.ts's lazy-import pattern (118-135).
- */
-export async function loadAdapterByName(adapterPath, name) {
-    const url = pathToFileURL(adapterPath).href; // runner-side; a bad path surfaces verbatim
+const SNAPSHOT_LOADER_URL = `data:text/javascript,${encodeURIComponent(`
+  let targetSpecifier = '';
+  let targetUrl = '';
+  let source = new ArrayBuffer(0);
+  export function initialize(data) {
+    targetSpecifier = data.targetSpecifier;
+    targetUrl = data.targetUrl;
+    source = data.source;
+  }
+  export async function resolve(specifier, context, nextResolve) {
+    if (specifier === targetSpecifier) {
+      return { url: targetUrl, shortCircuit: true };
+    }
+    return nextResolve(specifier, context);
+  }
+  export async function load(url, context, nextLoad) {
+    if (url === targetUrl) {
+      return { format: 'module', shortCircuit: true, source: new Uint8Array(source) };
+    }
+    return nextLoad(url, context);
+  }
+`)}`;
+/** Read the main module once. The same exact bytes are hashed and transferred to the ESM loader. */
+export function captureAdapterSource(adapterPath) {
+    const canonicalPath = fs.realpathSync(adapterPath);
+    const bytes = fs.readFileSync(canonicalPath);
+    const source = Uint8Array.from(bytes).buffer;
+    return {
+        canonicalUrl: pathToFileURL(canonicalPath).href,
+        source,
+        sourceSha256: createHash('sha256').update(new Uint8Array(source)).digest('hex'),
+    };
+}
+/** Import exactly the captured main-module bytes while preserving its canonical URL as import base. */
+export async function loadAdapterSnapshot(snapshot, name) {
     try {
-        await import(url);
+        const targetSpecifier = `bycli-verify-snapshot:${randomUUID()}`;
+        register(SNAPSHOT_LOADER_URL, import.meta.url, {
+            data: { targetSpecifier, targetUrl: snapshot.canonicalUrl, source: snapshot.source },
+            transferList: [snapshot.source],
+        });
+        await import(targetSpecifier);
     }
     catch (e) {
         // The adapter module's top-level code threw during evaluation (a SyntaxError, or a deliberate
@@ -189,29 +224,50 @@ export async function executeAdapterForVerify(command, opts) {
  * tests); `load` is injected so unit tests can supply an in-memory command. Never throws —
  * any failure becomes a terminal result so the parent always sees one and only one.
  */
-export async function runVerifyRunner(input, emit, load = loadAdapterByName, browserRunner) {
+export async function runVerifyRunner(input, emit, dependencies = {}) {
     emit({ type: 'started', requestId: input.requestId, pid: process.pid, stage: 'load' });
+    let sourceSha256;
     try {
-        const command = await load(input.adapterPath, input.name);
+        const capture = dependencies.capture ?? captureAdapterSource;
+        const load = dependencies.load ?? loadAdapterSnapshot;
+        const snapshot = await capture(input.adapterPath);
+        sourceSha256 = snapshot.sourceSha256;
+        if (input.expectedSourceSha256 !== undefined && input.expectedSourceSha256 !== sourceSha256) {
+            emit({
+                type: 'result', requestId: input.requestId, ok: false,
+                data: { stage: 'load', sourceSha256 },
+                error: { code: 'validation_failed', message: 'adapter source hash does not match expected source' },
+            });
+            return;
+        }
+        const command = await load(snapshot, input.name);
         const r = await executeAdapterForVerify(command, {
             name: input.name,
             fixture: input.fixture,
             trace: input.trace,
             seedArgs: input.executionSeedArgs ?? {},
             contextId: input.contextId,
-            browserRunner,
+            browserRunner: dependencies.browserRunner,
+        });
+        emit({
+            type: 'result', requestId: input.requestId, ok: r.ok,
+            data: { ...r.data, sourceSha256 },
+            error: r.ok ? null : r.error,
         });
-        emit({ type: 'result', requestId: input.requestId, ok: r.ok, data: r.data, error: r.ok ? null : r.error });
     }
     catch (e) {
-        // Load failure → single terminal result. An adapter-evaluation error (tagged by loadAdapterByName)
+        // Load failure → single terminal result. An adapter-evaluation error (tagged by loadAdapterSnapshot)
         // is adapter-controlled and may echo adapter-file contents, so its message is redacted; a
         // runner-side failure (bad path / resolve) is runner-generated and surfaces verbatim (Codex M7c).
         const adapterEval = e?.adapterEvaluation === true;
         const message = adapterEval ? REDACTED_ADAPTER_LOAD_MESSAGE : (e instanceof Error ? e.message : String(e));
         emit({
             type: 'result', requestId: input.requestId, ok: false,
-            data: { stage: 'load', trace: { policy: input.trace ?? 'retain-on-failure', retained: false, path: null } },
+            data: {
+                stage: 'load',
+                ...(sourceSha256 === undefined ? {} : { sourceSha256 }),
+                trace: { policy: input.trace ?? 'retain-on-failure', retained: false, path: null },
+            },
             error: { code: 'adapter_runtime_error', message, hint: 'adapter failed to load' },
         });
     }

package/dist/src/release-workflow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/weixin-built-in-docs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "publishConfig": {
     "access": "public"
   },
   "description": "Make any website or Electron App your CLI. AI-powered.",
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=20.6.0"
   },
   "type": "module",
   "workspaces": [
@@ -32,6 +32,7 @@
     "./download/article-download": "./dist/src/download/article-download.js",
     "./download/media-download": "./dist/src/download/media-download.js",
     "./download/progress": "./dist/src/download/progress.js",
+    "./download/wechat-article": "./dist/src/download/wechat-article.js",
     "./pipeline": "./dist/src/pipeline/index.js"
   },
   "files": [
@@ -66,6 +67,7 @@
     "advise:listing-id-pairing": "node scripts/check-listing-id-pairing.mjs",
     "check:silent-column-drop": "node scripts/check-silent-column-drop.mjs",
     "check:typed-error-lint": "node scripts/check-typed-error-lint.mjs",
+    "check:package-install": "node scripts/check-package-install.mjs",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs"
@@ -87,17 +89,19 @@
   },
   "dependencies": {
     "@mozilla/readability": "^0.6.0",
+    "@sovovs/bycli-recorder-core": "^0.1.0",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
     "js-yaml": "^4.1.0",
+    "parse5": "^7.3.0",
     "turndown": "^7.2.2",
     "turndown-plugin-gfm": "^1.0.2",
     "undici": "^6.25.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {
-    "@types/jsdom": "^27.0.0",
     "@types/js-yaml": "^4.0.9",
+    "@types/jsdom": "^27.0.0",
     "@types/node": "^25.5.2",
     "@types/turndown": "^5.0.6",
     "@types/ws": "^8.5.13",