@jackwener/opencli 1.6.1 → 1.6.3

package/dist/src/registry.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
+ */
+import type { IPage } from './types.js';
+export declare enum Strategy {
+    PUBLIC = "public",
+    COOKIE = "cookie",
+    HEADER = "header",
+    INTERCEPT = "intercept",
+    UI = "ui"
+}
+export interface Arg {
+    name: string;
+    type?: string;
+    default?: unknown;
+    required?: boolean;
+    valueRequired?: boolean;
+    positional?: boolean;
+    help?: string;
+    choices?: string[];
+}
+export interface RequiredEnv {
+    name: string;
+    help?: string;
+}
+export type CommandArgs = Record<string, any>;
+export interface CliCommand {
+    site: string;
+    name: string;
+    aliases?: string[];
+    description: string;
+    domain?: string;
+    strategy?: Strategy;
+    browser?: boolean;
+    args: Arg[];
+    columns?: string[];
+    func?: (page: IPage, kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
+    pipeline?: Record<string, unknown>[];
+    timeoutSeconds?: number;
+    /** Origin of this command: 'yaml', 'ts', or plugin name. */
+    source?: string;
+    footerExtra?: (kwargs: CommandArgs) => string | undefined;
+    requiredEnv?: RequiredEnv[];
+    validateArgs?: (kwargs: CommandArgs) => void;
+    /** Deprecation note shown in help / execution warnings. */
+    deprecated?: boolean | string;
+    /** Preferred replacement command, if any. */
+    replacedBy?: string;
+    /**
+     * Control pre-navigation for cookie/header context before command execution.
+     *
+     * Browser adapters using COOKIE/HEADER strategy need the page to be on the
+     * target domain so that `fetch(url, { credentials: 'include' })` carries cookies.
+     *
+     * - `undefined` / `true`: navigate to `https://${domain}` (default)
+     * - `false`: skip — adapter handles its own navigation (e.g. boss common.ts)
+     * - `string`: navigate to this specific URL instead of the domain root
+     */
+    navigateBefore?: boolean | string;
+    /** Override the default CLI output format when the user does not pass -f/--format. */
+    defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
+}
+/** Internal extension for lazy-loaded TS modules (not exposed in public API) */
+export interface InternalCliCommand extends CliCommand {
+    _lazy?: boolean;
+    _modulePath?: string;
+}
+export interface CliOptions extends Partial<Omit<CliCommand, 'args' | 'description'>> {
+    site: string;
+    name: string;
+    description?: string;
+    args?: Arg[];
+}
+declare global {
+    var __opencli_registry__: Map<string, CliCommand> | undefined;
+}
+export declare function cli(opts: CliOptions): CliCommand;
+export declare function getRegistry(): Map<string, CliCommand>;
+export declare function fullName(cmd: CliCommand): string;
+export declare function strategyLabel(cmd: CliCommand): string;
+export declare function registerCommand(cmd: CliCommand): void;

package/dist/src/runtime-detect.test.d.ts

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

package/dist/src/serialization.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Serialization and formatting helpers for CLI commands and args.
+ *
+ * Used by the `list` command, Commander --help, and build-manifest.
+ * Separated from registry.ts to keep the registry focused on types + registration.
+ */
+import type { Arg, CliCommand } from './registry.js';
+export type SerializedArg = {
+    name: string;
+    type: string;
+    required: boolean;
+    valueRequired: boolean;
+    positional: boolean;
+    choices: string[];
+    default: unknown;
+    help: string;
+};
+/** Stable arg schema — every field is always present (no sparse objects). */
+export declare function serializeArg(a: Arg): SerializedArg;
+/** Full command metadata for structured output (json/yaml). */
+export declare function serializeCommand(cmd: CliCommand): {
+    command: string;
+    site: string;
+    name: string;
+    aliases: string[];
+    description: string;
+    strategy: string;
+    browser: boolean;
+    args: SerializedArg[];
+    columns: string[];
+    domain: string | null;
+    deprecated: string | boolean | null;
+    replacedBy: string | null;
+};
+/** Human-readable arg summary: `<required> [optional]` style. */
+export declare function formatArgSummary(args: Arg[]): string;
+/** Generate the --help appendix showing registry metadata not exposed by Commander. */
+export declare function formatRegistryHelpText(cmd: CliCommand): string;

package/dist/src/serialization.js

@@ -0,0 +1,78 @@
+/**
+ * Serialization and formatting helpers for CLI commands and args.
+ *
+ * Used by the `list` command, Commander --help, and build-manifest.
+ * Separated from registry.ts to keep the registry focused on types + registration.
+ */
+import { fullName, strategyLabel } from './registry.js';
+/** Stable arg schema — every field is always present (no sparse objects). */
+export function serializeArg(a) {
+    return {
+        name: a.name,
+        type: a.type ?? 'string',
+        required: !!a.required,
+        valueRequired: !!a.valueRequired,
+        positional: !!a.positional,
+        choices: a.choices ?? [],
+        default: a.default ?? null,
+        help: a.help ?? '',
+    };
+}
+/** Full command metadata for structured output (json/yaml). */
+export function serializeCommand(cmd) {
+    return {
+        command: fullName(cmd),
+        site: cmd.site,
+        name: cmd.name,
+        aliases: cmd.aliases ?? [],
+        description: cmd.description,
+        strategy: strategyLabel(cmd),
+        browser: !!cmd.browser,
+        args: cmd.args.map(serializeArg),
+        columns: cmd.columns ?? [],
+        domain: cmd.domain ?? null,
+        deprecated: cmd.deprecated ?? null,
+        replacedBy: cmd.replacedBy ?? null,
+    };
+}
+// ── Formatting ──────────────────────────────────────────────────────────────
+/** Human-readable arg summary: `<required> [optional]` style. */
+export function formatArgSummary(args) {
+    return args
+        .map(a => {
+        if (a.positional)
+            return a.required ? `<${a.name}>` : `[${a.name}]`;
+        return a.required ? `--${a.name}` : `[--${a.name}]`;
+    })
+        .join(' ');
+}
+function summarizeChoices(choices) {
+    if (choices.length <= 4)
+        return choices.join(', ');
+    return `${choices.slice(0, 4).join(', ')}, ... (+${choices.length - 4} more)`;
+}
+/** Generate the --help appendix showing registry metadata not exposed by Commander. */
+export function formatRegistryHelpText(cmd) {
+    const lines = [];
+    const choicesArgs = cmd.args.filter(a => a.choices?.length);
+    for (const a of choicesArgs) {
+        const prefix = a.positional ? `<${a.name}>` : `--${a.name}`;
+        const def = a.default != null ? `  (default: ${a.default})` : '';
+        lines.push(`  ${prefix}: ${summarizeChoices(a.choices)}${def}`);
+    }
+    const meta = [];
+    meta.push(`Strategy: ${strategyLabel(cmd)}`);
+    meta.push(`Browser: ${cmd.browser ? 'yes' : 'no'}`);
+    if (cmd.domain)
+        meta.push(`Domain: ${cmd.domain}`);
+    if (cmd.deprecated)
+        meta.push(`Deprecated: ${typeof cmd.deprecated === 'string' ? cmd.deprecated : 'yes'}`);
+    if (cmd.replacedBy)
+        meta.push(`Use instead: ${cmd.replacedBy}`);
+    if (cmd.aliases?.length)
+        meta.push(`Aliases: ${cmd.aliases.join(', ')}`);
+    lines.push(meta.join(' | '));
+    if (cmd.columns?.length)
+        lines.push(`Output columns: ${cmd.columns.join(', ')}`);
+    return '\n' + lines.join('\n') + '\n';
+}

package/dist/src/serialization.test.d.ts

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

package/dist/src/synthesize.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Synthesize candidate CLIs from explore artifacts.
+ * Generates evaluate-based YAML pipelines (matching hand-written adapter patterns).
+ */
+import type { ExploreAuthSummary, ExploreEndpointArtifact, ExploreManifest } from './explore.js';
+interface RecommendedArg {
+    name: string;
+    type?: string;
+    required?: boolean;
+    default?: unknown;
+}
+interface StoreHint {
+    store: string;
+    action: string;
+}
+export interface SynthesizeCapability {
+    name: string;
+    description: string;
+    strategy: string;
+    confidence?: number;
+    endpoint?: string;
+    itemPath?: string | null;
+    recommendedColumns?: string[];
+    recommendedArgs?: RecommendedArg[];
+    storeHint?: StoreHint;
+}
+export interface GeneratedArgDefinition {
+    type: string;
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+}
+type CandidatePipelineStep = {
+    navigate: string;
+} | {
+    wait: number;
+} | {
+    evaluate: string;
+} | {
+    select: string;
+} | {
+    map: Record<string, string>;
+} | {
+    limit: string;
+} | {
+    fetch: {
+        url: string;
+    };
+} | {
+    tap: {
+        store: string;
+        action: string;
+        timeout: number;
+        capture?: string;
+        select?: string | null;
+    };
+};
+export interface CandidateYaml {
+    site: string;
+    name: string;
+    description: string;
+    domain: string;
+    strategy: string;
+    browser: boolean;
+    args: Record<string, GeneratedArgDefinition>;
+    pipeline: CandidatePipelineStep[];
+    columns: string[];
+}
+export interface SynthesizeCandidateSummary {
+    name: string;
+    path: string;
+    strategy: string;
+    confidence?: number;
+}
+export interface SynthesizeResult {
+    site: string;
+    explore_dir: string;
+    out_dir: string;
+    candidate_count: number;
+    candidates: SynthesizeCandidateSummary[];
+}
+interface LoadedExploreBundle {
+    manifest: ExploreManifest;
+    endpoints: ExploreEndpointArtifact[];
+    capabilities: SynthesizeCapability[];
+    auth: ExploreAuthSummary;
+}
+export declare function synthesizeFromExplore(target: string, opts?: {
+    outDir?: string;
+    top?: number;
+}): SynthesizeResult;
+export declare function renderSynthesizeSummary(result: SynthesizeResult): string;
+export declare function resolveExploreDir(target: string): string;
+export declare function loadExploreBundle(exploreDir: string): LoadedExploreBundle;
+export declare function buildCandidate(site: string, targetUrl: string, cap: SynthesizeCapability, endpoint: ExploreEndpointArtifact): {
+    name: string;
+    yaml: CandidateYaml;
+};
+export {};

package/dist/src/synthesize.js

@@ -0,0 +1,205 @@
+/**
+ * Synthesize candidate CLIs from explore artifacts.
+ * Generates evaluate-based YAML pipelines (matching hand-written adapter patterns).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { VOLATILE_PARAMS, SEARCH_PARAMS, LIMIT_PARAMS, PAGINATION_PARAMS } from './constants.js';
+export function synthesizeFromExplore(target, opts = {}) {
+    const exploreDir = resolveExploreDir(target);
+    const bundle = loadExploreBundle(exploreDir);
+    const targetDir = opts.outDir ?? path.join(exploreDir, 'candidates');
+    fs.mkdirSync(targetDir, { recursive: true });
+    const site = bundle.manifest.site;
+    const capabilities = (bundle.capabilities ?? [])
+        .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0))
+        .slice(0, opts.top ?? 3);
+    const candidates = [];
+    for (const cap of capabilities) {
+        const endpoint = chooseEndpoint(cap, bundle.endpoints);
+        if (!endpoint)
+            continue;
+        const candidate = buildCandidateYaml(site, bundle.manifest, cap, endpoint);
+        const filePath = path.join(targetDir, `${candidate.name}.yaml`);
+        fs.writeFileSync(filePath, yaml.dump(candidate.yaml, { sortKeys: false, lineWidth: 120 }));
+        candidates.push({ name: candidate.name, path: filePath, strategy: cap.strategy, confidence: cap.confidence });
+    }
+    const index = { site, target_url: bundle.manifest.target_url, generated_from: exploreDir, candidate_count: candidates.length, candidates };
+    fs.writeFileSync(path.join(targetDir, 'candidates.json'), JSON.stringify(index, null, 2));
+    return { site, explore_dir: exploreDir, out_dir: targetDir, candidate_count: candidates.length, candidates };
+}
+export function renderSynthesizeSummary(result) {
+    const lines = ['opencli synthesize: OK', `Site: ${result.site}`, `Source: ${result.explore_dir}`, `Candidates: ${result.candidate_count}`];
+    for (const c of result.candidates ?? [])
+        lines.push(`  • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}% confidence) → ${c.path}`);
+    return lines.join('\n');
+}
+export function resolveExploreDir(target) {
+    if (fs.existsSync(target))
+        return target;
+    const candidate = path.join('.opencli', 'explore', target);
+    if (fs.existsSync(candidate))
+        return candidate;
+    throw new Error(`Explore directory not found: ${target}`);
+}
+export function loadExploreBundle(exploreDir) {
+    return {
+        manifest: JSON.parse(fs.readFileSync(path.join(exploreDir, 'manifest.json'), 'utf-8')),
+        endpoints: JSON.parse(fs.readFileSync(path.join(exploreDir, 'endpoints.json'), 'utf-8')),
+        capabilities: JSON.parse(fs.readFileSync(path.join(exploreDir, 'capabilities.json'), 'utf-8')),
+        auth: JSON.parse(fs.readFileSync(path.join(exploreDir, 'auth.json'), 'utf-8')),
+    };
+}
+function chooseEndpoint(cap, endpoints) {
+    if (!endpoints.length)
+        return null;
+    // Match by endpoint pattern from capability
+    if (cap.endpoint) {
+        const endpointPattern = cap.endpoint;
+        const match = endpoints.find((endpoint) => endpoint.pattern === endpointPattern || endpoint.url?.includes(endpointPattern));
+        if (match)
+            return match;
+    }
+    return [...endpoints].sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
+}
+// ── URL templating ─────────────────────────────────────────────────────────
+function buildTemplatedUrl(rawUrl, cap, _endpoint) {
+    try {
+        const u = new URL(rawUrl);
+        const base = `${u.protocol}//${u.host}${u.pathname}`;
+        const params = [];
+        const hasKeyword = cap.recommendedArgs?.some((arg) => arg.name === 'keyword');
+        u.searchParams.forEach((v, k) => {
+            if (VOLATILE_PARAMS.has(k))
+                return;
+            if (hasKeyword && SEARCH_PARAMS.has(k))
+                params.push([k, '${{ args.keyword }}']);
+            else if (LIMIT_PARAMS.has(k))
+                params.push([k, '${{ args.limit | default(20) }}']);
+            else if (PAGINATION_PARAMS.has(k))
+                params.push([k, '${{ args.page | default(1) }}']);
+            else
+                params.push([k, v]);
+        });
+        return params.length ? base + '?' + params.map(([k, v]) => `${k}=${v}`).join('&') : base;
+    }
+    catch {
+        return rawUrl;
+    }
+}
+/**
+ * Build inline evaluate script for browser-based fetch+parse.
+ * Follows patterns from bilibili/hot.yaml and twitter/trending.yaml.
+ */
+function buildEvaluateScript(url, itemPath, endpoint) {
+    const pathChain = itemPath.split('.').map((p) => `?.${p}`).join('');
+    const detectedFields = endpoint?.detectedFields ?? {};
+    const hasFields = Object.keys(detectedFields).length > 0;
+    let mapCode = '';
+    if (hasFields) {
+        const mappings = Object.entries(detectedFields)
+            .map(([role, field]) => `      ${role}: item${String(field).split('.').map(p => `?.${p}`).join('')}`)
+            .join(',\n');
+        mapCode = `.map((item) => ({\n${mappings}\n    }))`;
+    }
+    return [
+        '(async () => {',
+        `  const res = await fetch(${JSON.stringify(url)}, {`,
+        `    credentials: 'include'`,
+        '  });',
+        '  const data = await res.json();',
+        `  return (data${pathChain} || [])${mapCode};`,
+        '})()\n',
+    ].join('\n');
+}
+// ── YAML pipeline generation ───────────────────────────────────────────────
+function buildCandidateYaml(site, manifest, cap, endpoint) {
+    const needsBrowser = cap.strategy !== 'public';
+    const pipeline = [];
+    const templatedUrl = buildTemplatedUrl(endpoint?.url ?? manifest.target_url, cap, endpoint);
+    let domain = '';
+    try {
+        domain = new URL(manifest.target_url).hostname;
+    }
+    catch { }
+    if (cap.strategy === 'store-action' && cap.storeHint) {
+        // Store Action: navigate + wait + tap (declarative, clean)
+        pipeline.push({ navigate: manifest.target_url });
+        pipeline.push({ wait: 3 });
+        const tapStep = {
+            store: cap.storeHint.store,
+            action: cap.storeHint.action,
+            timeout: 8,
+        };
+        // Infer capture pattern from endpoint URL
+        if (endpoint?.url) {
+            try {
+                const epUrl = new URL(endpoint.url);
+                const pathParts = epUrl.pathname.split('/').filter((p) => p);
+                // Use last meaningful path segment as capture pattern
+                const capturePart = pathParts.filter((p) => !p.match(/^v\d+$/)).pop();
+                if (capturePart)
+                    tapStep.capture = capturePart;
+            }
+            catch { }
+        }
+        if (cap.itemPath)
+            tapStep.select = cap.itemPath;
+        pipeline.push({ tap: tapStep });
+    }
+    else if (needsBrowser) {
+        // Browser-based: navigate + evaluate (like bilibili/hot.yaml, twitter/trending.yaml)
+        pipeline.push({ navigate: manifest.target_url });
+        const itemPath = cap.itemPath ?? 'data.data.list';
+        pipeline.push({ evaluate: buildEvaluateScript(templatedUrl, itemPath, endpoint) });
+    }
+    else {
+        // Public API: direct fetch (like hackernews/top.yaml)
+        pipeline.push({ fetch: { url: templatedUrl } });
+        if (cap.itemPath)
+            pipeline.push({ select: cap.itemPath });
+    }
+    // Map fields
+    const mapStep = {};
+    const columns = cap.recommendedColumns ?? ['title', 'url'];
+    if (!cap.recommendedArgs?.some((arg) => arg.name === 'keyword'))
+        mapStep['rank'] = '${{ index + 1 }}';
+    const detectedFields = endpoint?.detectedFields ?? {};
+    for (const col of columns) {
+        const fieldPath = detectedFields[col];
+        mapStep[col] = fieldPath ? `\${{ item.${fieldPath} }}` : `\${{ item.${col} }}`;
+    }
+    pipeline.push({ map: mapStep });
+    pipeline.push({ limit: '${{ args.limit | default(20) }}' });
+    // Args
+    const argsDef = {};
+    for (const arg of cap.recommendedArgs ?? []) {
+        const def = { type: arg.type ?? 'str' };
+        if (arg.required)
+            def.required = true;
+        if (arg.default != null)
+            def.default = arg.default;
+        if (arg.name === 'keyword')
+            def.description = 'Search keyword';
+        else if (arg.name === 'limit')
+            def.description = 'Number of items to return';
+        else if (arg.name === 'page')
+            def.description = 'Page number';
+        argsDef[arg.name] = def;
+    }
+    if (!argsDef['limit'])
+        argsDef['limit'] = { type: 'int', default: 20, description: 'Number of items to return' };
+    return {
+        name: cap.name,
+        yaml: {
+            site, name: cap.name, description: `${cap.description || site + ' ' + cap.name} (auto-generated)`,
+            domain, strategy: cap.strategy, browser: needsBrowser,
+            args: argsDef, pipeline, columns: Object.keys(mapStep),
+        },
+    };
+}
+export function buildCandidate(site, targetUrl, cap, endpoint) {
+    const manifest = { target_url: targetUrl, final_url: targetUrl };
+    return buildCandidateYaml(site, manifest, cap, endpoint);
+}

package/dist/src/tui.test.d.ts

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

package/dist/src/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Page interface: type-safe abstraction over browser page.
+ *
+ * All pipeline steps and CLI adapters should use this interface
+ * instead of `any` for browser interactions.
+ */
+export interface BrowserCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    expirationDate?: number;
+}
+export interface SnapshotOptions {
+    interactive?: boolean;
+    compact?: boolean;
+    maxDepth?: number;
+    raw?: boolean;
+    viewportExpand?: number;
+    maxTextLength?: number;
+}
+export interface WaitOptions {
+    text?: string;
+    selector?: string;
+    time?: number;
+    timeout?: number;
+}
+export interface ScreenshotOptions {
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    fullPage?: boolean;
+    path?: string;
+}
+export interface BrowserSessionInfo {
+    workspace?: string;
+    connected?: boolean;
+    [key: string]: unknown;
+}
+export interface IPage {
+    goto(url: string, options?: {
+        waitUntil?: 'load' | 'none';
+        settleMs?: number;
+    }): Promise<void>;
+    evaluate(js: string): Promise<any>;
+    getCookies(opts?: {
+        domain?: string;
+        url?: string;
+    }): Promise<BrowserCookie[]>;
+    snapshot(opts?: SnapshotOptions): Promise<any>;
+    click(ref: string): Promise<void>;
+    typeText(ref: string, text: string): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    scrollTo(ref: string): Promise<any>;
+    getFormState(): Promise<any>;
+    wait(options: number | WaitOptions): Promise<void>;
+    tabs(): Promise<any>;
+    closeTab?(index?: number): Promise<void>;
+    newTab?(): Promise<void>;
+    selectTab(index: number): Promise<void>;
+    networkRequests(includeStatic?: boolean): Promise<any>;
+    consoleMessages(level?: string): Promise<any>;
+    scroll(direction?: string, amount?: number): Promise<void>;
+    autoScroll(options?: {
+        times?: number;
+        delayMs?: number;
+    }): Promise<void>;
+    installInterceptor(pattern: string): Promise<void>;
+    getInterceptedRequests(): Promise<any[]>;
+    waitForCapture(timeout?: number): Promise<void>;
+    screenshot(options?: ScreenshotOptions): Promise<string>;
+    startNetworkCapture?(pattern?: string): Promise<void>;
+    readNetworkCapture?(): Promise<unknown[]>;
+    /**
+     * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
+     * Chrome reads the files directly — no base64 encoding or payload size limits.
+     */
+    setFileInput?(files: string[], selector?: string): Promise<void>;
+    /**
+     * Insert text via native CDP Input.insertText into the currently focused element.
+     * Useful for rich editors that ignore synthetic DOM value/text mutations.
+     */
+    insertText?(text: string): Promise<void>;
+    closeWindow?(): Promise<void>;
+    /** Returns the current page URL, or null if unavailable. */
+    getCurrentUrl?(): Promise<string | null>;
+    /** Returns the active tab ID, or undefined if not yet resolved. */
+    getActiveTabId?(): number | undefined;
+    /** Send a raw CDP command via chrome.debugger passthrough. */
+    cdp?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** Click at native coordinates via CDP Input.dispatchMouseEvent. */
+    nativeClick?(x: number, y: number): Promise<void>;
+    /** Type text via CDP Input.insertText. */
+    nativeType?(text: string): Promise<void>;
+    /** Press a key via CDP Input.dispatchKeyEvent. */
+    nativeKeyPress?(key: string, modifiers?: string[]): Promise<void>;
+}

package/dist/src/weixin-download.test.d.ts

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

package/dist/src/weixin-download.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+async function loadModule() {
+    return import('../clis/weixin/download.js');
+}
+describe('weixin publish time extraction', () => {
+    it('prefers publish_time text over create_time-like date strings', async () => {
+        const mod = await loadModule();
+        expect(mod.extractWechatPublishTime('2026年3月24日 22:38', 'var create_time = "2026年3月24日 22:38";')).toBe('2026年3月24日 22:38');
+    });
+    it('falls back to unix timestamp create_time values', async () => {
+        const mod = await loadModule();
+        expect(mod.extractWechatPublishTime('', 'var create_time = "1711291080";')).toBe('2024-03-24 22:38:00');
+    });
+    it('rejects malformed create_time values', async () => {
+        const mod = await loadModule();
+        expect(mod.extractWechatPublishTime('', 'var create_time = "2026年3月24日 22:38";')).toBe('');
+        expect(mod.extractWechatPublishTime('', 'var create_time = "1711291080abc";')).toBe('');
+        expect(mod.extractWechatPublishTime('', 'var create_time = "17112910800";')).toBe('');
+    });
+    it('builds a self-contained browser helper that matches fallback behavior', async () => {
+        const mod = await loadModule();
+        const extractInPage = eval(mod.buildExtractWechatPublishTimeJs());
+        expect(extractInPage('', 'var create_time = "1711291080";')).toBe('2024-03-24 22:38:00');
+    });
+    it('browser helper still prefers DOM publish_time text', async () => {
+        const mod = await loadModule();
+        const extractInPage = eval(mod.buildExtractWechatPublishTimeJs());
+        expect(extractInPage('2026年3月24日 22:38', 'var create_time = "1711291080";')).toBe('2026年3月24日 22:38');
+    });
+    it('detects WeChat verification gate pages', async () => {
+        const mod = await loadModule();
+        expect(mod.detectWechatAccessIssue('环境异常 当前环境异常，完成验证后即可继续访问。 去验证', '<html><body><a id="js_verify">去验证</a></body></html>')).toBe('environment verification required');
+    });
+    it('browser access detector matches the server-side verifier', async () => {
+        const mod = await loadModule();
+        const detectInPage = eval(mod.buildDetectWechatAccessIssueJs());
+        expect(detectInPage('环境异常 当前环境异常，完成验证后即可继续访问。 去验证', '<html>secitptpage/verify.html<a id="js_verify">去验证</a></html>')).toBe('environment verification required');
+    });
+    it('picks the first non-empty WeChat metadata field', async () => {
+        const mod = await loadModule();
+        expect(mod.pickFirstWechatMetaText('', 'Name cleared', '数字生命卡兹克')).toBe('数字生命卡兹克');
+        expect(mod.pickFirstWechatMetaText('', '  聊聊刚刚上线的PixVerse V6视频模型。  ')).toBe('聊聊刚刚上线的PixVerse V6视频模型。');
+    });
+});