@web-auto/camo 0.2.0 → 0.2.1

package/src/services/browser-service/internal/ElementRegistry.js

@@ -1,61 +1,61 @@
-/**
- * 元素注册表
- * 管理浏览器端 ElementHandle 的生命周期和映射
- */
-export class ElementRegistry {
-    elements = new Map();
-    pageMap = new Map(); // elementId -> pageId (for cleanup)
-    /**
-     * 注册元素并返回唯一 ID
-     */
-    register(element, pageId) {
-        const id = `el_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        this.elements.set(id, element);
-        if (pageId) {
-            this.pageMap.set(id, pageId);
-        }
-        return id;
-    }
-    /**
-     * 获取元素
-     */
-    get(id) {
-        return this.elements.get(id);
-    }
-    /**
-     * 释放元素
-     */
-    async release(id) {
-        const element = this.elements.get(id);
-        if (element) {
-            try {
-                await element.dispose();
-            }
-            catch (e) {
-                // Ignore disposal errors
-            }
-            this.elements.delete(id);
-            this.pageMap.delete(id);
-        }
-    }
-    /**
-     * 清理特定页面的所有元素
-     */
-    async clearPage(pageId) {
-        const toRemove = [];
-        for (const [id, pid] of this.pageMap.entries()) {
-            if (pid === pageId) {
-                toRemove.push(id);
-            }
-        }
-        await Promise.all(toRemove.map(id => this.release(id)));
-    }
-    /**
-     * 清理所有元素
-     */
-    async clearAll() {
-        const ids = Array.from(this.elements.keys());
-        await Promise.all(ids.map(id => this.release(id)));
-    }
-}
+/**
+ * 元素注册表
+ * 管理浏览器端 ElementHandle 的生命周期和映射
+ */
+export class ElementRegistry {
+    elements = new Map();
+    pageMap = new Map(); // elementId -> pageId (for cleanup)
+    /**
+     * 注册元素并返回唯一 ID
+     */
+    register(element, pageId) {
+        const id = `el_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.elements.set(id, element);
+        if (pageId) {
+            this.pageMap.set(id, pageId);
+        }
+        return id;
+    }
+    /**
+     * 获取元素
+     */
+    get(id) {
+        return this.elements.get(id);
+    }
+    /**
+     * 释放元素
+     */
+    async release(id) {
+        const element = this.elements.get(id);
+        if (element) {
+            try {
+                await element.dispose();
+            }
+            catch (e) {
+                // Ignore disposal errors
+            }
+            this.elements.delete(id);
+            this.pageMap.delete(id);
+        }
+    }
+    /**
+     * 清理特定页面的所有元素
+     */
+    async clearPage(pageId) {
+        const toRemove = [];
+        for (const [id, pid] of this.pageMap.entries()) {
+            if (pid === pageId) {
+                toRemove.push(id);
+            }
+        }
+        await Promise.all(toRemove.map(id => this.release(id)));
+    }
+    /**
+     * 清理所有元素
+     */
+    async clearAll() {
+        const ids = Array.from(this.elements.keys());
+        await Promise.all(ids.map(id => this.release(id)));
+    }
+}
 //# sourceMappingURL=ElementRegistry.js.map

package/src/services/browser-service/internal/ProfileLock.js

@@ -1,85 +1,85 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { resolveLocksRoot } from './storage-paths.js';
-export class ProfileLock {
-    profileId;
-    lockDir;
-    lockFile;
-    constructor(profileId, lockRoot = resolveLocksRoot()) {
-        this.profileId = profileId;
-        this.lockDir = lockRoot;
-        fs.mkdirSync(this.lockDir, { recursive: true });
-        this.lockFile = path.join(this.lockDir, `${this.profileId}.lock`);
-    }
-    isProcessRunning(pid) {
-        try {
-            process.kill(pid, 0);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    killProcess(pid) {
-        try {
-            process.kill(pid, 'SIGTERM');
-        }
-        catch { }
-        const start = Date.now();
-        while (Date.now() - start < 5000) {
-            if (!this.isProcessRunning(pid))
-                return;
-        }
-        try {
-            process.kill(pid, 'SIGKILL');
-        }
-        catch { }
-    }
-    acquire() {
-        if (fs.existsSync(this.lockFile)) {
-            try {
-                const raw = JSON.parse(fs.readFileSync(this.lockFile, 'utf-8'));
-                const pid = Number(raw?.pid);
-                if (pid && pid !== process.pid && this.isProcessRunning(pid)) {
-                    this.killProcess(pid);
-                }
-            }
-            catch {
-                // ignore corrupted lock
-            }
-            try {
-                fs.unlinkSync(this.lockFile);
-            }
-            catch { }
-        }
-        try {
-            const payload = JSON.stringify({
-                pid: process.pid,
-                profileId: this.profileId,
-                createdAt: Date.now(),
-                host: os.hostname(),
-            }, null, 2);
-            fs.writeFileSync(this.lockFile, payload, { encoding: 'utf-8' });
-            return true;
-        }
-        catch (err) {
-            console.error(`[ProfileLock] failed to acquire lock for ${this.profileId}:`, err);
-            return false;
-        }
-    }
-    release() {
-        try {
-            if (!fs.existsSync(this.lockFile))
-                return;
-            const raw = JSON.parse(fs.readFileSync(this.lockFile, 'utf-8'));
-            if (Number(raw?.pid) !== process.pid)
-                return;
-            fs.unlinkSync(this.lockFile);
-        }
-        catch (err) {
-            console.warn(`[ProfileLock] release failed for ${this.profileId}:`, err);
-        }
-    }
-}
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { resolveLocksRoot } from './storage-paths.js';
+export class ProfileLock {
+    profileId;
+    lockDir;
+    lockFile;
+    constructor(profileId, lockRoot = resolveLocksRoot()) {
+        this.profileId = profileId;
+        this.lockDir = lockRoot;
+        fs.mkdirSync(this.lockDir, { recursive: true });
+        this.lockFile = path.join(this.lockDir, `${this.profileId}.lock`);
+    }
+    isProcessRunning(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    killProcess(pid) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch { }
+        const start = Date.now();
+        while (Date.now() - start < 5000) {
+            if (!this.isProcessRunning(pid))
+                return;
+        }
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch { }
+    }
+    acquire() {
+        if (fs.existsSync(this.lockFile)) {
+            try {
+                const raw = JSON.parse(fs.readFileSync(this.lockFile, 'utf-8'));
+                const pid = Number(raw?.pid);
+                if (pid && pid !== process.pid && this.isProcessRunning(pid)) {
+                    this.killProcess(pid);
+                }
+            }
+            catch {
+                // ignore corrupted lock
+            }
+            try {
+                fs.unlinkSync(this.lockFile);
+            }
+            catch { }
+        }
+        try {
+            const payload = JSON.stringify({
+                pid: process.pid,
+                profileId: this.profileId,
+                createdAt: Date.now(),
+                host: os.hostname(),
+            }, null, 2);
+            fs.writeFileSync(this.lockFile, payload, { encoding: 'utf-8' });
+            return true;
+        }
+        catch (err) {
+            console.error(`[ProfileLock] failed to acquire lock for ${this.profileId}:`, err);
+            return false;
+        }
+    }
+    release() {
+        try {
+            if (!fs.existsSync(this.lockFile))
+                return;
+            const raw = JSON.parse(fs.readFileSync(this.lockFile, 'utf-8'));
+            if (Number(raw?.pid) !== process.pid)
+                return;
+            fs.unlinkSync(this.lockFile);
+        }
+        catch (err) {
+            console.warn(`[ProfileLock] release failed for ${this.profileId}:`, err);
+        }
+    }
+}
 //# sourceMappingURL=ProfileLock.js.map

package/src/services/browser-service/internal/SessionManager.js

@@ -1,184 +1,184 @@
-import { BrowserSession } from './BrowserSession.js';
-export const SESSION_CLOSED_EVENT = 'browser-service:session-closed';
-function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export class SessionManager {
-    sessions = new Map();
-    // Track owning process (e.g. script pid) and bind browser lifetime to it.
-    owners = new Map();
-    sessionFactory;
-    ownerWatchdog;
-    ownerWatchdogBusy = false;
-    debugLog(label, data) {
-        if (process.env.DEBUG !== '1' && process.env.CAMO_DEBUG !== '1' && process.env.CAMO_DEBUG !== '1')
-            return;
-        try {
-            console.log(`[browser-service:${label}] ${JSON.stringify(data)}`);
-        }
-        catch {
-            console.log(`[browser-service:${label}]`, data);
-        }
-    }
-    // Optional options are currently not used, but allowed for future extensions
-    constructor(_options, sessionFactory) {
-        this.sessionFactory = sessionFactory || ((opts) => new BrowserSession(opts));
-        const watchdogMs = Math.max(1000, Number(_options?.ownerWatchdogMs || 5000));
-        this.ownerWatchdog = setInterval(() => {
-            void this.reapDeadOwners();
-        }, watchdogMs);
-        this.ownerWatchdog.unref?.();
-    }
-    normalizeOwnerPid(value) {
-        const pid = Number(value || 0);
-        return Number.isFinite(pid) && pid > 0 ? pid : null;
-    }
-    bindOwner(profileId, pid) {
-        if (!pid)
-            return;
-        this.owners.set(profileId, { pid, startedAt: new Date().toISOString() });
-    }
-    async reapDeadOwners() {
-        if (this.ownerWatchdogBusy)
-            return;
-        this.ownerWatchdogBusy = true;
-        try {
-            for (const [profileId, owner] of this.owners.entries()) {
-                if (!owner?.pid)
-                    continue;
-                if (isProcessAlive(owner.pid))
-                    continue;
-                this.debugLog('owner:dead_cleanup', { profileId, deadPid: owner.pid });
-                await this.deleteSession(profileId).catch((err) => {
-                    this.debugLog('owner:dead_cleanup_error', {
-                        profileId,
-                        deadPid: owner.pid,
-                        error: err?.message || err,
-                    });
-                });
-            }
-        }
-        finally {
-            this.ownerWatchdogBusy = false;
-        }
-    }
-    async createSession(options) {
-        const profileId = options.profileId || options.sessionId || `session_${Date.now().toString(36)}`;
-        options.profileId = profileId;
-        if (!options.sessionName) {
-            options.sessionName = profileId;
-        }
-        this.debugLog('createSession:start', {
-            profileId,
-            headless: options.headless,
-            hasInitialUrl: Boolean(options.initialUrl),
-            ownerPid: Number(options.ownerPid || 0) || null,
-        });
-        const existing = this.sessions.get(profileId);
-        const ownerPid = this.normalizeOwnerPid(options.ownerPid);
-        if (existing) {
-            const owner = this.owners.get(profileId);
-            if (owner?.pid && !isProcessAlive(owner.pid)) {
-                // Owner died; treat existing session as stale and replace it.
-                this.debugLog('createSession:replace_stale_owner', { profileId, deadPid: owner.pid });
-                await this.deleteSession(profileId);
-            }
-            else {
-                if (ownerPid && owner?.pid && owner.pid !== ownerPid && isProcessAlive(owner.pid)) {
-                    throw new Error(`session_owned_by_another_process profile=${profileId} ownerPid=${owner.pid} requesterPid=${ownerPid}`);
-                }
-                this.bindOwner(profileId, ownerPid);
-                this.debugLog('createSession:reuse', {
-                    profileId,
-                    ownerPid: this.owners.get(profileId)?.pid || null,
-                    requesterPid: ownerPid,
-                });
-                // Reuse existing session (keepalive). Do not restart the browser if it's already running.
-                return { sessionId: profileId };
-            }
-        }
-        const session = this.sessionFactory(options);
-        session.onExit = (id) => {
-            const current = this.sessions.get(id);
-            if (current === session) {
-                this.sessions.delete(id);
-                // If the user closed the browser window, also terminate the owning script (if any).
-                const owner = this.owners.get(id);
-                if (owner?.pid) {
-                    try {
-                        process.kill(owner.pid, 'SIGTERM');
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-                this.owners.delete(id);
-                process.emit(SESSION_CLOSED_EVENT, id);
-            }
-        };
-        try {
-            await session.start(options.initialUrl);
-        }
-        catch (err) {
-            this.debugLog('createSession:start_failed', {
-                profileId,
-                error: err?.message || String(err),
-            });
-            session.onExit = undefined;
-            await session.close().catch(() => { });
-            throw err;
-        }
-        this.sessions.set(profileId, session);
-        this.debugLog('createSession:started', { profileId });
-        this.bindOwner(profileId, ownerPid);
-        return { sessionId: profileId };
-    }
-    getSession(profileId) {
-        this.debugLog('getSession', { profileId, hit: this.sessions.has(profileId) });
-        return this.sessions.get(profileId);
-    }
-    listSessions() {
-        return Array.from(this.sessions.values()).map((session) => ({
-            profileId: session.id,
-            session_id: session.id,
-            current_url: session.getCurrentUrl(),
-            mode: session.modeName,
-            owner_pid: this.owners.get(session.id)?.pid || null,
-            recording: session.getRecordingStatus(),
-        }));
-    }
-    async getSessionInfo(profileId) {
-        const session = this.getSession(profileId);
-        if (!session)
-            return null;
-        return session.getInfo();
-    }
-    async deleteSession(profileId) {
-        const session = this.sessions.get(profileId);
-        if (!session)
-            return false;
-        this.debugLog('deleteSession:start', { profileId });
-        session.onExit = undefined;
-        await session.close();
-        this.sessions.delete(profileId);
-        // Deleting a session from API should NOT kill the owner (Stop=only kill script lives in UI).
-        this.owners.delete(profileId);
-        process.emit(SESSION_CLOSED_EVENT, profileId);
-        this.debugLog('deleteSession:done', { profileId });
-        return true;
-    }
-    async shutdown() {
-        clearInterval(this.ownerWatchdog);
-        const jobs = Array.from(this.sessions.values()).map((session) => session.close().catch(() => { }));
-        await Promise.all(jobs);
-        this.sessions.clear();
-        this.owners.clear();
-    }
-}
-//# sourceMappingURL=SessionManager.js.map
+import { BrowserSession } from './BrowserSession.js';
+export const SESSION_CLOSED_EVENT = 'browser-service:session-closed';
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class SessionManager {
+    sessions = new Map();
+    // Track owning process (e.g. script pid) and bind browser lifetime to it.
+    owners = new Map();
+    sessionFactory;
+    ownerWatchdog;
+    ownerWatchdogBusy = false;
+    debugLog(label, data) {
+        if (process.env.DEBUG !== '1' && process.env.CAMO_DEBUG !== '1' && process.env.CAMO_DEBUG !== '1')
+            return;
+        try {
+            console.log(`[browser-service:${label}] ${JSON.stringify(data)}`);
+        }
+        catch {
+            console.log(`[browser-service:${label}]`, data);
+        }
+    }
+    // Optional options are currently not used, but allowed for future extensions
+    constructor(_options, sessionFactory) {
+        this.sessionFactory = sessionFactory || ((opts) => new BrowserSession(opts));
+        const watchdogMs = Math.max(1000, Number(_options?.ownerWatchdogMs || 5000));
+        this.ownerWatchdog = setInterval(() => {
+            void this.reapDeadOwners();
+        }, watchdogMs);
+        this.ownerWatchdog.unref?.();
+    }
+    normalizeOwnerPid(value) {
+        const pid = Number(value || 0);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    bindOwner(profileId, pid) {
+        if (!pid)
+            return;
+        this.owners.set(profileId, { pid, startedAt: new Date().toISOString() });
+    }
+    async reapDeadOwners() {
+        if (this.ownerWatchdogBusy)
+            return;
+        this.ownerWatchdogBusy = true;
+        try {
+            for (const [profileId, owner] of this.owners.entries()) {
+                if (!owner?.pid)
+                    continue;
+                if (isProcessAlive(owner.pid))
+                    continue;
+                this.debugLog('owner:dead_cleanup', { profileId, deadPid: owner.pid });
+                await this.deleteSession(profileId).catch((err) => {
+                    this.debugLog('owner:dead_cleanup_error', {
+                        profileId,
+                        deadPid: owner.pid,
+                        error: err?.message || err,
+                    });
+                });
+            }
+        }
+        finally {
+            this.ownerWatchdogBusy = false;
+        }
+    }
+    async createSession(options) {
+        const profileId = options.profileId || options.sessionId || `session_${Date.now().toString(36)}`;
+        options.profileId = profileId;
+        if (!options.sessionName) {
+            options.sessionName = profileId;
+        }
+        this.debugLog('createSession:start', {
+            profileId,
+            headless: options.headless,
+            hasInitialUrl: Boolean(options.initialUrl),
+            ownerPid: Number(options.ownerPid || 0) || null,
+        });
+        const existing = this.sessions.get(profileId);
+        const ownerPid = this.normalizeOwnerPid(options.ownerPid);
+        if (existing) {
+            const owner = this.owners.get(profileId);
+            if (owner?.pid && !isProcessAlive(owner.pid)) {
+                // Owner died; treat existing session as stale and replace it.
+                this.debugLog('createSession:replace_stale_owner', { profileId, deadPid: owner.pid });
+                await this.deleteSession(profileId);
+            }
+            else {
+                if (ownerPid && owner?.pid && owner.pid !== ownerPid && isProcessAlive(owner.pid)) {
+                    throw new Error(`session_owned_by_another_process profile=${profileId} ownerPid=${owner.pid} requesterPid=${ownerPid}`);
+                }
+                this.bindOwner(profileId, ownerPid);
+                this.debugLog('createSession:reuse', {
+                    profileId,
+                    ownerPid: this.owners.get(profileId)?.pid || null,
+                    requesterPid: ownerPid,
+                });
+                // Reuse existing session (keepalive). Do not restart the browser if it's already running.
+                return { sessionId: profileId };
+            }
+        }
+        const session = this.sessionFactory(options);
+        session.onExit = (id) => {
+            const current = this.sessions.get(id);
+            if (current === session) {
+                this.sessions.delete(id);
+                // If the user closed the browser window, also terminate the owning script (if any).
+                const owner = this.owners.get(id);
+                if (owner?.pid) {
+                    try {
+                        process.kill(owner.pid, 'SIGTERM');
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                this.owners.delete(id);
+                process.emit(SESSION_CLOSED_EVENT, id);
+            }
+        };
+        try {
+            await session.start(options.initialUrl);
+        }
+        catch (err) {
+            this.debugLog('createSession:start_failed', {
+                profileId,
+                error: err?.message || String(err),
+            });
+            session.onExit = undefined;
+            await session.close().catch(() => { });
+            throw err;
+        }
+        this.sessions.set(profileId, session);
+        this.debugLog('createSession:started', { profileId });
+        this.bindOwner(profileId, ownerPid);
+        return { sessionId: profileId };
+    }
+    getSession(profileId) {
+        this.debugLog('getSession', { profileId, hit: this.sessions.has(profileId) });
+        return this.sessions.get(profileId);
+    }
+    listSessions() {
+        return Array.from(this.sessions.values()).map((session) => ({
+            profileId: session.id,
+            session_id: session.id,
+            current_url: session.getCurrentUrl(),
+            mode: session.modeName,
+            owner_pid: this.owners.get(session.id)?.pid || null,
+            recording: session.getRecordingStatus(),
+        }));
+    }
+    async getSessionInfo(profileId) {
+        const session = this.getSession(profileId);
+        if (!session)
+            return null;
+        return session.getInfo();
+    }
+    async deleteSession(profileId) {
+        const session = this.sessions.get(profileId);
+        if (!session)
+            return false;
+        this.debugLog('deleteSession:start', { profileId });
+        session.onExit = undefined;
+        await session.close();
+        this.sessions.delete(profileId);
+        // Deleting a session from API should NOT kill the owner (Stop=only kill script lives in UI).
+        this.owners.delete(profileId);
+        process.emit(SESSION_CLOSED_EVENT, profileId);
+        this.debugLog('deleteSession:done', { profileId });
+        return true;
+    }
+    async shutdown() {
+        clearInterval(this.ownerWatchdog);
+        const jobs = Array.from(this.sessions.values()).map((session) => session.close().catch(() => { }));
+        await Promise.all(jobs);
+        this.sessions.clear();
+        this.owners.clear();
+    }
+}
+//# sourceMappingURL=SessionManager.js.map