e10-ebuilder-prototype 0.5.0

package/dist/index.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { CaptureError, errorInfo, VERSION } from './common.js';
+import { Store } from './store.js';
+import { fetchPages, fetchCatalog } from './platform.js';
+import { capture, launchChrome } from './capture.js';
+import { pack } from './archive.js';
+import { nextHtml, acceptHtml, failHtml, retryHtml } from './html.js';
+import { discoverMenus } from './menus.js';
+import { collectForms } from './forms.js';
+import { applicationInput } from './application.js';
+import { readEnvironmentAuthContext, readEnvironmentAuthStatus, readActiveEnvironmentAuthProfile, setEnvironmentAuth, verifyEnvironmentAuth, listEnvironmentAuthProfiles, useEnvironmentAuthProfile, } from './vendor/environment-auth.js';
+const spec = {
+    json: { type: 'boolean' },
+    help: { type: 'boolean' },
+    version: { type: 'boolean' },
+    'app-id': { type: 'string' },
+    'app-url': { type: 'string' },
+    'allow-temporary-records': { type: 'boolean' },
+    kind: { type: 'string' },
+    dir: { type: 'string' },
+    concurrency: { type: 'string' },
+    width: { type: 'string' },
+    height: { type: 'string' },
+    'timeout-ms': { type: 'string' },
+    'stable-ms': { type: 'string' },
+    retries: { type: 'string' },
+    'base-url': { type: 'string' },
+    eteamsid: { type: 'string' },
+    'eteamsid-stdin': { type: 'boolean' },
+    local: { type: 'boolean' },
+    'page-id': { type: 'string' },
+    token: { type: 'string' },
+    reason: { type: 'string' },
+};
+let secret = '';
+const safeAuth = (s) => ({
+    authenticated: s.authenticated,
+    status: s.status,
+    profile: s.profile,
+    baseUrl: s.baseUrl,
+    userId: s.userId,
+    tenantKey: s.tenantKey,
+});
+const help = `e10-ebuilder-prototype ${VERSION}
+run --app-id ID --dir DIR [--concurrency 4] [--json]
+run --app-url URL --dir DIR [--json]
+init --app-id ID --dir DIR [--allow-temporary-records]
+next|status|discover|collect|capture|pack|retry --dir DIR
+html next --dir DIR (allocate/resume up to concurrency host-AI jobs)
+html accept --dir DIR --kind page|form --page-id ID --token TOKEN
+html fail --dir DIR --kind page|form --page-id ID --token TOKEN --reason TEXT
+html retry --dir DIR [--kind page|form --page-id ID] (retry failures, or regenerate one target)
+run pauses at HTML for host AI; after accept, run/pack builds the ZIP.
+retry: retry failed pages and rebuild archive; run resumes interrupted work.
+auth set --base-url URL --eteamsid-stdin (also supports --eteamsid VALUE)
+auth status [--local]
+auth profile list|current|use NAME
+doctor
+Options: --width 1440 --height 900 --timeout-ms 10000 --stable-ms 800 --retries 1
+NEXT: run --app-id ID --dir DIR`;
+async function main() {
+    const { values: v, positionals: pos } = parseArgs({
+        options: spec,
+        allowPositionals: true,
+        strict: true,
+    });
+    const command = pos[0];
+    const output = (value) => {
+        if (v.json)
+            console.log(JSON.stringify(value));
+        else {
+            const { next, fix, ...rest } = value;
+            console.log(JSON.stringify(rest, null, 2));
+            if (fix)
+                console.log(`FIX: ${fix}`);
+            console.log(`NEXT: ${next || 'none'}`);
+        }
+    };
+    if (v.help || (!command && !v.version)) {
+        if (v.json)
+            output({ help, next: 'run --app-id ID --dir DIR' });
+        else
+            console.log(help);
+        return;
+    }
+    if (v.version || command === 'version') {
+        output({ version: VERSION, next: 'none' });
+        return;
+    }
+    if (command === 'doctor') {
+        const chrome = await launchChrome();
+        const version = chrome.version;
+        await chrome.close();
+        output({
+            ok: true,
+            version: VERSION,
+            node: process.version,
+            platform: process.platform,
+            chrome: version,
+            defaultConcurrency: 4,
+            next: 'auth status',
+        });
+        return;
+    }
+    if (command === 'auth') {
+        if (pos[1] === 'set') {
+            if (!v['base-url'])
+                throw new CaptureError('ARGUMENT_REQUIRED', '需要 --base-url');
+            if (v['eteamsid-stdin'] && v.eteamsid)
+                throw new CaptureError('ARGUMENT_CONFLICT', '仅选择一种 ETEAMSID 输入方式');
+            secret = v.eteamsid || '';
+            if (v['eteamsid-stdin']) {
+                const chunks = [];
+                for await (const chunk of process.stdin) {
+                    chunks.push(Buffer.from(chunk));
+                    if (chunks.reduce((n, b) => n + b.length, 0) > 16384)
+                        throw new CaptureError('INPUT_TOO_LARGE', 'ETEAMSID 输入过长');
+                }
+                secret = Buffer.concat(chunks).toString().trim();
+            }
+            if (!secret)
+                throw new CaptureError('ARGUMENT_REQUIRED', '需要 --eteamsid-stdin 或 --eteamsid');
+            output({
+                ...(await setEnvironmentAuth({ baseUrl: v['base-url'], eteamsId: secret })),
+                authenticated: true,
+                next: 'run --app-id ID --dir DIR',
+            });
+            return;
+        }
+        if (pos[1] === 'status') {
+            const status = v.local ? readEnvironmentAuthStatus() : await verifyEnvironmentAuth();
+            output({
+                ...safeAuth(status),
+                next: status.authenticated ? 'run --app-id ID --dir DIR' : 'auth set',
+            });
+            return;
+        }
+        if (pos[1] === 'profile') {
+            if (pos[2] === 'list')
+                output({ profiles: listEnvironmentAuthProfiles(), next: 'auth profile use NAME' });
+            else if (pos[2] === 'current')
+                output({ profile: readActiveEnvironmentAuthProfile(), next: 'run --app-id ID --dir DIR' });
+            else if (pos[2] === 'use' && pos[3]) {
+                const a = useEnvironmentAuthProfile(pos[3]);
+                output({ profile: pos[3], baseUrl: a.baseUrl, next: 'run --app-id ID --dir DIR' });
+            }
+            else
+                throw new CaptureError('COMMAND_INVALID', 'auth profile list|current|use NAME');
+            return;
+        }
+        throw new CaptureError('COMMAND_INVALID', 'auth set|status|profile');
+    }
+    if (![
+        'init',
+        'next',
+        'status',
+        'discover',
+        'collect',
+        'capture',
+        'pack',
+        'run',
+        'retry',
+        'html',
+    ].includes(command))
+        throw new CaptureError('COMMAND_INVALID', `未知命令: ${command}`);
+    if (!v.dir)
+        throw new CaptureError('ARGUMENT_REQUIRED', '需要 --dir');
+    const store = new Store(v.dir);
+    const settings = {};
+    for (const [arg, key, min, max] of [
+        ['concurrency', 'concurrency', 1, 8],
+        ['width', 'width', 320, 3840],
+        ['height', 'height', 320, 2160],
+        ['timeout-ms', 'timeoutMs', 2000, 600000],
+        ['stable-ms', 'stableMs', 200, 10000],
+        ['retries', 'retries', 0, 3],
+    ]) {
+        if (v[arg] !== undefined) {
+            const value = Number(v[arg]);
+            if (!Number.isInteger(value) || value < min || value > max)
+                throw new CaptureError('ARGUMENT_INVALID', `${arg} 范围 ${min}..${max}`);
+            settings[key] = value;
+        }
+    }
+    const report = async (s) => {
+        const { results, htmlResults, formResults, formHtmlResults, ...status } = await store.status(s);
+        const local = ['DISCOVER', 'COLLECT', 'CAPTURE'].includes(status.state)
+            ? readEnvironmentAuthStatus()
+            : { authenticated: true };
+        const state = !local.authenticated && ['DISCOVER', 'COLLECT', 'CAPTURE'].includes(status.state)
+            ? 'WAITING_AUTH'
+            : status.state;
+        const next = state === 'WAITING_AUTH'
+            ? 'auth set'
+            : state === 'DISCOVER'
+                ? 'discover'
+                : state === 'COLLECT'
+                    ? 'collect'
+                    : state === 'CAPTURE'
+                        ? 'capture'
+                        : state === 'HTML'
+                            ? 'html next'
+                            : state === 'PACKAGE'
+                                ? 'pack'
+                                : state === 'PARTIAL'
+                                    ? 'retry'
+                                    : 'none';
+        output({
+            ...status,
+            state,
+            appId: s.appId,
+            directory: store.root,
+            warnedPages: results
+                .filter((r) => r?.status === 'succeeded' && r.warnings?.length)
+                .map((r) => ({ id: r.id, name: r.name, warnings: r.warnings })),
+            failedPages: results
+                .filter((r) => r?.status === 'failed')
+                .map((r) => ({ id: r.id, name: r.name, error: r.history.at(-1)?.error })),
+            failedHtmlPages: htmlResults
+                .filter((r, i) => r?.status === 'failed' && r.sourceSha256 === results[i]?.sha256)
+                .map((r) => ({ id: r.id, error: r.error })),
+            failedForms: formResults.flatMap((r, i) => r?.status === 'failed' ? [{ id: r.id, name: s.formPages?.[i].name, error: r.error }] : []),
+            failedFormHtml: formHtmlResults.flatMap((r, i) => r?.status === 'failed' && r.sourceSha256 === formResults[i]?.sha256
+                ? [{ id: r.id, error: r.error }]
+                : []),
+            formWarnings: formResults.flatMap((r, i) => r?.warnings?.length
+                ? [{ id: r.id, name: s.formPages?.[i].name, warnings: r.warnings }]
+                : []),
+            skippedMenus: s.skippedMenus,
+            next,
+        });
+        if (state === 'PARTIAL')
+            process.exitCode = 2;
+    };
+    if (command === 'status' || command === 'next') {
+        await report(await store.load());
+        return;
+    }
+    await store.lock(async () => {
+        let s;
+        if (command === 'init' || command === 'run') {
+            if (v['app-id'] || v['app-url']) {
+                const input = applicationInput(v['app-url'] || v['app-id']);
+                if (v['app-id'] && applicationInput(v['app-id']).appId !== input.appId)
+                    throw new CaptureError('APP_INPUT_CONFLICT', '应用 ID 与地址不一致');
+                s = await store.init(input.appId, settings);
+                if (input.origin) {
+                    if ((s.requestedOrigin && s.requestedOrigin !== input.origin) ||
+                        (s.environment && s.environment.origin !== input.origin))
+                        throw new CaptureError('ENVIRONMENT_MISMATCH', '任务目录已绑定其它环境');
+                    s.requestedOrigin = input.origin;
+                    await store.save(s);
+                }
+            }
+            else if (command === 'run')
+                s = await store.load();
+            else
+                throw new CaptureError('ARGUMENT_REQUIRED', 'init 需要 --app-id 或 --app-url');
+        }
+        else
+            s = await store.load();
+        if (v['allow-temporary-records']) {
+            if (!['run', 'init'].includes(command))
+                throw new CaptureError('ARGUMENT_INVALID', '临时记录开关只能在 init/run 时启用');
+            if (s.discoveredAt && !s.allowTemporaryRecords)
+                throw new CaptureError('SETTINGS_MISMATCH', '已采集的只读任务请使用新目录启用临时参考记录');
+            s.allowTemporaryRecords = true;
+            await store.save(s);
+        }
+        if (command === 'init') {
+            await report(s);
+            return;
+        }
+        if (command === 'pack') {
+            await pack(store, s);
+            await report(s);
+            return;
+        }
+        if (command === 'html') {
+            const kind = v.kind || 'page';
+            if (kind !== 'page' && kind !== 'form')
+                throw new CaptureError('ARGUMENT_INVALID', 'kind 必须为 page 或 form');
+            if (pos[1] === 'next') {
+                output(await nextHtml(store, s));
+                return;
+            }
+            if (pos[1] === 'retry') {
+                await retryHtml(store, s, v['page-id'] ? { id: v['page-id'], kind } : undefined);
+                await report(s);
+                return;
+            }
+            if (!['accept', 'fail'].includes(pos[1]))
+                throw new CaptureError('COMMAND_INVALID', 'html next|accept|fail|retry');
+            if (!v['page-id'] || !v.token)
+                throw new CaptureError('ARGUMENT_REQUIRED', '需要 --page-id 和 --token');
+            if (pos[1] === 'accept')
+                await acceptHtml(store, s, v['page-id'], v.token, kind);
+            else {
+                if (!v.reason)
+                    throw new CaptureError('ARGUMENT_REQUIRED', '需要 --reason，不能包含登录信息');
+                await failHtml(store, s, v['page-id'], v.token, v.reason, kind);
+            }
+            await report(s);
+            return;
+        }
+        if (command === 'retry')
+            await retryHtml(store, s);
+        const before = await store.status(s);
+        const needsCapture = ['capture', 'run', 'retry'].includes(command) &&
+            (before.pending > 0 || (command === 'retry' && before.failed > 0));
+        const needsDiscover = (!s.pages ||
+            (s.siteRequired && (!s.forms || !s.appName)) ||
+            (s.menuRequired && (!s.menus || !s.formPages))) &&
+            ['discover', 'run'].includes(command);
+        const needsCollect = s.menuRequired &&
+            ['collect', 'run', 'retry'].includes(command) &&
+            (before.temporaryRecords.pending > 0 ||
+                before.collection.pending > 0 ||
+                (command === 'retry' && before.collection.failed > 0));
+        if (command === 'collect' && (!s.formPages || !s.menus))
+            throw new CaptureError('CATALOG_REQUIRED', '先执行 discover 获取发布菜单');
+        if (needsDiscover || needsCapture || needsCollect) {
+            const auth = readEnvironmentAuthContext();
+            secret = auth.eteamsId;
+            store.bind(s, auth);
+            await store.save(s);
+            if (needsDiscover) {
+                if (s.menuRequired)
+                    Object.assign(s, await discoverMenus(auth, s.appId));
+                else {
+                    if (!s.pages)
+                        s.pages = await fetchPages(auth, s.appId);
+                    if (s.siteRequired && (!s.forms || !s.appName))
+                        Object.assign(s, await fetchCatalog(auth, s.appId));
+                }
+                s.discoveredAt = new Date().toISOString();
+                await store.save(s);
+            }
+            if (s.menuRequired && ['collect', 'run', 'retry'].includes(command))
+                await collectForms(store, s, auth, command === 'retry');
+            if (['capture', 'run', 'retry'].includes(command))
+                await capture(store, s, auth, {
+                    retryFailed: command === 'retry',
+                    progress: (event) => console.error(JSON.stringify(event)),
+                });
+        }
+        if ((command === 'run' || command === 'retry') && (await store.status(s)).state === 'PACKAGE')
+            await pack(store, s);
+        await report(s);
+    });
+}
+main().catch((e) => {
+    const error = errorInfo(e, secret);
+    const value = {
+        ok: false,
+        error,
+        fix: error.code === 'E10_LOGIN_REQUIRED'
+            ? '执行 auth set 后用原目录重新 run'
+            : '根据 error 修正后用原目录恢复',
+        next: 'none',
+    };
+    if (process.argv.includes('--json'))
+        console.log(JSON.stringify(value));
+    else {
+        console.error(JSON.stringify(error, null, 2));
+        console.error(`FIX: ${value.fix}\nNEXT: none`);
+    }
+    process.exitCode = 1;
+});

package/dist/menus.d.ts

@@ -0,0 +1,32 @@
+import type { E10AuthContext } from './vendor/environment-auth.js';
+import type { FormPage, MenuItem, SkippedMenu } from './model.js';
+export declare function navigationKey(value: string): string;
+type Target = {
+    kind: 'page';
+    pageId: string;
+} | {
+    kind: 'combined';
+    appId: string;
+    combinationId?: string;
+} | Omit<FormPage, 'id' | 'menuId' | 'name' | 'appId'>;
+export declare function parseMenus(data: any, appId: string, origin: string, prefix?: string): {
+    menus: MenuItem[];
+    forms: FormPage[];
+    skipped: SkippedMenu[];
+    combinations: {
+        key: string;
+        target: Extract<Target, {
+            kind: "combined";
+        }>;
+    }[];
+};
+export declare function menuItems(menus: MenuItem[]): MenuItem[];
+export declare function discoverMenus(auth: E10AuthContext, appId: string): Promise<{
+    appName: string;
+    menus: MenuItem[];
+    skippedMenus: SkippedMenu[];
+    pages: import("./model.js").PageItem[];
+    forms: import("./model.js").FormItem[];
+    formPages: FormPage[];
+}>;
+export {};