@web-auto/webauto 0.1.1 → 0.1.2

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

@@ -0,0 +1,148 @@
+/**
+ * RemoteSessionManager - 远程会话管理器
+ *
+ * 作用：在 Unified API (7701) 中管理对 Browser Service (7704) 的远程会话
+ * 核心职责：创建/销毁/查询远程会话，并返回 RemoteBrowserSession 适配器
+ */
+import { RemoteBrowserSession } from './RemoteBrowserSession.js';
+import { fetch } from 'undici';
+import { getStateRegistry } from './state-registry.js';
+export class RemoteSessionManager {
+    sessions = new Map();
+    browserServiceUrl;
+    stateRegistry;
+    constructor(options) {
+        // 支持两种构造方式：
+        // 1. { browserServiceUrl: string }
+        // 2. { host: string, port: number, ... } (兼容原 SessionManager)
+        this.browserServiceUrl = options.browserServiceUrl || `http://${options.host || '127.0.0.1'}:${options.port || 7704}`;
+        this.stateRegistry = getStateRegistry();
+    }
+    /**
+     * 创建远程会话
+     */
+    async createSession(options) {
+        const sessionId = options.sessionId || options.profileId || `session_${Date.now().toString(36)}`;
+        // 通过 HTTP 调用 Browser Service 创建会话
+        const response = await fetch(`${this.browserServiceUrl}/command`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'start',
+                args: {
+                    profileId: sessionId,
+                    headless: options.headless,
+                    url: options.url
+                }
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to create remote session: ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (!result.success) {
+            throw new Error(result.error || 'Failed to create remote session');
+        }
+        // 创建本地代理对象
+        const remoteSession = new RemoteBrowserSession({
+            sessionId,
+            browserServiceUrl: this.browserServiceUrl
+        });
+        this.sessions.set(sessionId, remoteSession);
+        this.stateRegistry.updateSessionState(sessionId, {
+            profileId: sessionId,
+            sessionId,
+            currentUrl: options.url || '',
+        });
+        return { sessionId };
+    }
+    /**
+     * 获取会话
+     */
+    getSession(sessionId) {
+        let session = this.sessions.get(sessionId);
+        if (session)
+            return session;
+        // 隐式创建会话代理（如果会话在远端存在但本地未缓存）
+        // 这允许不通过 createSession 也能访问已存在的会话
+        session = new RemoteBrowserSession({
+            sessionId,
+            browserServiceUrl: this.browserServiceUrl
+        });
+        this.sessions.set(sessionId, session);
+        return session;
+    }
+    /**
+     * 列出所有会话
+     */
+    async listSessions() {
+        // 从 Browser Service 查询会话列表
+        const response = await fetch(`${this.browserServiceUrl}/command`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'getStatus'
+            })
+        });
+        if (!response.ok) {
+            console.warn('[RemoteSessionManager] Failed to fetch sessions:', response.statusText);
+            return [];
+        }
+        const result = await response.json();
+        // BrowserService returns { ok: true, body: { ok: true, sessions: [...] } }
+        // or { ok: true, sessions: [...] } (depending on how it's wrapped)
+        const sessions = result.body?.sessions || result.sessions || result.data?.sessions || result.data || [];
+        if (Array.isArray(sessions)) {
+            sessions.forEach((session) => {
+                const profileId = session.profileId || session.profile_id || session.sessionId || session.session_id;
+                if (!profileId)
+                    return;
+                this.stateRegistry.updateSessionState(profileId, {
+                    profileId,
+                    sessionId: session.sessionId || session.session_id || profileId,
+                    currentUrl: session.currentUrl || session.current_url || '',
+                });
+            });
+        }
+        this.stateRegistry.flush();
+        return sessions;
+    }
+    /**
+     * 获取会话信息
+     */
+    async getSessionInfo(sessionId) {
+        const session = this.getSession(sessionId);
+        if (!session)
+            return null;
+        return session.getInfo();
+    }
+    /**
+     * 删除会话
+     */
+    async deleteSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        try {
+            await session.close();
+            this.sessions.delete(sessionId);
+            this.stateRegistry.removeSessionState(sessionId);
+            return true;
+        }
+        catch (error) {
+            console.warn(`[RemoteSessionManager] Failed to delete session ${sessionId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * 关闭所有会话
+     */
+    async shutdown() {
+        const entries = Array.from(this.sessions.entries());
+        const jobs = entries.map(([, session]) => session.close().catch(() => { }));
+        await Promise.all(jobs);
+        entries.forEach(([sessionId]) => this.stateRegistry.removeSessionState(sessionId));
+        this.sessions.clear();
+    }
+}
+//# sourceMappingURL=RemoteSessionManager.js.map

package/dist/services/unified-api/container-operations-handler.js

@@ -0,0 +1,115 @@
+import { logDebug } from '../../modules/logging/src/index.js';
+import { ensureBuiltinOperations } from '../../modules/operations/src/builtin.js';
+// Ensure builtin operations are registered before handling any requests
+ensureBuiltinOperations();
+export async function handleContainerOperations(req, res, sessionManager, executor) {
+    const url = new URL(req.url || '', `http://${req.headers.host}`);
+    // POST /v1/container/:containerId/execute
+    const executeMatch = url.pathname.match(/^\/v1\/container\/([^/]+)\/execute$/);
+    if (executeMatch && req.method === 'POST') {
+        const containerId = executeMatch[1];
+        const body = await readJsonBody(req);
+        const { operationId, config, sessionId } = body || {};
+        if (!sessionId) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'sessionId required' }));
+            return true;
+        }
+        if (!operationId) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'operationId required' }));
+            return true;
+        }
+        logDebug('container-ops', 'execute', { containerId, operationId, sessionId });
+        try {
+            const session = sessionManager?.getSession?.(sessionId);
+            if (!session) {
+                throw new Error(`Session not found: ${sessionId}`);
+            }
+            const page = await session.ensurePage();
+            const context = {
+                containerId,
+                page: {
+                    evaluate: async (fn, ...args) => page.evaluate(fn, ...args),
+                    keyboard: page.keyboard
+                        ? {
+                            type: async (text, options) => {
+                                await page.keyboard.type(text, { delay: options?.delay });
+                                if (options?.submit) {
+                                    await page.keyboard.press('Enter');
+                                }
+                            },
+                            press: async (key, options) => {
+                                await page.keyboard.press(key, { delay: options?.delay });
+                            },
+                        }
+                        : undefined,
+                    // Protocol mode operations read ctx.page.mouse directly.
+                    mouse: page.mouse
+                        ? {
+                            click: async (x, y, options) => page.mouse.click(x, y, options),
+                            move: async (x, y, options) => page.mouse.move(x, y, options),
+                            wheel: async (deltaX, deltaY) => page.mouse.wheel(deltaX, deltaY),
+                        }
+                        : undefined,
+                },
+                systemInput: {
+                    mouseMove: async (x, y, steps) => {
+                        if (!page.mouse?.move)
+                            throw new Error('Page mouse.move not available');
+                        await page.mouse.move(x, y, { steps: steps || 1 });
+                        return { success: true };
+                    },
+                    mouseClick: async (x, y, button, clicks) => {
+                        if (!page.mouse?.click)
+                            throw new Error('Page mouse.click not available');
+                        await page.mouse.click(x, y, { button: button || 'left', clickCount: clicks || 1 });
+                        return { success: true };
+                    },
+                    mouseWheel: async (deltaX, deltaY) => {
+                        if (!page.mouse?.wheel)
+                            throw new Error('Page mouse.wheel not available');
+                        await page.mouse.wheel(deltaX || 0, deltaY || 0);
+                        return { success: true };
+                    },
+                },
+                logger: {
+                    info: (...args) => logDebug('container-ops', 'info', args),
+                    warn: (...args) => logDebug('container-ops', 'warn', args),
+                    error: (...args) => logDebug('container-ops', 'error', args),
+                },
+            };
+            // Avoid hung container operations (especially on camoufox) from blocking the caller forever.
+            // Per-stage logging should live inside operations; this is a hard cap.
+            const hardTimeoutMs = typeof config?.timeoutMs === 'number' && Number.isFinite(config.timeoutMs)
+                ? Math.max(1000, Math.floor(config.timeoutMs))
+                : 30_000;
+            const hardTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error(`container_operation_timeout_${hardTimeoutMs}ms`)), hardTimeoutMs));
+            const result = (await Promise.race([
+                executor.execute(containerId, operationId, config || {}, context),
+                hardTimeout,
+            ]));
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: err.message || String(err) }));
+        }
+        return true;
+    }
+    return false;
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(chunk);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString('utf8').trim();
+    if (!raw)
+        return {};
+    return JSON.parse(raw);
+}
+//# sourceMappingURL=container-operations-handler.js.map