@web-auto/webauto 0.1.1 → 0.1.3

package/dist/services/controller/src/index.js

@@ -0,0 +1,2 @@
+export { UiController } from './controller.js';
+//# sourceMappingURL=index.js.map

package/dist/services/controller/src/payload-normalizer.js

@@ -0,0 +1,129 @@
+/**
+ * Payload 统一解析层
+ *
+ * 职责：
+ * - 将各种变体字段（profile/profileId/profile_id, sessionId/session_id）统一为标准格式
+ * - 验证必需字段并提供清晰错误信息
+ * - 支持从 payload 内部提取字段（如 config, options）
+ *
+ * 设计原则：
+ * - 优先使用标准字段名（profile）
+ * - 兼容历史变体（profileId, profile_id, sessionId, session_id）
+ * - config/options 内的字段提升到顶层（便于访问）
+ * - 提供清晰的错误信息
+ */
+/**
+ * 统一 payload 解析
+ *
+ * @example
+ * const normalized = normalizePayload(payload, {
+ *   required: ['profile'],
+ *   allowTopLevel: true
+ * });
+ */
+export function normalizePayload(payload = {}, options = {}) {
+    const { required = [], allowTopLevel = true, strict = false, defaultProfile } = options;
+    const normalized = {};
+    const errors = [];
+    // 1. 处理 profile 字段变体（优先级：profile > profileId > profile_id > sessionId）
+    const profile = payload.profile ||
+        payload.profileId ||
+        payload.profile_id ||
+        payload.sessionId ||
+        payload.session_id ||
+        defaultProfile;
+    if (profile) {
+        normalized.profile = profile;
+    }
+    // 2. 处理其他常见字段（直接从 payload 顶层提取）
+    const commonFields = [
+        'url',
+        'containerId',
+        'operationId',
+        'script',
+        'selector',
+        'path',
+        'style',
+        'duration',
+        'timeout',
+        'maxDepth',
+        'maxChildren',
+        'rootSelector',
+        'channel',
+        'sticky',
+        'maxMatches'
+    ];
+    for (const field of commonFields) {
+        if (field in payload && payload[field] !== undefined) {
+            normalized[field] = payload[field];
+        }
+    }
+    // 3. 提取内部字段（config/options）并提升到顶层
+    // 优先使用 config，其次 options
+    const internalConfig = payload.config || payload.options;
+    if (internalConfig && typeof internalConfig === 'object') {
+        // 将内部字段提升到顶层（便于访问）
+        Object.assign(normalized, internalConfig);
+        // 同时保留原始引用（便于调试）
+        normalized.config = internalConfig;
+    }
+    // 4. 处理其他顶层字段（根据 allowTopLevel 决定）
+    if (allowTopLevel) {
+        const reservedFields = new Set([
+            'profile',
+            'profileId',
+            'profile_id',
+            'sessionId',
+            'session_id',
+            'config',
+            'options'
+        ]);
+        for (const [key, value] of Object.entries(payload)) {
+            if (!reservedFields.has(key) && !(key in normalized)) {
+                if (strict) {
+                    errors.push(`Unexpected field in payload: ${key}`);
+                }
+                else {
+                    normalized[key] = value;
+                }
+            }
+        }
+    }
+    // 5. 验证必需字段
+    for (const field of required) {
+        if (!(field in normalized) || normalized[field] === undefined || normalized[field] === null) {
+            errors.push(`Missing required field: ${field}`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Payload validation failed:\n  - ${errors.join('\n  - ')}`);
+    }
+    return normalized;
+}
+/**
+ * 创建带验证的 payload 解析器（闭包形式，便于复用配置）
+ */
+export function createPayloadParser(options) {
+    return (payload) => normalizePayload(payload, options);
+}
+/**
+ * 验证 payload 是否包含指定字段
+ */
+export function hasRequiredFields(payload, fields) {
+    return fields.every((field) => {
+        const value = payload[field];
+        return value !== undefined && value !== null && value !== '';
+    });
+}
+/**
+ * 提取 profile（兼容多种写法）
+ */
+export function extractProfile(payload) {
+    return (payload.profile ||
+        payload.profileId ||
+        payload.profile_id ||
+        payload.sessionId ||
+        payload.session_id);
+}
+export default normalizePayload;
+//# sourceMappingURL=payload-normalizer.js.map

package/dist/services/shared/heartbeat.js

@@ -0,0 +1,120 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+function resolveNumber(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return parsed;
+}
+function resolveHeartbeatFile(filePath) {
+    if (filePath && String(filePath).trim())
+        return String(filePath).trim();
+    if (process.env.WEBAUTO_HEARTBEAT_FILE)
+        return String(process.env.WEBAUTO_HEARTBEAT_FILE).trim();
+    return path.join(os.homedir(), '.webauto', 'run', 'xhs-heartbeat.json');
+}
+function readHeartbeat(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!data || typeof data !== 'object')
+            return null;
+        return {
+            ts: typeof data.ts === 'string' ? data.ts : undefined,
+            status: typeof data.status === 'string' ? data.status : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function startHeartbeatWatcher(options) {
+    const filePath = options.filePath || process.env.WEBAUTO_HEARTBEAT_FILE;
+    if (!filePath)
+        return () => { };
+    const staleMs = resolveNumber(options.staleMs ?? process.env.WEBAUTO_HEARTBEAT_STALE_MS, 45_000);
+    const intervalMs = resolveNumber(options.intervalMs ?? process.env.WEBAUTO_HEARTBEAT_INTERVAL_MS, Math.max(2000, Math.floor(staleMs / 3)));
+    const serviceName = options.serviceName || 'service';
+    const startAt = Date.now();
+    const timer = setInterval(() => {
+        let ts = 0;
+        let status = '';
+        const payload = readHeartbeat(filePath);
+        if (payload) {
+            status = String(payload.status || '');
+            ts = payload.ts ? Date.parse(payload.ts) : 0;
+        }
+        if (!ts) {
+            try {
+                const stat = fs.statSync(filePath);
+                ts = Number(stat.mtimeMs || 0);
+            }
+            catch (err) {
+                if (err?.code === 'ENOENT') {
+                    if (Date.now() - startAt > staleMs) {
+                        console.warn(`[heartbeat] ${serviceName} exit: heartbeat file missing (${filePath})`);
+                        process.exit(0);
+                    }
+                }
+                return;
+            }
+        }
+        if (status === 'stopped') {
+            console.warn(`[heartbeat] ${serviceName} exit: main process stopped`);
+            process.exit(0);
+        }
+        const age = Date.now() - ts;
+        if (age > staleMs) {
+            console.warn(`[heartbeat] ${serviceName} exit: heartbeat stale ${age}ms > ${staleMs}ms`);
+            process.exit(0);
+        }
+    }, intervalMs);
+    timer.unref();
+    return () => clearInterval(timer);
+}
+export function startHeartbeatWriter(options = {}) {
+    const filePath = resolveHeartbeatFile(options.filePath);
+    const intervalMs = resolveNumber(options.intervalMs ?? process.env.WEBAUTO_HEARTBEAT_INTERVAL_MS, 5000);
+    const staleMs = resolveNumber(options.staleMs ?? process.env.WEBAUTO_HEARTBEAT_STALE_MS, 45_000);
+    let status = String(options.initialStatus || 'running');
+    process.env.WEBAUTO_HEARTBEAT_FILE = filePath;
+    process.env.WEBAUTO_HEARTBEAT_INTERVAL_MS = String(intervalMs);
+    process.env.WEBAUTO_HEARTBEAT_STALE_MS = String(staleMs);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    catch {
+        // ignore dir creation failure
+    }
+    const write = (nextStatus) => {
+        if (nextStatus)
+            status = String(nextStatus);
+        const payload = {
+            pid: process.pid,
+            ts: new Date().toISOString(),
+            status,
+        };
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(payload));
+        }
+        catch {
+            // ignore heartbeat write failures
+        }
+    };
+    write(status);
+    const timer = setInterval(() => write(), intervalMs);
+    timer.unref();
+    const stop = () => {
+        write('stopped');
+        clearInterval(timer);
+    };
+    process.on('exit', stop);
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    const setStatus = (nextStatus) => {
+        write(nextStatus || 'running');
+    };
+    return { stop, filePath, intervalMs, staleMs, setStatus };
+}
+//# sourceMappingURL=heartbeat.js.map

package/dist/services/shared/lib/errorHandler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=errorHandler.js.map

package/dist/services/shared/serviceProcessLogger.js

@@ -0,0 +1,139 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const INSTALLED = new Set();
+function ensureLogDir() {
+    const dir = path.join(os.homedir(), '.webauto', 'logs');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    return dir;
+}
+function safeAppend(filePath, line) {
+    try {
+        fs.appendFileSync(filePath, line);
+    }
+    catch {
+        // ignore
+    }
+}
+function formatError(err) {
+    if (!err || typeof err !== 'object')
+        return { message: String(err) };
+    const anyErr = err;
+    return {
+        name: typeof anyErr.name === 'string' ? anyErr.name : undefined,
+        message: typeof anyErr.message === 'string' ? anyErr.message : String(err),
+        stack: typeof anyErr.stack === 'string' ? anyErr.stack : undefined,
+        code: typeof anyErr.code === 'string' ? anyErr.code : undefined,
+    };
+}
+function createConsoleTee(logFile) {
+    const kWrapped = Symbol.for('webauto.consoleTeeWrapped');
+    const g = globalThis;
+    if (g[kWrapped])
+        return;
+    g[kWrapped] = true;
+    const originals = {
+        log: console.log.bind(console),
+        info: console.info.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+    };
+    const wrap = (level) => {
+        return (...args) => {
+            const ts = new Date().toISOString();
+            const msg = args
+                .map((a) => {
+                if (typeof a === 'string')
+                    return a;
+                try {
+                    return JSON.stringify(a);
+                }
+                catch {
+                    return String(a);
+                }
+            })
+                .join(' ');
+            safeAppend(logFile, `[${ts}] [${level.toUpperCase()}] ${msg}\n`);
+            originals[level](...args);
+        };
+    };
+    console.log = wrap('log');
+    console.info = wrap('info');
+    console.warn = wrap('warn');
+    console.error = wrap('error');
+}
+export function installServiceProcessLogger(opts) {
+    const serviceName = String(opts.serviceName || '').trim();
+    const id = `service:${serviceName}`;
+    if (!serviceName)
+        return { logEvent: () => { } };
+    if (INSTALLED.has(id))
+        return { logEvent: () => { } };
+    INSTALLED.add(id);
+    const logDir = ensureLogDir();
+    const crashFile = path.join(logDir, `${serviceName}.crash.jsonl`);
+    const consoleLogFile = path.join(logDir, `${serviceName}.log`);
+    const tee = typeof opts.teeConsoleToFile === 'boolean'
+        ? opts.teeConsoleToFile
+        : !!(process.stdout.isTTY || process.stderr.isTTY);
+    if (tee)
+        createConsoleTee(consoleLogFile);
+    const base = {
+        service: serviceName,
+        pid: process.pid,
+        node: process.version,
+    };
+    const logEvent = (event, data = {}) => {
+        safeAppend(crashFile, `${JSON.stringify({
+            ts: new Date().toISOString(),
+            ...base,
+            event,
+            ...data,
+        })}\n`);
+    };
+    logEvent('process_start', {
+        argv: process.argv,
+        cwd: process.cwd(),
+        ppid: process.ppid,
+        stdoutIsTTY: !!process.stdout.isTTY,
+        stderrIsTTY: !!process.stderr.isTTY,
+    });
+    process.on('uncaughtException', (err) => {
+        logEvent('uncaughtException', { error: formatError(err) });
+        // Keep the process alive for post-mortem visibility, but mark non-zero.
+        process.exitCode = 1;
+    });
+    process.on('unhandledRejection', (reason) => {
+        logEvent('unhandledRejection', { reason: formatError(reason) });
+        process.exitCode = 1;
+    });
+    const tapSignal = (signal) => {
+        const hadExisting = process.listenerCount(signal) > 0;
+        const handler = () => {
+            logEvent('signal', { signal });
+            process.off(signal, handler);
+            // If we were the only listener, re-send the signal so Node's default behavior applies.
+            if (!hadExisting) {
+                try {
+                    process.kill(process.pid, signal);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        };
+        process.on(signal, handler);
+    };
+    tapSignal('SIGINT');
+    tapSignal('SIGTERM');
+    tapSignal('SIGHUP');
+    process.on('beforeExit', (code) => logEvent('beforeExit', { code }));
+    process.on('exit', (code) => logEvent('exit', { code }));
+    return { logEvent };
+}
+//# sourceMappingURL=serviceProcessLogger.js.map

package/dist/services/unified-api/RemoteBrowserSession.js

@@ -0,0 +1,176 @@
+/**
+ * RemoteBrowserSession - 远程浏览器会话适配器
+ *
+ * 作用：让 Unified API (7701) 能够代理对 Browser Service (7704) 的调用
+ * 核心职责：通过 HTTP 与 Browser Service 通信，模拟本地 BrowserSession 接口
+ */
+import { fetch } from 'undici';
+/**
+ * 远程浏览器会话代理
+ *
+ * 实现与 BrowserSession 兼容的接口，但所有操作都通过 HTTP 转发到 Browser Service
+ */
+export class RemoteBrowserSession {
+    sessionId;
+    baseUrl;
+    lastKnownUrl = null;
+    constructor(options) {
+        this.sessionId = options.sessionId;
+        this.baseUrl = options.browserServiceUrl;
+    }
+    get id() {
+        return this.sessionId;
+    }
+    get currentPage() {
+        return this.createPageProxy();
+    }
+    createPageProxy() {
+        return {
+            evaluate: async (fn, ...args) => {
+                return this.evaluate(fn, ...args);
+            },
+            url: () => this.getCurrentUrl() || '',
+            mouse: {
+                move: async (x, y, options) => {
+                    return this.sendCommand('mouse:move', { x, y, steps: options?.steps || 3 });
+                },
+                click: async (x, y, options) => {
+                    // 注意：options可能包含button、clicks、delay
+                    return this.sendCommand('mouse:click', { x, y,
+                        button: options?.button || 'left',
+                        clicks: options?.clickCount || 1,
+                        delay: options?.delay || 50
+                    });
+                },
+                wheel: async (deltaX, deltaY) => {
+                    return this.sendCommand('mouse:wheel', { deltaX, deltaY });
+                },
+            },
+            keyboard: {
+                type: async (text, options) => {
+                    return this.sendCommand('keyboard:type', {
+                        text,
+                        delay: options?.delay,
+                        submit: options?.submit,
+                    });
+                },
+                press: async (key, options) => {
+                    return this.sendCommand('keyboard:press', {
+                        key,
+                        delay: options?.delay,
+                    });
+                },
+            }
+        };
+    }
+    async ensurePage(url) {
+        if (url) {
+            await this.goto(url);
+        }
+        return this.createPageProxy();
+    }
+    async sendCommand(action, args) {
+        const url = `${this.baseUrl}/command`;
+        const payload = {
+            action,
+            args: {
+                profileId: this.sessionId,
+                ...args
+            }
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            const detail = text ? ` | ${text}` : '';
+            throw new Error(`Browser Service command failed: HTTP ${response.status} ${response.statusText}${detail}`);
+        }
+        const result = await response.json();
+        // Browser Service 使用 { ok: boolean, body?: any, error?: string } 结构，
+        // 旧代码使用 { success: boolean, data?: any, error?: string }。
+        const isError = result?.success === false ||
+            result?.ok === false;
+        if (isError) {
+            // 打印原始返回，便于定位协议不一致问题
+            // 注意：这里是 Unified API 侧日志，不会泄露页面内容
+            // eslint-disable-next-line no-console
+            console.error('[RemoteBrowserSession] sendCommand error payload', action, result);
+            throw new Error(result.error || 'Unknown error');
+        }
+        // 统一返回 data/body/result 中的有效字段
+        if (result.data !== undefined)
+            return result.data;
+        if (result.body !== undefined)
+            return result.body;
+        if (result.result !== undefined)
+            return result.result;
+        return result;
+    }
+    async goto(url) {
+        await this.sendCommand('goto', { url });
+        this.lastKnownUrl = url;
+    }
+    getCurrentUrl() {
+        return this.lastKnownUrl;
+    }
+    async evaluate(expression, arg) {
+        // 注意：tsx/esbuild 可能会在函数源码中注入 __name 等辅助方法；
+        // 直接 toString() 后在页面上下文执行会触发 ReferenceError。
+        // 这里注入一个 noop __name 以保证序列化函数可执行。
+        const script = typeof expression === 'function'
+            ? (() => {
+                const fnSource = expression.toString();
+                const argSource = typeof arg === 'undefined' ? 'undefined' : JSON.stringify(arg);
+                return `(function(){ const __name = (fn) => fn; return (${fnSource})(${argSource}); })()`;
+            })()
+            : expression;
+        return this.sendCommand('evaluate', { script });
+    }
+    async screenshot(fullPage = true) {
+        const result = await this.sendCommand('screenshot', { fullPage });
+        if (typeof result === 'string') {
+            return Buffer.from(result, 'base64');
+        }
+        return result;
+    }
+    async click(selector) {
+        await this.sendCommand('click', { selector });
+    }
+    async fill(selector, text) {
+        await this.sendCommand('fill', { selector, text });
+    }
+    async getCookies() {
+        return this.sendCommand('getCookies');
+    }
+    async saveCookiesToFile(filePath) {
+        return this.sendCommand('saveCookies', { path: filePath });
+    }
+    async saveCookiesIfStable(filePath, opts = {}) {
+        return this.sendCommand('saveCookiesIfStable', { path: filePath, ...opts });
+    }
+    async injectCookiesFromFile(filePath) {
+        return this.sendCommand('loadCookies', { path: filePath });
+    }
+    async getInfo() {
+        return this.sendCommand('getStatus');
+    }
+    async close() {
+        await this.sendCommand('stop');
+    }
+    setMode(mode) {
+        this.sendCommand('setMode', { mode }).catch(() => {
+            // ignore unsupported command
+        });
+    }
+    addRuntimeEventObserver(_observer) {
+        console.warn('[RemoteBrowserSession] addRuntimeEventObserver not implemented');
+        return () => { };
+    }
+    get modeName() {
+        return 'dev';
+    }
+}
+//# sourceMappingURL=RemoteBrowserSession.js.map