gologin-web-access 0.3.0

package/dist/internal-agent/daemon/refStore.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefStore = void 0;
+class RefStore {
+    store = new Map();
+    set(sessionId, refs) {
+        const map = new Map();
+        for (const descriptor of refs) {
+            map.set(descriptor.ref, descriptor);
+        }
+        this.store.set(sessionId, map);
+    }
+    get(sessionId, ref) {
+        return this.store.get(sessionId)?.get(ref);
+    }
+    list(sessionId) {
+        return Array.from(this.store.get(sessionId)?.values() ?? []);
+    }
+    clear(sessionId) {
+        this.store.delete(sessionId);
+    }
+    has(sessionId) {
+        return this.store.has(sessionId);
+    }
+}
+exports.RefStore = RefStore;

package/dist/internal-agent/daemon/server.js

@@ -0,0 +1,330 @@
+"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 node_path_1 = __importDefault(require("node:path"));
+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 = [];
+const daemonProjectRoot = node_path_1.default.resolve(__dirname, "..", "..", "..");
+const daemonVersion = readPackageVersion(daemonProjectRoot);
+const daemonStartedAt = new Date().toISOString();
+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"],
+                projectRoot: daemonProjectRoot,
+                version: daemonVersion,
+                startedAt: daemonStartedAt
+            };
+            (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 tabsSessionId = matchSessionRoute(pathname, "tabs");
+        if (method === "GET" && tabsSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.tabs(tabsSessionId));
+            return;
+        }
+        const tabOpenSessionId = matchSessionRoute(pathname, "tabopen");
+        if (method === "POST" && tabOpenSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.tabOpen(tabOpenSessionId, body?.url));
+            return;
+        }
+        const tabFocusSessionId = matchSessionRoute(pathname, "tabfocus");
+        if (method === "POST" && tabFocusSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.tabFocus(tabFocusSessionId, body.index));
+            return;
+        }
+        const tabCloseSessionId = matchSessionRoute(pathname, "tabclose");
+        if (method === "POST" && tabCloseSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.tabClose(tabCloseSessionId, body?.index));
+            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 backSessionId = matchSessionRoute(pathname, "back");
+        if (method === "POST" && backSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.back(backSessionId));
+            return;
+        }
+        const forwardSessionId = matchSessionRoute(pathname, "forward");
+        if (method === "POST" && forwardSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.forward(forwardSessionId));
+            return;
+        }
+        const reloadSessionId = matchSessionRoute(pathname, "reload");
+        if (method === "POST" && reloadSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.reload(reloadSessionId));
+            return;
+        }
+        const cookiesSessionId = matchSessionRoute(pathname, "cookies");
+        if (method === "GET" && cookiesSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.cookies(cookiesSessionId));
+            return;
+        }
+        const cookiesImportSessionId = matchSessionRoute(pathname, "cookies-import");
+        if (method === "POST" && cookiesImportSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.cookiesImport(cookiesImportSessionId, body.cookies));
+            return;
+        }
+        const cookiesClearSessionId = matchSessionRoute(pathname, "cookies-clear");
+        if (method === "POST" && cookiesClearSessionId) {
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.cookiesClear(cookiesClearSessionId));
+            return;
+        }
+        const storageExportSessionId = matchSessionRoute(pathname, "storage-export");
+        if (method === "POST" && storageExportSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.storageExport(storageExportSessionId, body?.scope));
+            return;
+        }
+        const storageImportSessionId = matchSessionRoute(pathname, "storage-import");
+        if (method === "POST" && storageImportSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.storageImport(storageImportSessionId, body.state, body.scope, body.clear === true));
+            return;
+        }
+        const storageClearSessionId = matchSessionRoute(pathname, "storage-clear");
+        if (method === "POST" && storageClearSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.storageClear(storageClearSessionId, body?.scope));
+            return;
+        }
+        const evalSessionId = matchSessionRoute(pathname, "eval");
+        if (method === "POST" && evalSessionId) {
+            const body = (await (0, utils_1.readJsonBody)(request));
+            (0, utils_1.writeJsonResponse)(response, 200, await sessionManager.eval(evalSessionId, body.expression));
+            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, body.pressEscape === 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);
+        });
+    });
+}
+function readPackageVersion(projectRoot) {
+    try {
+        const raw = node_fs_1.default.readFileSync(node_path_1.default.join(projectRoot, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+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);
+});