e10-ebuilder-prototype 0.5.0

package/dist/runtime-support.mjs

@@ -0,0 +1,279 @@
+// Portable runtime primitives shared by the installed CLI and the pre-install Skill.
+// Windows cmd invocation/cleanup follow ui-code-agent's Windows canary fixes (2026-08-25).
+import fs from 'node:fs/promises';
+import { existsSync, renameSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+const here = fileURLToPath(import.meta.url);
+const fail = (code, message = code) => Object.assign(new Error(message), { code });
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function environmentValue(env, name, platform = process.platform) {
+    return platform === 'win32'
+        ? Object.entries(env).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1]
+        : env[name];
+}
+export function productStateRoot(env = process.env, platform = process.platform, homeDirectory = os.homedir()) {
+    const api = platform === 'win32' ? path.win32 : path.posix;
+    const get = (name) => environmentValue(env, name, platform)?.trim();
+    if (get('E10_PAGE_CAPTURE_HOME'))
+        return api.resolve(get('E10_PAGE_CAPTURE_HOME'));
+    const base = platform === 'win32'
+        ? get('LOCALAPPDATA') || api.join(get('USERPROFILE') || homeDirectory, 'AppData', 'Local')
+        : platform === 'darwin'
+            ? api.join(homeDirectory, 'Library', 'Application Support')
+            : get('XDG_STATE_HOME') || api.join(homeDirectory, '.local', 'state');
+    // Keep the established auth/runtime namespace across the product rename.
+    return api.join(base, 'e10-page-capture');
+}
+export function npmEnvironment(env = process.env) {
+    const childEnv = { ...env };
+    for (const key of Object.keys(childEnv)) {
+        if ([
+            'npm_config_update_notifier',
+            'npm_config_cache',
+            'codebuddy_session_id',
+            'claude_session_id',
+        ].includes(key.toLowerCase()))
+            delete childEnv[key];
+    }
+    childEnv.npm_config_update_notifier = 'false';
+    return childEnv;
+}
+export function resolveNpmPath({ platform = process.platform, env = process.env, nodePath = process.execPath, fileExists = existsSync, } = {}) {
+    const api = platform === 'win32' ? path.win32 : path.posix;
+    const get = (name) => environmentValue(env, name, platform);
+    const directory = api.dirname(nodePath);
+    const candidates = [
+        get('npm_execpath'),
+        api.join(directory, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        api.join(directory, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    ];
+    const names = platform === 'win32' ? ['npm.cmd', 'npm.bat'] : ['npm'];
+    for (const dir of [directory, ...(get('PATH') || '').split(platform === 'win32' ? ';' : ':')]) {
+        if (dir)
+            for (const name of names)
+                candidates.push(api.join(dir.replace(/^"|"$/g, ''), name));
+    }
+    const found = candidates.find((p) => p && api.isAbsolute(p) && fileExists(p));
+    if (!found)
+        throw fail('NPM_NOT_FOUND', '未找到 npm；请使用包含 npm 的 Node.js >=22.5');
+    return api.resolve(found);
+}
+export function processInvocation(command, args, platform = process.platform, env = process.env, nodePath = process.execPath) {
+    if (/\.(?:mjs|cjs|js)$/i.test(command))
+        return { command: nodePath, args: [command, ...args], shell: false, env };
+    if (platform !== 'win32' || !/\.(?:cmd|bat)$/i.test(command))
+        return { command, args, shell: false, env };
+    const childEnv = { ...env }, prefix = 'E10_CAPTURE_CMD_VALUE_';
+    for (const key of Object.keys(childEnv))
+        if (key.toLowerCase().startsWith(prefix.toLowerCase()))
+            delete childEnv[key];
+    const refs = [command, ...args].map((value, i) => {
+        if (/[\0\r\n]/.test(value))
+            throw fail('INVALID_ARGUMENT', 'Windows cmd 参数包含 NUL/CR/LF');
+        const key = prefix + i;
+        childEnv[key] = value.replaceAll('"', '""');
+        return `"%${key}%"`;
+    });
+    return {
+        command: environmentValue(env, 'ComSpec', platform)?.trim() || 'cmd.exe',
+        args: ['/d', '/s', '/v:off', '/c', `"${refs.join(' ')}"`],
+        shell: false,
+        env: childEnv,
+        windowsVerbatimArguments: true,
+    };
+}
+export function processTreeTerminationInvocation(pid, platform = process.platform) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        throw fail('INVALID_PID');
+    return platform === 'win32'
+        ? { command: 'taskkill.exe', args: ['/pid', String(pid), '/t', '/f'], shell: false }
+        : null;
+}
+export function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        if (e.code === 'ESRCH')
+            return false;
+        throw e;
+    }
+}
+export async function terminateProcessTree(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        throw fail('INVALID_PID');
+    if (!processAlive(pid))
+        return;
+    const call = processTreeTerminationInvocation(pid);
+    if (call) {
+        await new Promise((resolve, reject) => {
+            const p = spawn(call.command, call.args, { shell: false, stdio: 'ignore', windowsHide: true });
+            const timer = setTimeout(() => {
+                p.kill();
+                reject(fail('PROCESS_TREE_KILL_TIMEOUT'));
+            }, 5000);
+            p.once('error', (e) => {
+                clearTimeout(timer);
+                reject(e);
+            });
+            p.once('close', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    else {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch (e) {
+            if (e.code !== 'ESRCH')
+                throw e;
+        }
+    }
+    const deadline = Date.now() + 5000;
+    while (processAlive(pid) && Date.now() < deadline)
+        await delay(50);
+    if (processAlive(pid))
+        throw fail('PROCESS_STILL_RUNNING');
+}
+export async function runChild(command, args, { cwd, stdio = 'inherit', timeout = 120000, env = process.env } = {}) {
+    const call = processInvocation(command, args, process.platform, env);
+    return new Promise((resolve, reject) => {
+        const p = spawn(call.command, call.args, { ...call, cwd, stdio, windowsHide: true });
+        let stopping = false;
+        const cleanup = () => {
+            clearTimeout(timer);
+            process.removeListener('SIGINT', interrupt);
+            process.removeListener('SIGTERM', interrupt);
+        };
+        const stop = async (code) => {
+            if (stopping)
+                return;
+            stopping = true;
+            cleanup();
+            try {
+                if (p.pid)
+                    await terminateProcessTree(p.pid);
+                reject(fail(code));
+            }
+            catch (e) {
+                reject(e);
+            }
+        };
+        const interrupt = () => {
+            void stop('CHILD_INTERRUPTED');
+        };
+        const timer = setTimeout(() => {
+            void stop('CHILD_TIMEOUT');
+        }, timeout);
+        process.once('SIGINT', interrupt);
+        process.once('SIGTERM', interrupt);
+        p.once('error', (e) => {
+            cleanup();
+            if (!stopping)
+                reject(e);
+        });
+        p.once('close', (code) => {
+            cleanup();
+            if (!stopping)
+                resolve(code ?? 1);
+        });
+    });
+}
+export function chromeExecutable({ platform = process.platform, env = process.env, homeDirectory = os.homedir(), fileExists = existsSync, } = {}) {
+    const api = platform === 'win32' ? path.win32 : path.posix;
+    const get = (name) => environmentValue(env, name, platform)?.trim();
+    const explicit = get('E10_PAGE_CAPTURE_CHROME');
+    if (explicit) {
+        if (!api.isAbsolute(explicit) || !fileExists(explicit))
+            throw fail('CHROME_PATH_INVALID', 'E10_PAGE_CAPTURE_CHROME 必须指向已存在的 Chrome 绝对路径');
+        return api.resolve(explicit);
+    }
+    const candidates = platform === 'win32'
+        ? [
+            get('ProgramFiles'),
+            get('ProgramFiles(x86)'),
+            get('LOCALAPPDATA'),
+            api.join(get('USERPROFILE') || homeDirectory, 'AppData', 'Local'),
+        ]
+            .filter(Boolean)
+            .map((dir) => api.join(dir, 'Google', 'Chrome', 'Application', 'chrome.exe'))
+        : platform === 'darwin'
+            ? [
+                '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                api.join(homeDirectory, 'Applications', 'Google Chrome.app', 'Contents', 'MacOS', 'Google Chrome'),
+            ]
+            : ['/opt/google/chrome/chrome', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'];
+    const found = candidates.find(fileExists);
+    if (!found)
+        throw fail('CHROME_NOT_FOUND', '未找到 Google Chrome；请安装或设置 E10_PAGE_CAPTURE_CHROME');
+    return found;
+}
+export async function renameWithRetry(source, target, rename = fs.rename) {
+    for (let i = 0;; i++) {
+        try {
+            await rename(source, target);
+            return;
+        }
+        catch (e) {
+            if (i === 5 || !['EPERM', 'EACCES', 'EBUSY'].includes(e.code))
+                throw e;
+            await delay(50 * (i + 1));
+        }
+    }
+}
+export function renameWithRetrySync(source, target) {
+    for (let i = 0;; i++) {
+        try {
+            renameSync(source, target);
+            return;
+        }
+        catch (e) {
+            if (i === 5 || !['EPERM', 'EACCES', 'EBUSY'].includes(e.code))
+                throw e;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50 * (i + 1));
+        }
+    }
+}
+export function reservedWindowsName(name) {
+    return /^(?:con|prn|aux|nul|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(name);
+}
+// Removing a managed directory runs outside the long-lived host: Windows Sandbox
+// file deletion can otherwise remain pending even after Chrome has already exited.
+export async function cleanupOwnedDirectory(target, parent, prefix) {
+    assertCleanupTarget(target, parent, prefix);
+    if (!existsSync(target))
+        return;
+    const code = await runChild(process.execPath, [here, '--cleanup-owned', target, parent, prefix], {
+        stdio: 'ignore',
+        timeout: process.platform === 'win32' ? 30000 : 15000,
+    });
+    if (code !== 0 || existsSync(target))
+        throw fail('DIRECTORY_CLEANUP_FAILED', `清理未完成: ${target}`);
+}
+function assertCleanupTarget(target, parent, prefix) {
+    const relative = path.relative(path.resolve(parent), path.resolve(target));
+    if (!prefix ||
+        !relative ||
+        relative === '..' ||
+        path.isAbsolute(relative) ||
+        relative.includes(path.sep) ||
+        !relative.startsWith(prefix))
+        throw fail('CLEANUP_TARGET_INVALID');
+}
+if (process.argv[1] &&
+    path.resolve(process.argv[1]) === here &&
+    process.argv[2] === '--cleanup-owned') {
+    const [target, parent, prefix] = process.argv.slice(3);
+    assertCleanupTarget(target, parent, prefix);
+    const actualParent = await fs.realpath(parent);
+    const actualTargetParent = await fs.realpath(path.dirname(target));
+    if (actualParent !== actualTargetParent)
+        throw fail('CLEANUP_TARGET_INVALID');
+    await fs.rm(target, { recursive: true, force: true, maxRetries: 8, retryDelay: 200 });
+}

package/dist/site.d.ts

@@ -0,0 +1,34 @@
+import { Store } from './store.js';
+import type { TaskState, MenuItem } from './model.js';
+export declare const TEMPLATE_VERSION = 7;
+export declare const pageHtmlPath: (pageId: string) => string;
+export declare const formHtmlPath: (formId: string) => string;
+export declare const escapeHtml: (value: string) => string;
+export interface SiteItem {
+    id: string;
+    name: string;
+    kind: 'page' | 'form';
+    html: string;
+    png?: string;
+    available: boolean;
+    objId?: string;
+    objectIds?: string[];
+    workflowType?: string;
+}
+export declare function renderIndex(appName: string, items: SiteItem[], menus?: MenuItem[], appId?: string): Promise<string>;
+export declare function renderPlaceholder(name: string, form?: boolean, failed?: boolean): Promise<string>;
+export declare function buildSite(store: Store, s: TaskState, status: Awaited<ReturnType<Store['status']>>): Promise<{
+    items: SiteItem[];
+    metadata: Map<string, {
+        readonly sha256: string;
+        readonly bytes: number;
+    }>;
+    templateVersion: number;
+    finish(manifest: unknown): Promise<{
+        entry: string;
+        files: {
+            path: string;
+            sha256: string;
+        }[];
+    }>;
+}>;

package/dist/site.js

@@ -0,0 +1,195 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { filenames } from './store.js';
+import { atomicJson, bounded, CaptureError, fileDigest, id, mapLimit } from './common.js';
+import { renameWithRetry } from './runtime-support.mjs';
+import { launchChrome } from './capture.js';
+import { navigationKey } from './menus.js';
+import { createOfflineStorage } from './offline-store.mjs';
+import { verifiedForm } from './forms.js';
+export const TEMPLATE_VERSION = 7;
+export const pageHtmlPath = (pageId) => `page/${id(pageId)}/${id(pageId)}.html`;
+export const formHtmlPath = (formId) => `form/${navigationKey(formId)}/${navigationKey(formId)}.html`;
+export const escapeHtml = (value) => value.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+export async function renderIndex(appName, items, menus, appId) {
+    const template = await fs.readFile(new URL('./templates/index.html', import.meta.url), 'utf8');
+    const encode = (data) => JSON.stringify(data)
+        .replaceAll('<', '\\u003c')
+        .replaceAll('\u2028', '\\u2028')
+        .replaceAll('\u2029', '\\u2029');
+    return template
+        .replace('__OFFLINE_STORAGE__', () => createOfflineStorage.toString())
+        .replace('__APP_TITLE__', () => escapeHtml(appName))
+        .replace('__CATALOG_JSON__', () => encode({ appName, items, menus, appId }));
+}
+export async function renderPlaceholder(name, form = true, failed = false) {
+    const template = await fs.readFile(new URL('./templates/placeholder.html', import.meta.url), 'utf8');
+    const values = {
+        NAME: name,
+        BADGE: form ? (failed ? '表单 · 暂不可用' : '表单 · 暂未对接') : '页面 · 暂不可用',
+        DESCRIPTION: form && !failed ? '表单功能暂未对接。' : '此页面暂不可用，请稍后重试。',
+    };
+    return template.replace(/__(NAME|BADGE|DESCRIPTION)__/g, (_, key) => escapeHtml(values[key]));
+}
+async function writeAtomic(filename, bytes) {
+    await fs.mkdir(path.dirname(filename), { recursive: true });
+    const temporary = `${filename}.${randomUUID()}.tmp`;
+    try {
+        await fs.writeFile(temporary, bytes, { flag: 'wx', mode: 0o600 });
+        await renameWithRetry(temporary, filename);
+    }
+    finally {
+        await fs.rm(temporary, { force: true });
+    }
+}
+export async function buildSite(store, s, status) {
+    if (!s.pages || !s.forms || !s.appName)
+        throw new CaptureError('CATALOG_REQUIRED', '先执行 run 完成应用和表单目录发现');
+    const files = new Set(), items = [], sources = new Map();
+    const target = (relative) => store.artifact(`site/${relative}`);
+    const put = async (relative, bytes) => {
+        await writeAtomic(target(relative), bytes);
+        files.add(relative);
+    };
+    for (const [i, p] of s.pages.entries()) {
+        const r = status.results[i], html = status.htmlResults[i];
+        const item = {
+            id: p.id,
+            name: p.name,
+            kind: 'page',
+            html: pageHtmlPath(p.id),
+            available: await store.verifiedHtml(html, r),
+        };
+        if (await store.verified(r)) {
+            item.png = `page/${p.id}/${filenames([p]).get(p.id)}`;
+            await put(item.png, await fs.readFile(store.artifact(r.file)));
+        }
+        sources.set(item.html, item.available
+            ? await fs.readFile(store.artifact(html.file), 'utf8')
+            : await renderPlaceholder(p.name, false));
+        items.push(item);
+    }
+    for (const [i, f] of (s.menuRequired ? s.formPages || [] : s.forms).entries()) {
+        const pngName = filenames([
+            { id: f.id, name: f.name, appId: s.appId, url: '', terminal: 'PC' },
+        ]).get(f.id);
+        const source = status.formResults[i], html = status.formHtmlResults[i];
+        const available = !!s.menuRequired &&
+            (await verifiedForm(store, source)) &&
+            (await store.verifiedHtml(html, source));
+        const item = {
+            id: f.id,
+            name: f.name,
+            kind: 'form',
+            html: formHtmlPath(f.id),
+            png: `form/${f.id}/${pngName}`,
+            available,
+            ...(s.menuRequired
+                ? {
+                    objId: source?.objId,
+                    ...(source?.kind === 'workflow'
+                        ? { objectIds: source.objectIds, workflowType: f.workflowType }
+                        : {}),
+                }
+                : {}),
+        };
+        sources.set(item.html, available
+            ? await fs.readFile(store.artifact(html.file), 'utf8')
+            : await renderPlaceholder(f.name, true, !!s.menuRequired));
+        items.push(item);
+    }
+    if (items.some((item) => item.kind === 'form')) {
+        const chrome = await launchChrome();
+        try {
+            const context = await chrome.browser.newContext({
+                viewport: { width: 1440, height: 900 },
+                offline: true,
+            });
+            try {
+                const outcomes = await mapLimit(items.filter((i) => i.kind === 'form'), s.settings.concurrency, async (item) => {
+                    let page, failure = null;
+                    try {
+                        page = await context.newPage();
+                        const errors = [];
+                        page.on('pageerror', (error) => errors.push(error.message));
+                        await page.setContent(sources.get(item.html), { waitUntil: 'load', timeout: 10000 });
+                        if (s.menuRequired && item.available)
+                            await page.waitForFunction(() => window.__E10_FORM_READY__ === true, undefined, { timeout: 10000 });
+                        await page.evaluate(() => document.fonts.ready);
+                        if (errors.length)
+                            throw new CaptureError('FORM_RENDER_FAILED', `表单 ${item.id} 本地渲染出现脚本错误`);
+                        await put(item.png, await page.screenshot({ fullPage: true, timeout: 10000 }));
+                    }
+                    catch (error) {
+                        failure = error;
+                        if (s.menuRequired && item.available) {
+                            const receipt = await store.htmlResult(item.id, 'form');
+                            if (receipt) {
+                                receipt.status = 'failed';
+                                receipt.finishedAt = new Date().toISOString();
+                                receipt.error = {
+                                    code: 'FORM_RENDER_FAILED',
+                                    message: '本地表单渲染或初始化失败；执行 html retry 后修复并重新生成',
+                                };
+                                await store.saveHtmlResult(receipt);
+                            }
+                            failure = new CaptureError('FORM_RENDER_FAILED', `表单 ${item.id} 本地渲染失败，执行 html retry 后修复并重新生成`);
+                        }
+                    }
+                    finally {
+                        if (page)
+                            try {
+                                await bounded(page.close(), 8000, 'PAGE_CLOSE_TIMEOUT');
+                            }
+                            catch (error) {
+                                failure ||= error;
+                            }
+                    }
+                    return failure;
+                });
+                const error = outcomes.find(Boolean);
+                if (error)
+                    throw error;
+            }
+            finally {
+                await bounded(context.close(), 8000, 'CONTEXT_CLOSE_TIMEOUT');
+            }
+        }
+        finally {
+            await chrome.close();
+        }
+    }
+    // URL path separators are always '/', even when the filesystem is Windows.
+    const menu = items.map((item) => ({
+        ...item,
+        html: item.html.split('/').map(encodeURIComponent).join('/'),
+        png: item.png?.split('/').map(encodeURIComponent).join('/'),
+    }));
+    for (const item of items)
+        await put(item.html, sources.get(item.html));
+    await put('index.html', await renderIndex(s.appName, menu, s.menuRequired ? s.menus : undefined, s.appId));
+    const metadata = new Map(await mapLimit([...files], 4, async (relative) => [
+        relative,
+        {
+            sha256: await fileDigest(target(relative)),
+            bytes: (await fs.stat(target(relative))).size,
+        },
+    ]));
+    return {
+        items,
+        metadata,
+        templateVersion: TEMPLATE_VERSION,
+        async finish(manifest) {
+            await atomicJson(target('manifest.json'), manifest);
+            files.add('manifest.json');
+            return {
+                entry: 'site/index.html',
+                files: await mapLimit([...files].sort(), 4, async (relative) => ({
+                    path: `site/${relative}`,
+                    sha256: await fileDigest(target(relative)),
+                })),
+            };
+        },
+    };
+}

package/dist/store.d.ts

@@ -0,0 +1,90 @@
+import { type TaskState, type PageResult, type Settings, type PageItem, type HtmlResult } from './model.js';
+import type { E10AuthContext } from './vendor/environment-auth.js';
+export declare const htmlArtifact: (key: string, kind?: "page" | "form") => string;
+export declare class Store {
+    readonly root: string;
+    readonly meta: string;
+    readonly artifacts: string;
+    constructor(dir: string);
+    load(): Promise<TaskState>;
+    save(s: TaskState): Promise<void>;
+    init(appId: string, settings?: Partial<Settings>): Promise<TaskState>;
+    bind(s: TaskState, a: E10AuthContext): void;
+    receiptPath(pageId: string): string;
+    result(pageId: string): Promise<PageResult | undefined>;
+    saveResult(r: PageResult): Promise<void>;
+    htmlReceiptPath(pageId: string, kind?: 'page' | 'form'): string;
+    htmlResult(pageId: string, kind?: 'page' | 'form'): Promise<HtmlResult | undefined>;
+    saveHtmlResult(r: HtmlResult): Promise<void>;
+    verifiedHtml(r: HtmlResult | undefined, png: Pick<PageResult, 'id' | 'status' | 'sha256'> | undefined): Promise<boolean>;
+    artifact(relative: string): string;
+    verified(r: PageResult | undefined): Promise<boolean>;
+    status(s: TaskState): Promise<{
+        state: string;
+        total: number;
+        succeeded: number;
+        failed: number;
+        pending: number;
+        results: (PageResult | undefined)[];
+        htmlResults: (HtmlResult | undefined)[];
+        formResults: (import("./model.js").FormCollection | undefined)[];
+        formHtmlResults: (HtmlResult | undefined)[];
+        pageHtml: {
+            required: boolean;
+            succeeded: number;
+            failed: number;
+            running: number;
+            pending: number;
+        };
+        formHtml: {
+            succeeded: number;
+            failed: number;
+            running: number;
+            pending: number;
+        };
+        collection: {
+            succeeded: number;
+            failed: number;
+            pending: number;
+        };
+        temporaryRecords: {
+            total: number;
+            pending: number;
+            cleaned: number;
+        };
+        html: {
+            required: boolean;
+            succeeded: number;
+            failed: number;
+            running: number;
+            pending: number;
+        };
+        appName: string | undefined;
+        forms: {
+            total: number;
+            integrated: number;
+            placeholders: number;
+            collection: {
+                succeeded: number;
+                failed: number;
+                pending: number;
+            };
+            html: {
+                succeeded: number;
+                failed: number;
+                running: number;
+                pending: number;
+            };
+        } | {
+            total: number;
+            integrated: number;
+            placeholders: number;
+            collection?: undefined;
+            html?: undefined;
+        };
+        entry: string | undefined;
+        archive: string | undefined;
+    }>;
+    lock<T>(action: () => Promise<T>): Promise<T>;
+}
+export declare function filenames(pages: PageItem[]): Map<string, string>;