@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/camo-backend/src/internal/ElementRegistry.js

@@ -0,0 +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)));
+    }
+}
+//# sourceMappingURL=ElementRegistry.js.map

package/dist/modules/camo-backend/src/internal/ProfileLock.js

@@ -0,0 +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);
+        }
+    }
+}
+//# sourceMappingURL=ProfileLock.js.map

package/dist/modules/camo-backend/src/internal/SessionManager.js

@@ -0,0 +1,172 @@
+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.WEBAUTO_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);
+            }
+        };
+        await session.start(options.initialUrl);
+        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,
+        }));
+    }
+    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