gologin-agent-browser-cli 0.2.0 → 0.2.1

package/dist/cli.js

@@ -80,8 +80,8 @@ const commandUsage = {
     upload: "upload <target> <file...> [--session <sessionId>]",
     pdf: "pdf <path> [--session <sessionId>]",
     screenshot: "screenshot <path> [--annotate] [--press-escape] [--session <sessionId>]",
-    close: "close [--session <sessionId>] (aliases: quit, exit)",
-    sessions: "sessions",
+    close: "close [--session <sessionId>] [--all] (aliases: quit, exit)",
+    sessions: "sessions [--prune] [--older-than-ms <ms>]",
     current: "current"
 };
 function printUsage() {

package/dist/commands/close.js

@@ -1,10 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCloseCommand = runCloseCommand;
+const errors_1 = require("../lib/errors");
 const utils_1 = require("../lib/utils");
 async function runCloseCommand(context, argv) {
     const parsed = (0, utils_1.parseArgs)(argv);
+    const closeAll = (0, utils_1.getFlagBoolean)(parsed, "all");
     const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    if (closeAll) {
+        if (sessionId) {
+            throw new errors_1.AppError("BAD_REQUEST", "--all cannot be combined with --session", 400);
+        }
+        const response = await context.client.request("POST", "/sessions/close-all");
+        context.stdout.write(`closed ${response.closed} session(s)\n`);
+        return;
+    }
     const resolvedSessionId = sessionId ??
         (await context.client.request("GET", "/sessions/current")).sessionId;
     const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/close`);

package/dist/commands/sessions.js

@@ -1,9 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSessionsCommand = runSessionsCommand;
+const errors_1 = require("../lib/errors");
 const utils_1 = require("../lib/utils");
+function parseOlderThanMs(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new errors_1.AppError("BAD_REQUEST", "--older-than-ms must be a non-negative integer", 400);
+    }
+    return parsed;
+}
 async function runSessionsCommand(context, argv) {
-    (0, utils_1.parseArgs)(argv);
+    const parsed = (0, utils_1.parseArgs)(argv);
+    if ((0, utils_1.getFlagBoolean)(parsed, "prune")) {
+        const olderThanMs = parseOlderThanMs((0, utils_1.getFlagString)(parsed, "older-than-ms"));
+        const prune = await context.client.request("POST", "/sessions/prune", {
+            maxIdleMs: olderThanMs,
+        });
+        context.stderr.write(`pruned ${prune.closed} session(s) idle for at least ${prune.maxIdleMs}ms\n`);
+    }
     const response = await context.client.request("GET", "/sessions");
     if (response.sessions.length === 0) {
         context.stdout.write("no sessions\n");

package/dist/daemon/server.js

@@ -46,6 +46,15 @@ async function handleRequest(request, response) {
             (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.currentSession());
             return;
         }
+        if (method === "POST" && pathname === "/sessions/close-all") {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.closeAll());
+            return;
+        }
+        if (method === "POST" && pathname === "/sessions/prune") {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.pruneSessions(body?.maxIdleMs));
+            return;
+        }
         if (method === "POST" && pathname === "/sessions/open") {
             const body = (await (0, utils_1.readJsonBody)(request));
             (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.open(body));

package/dist/daemon/sessionManager.d.ts

@@ -1,6 +1,8 @@
-import type { ActionResponse, AgentConfig, BrowserCookie, CheckResponse, ClickResponse, CloseSessionResponse, CookiesClearResponse, CookiesImportResponse, CookiesResponse, DoubleClickResponse, EvalResponse, FillResponse, FindRequest, FindResponse, FocusResponse, GetKind, GetResponse, HoverResponse, OpenSessionRequest, OpenSessionResponse, PdfResponse, PressResponse, ScrollDirection, ScrollIntoViewResponse, ScrollResponse, ScreenshotResponse, SelectResponse, SessionSummary, SessionsResponse, SnapshotResponse, StorageClearResponse, StorageExportResponse, StorageImportResponse, StorageScope, StorageState, TabCloseResponse, TabFocusResponse, TabOpenResponse, TabsResponse, TypeResponse, UncheckResponse, UploadResponse, WaitResponse } from "../lib/types";
+import type { ActionResponse, AgentConfig, BrowserCookie, CheckResponse, ClickResponse, CloseSessionResponse, CloseAllSessionsResponse, CookiesClearResponse, CookiesImportResponse, CookiesResponse, DoubleClickResponse, EvalResponse, FillResponse, FindRequest, FindResponse, FocusResponse, GetKind, GetResponse, HoverResponse, OpenSessionRequest, OpenSessionResponse, PdfResponse, PressResponse, PruneSessionsResponse, ScrollDirection, ScrollIntoViewResponse, ScrollResponse, ScreenshotResponse, SelectResponse, SessionSummary, SessionsResponse, SnapshotResponse, StorageClearResponse, StorageExportResponse, StorageImportResponse, StorageScope, StorageState, TabCloseResponse, TabFocusResponse, TabOpenResponse, TabsResponse, TypeResponse, UncheckResponse, UploadResponse, WaitResponse } from "../lib/types";
 export declare class SessionManager {
     private readonly config;
+    private static readonly DEFAULT_PRUNE_IDLE_MS;
+    private static readonly CLOUD_SLOT_RELEASE_WAIT_MS;
     private readonly sessions;
     private activeSessionId?;
     private readonly refStore;
@@ -8,6 +10,10 @@ export declare class SessionManager {
     private nowIso;
     private requireToken;
     private sessionExpired;
+    private sessionIdleMs;
+    private isCloudSlotLimitError;
+    private pruneInactiveSessions;
+    private waitForCloudSlotRelease;
     private destroySession;
     private getSessionOrThrow;
     private evictExpiredSessions;
@@ -17,6 +23,7 @@ export declare class SessionManager {
     private resetSnapshotState;
     private activatePage;
     private validateIdleTimeout;
+    private createSessionRecord;
     private resolveTargetLocator;
     private runTargetAction;
     open(request: OpenSessionRequest): Promise<OpenSessionResponse>;
@@ -62,5 +69,6 @@ export declare class SessionManager {
     close(sessionId?: string): Promise<CloseSessionResponse>;
     listSessions(): Promise<SessionsResponse>;
     currentSession(): Promise<SessionSummary>;
-    closeAll(): Promise<void>;
+    pruneSessions(maxIdleMs?: number): Promise<PruneSessionsResponse>;
+    closeAll(): Promise<CloseAllSessionsResponse>;
 }

package/dist/daemon/sessionManager.js

@@ -13,6 +13,8 @@ const refStore_1 = require("./refStore");
 const snapshot_1 = require("./snapshot");
 class SessionManager {
     config;
+    static DEFAULT_PRUNE_IDLE_MS = 10 * 60 * 1000;
+    static CLOUD_SLOT_RELEASE_WAIT_MS = 3_000;
     sessions = new Map();
     activeSessionId;
     refStore = new refStore_1.RefStore();
@@ -38,6 +40,32 @@ class SessionManager {
         }
         return Date.now() - lastActivityAt > session.idleTimeoutMs;
     }
+    sessionIdleMs(session) {
+        const lastActivityAt = Date.parse(session.lastActivityAt);
+        if (Number.isNaN(lastActivityAt)) {
+            return 0;
+        }
+        return Math.max(0, Date.now() - lastActivityAt);
+    }
+    isCloudSlotLimitError(error) {
+        return (error instanceof errors_1.AppError &&
+            error.code === "BROWSER_CONNECTION_FAILED" &&
+            /max parallel cloud launches limit/i.test(error.message));
+    }
+    async pruneInactiveSessions(maxIdleMs = SessionManager.DEFAULT_PRUNE_IDLE_MS) {
+        const closedSessionIds = [];
+        for (const session of Array.from(this.sessions.values())) {
+            if (this.sessionIdleMs(session) < maxIdleMs) {
+                continue;
+            }
+            closedSessionIds.push(session.sessionId);
+            await this.destroySession(session);
+        }
+        return closedSessionIds;
+    }
+    async waitForCloudSlotRelease() {
+        await new Promise((resolve) => setTimeout(resolve, SessionManager.CLOUD_SLOT_RELEASE_WAIT_MS));
+    }
     async destroySession(session) {
         await (0, browser_1.closeSessionHandles)(session).catch(() => undefined);
         this.sessions.delete(session.sessionId);
@@ -116,6 +144,30 @@ class SessionManager {
             throw new errors_1.AppError("BAD_REQUEST", "--idle-timeout-ms must be a positive integer", 400);
         }
     }
+    async createSessionRecord(token, sessionId, profileId, request, createdAt, resolvedProxy, autoCreatedProfile) {
+        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);
+        }
+        return {
+            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
+        };
+    }
     async resolveTargetLocator(session, target) {
         if ((0, utils_1.isRefTarget)(target)) {
             const descriptor = this.refStore.get(session.sessionId, target);
@@ -142,6 +194,7 @@ class SessionManager {
     async open(request) {
         const token = this.requireToken();
         this.validateIdleTimeout(request.idleTimeoutMs);
+        await this.pruneInactiveSessions();
         if (request.profileId && request.proxy) {
             throw new errors_1.AppError("BAD_REQUEST", "proxy flags cannot be combined with --profile", 400);
         }
@@ -180,35 +233,36 @@ class SessionManager {
             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);
+            let session;
+            try {
+                session = await this.createSessionRecord(token, sessionId, profileId, request, createdAt, resolvedProxy, autoCreatedProfile);
+            }
+            catch (error) {
+                if (!this.isCloudSlotLimitError(error)) {
+                    throw error;
+                }
+                if (this.sessions.size === 0) {
+                    throw new errors_1.AppError("BROWSER_CONNECTION_FAILED", `${error.message}. No tracked local sessions were available to close. Wait for cloud slots to free up or close stale sessions from another daemon, then retry.`, error.status, error.details);
+                }
+                const closedSessionIds = (await this.closeAll()).closedSessionIds;
+                await this.waitForCloudSlotRelease();
+                try {
+                    session = await this.createSessionRecord(token, sessionId, profileId, request, createdAt, resolvedProxy, autoCreatedProfile);
+                }
+                catch (retryError) {
+                    if (retryError instanceof errors_1.AppError && retryError.code === "BROWSER_CONNECTION_FAILED") {
+                        throw new errors_1.AppError(retryError.code, `${retryError.message}. Closed tracked sessions (${closedSessionIds.join(", ")}) and retried once, but the cloud slot was still unavailable.`, retryError.status, retryError.details);
+                    }
+                    throw retryError;
+                }
             }
-            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,
+                url: session.currentUrl,
                 proxy: session.proxy,
                 idleTimeoutMs: session.idleTimeoutMs
             };
@@ -436,10 +490,11 @@ class SessionManager {
                 value
             };
         }
-        if (!target) {
+        const resolvedTarget = target ?? (kind === "text" || kind === "html" ? "body" : undefined);
+        if (!resolvedTarget) {
             throw new errors_1.AppError("BAD_REQUEST", `get ${kind} requires a target`, 400);
         }
-        const locator = await this.resolveTargetLocator(session, target);
+        const locator = await this.resolveTargetLocator(session, resolvedTarget);
         const value = await (0, browser_1.readLocatorValue)(locator, kind, this.config.actionTimeoutMs);
         this.markSessionState(session);
         return {
@@ -673,12 +728,26 @@ class SessionManager {
     async currentSession() {
         return this.toSummary(await this.getSessionOrThrow());
     }
+    async pruneSessions(maxIdleMs = SessionManager.DEFAULT_PRUNE_IDLE_MS) {
+        const closedSessionIds = await this.pruneInactiveSessions(maxIdleMs);
+        return {
+            closed: closedSessionIds.length,
+            closedSessionIds,
+            maxIdleMs,
+        };
+    }
     async closeAll() {
+        const closedSessionIds = [];
         for (const session of Array.from(this.sessions.values())) {
+            closedSessionIds.push(session.sessionId);
             await this.destroySession(session);
         }
         this.sessions.clear();
         this.activeSessionId = undefined;
+        return {
+            closed: closedSessionIds.length,
+            closedSessionIds,
+        };
     }
 }
 exports.SessionManager = SessionManager;

package/dist/lib/types.d.ts

@@ -206,10 +206,22 @@ export interface CloseSessionResponse {
     sessionId: string;
     closed: true;
 }
+export interface CloseAllSessionsResponse {
+    closed: number;
+    closedSessionIds: string[];
+}
 export interface SessionsResponse {
     activeSessionId?: string;
     sessions: SessionSummary[];
 }
+export interface PruneSessionsRequest {
+    maxIdleMs?: number;
+}
+export interface PruneSessionsResponse {
+    closed: number;
+    closedSessionIds: string[];
+    maxIdleMs: number;
+}
 export interface TabSummary {
     index: number;
     url: string;

package/dist/lib/utils.js

@@ -26,7 +26,7 @@ const errors_1 = require("./errors");
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
-    const booleanFlags = new Set(["interactive", "exact", "annotate", "press-escape", "json", "clear"]);
+    const booleanFlags = new Set(["interactive", "exact", "annotate", "press-escape", "json", "clear", "all", "prune"]);
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === "-i") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gologin-agent-browser-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Agent-native cloud browser automation CLI for Gologin",
   "main": "dist/cli.js",
   "types": "dist/lib/types.d.ts",