gologin-agent-browser-cli 0.1.0

package/dist/daemon/sessionManager.js

@@ -0,0 +1,512 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const browser_1 = require("./browser");
+const refStore_1 = require("./refStore");
+const snapshot_1 = require("./snapshot");
+class SessionManager {
+    config;
+    sessions = new Map();
+    activeSessionId;
+    refStore = new refStore_1.RefStore();
+    constructor(config) {
+        this.config = config;
+    }
+    nowIso() {
+        return new Date().toISOString();
+    }
+    requireToken() {
+        if (!this.config.token) {
+            throw new errors_1.AppError("TOKEN_MISSING", "GOLOGIN_TOKEN is required for open", 400);
+        }
+        return this.config.token;
+    }
+    sessionExpired(session) {
+        if (session.idleTimeoutMs === undefined) {
+            return false;
+        }
+        const lastActivityAt = Date.parse(session.lastActivityAt);
+        if (Number.isNaN(lastActivityAt)) {
+            return false;
+        }
+        return Date.now() - lastActivityAt > session.idleTimeoutMs;
+    }
+    async destroySession(session) {
+        await (0, browser_1.closeSessionHandles)(session).catch(() => undefined);
+        this.sessions.delete(session.sessionId);
+        this.refStore.clear(session.sessionId);
+        if (session.autoCreatedProfile && session.profileId && this.config.token) {
+            await (0, browser_1.deleteProfile)(this.config.token, session.profileId).catch(() => undefined);
+        }
+        if (this.activeSessionId === session.sessionId) {
+            this.activeSessionId = Array.from(this.sessions.keys()).at(-1);
+        }
+    }
+    async getSessionOrThrow(sessionId) {
+        const resolvedId = sessionId ?? this.activeSessionId;
+        if (!resolvedId) {
+            throw new errors_1.AppError("SESSION_NOT_FOUND", "no active session", 404);
+        }
+        const session = this.sessions.get(resolvedId);
+        if (!session) {
+            throw new errors_1.AppError("SESSION_NOT_FOUND", `session ${resolvedId} does not exist`, 404, { sessionId: resolvedId });
+        }
+        if (this.sessionExpired(session)) {
+            const idleTimeoutMs = session.idleTimeoutMs;
+            await this.destroySession(session);
+            throw new errors_1.AppError("SESSION_EXPIRED", `session ${resolvedId} expired after ${idleTimeoutMs}ms of inactivity`, 404, { sessionId: resolvedId, idleTimeoutMs });
+        }
+        return session;
+    }
+    async evictExpiredSessions() {
+        for (const session of Array.from(this.sessions.values())) {
+            if (this.sessionExpired(session)) {
+                await this.destroySession(session);
+            }
+        }
+    }
+    toSummary(session) {
+        return {
+            sessionId: session.sessionId,
+            profileId: session.profileId,
+            url: session.currentUrl,
+            active: session.sessionId === this.activeSessionId,
+            hasSnapshot: session.hasSnapshot,
+            staleSnapshot: session.staleSnapshot,
+            liveViewUrl: session.liveViewUrl,
+            proxy: session.proxy,
+            createdAt: session.createdAt,
+            lastActivityAt: session.lastActivityAt,
+            idleTimeoutMs: session.idleTimeoutMs,
+            lastScreenshotPath: session.lastScreenshotPath,
+            lastPdfPath: session.lastPdfPath
+        };
+    }
+    touchSession(session) {
+        session.currentUrl = session.page.url();
+        session.lastActivityAt = this.nowIso();
+        this.activeSessionId = session.sessionId;
+    }
+    markSessionState(session, staleSnapshot = session.staleSnapshot) {
+        this.touchSession(session);
+        session.staleSnapshot = staleSnapshot;
+    }
+    validateIdleTimeout(idleTimeoutMs) {
+        if (idleTimeoutMs === undefined) {
+            return;
+        }
+        if (!Number.isInteger(idleTimeoutMs) || idleTimeoutMs <= 0) {
+            throw new errors_1.AppError("BAD_REQUEST", "--idle-timeout-ms must be a positive integer", 400);
+        }
+    }
+    async resolveTargetLocator(session, target) {
+        if ((0, utils_1.isRefTarget)(target)) {
+            const descriptor = this.refStore.get(session.sessionId, target);
+            if (!descriptor) {
+                throw new errors_1.AppError("REF_NOT_FOUND", `ref ${target} is not available in session ${session.sessionId}`, 404, {
+                    ref: target,
+                    sessionId: session.sessionId
+                });
+            }
+            return (0, browser_1.resolveDescriptorLocator)(session.page, descriptor);
+        }
+        return (0, browser_1.resolveSelectorLocator)(session.page, target, this.config.actionTimeoutMs);
+    }
+    async runTargetAction(session, target, action, value) {
+        const locator = await this.resolveTargetLocator(session, target);
+        await (0, browser_1.performLocatorAction)(session.page, locator, action, this.config.actionTimeoutMs, value);
+        this.markSessionState(session, true);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            staleSnapshot: true
+        };
+    }
+    async open(request) {
+        const token = this.requireToken();
+        this.validateIdleTimeout(request.idleTimeoutMs);
+        if (request.profileId && request.proxy) {
+            throw new errors_1.AppError("BAD_REQUEST", "proxy flags cannot be combined with --profile", 400);
+        }
+        if (request.sessionId && this.sessions.has(request.sessionId)) {
+            const existing = await this.getSessionOrThrow(request.sessionId);
+            if (request.profileId && existing.profileId && request.profileId !== existing.profileId) {
+                throw new errors_1.AppError("BAD_REQUEST", `session ${existing.sessionId} already uses profile ${existing.profileId}`, 400);
+            }
+            if (request.proxy) {
+                throw new errors_1.AppError("BAD_REQUEST", `session ${existing.sessionId} already exists; proxy cannot be changed`, 400);
+            }
+            if (request.idleTimeoutMs !== undefined) {
+                existing.idleTimeoutMs = request.idleTimeoutMs;
+            }
+            existing.currentUrl = await (0, browser_1.navigatePage)(existing.page, request.url, this.config.navigationTimeoutMs);
+            existing.hasSnapshot = false;
+            existing.staleSnapshot = true;
+            existing.lastActivityAt = this.nowIso();
+            this.refStore.clear(existing.sessionId);
+            this.activeSessionId = existing.sessionId;
+            return {
+                sessionId: existing.sessionId,
+                profileId: existing.profileId,
+                url: existing.currentUrl,
+                liveViewUrl: existing.liveViewUrl,
+                proxy: existing.proxy,
+                idleTimeoutMs: existing.idleTimeoutMs
+            };
+        }
+        let profileId = request.profileId ?? this.config.defaultProfileId;
+        let autoCreatedProfile = false;
+        let resolvedProxy;
+        const sessionId = request.sessionId ?? (0, utils_1.generateSessionId)(this.sessions.keys());
+        const createdAt = this.nowIso();
+        if (!profileId) {
+            const created = await (0, browser_1.createManagedProfile)(token, sessionId, request.proxy);
+            profileId = created.profileId;
+            resolvedProxy = created.proxy;
+            autoCreatedProfile = true;
+        }
+        try {
+            const connection = await (0, browser_1.connectToBrowser)(this.config, token, profileId);
+            const currentUrl = await (0, browser_1.navigatePage)(connection.page, request.url, this.config.navigationTimeoutMs);
+            const lastActivityAt = this.nowIso();
+            if (!resolvedProxy && profileId) {
+                resolvedProxy = await (0, browser_1.getCloudProfileProxy)(token, profileId).catch(() => undefined);
+            }
+            const session = {
+                sessionId,
+                profileId,
+                autoCreatedProfile,
+                connectUrl: connection.connectUrl,
+                browser: connection.browser,
+                context: connection.context,
+                page: connection.page,
+                currentUrl,
+                hasSnapshot: false,
+                staleSnapshot: false,
+                proxy: resolvedProxy,
+                createdAt,
+                lastActivityAt,
+                idleTimeoutMs: request.idleTimeoutMs
+            };
+            this.sessions.set(sessionId, session);
+            this.activeSessionId = sessionId;
+            this.refStore.clear(sessionId);
+            return {
+                sessionId,
+                profileId,
+                url: currentUrl,
+                proxy: session.proxy,
+                idleTimeoutMs: session.idleTimeoutMs
+            };
+        }
+        catch (error) {
+            if (autoCreatedProfile && profileId) {
+                await (0, browser_1.deleteProfile)(token, profileId).catch(() => undefined);
+            }
+            throw error;
+        }
+    }
+    async snapshot(sessionId, interactive = false) {
+        const session = await this.getSessionOrThrow(sessionId);
+        const snapshot = await (0, snapshot_1.buildSnapshot)(session.page, { interactive });
+        this.refStore.set(session.sessionId, snapshot.refs);
+        session.currentUrl = session.page.url();
+        session.hasSnapshot = true;
+        session.staleSnapshot = false;
+        session.lastActivityAt = this.nowIso();
+        this.activeSessionId = session.sessionId;
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            items: snapshot.items
+        };
+    }
+    async click(sessionId, target) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "click");
+    }
+    async type(sessionId, target, text) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "type", text);
+    }
+    async fill(sessionId, target, text) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "fill", text);
+    }
+    async hover(sessionId, target) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "hover");
+    }
+    async focus(sessionId, target) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "focus");
+    }
+    async doubleClick(sessionId, target) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "dblclick");
+    }
+    async select(sessionId, target, value) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "select", value);
+    }
+    async check(sessionId, target) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "check");
+    }
+    async uncheck(sessionId, target) {
+        return this.runTargetAction(await this.getSessionOrThrow(sessionId), target, "uncheck");
+    }
+    async press(sessionId, key, target) {
+        const session = await this.getSessionOrThrow(sessionId);
+        if (target) {
+            const locator = await this.resolveTargetLocator(session, target);
+            await locator.focus({ timeout: this.config.actionTimeoutMs });
+        }
+        await (0, browser_1.pressKey)(session.page, key, this.config.actionTimeoutMs);
+        this.markSessionState(session, true);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            staleSnapshot: true
+        };
+    }
+    async scroll(sessionId, direction, pixels = 500, target) {
+        const session = await this.getSessionOrThrow(sessionId);
+        if (target) {
+            const locator = await this.resolveTargetLocator(session, target);
+            await (0, browser_1.scrollElement)(locator, direction, pixels);
+        }
+        else {
+            await (0, browser_1.scrollPage)(session.page, direction, pixels);
+        }
+        this.markSessionState(session);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            target,
+            direction,
+            pixels
+        };
+    }
+    async scrollIntoView(sessionId, target) {
+        const session = await this.getSessionOrThrow(sessionId);
+        const locator = await this.resolveTargetLocator(session, target);
+        await (0, browser_1.scrollLocatorIntoView)(locator, this.config.actionTimeoutMs);
+        this.markSessionState(session);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            staleSnapshot: session.staleSnapshot
+        };
+    }
+    async upload(sessionId, target, files) {
+        const session = await this.getSessionOrThrow(sessionId);
+        const locator = await this.resolveTargetLocator(session, target);
+        try {
+            await (0, browser_1.uploadFiles)(locator, files, this.config.actionTimeoutMs);
+        }
+        catch (error) {
+            throw new errors_1.AppError("UPLOAD_FAILED", error instanceof Error ? error.message : String(error), 500, {
+                files
+            });
+        }
+        this.markSessionState(session, true);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            staleSnapshot: true,
+            files
+        };
+    }
+    async wait(sessionId, request) {
+        const session = await this.getSessionOrThrow(sessionId);
+        const timeoutMs = request.timeoutMs ?? this.config.navigationTimeoutMs;
+        if (request.timeoutMs && !request.target && !request.text && !request.urlPattern && !request.loadState) {
+            await new Promise((resolve) => setTimeout(resolve, request.timeoutMs));
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                waitedFor: `${request.timeoutMs}ms`
+            };
+        }
+        if (request.target) {
+            const locator = await this.resolveTargetLocator(session, request.target);
+            await (0, browser_1.waitForTarget)(locator, timeoutMs);
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                waitedFor: request.target
+            };
+        }
+        if (request.text) {
+            await (0, browser_1.waitForPageText)(session.page, request.text, timeoutMs);
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                waitedFor: `text:${request.text}`
+            };
+        }
+        if (request.urlPattern) {
+            await (0, browser_1.waitForPageUrl)(session.page, request.urlPattern, timeoutMs);
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                waitedFor: `url:${request.urlPattern}`
+            };
+        }
+        if (request.loadState) {
+            await (0, browser_1.waitForPageLoad)(session.page, request.loadState, timeoutMs);
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                waitedFor: `load:${request.loadState}`
+            };
+        }
+        throw new errors_1.AppError("BAD_REQUEST", "wait requires a target, timeout, --text, --url, or --load", 400);
+    }
+    async get(sessionId, kind, target) {
+        const session = await this.getSessionOrThrow(sessionId);
+        if (kind === "url") {
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                value: session.currentUrl
+            };
+        }
+        if (kind === "title") {
+            const value = await session.page.title();
+            this.markSessionState(session);
+            return {
+                sessionId: session.sessionId,
+                url: session.currentUrl,
+                value
+            };
+        }
+        if (!target) {
+            throw new errors_1.AppError("BAD_REQUEST", `get ${kind} requires a target`, 400);
+        }
+        const locator = await this.resolveTargetLocator(session, target);
+        const value = await (0, browser_1.readLocatorValue)(locator, kind, this.config.actionTimeoutMs);
+        this.markSessionState(session);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            value
+        };
+    }
+    async find(sessionId, request) {
+        const session = await this.getSessionOrThrow(sessionId);
+        const locator = await (0, browser_1.resolveSemanticLocator)(session.page, request.locator, this.config.actionTimeoutMs);
+        const value = await (0, browser_1.performLocatorAction)(session.page, locator, request.action, this.config.actionTimeoutMs, request.value);
+        const staleSnapshot = (0, browser_1.actionMutatesSnapshot)(request.action);
+        this.markSessionState(session, staleSnapshot ? true : session.staleSnapshot);
+        return {
+            sessionId: session.sessionId,
+            url: session.currentUrl,
+            staleSnapshot: session.staleSnapshot,
+            value
+        };
+    }
+    async screenshot(sessionId, targetPath, annotate = false) {
+        const session = await this.getSessionOrThrow(sessionId);
+        try {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+            if (annotate) {
+                const snapshot = await (0, snapshot_1.buildSnapshot)(session.page, { interactive: true });
+                this.refStore.set(session.sessionId, snapshot.refs);
+                session.hasSnapshot = true;
+                session.staleSnapshot = false;
+                const labels = [];
+                for (const descriptor of snapshot.refs) {
+                    const locator = await (0, browser_1.resolveDescriptorLocator)(session.page, descriptor).catch(() => undefined);
+                    if (!locator) {
+                        continue;
+                    }
+                    const box = await locator.boundingBox().catch(() => null);
+                    if (!box) {
+                        continue;
+                    }
+                    labels.push({
+                        ref: descriptor.ref,
+                        x: box.x,
+                        y: box.y
+                    });
+                }
+                await (0, browser_1.annotatePageWithRefs)(session.page, labels);
+            }
+            await session.page.screenshot({
+                path: targetPath,
+                fullPage: true
+            });
+            if (annotate) {
+                await (0, browser_1.clearPageAnnotations)(session.page).catch(() => undefined);
+            }
+        }
+        catch (error) {
+            if (annotate) {
+                await (0, browser_1.clearPageAnnotations)(session.page).catch(() => undefined);
+            }
+            throw new errors_1.AppError("SCREENSHOT_FAILED", error instanceof Error ? error.message : String(error), 500, {
+                path: targetPath
+            });
+        }
+        session.lastScreenshotPath = targetPath;
+        this.touchSession(session);
+        return {
+            sessionId: session.sessionId,
+            path: targetPath,
+            url: session.currentUrl,
+            annotated: annotate
+        };
+    }
+    async pdf(sessionId, targetPath) {
+        const session = await this.getSessionOrThrow(sessionId);
+        try {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+            await (0, browser_1.savePdf)(session.page, targetPath);
+        }
+        catch (error) {
+            throw new errors_1.AppError("PDF_FAILED", error instanceof Error ? error.message : String(error), 500, {
+                path: targetPath
+            });
+        }
+        session.lastPdfPath = targetPath;
+        this.markSessionState(session);
+        return {
+            sessionId: session.sessionId,
+            path: targetPath,
+            url: session.currentUrl
+        };
+    }
+    async close(sessionId) {
+        const session = await this.getSessionOrThrow(sessionId);
+        await this.destroySession(session);
+        return {
+            sessionId: session.sessionId,
+            closed: true
+        };
+    }
+    async listSessions() {
+        await this.evictExpiredSessions();
+        return {
+            activeSessionId: this.activeSessionId,
+            sessions: Array.from(this.sessions.values()).map((session) => this.toSummary(session))
+        };
+    }
+    async currentSession() {
+        return this.toSummary(await this.getSessionOrThrow());
+    }
+    async closeAll() {
+        for (const session of Array.from(this.sessions.values())) {
+            await this.destroySession(session);
+        }
+        this.sessions.clear();
+        this.activeSessionId = undefined;
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/daemon/snapshot.d.ts

@@ -0,0 +1,8 @@
+import type { Page } from "playwright";
+import type { RawSnapshotCandidate, SnapshotBuildResult } from "../lib/types";
+type SnapshotOptions = {
+    interactive?: boolean;
+};
+export declare function buildSnapshotModel(rawCandidates: RawSnapshotCandidate[], options?: SnapshotOptions): SnapshotBuildResult;
+export declare function buildSnapshot(page: Page, options?: SnapshotOptions): Promise<SnapshotBuildResult>;
+export {};