gologin-agent-browser-cli 0.1.0

package/dist/daemon/snapshot.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSnapshotModel = buildSnapshotModel;
+exports.buildSnapshot = buildSnapshot;
+const INTERACTIVE_KINDS = new Set([
+    "link",
+    "button",
+    "input",
+    "checkbox",
+    "radio",
+    "textarea",
+    "select"
+]);
+function normalizeWhitespace(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function buildCandidateKey(candidate) {
+    return [
+        candidate.kind,
+        candidate.tag,
+        candidate.role ?? "",
+        normalizeWhitespace(candidate.accessibleName) ?? "",
+        normalizeWhitespace(candidate.text) ?? "",
+        normalizeWhitespace(candidate.ariaLabel) ?? "",
+        normalizeWhitespace(candidate.placeholder) ?? "",
+        normalizeWhitespace(candidate.name) ?? "",
+        normalizeWhitespace(candidate.href) ?? "",
+        normalizeWhitespace(candidate.inputType) ?? ""
+    ].join("|");
+}
+function candidateText(candidate) {
+    return (normalizeWhitespace(candidate.accessibleName) ??
+        normalizeWhitespace(candidate.text) ??
+        normalizeWhitespace(candidate.selectedText) ??
+        normalizeWhitespace(candidate.placeholder) ??
+        normalizeWhitespace(candidate.name) ??
+        normalizeWhitespace(candidate.href));
+}
+function buildSnapshotModel(rawCandidates, options = {}) {
+    const counters = new Map();
+    const items = [];
+    const refs = [];
+    for (const candidate of rawCandidates) {
+        if (options.interactive && !INTERACTIVE_KINDS.has(candidate.kind)) {
+            continue;
+        }
+        const text = candidateText(candidate);
+        if (!text) {
+            continue;
+        }
+        const key = buildCandidateKey(candidate);
+        const nth = counters.get(key) ?? 0;
+        counters.set(key, nth + 1);
+        const ref = `@e${items.length + 1}`;
+        items.push({
+            ref,
+            kind: candidate.kind,
+            text,
+            role: candidate.role,
+            flags: [
+                ...(candidate.checked === true ? ["checked"] : []),
+                ...(candidate.disabled === true ? ["disabled"] : []),
+                ...(normalizeWhitespace(candidate.selectedText) ? [`selected=${normalizeWhitespace(candidate.selectedText)}`] : [])
+            ]
+        });
+        refs.push({
+            ref,
+            kind: candidate.kind,
+            tag: candidate.tag,
+            role: candidate.role,
+            text: normalizeWhitespace(candidate.text),
+            accessibleName: normalizeWhitespace(candidate.accessibleName),
+            ariaLabel: normalizeWhitespace(candidate.ariaLabel),
+            placeholder: normalizeWhitespace(candidate.placeholder),
+            inputType: normalizeWhitespace(candidate.inputType),
+            name: normalizeWhitespace(candidate.name),
+            href: normalizeWhitespace(candidate.href),
+            nth,
+            checked: candidate.checked,
+            disabled: candidate.disabled,
+            selectedText: normalizeWhitespace(candidate.selectedText)
+        });
+    }
+    return { items, refs };
+}
+async function buildSnapshot(page, options = {}) {
+    const candidates = await page.evaluate(() => {
+        const selectors = [
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "a",
+            "button",
+            "input",
+            "textarea",
+            "select",
+            "p",
+            "[role='heading']",
+            "[role='link']",
+            "[role='button']",
+            "[role='textbox']"
+        ].join(",");
+        const seen = new WeakSet();
+        function normalize(value) {
+            if (!value) {
+                return undefined;
+            }
+            const trimmed = value.replace(/\s+/g, " ").trim();
+            return trimmed.length > 0 ? trimmed : undefined;
+        }
+        function isVisible(element) {
+            const htmlElement = element;
+            const style = window.getComputedStyle(htmlElement);
+            const rect = htmlElement.getBoundingClientRect();
+            return (style.display !== "none" &&
+                style.visibility !== "hidden" &&
+                style.opacity !== "0" &&
+                rect.width > 0 &&
+                rect.height > 0);
+        }
+        function implicitRole(element) {
+            const tag = element.tagName.toLowerCase();
+            if (/^h[1-6]$/.test(tag)) {
+                return "heading";
+            }
+            if (tag === "a") {
+                return "link";
+            }
+            if (tag === "button") {
+                return "button";
+            }
+            if (tag === "textarea") {
+                return "textbox";
+            }
+            if (tag === "select") {
+                return "combobox";
+            }
+            if (tag === "input") {
+                const type = element.type.toLowerCase();
+                if (type === "submit" || type === "button" || type === "reset") {
+                    return "button";
+                }
+                if (type === "checkbox") {
+                    return "checkbox";
+                }
+                if (type === "radio") {
+                    return "radio";
+                }
+                return "textbox";
+            }
+            return undefined;
+        }
+        function associatedLabel(element) {
+            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) {
+                const labels = Array.from(element.labels ?? []);
+                const text = labels
+                    .map((label) => normalize(label.textContent))
+                    .filter((value) => Boolean(value))
+                    .join(" ");
+                return normalize(text);
+            }
+            return undefined;
+        }
+        function kindFor(element) {
+            const tag = element.tagName.toLowerCase();
+            const role = element.getAttribute("role");
+            if (/^h[1-6]$/.test(tag) || role === "heading") {
+                return "heading";
+            }
+            if (tag === "a" || role === "link") {
+                return "link";
+            }
+            if (tag === "button" || role === "button") {
+                return "button";
+            }
+            if (tag === "textarea") {
+                return "textarea";
+            }
+            if (tag === "select") {
+                return "select";
+            }
+            if (tag === "input") {
+                const inputType = element.type.toLowerCase();
+                if (inputType === "checkbox") {
+                    return "checkbox";
+                }
+                if (inputType === "radio") {
+                    return "radio";
+                }
+                return "input";
+            }
+            if (role === "textbox") {
+                return "input";
+            }
+            if (tag === "p") {
+                return "paragraph";
+            }
+            return undefined;
+        }
+        function isParagraphWrappedInteractive(element) {
+            if (element.tagName.toLowerCase() !== "p") {
+                return false;
+            }
+            const children = Array.from(element.children);
+            if (children.length !== 1) {
+                return false;
+            }
+            const childTag = children[0]?.tagName.toLowerCase();
+            return childTag === "a" || childTag === "button";
+        }
+        const result = [];
+        for (const element of Array.from(document.querySelectorAll(selectors))) {
+            if (seen.has(element) || !isVisible(element)) {
+                continue;
+            }
+            seen.add(element);
+            const tag = element.tagName.toLowerCase();
+            const kind = kindFor(element);
+            if (!kind) {
+                continue;
+            }
+            if (isParagraphWrappedInteractive(element)) {
+                continue;
+            }
+            const explicitRole = normalize(element.getAttribute("role"));
+            const role = explicitRole ?? implicitRole(element);
+            const text = tag === "input" || tag === "textarea" || tag === "select"
+                ? undefined
+                : normalize(element.innerText || element.textContent);
+            const placeholder = element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement
+                ? normalize(element.placeholder)
+                : undefined;
+            const inputType = element instanceof HTMLInputElement ? normalize(element.type) : undefined;
+            const name = element instanceof HTMLInputElement ||
+                element instanceof HTMLTextAreaElement ||
+                element instanceof HTMLSelectElement
+                ? normalize(element.name)
+                : undefined;
+            const ariaLabel = normalize(element.getAttribute("aria-label"));
+            const label = associatedLabel(element);
+            const checked = element instanceof HTMLInputElement ? element.checked : undefined;
+            const disabled = element instanceof HTMLInputElement ||
+                element instanceof HTMLTextAreaElement ||
+                element instanceof HTMLSelectElement ||
+                element instanceof HTMLButtonElement
+                ? element.disabled
+                : element.hasAttribute("disabled");
+            const selectedText = element instanceof HTMLSelectElement
+                ? normalize(Array.from(element.selectedOptions)
+                    .map((option) => option.textContent ?? "")
+                    .join(" "))
+                : undefined;
+            const accessibleName = ariaLabel ??
+                label ??
+                normalize(element.innerText || element.textContent) ??
+                placeholder ??
+                name;
+            const href = element instanceof HTMLAnchorElement ? normalize(element.href) : undefined;
+            result.push({
+                kind,
+                tag,
+                role,
+                text,
+                accessibleName,
+                ariaLabel,
+                placeholder,
+                inputType,
+                name,
+                href,
+                checked,
+                disabled,
+                selectedText
+            });
+        }
+        return result;
+    });
+    return buildSnapshotModel(candidates, options);
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "./types";
+export declare function loadConfig(): AgentConfig;
+export declare function ensureStateDir(config: AgentConfig): void;

package/dist/lib/config.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.ensureStateDir = ensureStateDir;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const DEFAULT_CONNECT_BASE = "https://cloudbrowser.gologin.com/connect";
+const DEFAULT_DAEMON_PORT = 44777;
+const DEFAULT_DAEMON_HOST = "127.0.0.1";
+const DEFAULT_NAVIGATION_TIMEOUT_MS = 30_000;
+const DEFAULT_ACTION_TIMEOUT_MS = 10_000;
+function parsePort(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const port = Number(value);
+    return Number.isInteger(port) && port > 0 ? port : fallback;
+}
+function readConfigFile(configPath) {
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(configPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function loadConfig() {
+    const homeDir = node_os_1.default.homedir();
+    const baseDir = node_path_1.default.join(homeDir, ".gologin-agent-browser");
+    const configPath = node_path_1.default.join(baseDir, "config.json");
+    const logPath = node_path_1.default.join(baseDir, "daemon.log");
+    const socketPath = node_path_1.default.join(node_os_1.default.tmpdir(), "gologin-agent-browser.sock");
+    const fileConfig = readConfigFile(configPath);
+    return {
+        token: process.env.GOLOGIN_TOKEN ?? fileConfig.token,
+        defaultProfileId: process.env.GOLOGIN_PROFILE_ID ?? fileConfig.defaultProfileId,
+        connectBase: process.env.GOLOGIN_CONNECT_BASE ?? fileConfig.connectBase ?? DEFAULT_CONNECT_BASE,
+        daemonPort: parsePort(process.env.GOLOGIN_DAEMON_PORT, fileConfig.daemonPort ?? DEFAULT_DAEMON_PORT),
+        daemonHost: DEFAULT_DAEMON_HOST,
+        socketPath,
+        configPath,
+        logPath,
+        navigationTimeoutMs: DEFAULT_NAVIGATION_TIMEOUT_MS,
+        actionTimeoutMs: DEFAULT_ACTION_TIMEOUT_MS
+    };
+}
+function ensureStateDir(config) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(config.configPath), { recursive: true });
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,12 @@
+import type { DaemonErrorPayload } from "./types";
+export type ErrorCode = "DAEMON_UNREACHABLE" | "TOKEN_MISSING" | "PROFILE_MISSING" | "SESSION_NOT_FOUND" | "SESSION_EXPIRED" | "REF_NOT_FOUND" | "BROWSER_CONNECTION_FAILED" | "NAVIGATION_TIMEOUT" | "SCREENSHOT_FAILED" | "PDF_FAILED" | "UPLOAD_FAILED" | "BAD_REQUEST" | "INTERNAL_ERROR";
+export declare class AppError extends Error {
+    readonly code: ErrorCode;
+    readonly status: number;
+    readonly details?: Record<string, unknown>;
+    constructor(code: ErrorCode, message: string, status?: number, details?: Record<string, unknown>);
+}
+export declare function isDaemonErrorPayload(value: unknown): value is DaemonErrorPayload;
+export declare function serializeError(error: unknown): DaemonErrorPayload;
+export declare function fromDaemonError(payload: DaemonErrorPayload): AppError;
+export declare function formatErrorLine(error: unknown): string;

package/dist/lib/errors.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+exports.isDaemonErrorPayload = isDaemonErrorPayload;
+exports.serializeError = serializeError;
+exports.fromDaemonError = fromDaemonError;
+exports.formatErrorLine = formatErrorLine;
+class AppError extends Error {
+    code;
+    status;
+    details;
+    constructor(code, message, status = 500, details) {
+        super(message);
+        this.name = "AppError";
+        this.code = code;
+        this.status = status;
+        this.details = details;
+    }
+}
+exports.AppError = AppError;
+function isDaemonErrorPayload(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.code === "string" &&
+        typeof candidate.message === "string" &&
+        typeof candidate.status === "number");
+}
+function serializeError(error) {
+    if (error instanceof AppError) {
+        return {
+            code: error.code,
+            message: error.message,
+            status: error.status,
+            details: error.details
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            code: "INTERNAL_ERROR",
+            message: error.message,
+            status: 500
+        };
+    }
+    return {
+        code: "INTERNAL_ERROR",
+        message: String(error),
+        status: 500
+    };
+}
+function fromDaemonError(payload) {
+    return new AppError(payload.code, payload.message, payload.status, payload.details);
+}
+function formatErrorLine(error) {
+    if (error instanceof AppError) {
+        return `${error.code}: ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `${error.name}: ${error.message}`;
+    }
+    return `INTERNAL_ERROR: ${String(error)}`;
+}