gologin-agent-browser-cli 0.1.0

package/dist/daemon/server.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = __importDefault(require("node:http"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("../lib/config");
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const sessionManager_1 = require("./sessionManager");
+const config = (0, config_1.loadConfig)();
+(0, config_1.ensureStateDir)(config);
+const sessionManager = new sessionManager_1.SessionManager(config);
+const activeServers = [];
+function logInfo(message) {
+    (0, utils_1.appendLog)(config.logPath, `[INFO] ${message}`);
+}
+function logError(message, error) {
+    const suffix = error instanceof Error ? ` ${error.stack ?? error.message}` : error ? ` ${String(error)}` : "";
+    (0, utils_1.appendLog)(config.logPath, `[ERROR] ${message}${suffix}`);
+}
+function matchSessionRoute(pathname, suffix) {
+    const match = pathname.match(new RegExp(`^/sessions/([^/]+)/${suffix}$`));
+    return match?.[1];
+}
+async function handleRequest(request, response) {
+    try {
+        const method = request.method ?? "GET";
+        const url = new URL(request.url ?? "/", "http://127.0.0.1");
+        const pathname = url.pathname;
+        if (method === "GET" && pathname === "/health") {
+            const payload = {
+                ok: true,
+                pid: process.pid,
+                transports: process.platform === "win32" ? ["http"] : ["socket", "http"]
+            };
+            (0, utils_1.writeJsonResponse)(response, 200, payload);
+            return;
+        }
+        if (method === "GET" && pathname === "/sessions") {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.listSessions());
+            return;
+        }
+        if (method === "GET" && pathname === "/sessions/current") {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.currentSession());
+            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));
+            return;
+        }
+        const snapshotSessionId = matchSessionRoute(pathname, "snapshot");
+        if (method === "POST" && snapshotSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            const payload = await sessionManager.snapshot(snapshotSessionId, body?.interactive === true);
+            (0, utils_1.writeJsonResponse)(response, 200, payload);
+            return;
+        }
+        const clickSessionId = matchSessionRoute(pathname, "click");
+        if (method === "POST" && clickSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.click(clickSessionId, body.target));
+            return;
+        }
+        const typeSessionId = matchSessionRoute(pathname, "type");
+        if (method === "POST" && typeSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.type(typeSessionId, body.target, body.text));
+            return;
+        }
+        const fillSessionId = matchSessionRoute(pathname, "fill");
+        if (method === "POST" && fillSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.fill(fillSessionId, body.target, body.text));
+            return;
+        }
+        const hoverSessionId = matchSessionRoute(pathname, "hover");
+        if (method === "POST" && hoverSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.hover(hoverSessionId, body.target));
+            return;
+        }
+        const focusSessionId = matchSessionRoute(pathname, "focus");
+        if (method === "POST" && focusSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.focus(focusSessionId, body.target));
+            return;
+        }
+        const doubleClickSessionId = matchSessionRoute(pathname, "dblclick");
+        if (method === "POST" && doubleClickSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.doubleClick(doubleClickSessionId, body.target));
+            return;
+        }
+        const selectSessionId = matchSessionRoute(pathname, "select");
+        if (method === "POST" && selectSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.select(selectSessionId, body.target, body.value));
+            return;
+        }
+        const checkSessionId = matchSessionRoute(pathname, "check");
+        if (method === "POST" && checkSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.check(checkSessionId, body.target));
+            return;
+        }
+        const uncheckSessionId = matchSessionRoute(pathname, "uncheck");
+        if (method === "POST" && uncheckSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.uncheck(uncheckSessionId, body.target));
+            return;
+        }
+        const pressSessionId = matchSessionRoute(pathname, "press");
+        if (method === "POST" && pressSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.press(pressSessionId, body.key, body.target));
+            return;
+        }
+        const waitSessionId = matchSessionRoute(pathname, "wait");
+        if (method === "POST" && waitSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.wait(waitSessionId, body));
+            return;
+        }
+        const scrollSessionId = matchSessionRoute(pathname, "scroll");
+        if (method === "POST" && scrollSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.scroll(scrollSessionId, body.direction, body.pixels, body.target));
+            return;
+        }
+        const scrollIntoViewSessionId = matchSessionRoute(pathname, "scrollintoview");
+        if (method === "POST" && scrollIntoViewSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.scrollIntoView(scrollIntoViewSessionId, body.target));
+            return;
+        }
+        const getSessionId = matchSessionRoute(pathname, "get");
+        if (method === "POST" && getSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.get(getSessionId, body.kind, body.target));
+            return;
+        }
+        const findSessionId = matchSessionRoute(pathname, "find");
+        if (method === "POST" && findSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.find(findSessionId, body));
+            return;
+        }
+        const screenshotSessionId = matchSessionRoute(pathname, "screenshot");
+        if (method === "POST" && screenshotSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.screenshot(screenshotSessionId, body.path, body.annotate === true));
+            return;
+        }
+        const uploadSessionId = matchSessionRoute(pathname, "upload");
+        if (method === "POST" && uploadSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.upload(uploadSessionId, body.target, body.files));
+            return;
+        }
+        const pdfSessionId = matchSessionRoute(pathname, "pdf");
+        if (method === "POST" && pdfSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.pdf(pdfSessionId, body.path));
+            return;
+        }
+        const closeSessionId = matchSessionRoute(pathname, "close");
+        if (method === "POST" && closeSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.close(closeSessionId));
+            return;
+        }
+        throw new errors_1.AppError("BAD_REQUEST", `Unsupported route ${method} ${pathname}`, 404);
+    }
+    catch (error) {
+        const payload = (0, errors_1.serializeError)(error);
+        logError(`Request failed for ${request.method} ${request.url}`, error);
+        (0, utils_1.writeJsonResponse)(response, payload.status, payload);
+    }
+}
+function createServer() {
+    return node_http_1.default.createServer((request, response) => {
+        handleRequest(request, response).catch((error) => {
+            const payload = (0, errors_1.serializeError)(error);
+            logError("Unhandled request failure", error);
+            (0, utils_1.writeJsonResponse)(response, payload.status, payload);
+        });
+    });
+}
+async function startServers() {
+    if (process.platform !== "win32" && node_fs_1.default.existsSync(config.socketPath)) {
+        node_fs_1.default.unlinkSync(config.socketPath);
+    }
+    if (process.platform !== "win32") {
+        const socketServer = createServer();
+        activeServers.push(socketServer);
+        await new Promise((resolve, reject) => {
+            socketServer.once("error", reject);
+            socketServer.listen(config.socketPath, () => resolve());
+        });
+        logInfo(`Socket server listening at ${config.socketPath}`);
+    }
+    const httpServer = createServer();
+    activeServers.push(httpServer);
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(config.daemonPort, config.daemonHost, () => resolve());
+    });
+    logInfo(`HTTP server listening at http://${config.daemonHost}:${config.daemonPort}`);
+}
+async function shutdown(signal) {
+    logInfo(`Received ${signal}, shutting down`);
+    await sessionManager.closeAll();
+    await Promise.all(activeServers.map((server) => new Promise((resolve) => {
+        server.close(() => resolve());
+    })));
+    if (process.platform !== "win32" && node_fs_1.default.existsSync(config.socketPath)) {
+        node_fs_1.default.unlinkSync(config.socketPath);
+    }
+}
+process.on("SIGINT", () => {
+    shutdown("SIGINT").finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    shutdown("SIGTERM").finally(() => process.exit(0));
+});
+startServers()
+    .then(() => {
+    logInfo("GoLogin Agent daemon started");
+})
+    .catch((error) => {
+    logError("Failed to start daemon", error);
+    process.exit(1);
+});

package/dist/daemon/sessionManager.d.ts

@@ -0,0 +1,50 @@
+import type { AgentConfig, CheckResponse, ClickResponse, CloseSessionResponse, DoubleClickResponse, FillResponse, FindRequest, FindResponse, FocusResponse, GetKind, GetResponse, HoverResponse, OpenSessionRequest, OpenSessionResponse, PdfResponse, PressResponse, ScrollDirection, ScrollIntoViewResponse, ScrollResponse, ScreenshotResponse, SelectResponse, SessionSummary, SessionsResponse, SnapshotResponse, TypeResponse, UncheckResponse, UploadResponse, WaitResponse } from "../lib/types";
+export declare class SessionManager {
+    private readonly config;
+    private readonly sessions;
+    private activeSessionId?;
+    private readonly refStore;
+    constructor(config: AgentConfig);
+    private nowIso;
+    private requireToken;
+    private sessionExpired;
+    private destroySession;
+    private getSessionOrThrow;
+    private evictExpiredSessions;
+    private toSummary;
+    private touchSession;
+    private markSessionState;
+    private validateIdleTimeout;
+    private resolveTargetLocator;
+    private runTargetAction;
+    open(request: OpenSessionRequest): Promise<OpenSessionResponse>;
+    snapshot(sessionId?: string, interactive?: boolean): Promise<SnapshotResponse>;
+    click(sessionId: string | undefined, target: string): Promise<ClickResponse>;
+    type(sessionId: string | undefined, target: string, text: string): Promise<TypeResponse>;
+    fill(sessionId: string | undefined, target: string, text: string): Promise<FillResponse>;
+    hover(sessionId: string | undefined, target: string): Promise<HoverResponse>;
+    focus(sessionId: string | undefined, target: string): Promise<FocusResponse>;
+    doubleClick(sessionId: string | undefined, target: string): Promise<DoubleClickResponse>;
+    select(sessionId: string | undefined, target: string, value: string): Promise<SelectResponse>;
+    check(sessionId: string | undefined, target: string): Promise<CheckResponse>;
+    uncheck(sessionId: string | undefined, target: string): Promise<UncheckResponse>;
+    press(sessionId: string | undefined, key: string, target?: string): Promise<PressResponse>;
+    scroll(sessionId: string | undefined, direction: ScrollDirection, pixels?: number, target?: string): Promise<ScrollResponse>;
+    scrollIntoView(sessionId: string | undefined, target: string): Promise<ScrollIntoViewResponse>;
+    upload(sessionId: string | undefined, target: string, files: string[]): Promise<UploadResponse>;
+    wait(sessionId: string | undefined, request: {
+        target?: string;
+        text?: string;
+        urlPattern?: string;
+        loadState?: "load" | "domcontentloaded" | "networkidle";
+        timeoutMs?: number;
+    }): Promise<WaitResponse>;
+    get(sessionId: string | undefined, kind: GetKind, target?: string): Promise<GetResponse>;
+    find(sessionId: string | undefined, request: FindRequest): Promise<FindResponse>;
+    screenshot(sessionId: string | undefined, targetPath: string, annotate?: boolean): Promise<ScreenshotResponse>;
+    pdf(sessionId: string | undefined, targetPath: string): Promise<PdfResponse>;
+    close(sessionId?: string): Promise<CloseSessionResponse>;
+    listSessions(): Promise<SessionsResponse>;
+    currentSession(): Promise<SessionSummary>;
+    closeAll(): Promise<void>;
+}