ppxc-leads-mcp 0.1.0

package/dist/browser/kernel/runner-page-manager.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerPageManager = void 0;
+const logger_1 = require("./logger");
+const runner_page_session_1 = require("./runner-page-session");
+const log = logger_1.logger.scope("page-manager");
+class RunnerPageManager {
+    constructor(opts = {}) {
+        this._sessions = new Map();
+        this._windowCreateIndexes = new Map();
+        this._lastRecycleReasons = new Map();
+        this._opts = {
+            maxConcurrent: opts.maxConcurrent ?? 2,
+            defaultVisible: opts.defaultVisible ?? false,
+            navigationTimeoutMs: opts.navigationTimeoutMs ?? 25000,
+            collectMaxWaitMs: opts.collectMaxWaitMs ?? 12000,
+            collectMaxItems: opts.collectMaxItems ?? 30,
+            sessionDefaults: opts.sessionDefaults ?? {},
+        };
+    }
+    acquire(slotId, override) {
+        const existing = this._sessions.get(slotId);
+        if (existing && existing.isAlive()) {
+            if (existing.shouldRecycleOnRelease()) {
+                const reason = existing.lastRecycleReason ?? "recycle_after_session_marked_unusable";
+                this._lastRecycleReasons.set(slotId, reason);
+                log.warn(`slot ${slotId} previous session marked for recycle, will create fresh`, {
+                    reason,
+                    sessionId: existing.sessionId,
+                    windowCreateIndex: existing.windowCreateIndex,
+                });
+                void existing.close();
+                this._sessions.delete(slotId);
+            }
+            else {
+                if (override?.visible === true) {
+                    existing.reveal();
+                }
+                log.info(`slot ${slotId} session reused`, {
+                    total: this._sessions.size,
+                    warmed: existing.isWarmed(),
+                    sessionId: existing.sessionId,
+                    windowCreateIndex: existing.windowCreateIndex,
+                });
+                return existing;
+            }
+        }
+        if (existing && !existing.isAlive()) {
+            log.warn(`slot ${slotId} previous session dead, will create fresh`);
+            void existing.close();
+            this._sessions.delete(slotId);
+        }
+        if (this._sessions.size >= this._opts.maxConcurrent) {
+            throw new Error(`RunnerPageManager: max concurrent sessions reached (${this._opts.maxConcurrent})`);
+        }
+        const windowCreateIndex = (this._windowCreateIndexes.get(slotId) ?? 0) + 1;
+        this._windowCreateIndexes.set(slotId, windowCreateIndex);
+        const session = new runner_page_session_1.RunnerPageSession({
+            slotId,
+            windowCreateIndex,
+            lastRecycleReason: this._lastRecycleReasons.get(slotId) ?? null,
+            visible: override?.visible ?? this._opts.defaultVisible,
+            navigationTimeoutMs: override?.navigationTimeoutMs ?? this._opts.navigationTimeoutMs,
+            collectMaxWaitMs: override?.collectMaxWaitMs ?? this._opts.collectMaxWaitMs,
+            collectMaxItems: override?.collectMaxItems ?? this._opts.collectMaxItems,
+            ...this._opts.sessionDefaults,
+            ...override,
+        });
+        this._sessions.set(slotId, session);
+        log.info(`slot ${slotId} session created`, {
+            total: this._sessions.size,
+            maxConcurrent: this._opts.maxConcurrent,
+            sessionId: session.sessionId,
+            windowCreateIndex,
+            lastRecycleReason: session.lastRecycleReason,
+        });
+        return session;
+    }
+    async release(slotId) {
+        const session = this._sessions.get(slotId);
+        if (!session)
+            return;
+        this._sessions.delete(slotId);
+        if (session.lastRecycleReason) {
+            this._lastRecycleReasons.set(slotId, session.lastRecycleReason);
+        }
+        await session.close();
+        log.info(`slot ${slotId} session released`, { total: this._sessions.size });
+    }
+    async invalidate(slotId, opts = {}) {
+        const session = this._sessions.get(slotId);
+        if (!session)
+            return;
+        const reason = opts.reason ?? "unknown";
+        session.invalidateWarmed();
+        session.markForRecycle(reason);
+        this._lastRecycleReasons.set(slotId, reason);
+        log.warn(`slot ${slotId} session invalidated`, {
+            reason,
+            release: opts.release === true,
+            total: this._sessions.size,
+            sessionId: session.sessionId,
+            windowCreateIndex: session.windowCreateIndex,
+        });
+        if (opts.release === true) {
+            await this.release(slotId);
+        }
+    }
+    reveal(slotId) {
+        return this._sessions.get(slotId)?.reveal() === true;
+    }
+    revealStatus(slotId) {
+        const session = this._sessions.get(slotId);
+        if (!session) {
+            return {
+                alive: false,
+                visible: false,
+                focused: false,
+                minimized: false,
+                bounds: null,
+                platform: process.platform,
+            };
+        }
+        return session.revealStatus();
+    }
+    getSession(slotId) {
+        return this._sessions.get(slotId) ?? null;
+    }
+    hideAll() {
+        for (const s of this._sessions.values()) {
+            s.hide();
+        }
+    }
+    async destroyAll() {
+        const all = Array.from(this._sessions.values());
+        this._sessions.clear();
+        await Promise.all(all.map((s) => s.close().catch(() => undefined)));
+        log.info(`destroyed all sessions`, { count: all.length });
+    }
+    get activeSlotIds() {
+        return Array.from(this._sessions.keys());
+    }
+}
+exports.RunnerPageManager = RunnerPageManager;
+//# sourceMappingURL=runner-page-manager.js.map