@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/update-check.js

@@ -0,0 +1,112 @@
+/**
+ * Non-blocking update checker.
+ *
+ * Pattern: register exit-hook + kick-off-background-fetch
+ * - On startup: kick off background fetch (non-blocking)
+ * - On process exit: read cache, print notice if newer version exists
+ * - Check interval: 24 hours
+ * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
+ * - Never delays or blocks the CLI command
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import chalk from 'chalk';
+import { PKG_VERSION } from './version.js';
+const CACHE_DIR = path.join(os.homedir(), '.opencli');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@jackwener/opencli/latest';
+// Read cache once at module load — shared by both exported functions
+const _cache = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+})();
+function writeCache(latestVersion) {
+    try {
+        fs.mkdirSync(CACHE_DIR, { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify({ lastCheck: Date.now(), latestVersion }), 'utf-8');
+    }
+    catch {
+        // Best-effort; never fail
+    }
+}
+/** Compare semver strings. Returns true if `a` is strictly newer than `b`. */
+function isNewer(a, b) {
+    const parse = (v) => v.replace(/^v/, '').split('-')[0].split('.').map(Number);
+    const pa = parse(a);
+    const pb = parse(b);
+    if (pa.some(isNaN) || pb.some(isNaN))
+        return false;
+    const [aMaj, aMin, aPat] = pa;
+    const [bMaj, bMin, bPat] = pb;
+    if (aMaj !== bMaj)
+        return aMaj > bMaj;
+    if (aMin !== bMin)
+        return aMin > bMin;
+    return aPat > bPat;
+}
+function isCI() {
+    return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION);
+}
+/**
+ * Register a process exit hook that prints an update notice if a newer
+ * version was found on the last background check.
+ * Notice appears after command output — same pattern as npm/gh/yarn.
+ * Skipped during --get-completions to avoid polluting shell completion output.
+ */
+export function registerUpdateNoticeOnExit() {
+    if (isCI())
+        return;
+    if (process.argv.includes('--get-completions'))
+        return;
+    process.on('exit', (code) => {
+        if (code !== 0)
+            return; // Don't show update notice on error exit
+        if (!_cache)
+            return;
+        if (!isNewer(_cache.latestVersion, PKG_VERSION))
+            return;
+        try {
+            process.stderr.write(chalk.yellow(`\n  Update available: v${PKG_VERSION} → v${_cache.latestVersion}\n`) +
+                chalk.dim(`  Run: npm install -g @jackwener/opencli\n\n`));
+        }
+        catch {
+            // Ignore broken pipe (stderr closed before process exits)
+        }
+    });
+}
+/**
+ * Kick off a background fetch to npm registry. Writes to cache for next run.
+ * Fully non-blocking — never awaited.
+ */
+export function checkForUpdateBackground() {
+    if (isCI())
+        return;
+    if (_cache && Date.now() - _cache.lastCheck < CHECK_INTERVAL_MS)
+        return;
+    void (async () => {
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 3000);
+            const res = await fetch(NPM_REGISTRY_URL, {
+                signal: controller.signal,
+                headers: { 'User-Agent': `opencli/${PKG_VERSION}` },
+            });
+            clearTimeout(timer);
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            if (typeof data.version === 'string') {
+                writeCache(data.version);
+            }
+        }
+        catch {
+            // Network error: silently skip, try again next run
+        }
+    })();
+}

package/vendor/opencli/dist/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared utility functions used across the codebase.
+ */
+/** Type guard: checks if a value is a non-null, non-array object. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Simple async concurrency limiter. */
+export declare function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/** Pause for the given number of milliseconds. */
+export declare function sleep(ms: number): Promise<void>;
+/** Save a base64-encoded string to a file, creating parent directories as needed. */
+export declare function saveBase64ToFile(base64: string, filePath: string): Promise<void>;

package/vendor/opencli/dist/utils.js

@@ -0,0 +1,33 @@
+/**
+ * Shared utility functions used across the codebase.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Type guard: checks if a value is a non-null, non-array object. */
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Simple async concurrency limiter. */
+export async function mapConcurrent(items, limit, fn) {
+    const results = new Array(items.length);
+    let index = 0;
+    async function worker() {
+        while (index < items.length) {
+            const i = index++;
+            results[i] = await fn(items[i], i);
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+/** Pause for the given number of milliseconds. */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/** Save a base64-encoded string to a file, creating parent directories as needed. */
+export async function saveBase64ToFile(base64, filePath) {
+    const dir = path.dirname(filePath);
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(filePath, Buffer.from(base64, 'base64'));
+}

package/vendor/opencli/dist/validate.d.ts

@@ -0,0 +1,14 @@
+export interface FileValidationResult {
+    path: string;
+    errors: string[];
+    warnings: string[];
+}
+export interface ValidationReport {
+    ok: boolean;
+    results: FileValidationResult[];
+    errors: number;
+    warnings: number;
+    files: number;
+}
+export declare function validateClisWithTarget(dirs: string[], target?: string): ValidationReport;
+export declare function renderValidationReport(report: ValidationReport): string;

package/vendor/opencli/dist/validate.js

@@ -0,0 +1,96 @@
+/** Validate CLI definitions. */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { getErrorMessage } from './errors.js';
+/** All recognized pipeline step names */
+const KNOWN_STEP_NAMES = new Set([
+    'navigate', 'click', 'type', 'wait', 'press', 'snapshot',
+    'fetch', 'evaluate',
+    'select', 'map', 'filter', 'sort', 'limit',
+    'intercept', 'tap', 'download',
+]);
+import { isRecord } from './utils.js';
+export function validateClisWithTarget(dirs, target) {
+    const results = [];
+    let errors = 0;
+    let warnings = 0;
+    let files = 0;
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const site of fs.readdirSync(dir)) {
+            if (target && site !== target && !target.startsWith(site + '/'))
+                continue;
+            const siteDir = path.join(dir, site);
+            if (!fs.statSync(siteDir).isDirectory())
+                continue;
+            for (const file of fs.readdirSync(siteDir)) {
+                if (!file.endsWith('.yaml') && !file.endsWith('.yml'))
+                    continue;
+                if (target && target.includes('/') && !target.endsWith(file.replace(/\.(yaml|yml)$/, '')))
+                    continue;
+                files++;
+                const filePath = path.join(siteDir, file);
+                const r = validateYamlFile(filePath);
+                results.push(r);
+                errors += r.errors.length;
+                warnings += r.warnings.length;
+            }
+        }
+    }
+    return { ok: errors === 0, results, errors, warnings, files };
+}
+function validateYamlFile(filePath) {
+    const errors = [];
+    const warnings = [];
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const def = yaml.load(raw);
+        if (!isRecord(def)) {
+            errors.push('Not a valid YAML object');
+            return { path: filePath, errors, warnings };
+        }
+        if (!def.site)
+            errors.push('Missing "site"');
+        if (!def.name)
+            errors.push('Missing "name"');
+        if (def.pipeline && !Array.isArray(def.pipeline))
+            errors.push('"pipeline" must be an array');
+        if (def.columns && !Array.isArray(def.columns))
+            errors.push('"columns" must be an array');
+        if (def.args && typeof def.args !== 'object')
+            errors.push('"args" must be an object');
+        // Validate pipeline step names (catch typos like 'navaigate')
+        if (Array.isArray(def.pipeline)) {
+            for (let i = 0; i < def.pipeline.length; i++) {
+                const step = def.pipeline[i];
+                if (step && typeof step === 'object') {
+                    const stepKeys = Object.keys(step);
+                    for (const key of stepKeys) {
+                        if (!KNOWN_STEP_NAMES.has(key)) {
+                            warnings.push(`Pipeline step ${i}: unknown step name "${key}" (did you mean one of: ${[...KNOWN_STEP_NAMES].join(', ')}?)`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`YAML parse error: ${getErrorMessage(e)}`);
+    }
+    return { path: filePath, errors, warnings };
+}
+export function renderValidationReport(report) {
+    const lines = [`opencli validate: ${report.ok ? 'PASS' : 'FAIL'}`, `Checked ${report.results.length} CLI(s) in ${report.files} file(s)`, `Errors: ${report.errors}  Warnings: ${report.warnings}`];
+    for (const r of report.results) {
+        if (r.errors.length > 0 || r.warnings.length > 0) {
+            lines.push(`\n${r.path}:`);
+            for (const e of r.errors)
+                lines.push(`  ❌ ${e}`);
+            for (const w of r.warnings)
+                lines.push(`  ⚠️  ${w}`);
+        }
+    }
+    return lines.join('\n');
+}

package/vendor/opencli/dist/verify.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Verification: runs validation and optional smoke test.
+ *
+ * The smoke test is intentionally kept as a stub — full browser-based
+ * smoke testing requires a running browser session and is better suited
+ * to the `opencli test` command or CI pipelines.
+ */
+import { type ValidationReport } from './validate.js';
+export interface VerifyOptions {
+    builtinClis: string;
+    userClis: string;
+    target?: string;
+    smoke?: boolean;
+}
+export interface VerifyReport {
+    ok: boolean;
+    validation: ValidationReport;
+    smoke: null | {
+        requested: boolean;
+        executed: boolean;
+        ok: boolean;
+        summary: string;
+    };
+}
+export declare function verifyClis(opts: VerifyOptions): Promise<VerifyReport>;
+export declare function renderVerifyReport(report: VerifyReport): string;

package/vendor/opencli/dist/verify.js

@@ -0,0 +1,67 @@
+/**
+ * Verification: runs validation and optional smoke test.
+ *
+ * The smoke test is intentionally kept as a stub — full browser-based
+ * smoke testing requires a running browser session and is better suited
+ * to the `opencli test` command or CI pipelines.
+ */
+import { validateClisWithTarget, renderValidationReport } from './validate.js';
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export async function verifyClis(opts) {
+    const report = validateClisWithTarget([opts.builtinClis, opts.userClis], opts.target);
+    let smoke = null;
+    if (opts.smoke) {
+        smoke = await runSmokeTests(opts.builtinClis);
+    }
+    return { ok: report.ok && (smoke?.ok ?? true), validation: report, smoke };
+}
+export function renderVerifyReport(report) {
+    const base = renderValidationReport(report.validation);
+    if (!report.smoke)
+        return base;
+    const status = report.smoke.ok ? 'PASS' : 'FAIL';
+    const mode = report.smoke.executed ? 'executed' : 'skipped';
+    return `${base}\nSmoke: ${status} (${mode}) — ${report.smoke.summary}`;
+}
+async function runSmokeTests(builtinClis) {
+    const projectRoot = path.resolve(builtinClis, '..', '..');
+    const smokeDir = path.join(projectRoot, 'tests', 'smoke');
+    if (!fs.existsSync(smokeDir)) {
+        return {
+            requested: true,
+            executed: false,
+            ok: false,
+            summary: 'Smoke tests are unavailable in this package/environment.',
+        };
+    }
+    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    return new Promise((resolve) => {
+        const child = spawn(npx, ['vitest', 'run', 'tests/smoke/', '--reporter=dot'], {
+            cwd: projectRoot,
+            env: { ...process.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            resolve({
+                requested: true,
+                executed: false,
+                ok: false,
+                summary: `Failed to start smoke tests: ${error.message}`,
+            });
+        });
+        child.on('close', (code) => {
+            resolve({
+                requested: true,
+                executed: true,
+                ok: code === 0,
+                summary: code === 0 ? 'tests/smoke passed' : (stderr.trim() || `vitest exited with code ${code}`),
+            });
+        });
+    });
+}

package/vendor/opencli/dist/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Single source of truth for package version.
+ */
+export declare const PKG_VERSION: string;

package/vendor/opencli/dist/version.js

@@ -0,0 +1,16 @@
+/**
+ * Single source of truth for package version.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgJsonPath = path.resolve(__dirname, '..', 'package.json');
+export const PKG_VERSION = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8')).version;
+    }
+    catch {
+        return '0.0.0';
+    }
+})();

package/vendor/opencli/dist/weixin-download.test.d.ts

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

package/vendor/opencli/dist/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视频模型。');
+    });
+});

package/vendor/opencli/dist/yaml-schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared YAML CLI definition types.
+ * Used by both discovery.ts (runtime) and build-manifest.ts (build-time).
+ */
+export interface YamlArgDefinition {
+    type?: string;
+    default?: unknown;
+    required?: boolean;
+    positional?: boolean;
+    description?: string;
+    help?: string;
+    choices?: string[];
+}
+export interface YamlCliDefinition {
+    site?: string;
+    name?: string;
+    description?: string;
+    domain?: string;
+    strategy?: string;
+    browser?: boolean;
+    args?: Record<string, YamlArgDefinition>;
+    columns?: string[];
+    pipeline?: Record<string, unknown>[];
+    timeout?: number;
+    navigateBefore?: boolean | string;
+}
+import type { Arg } from './registry.js';
+/** Convert YAML args definition to the internal Arg[] format. */
+export declare function parseYamlArgs(args: Record<string, YamlArgDefinition> | undefined): Arg[];

package/vendor/opencli/dist/yaml-schema.js

@@ -0,0 +1,22 @@
+/**
+ * Shared YAML CLI definition types.
+ * Used by both discovery.ts (runtime) and build-manifest.ts (build-time).
+ */
+/** Convert YAML args definition to the internal Arg[] format. */
+export function parseYamlArgs(args) {
+    if (!args || typeof args !== 'object')
+        return [];
+    const result = [];
+    for (const [argName, argDef] of Object.entries(args)) {
+        result.push({
+            name: argName,
+            type: argDef?.type ?? 'str',
+            default: argDef?.default,
+            required: argDef?.required ?? false,
+            positional: argDef?.positional ?? false,
+            help: argDef?.description ?? argDef?.help ?? '',
+            choices: argDef?.choices,
+        });
+    }
+    return result;
+}