gologin-agent-browser-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GoLogin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# GoLogin Agent CLI
+
+GoLogin Agent CLI is a cloud browser automation CLI built for AI agents. It turns GoLogin Cloud Browser into a persistent, scriptable runtime with compact page snapshots, ref-based interaction, session memory, and shell-friendly commands.
+
+It is designed for agent loops that need to stay simple:
+
+- open a live browser session
+- read the page as a compact text snapshot
+- act on stable refs like `@e3`
+- keep working across multiple CLI calls through a local daemon
+- save artifacts such as screenshots and PDFs when needed
+
+Unlike local-browser automation tools, it runs on top of a cloud browser stack built around GoLogin profiles, proxies, fingerprinting, and anti-detect capabilities.
+
+## Why Cloud Browser
+
+Local-browser automation is convenient, but it comes with hard limits for agent workflows that need to survive real-world websites:
+
+- local browsers are easier to detect
+- local runs usually do not carry profile-based fingerprinting
+- local runs do not come with persistent cloud browser profiles
+- local networking is limited unless you bolt on your own proxy layer
+- local sessions are harder to standardize across agents and environments
+
+GoLogin Agent CLI takes the opposite approach:
+
+- cloud browser runtime instead of a local browser process
+- GoLogin profiles as the session identity layer
+- proxy-aware browser sessions
+- fingerprint and anti-detect capabilities inherited from GoLogin
+- a persistent daemon that keeps agent sessions alive across CLI calls
+
+## Architecture
+
+The system has two parts:
+
+- `gologin-agent-browser` CLI
+- a persistent local daemon
+
+The CLI parses commands, auto-starts the daemon when needed, and prints compact output for agents. The daemon owns live browser sessions, connects to GoLogin Cloud Browser through Playwright `connectOverCDP`, keeps the active page in memory, builds snapshots, resolves refs like `@e1`, and tracks session metadata such as proxy mode, idle timeout, and generated artifacts.
+
+If you do not provide a profile id, the daemon creates a temporary GoLogin cloud profile through the GoLogin API, uses it to open the session, and attempts to delete it when the session is closed.
+
+Transport is local only:
+
+- Unix socket at `${TMPDIR:-/tmp}/gologin-agent-browser.sock` on Unix-like systems
+- localhost HTTP on `127.0.0.1:${GOLOGIN_DAEMON_PORT:-44777}`
+
+## Installation
+
+Node.js 18+ is required.
+
+Install from npm:
+
+```bash
+npm install -g gologin-agent-browser-cli
+```
+
+Run it directly:
+
+```bash
+gologin-agent-browser --help
+```
+
+Or use it without a global install:
+
+```bash
+npx gologin-agent-browser-cli --help
+```
+
+Developer setup from source:
+
+```bash
+git clone https://gitlab.com/easync/agent-browser.git
+cd agent-browser
+npm install
+npm run build
+```
+
+## Required Environment
+
+- `GOLOGIN_TOKEN` required for `open`
+- `GOLOGIN_PROFILE_ID` optional default profile for `open`
+- `GOLOGIN_DAEMON_PORT` optional, defaults to `44777`
+- `GOLOGIN_CONNECT_BASE` optional, defaults to `https://cloudbrowser.gologin.com/connect`
+
+Optional config file:
+
+```json
+{
+  "token": "from-your-own-secret-store",
+  "defaultProfileId": "profile-id",
+  "daemonPort": 44777,
+  "connectBase": "https://cloudbrowser.gologin.com/connect"
+}
+```
+
+Save it as `~/.gologin-agent-browser/config.json`.
+
+## Quickstart
+
+```bash
+export GOLOGIN_TOKEN=your_token
+
+gologin-agent-browser open https://example.com
+gologin-agent-browser snapshot -i
+gologin-agent-browser current
+gologin-agent-browser click @e3
+gologin-agent-browser fill "input[name='email']" "test@example.com"
+gologin-agent-browser scroll down 600
+gologin-agent-browser get title
+gologin-agent-browser pdf page.pdf
+gologin-agent-browser screenshot page.png --annotate
+gologin-agent-browser sessions
+gologin-agent-browser close
+```
+
+More examples:
+
+```bash
+gologin-agent-browser open https://example.com --proxy-host 1.2.3.4 --proxy-port 8080 --proxy-mode http --idle-timeout-ms 300000
+gologin-agent-browser open https://example.com --profile your-preconfigured-gologin-profile
+gologin-agent-browser click "a[href*='iana']"
+gologin-agent-browser type @e4 "hello world"
+gologin-agent-browser focus "input[name='email']"
+gologin-agent-browser press Enter
+gologin-agent-browser select "select[name='plan']" pro
+gologin-agent-browser check "input[name='terms']"
+gologin-agent-browser uncheck "input[name='newsletter']"
+gologin-agent-browser scrollintoview "#submit"
+gologin-agent-browser find label "Email" fill "test@example.com"
+gologin-agent-browser upload "input[type='file']" /absolute/path/to/avatar.png
+gologin-agent-browser wait --text "Welcome"
+```
+
+## Commands
+
+- `open <url> [--profile <profileId>] [--session <sessionId>] [--idle-timeout-ms <ms>]`
+- `open <url> [--proxy-host <host> --proxy-port <port> --proxy-mode <http|socks4|socks5> --proxy-user <user> --proxy-pass <pass>]`
+- `snapshot [--session <sessionId>] [--interactive]`
+- `click <target> [--session <sessionId>]`
+- `dblclick <target> [--session <sessionId>]`
+- `focus <target> [--session <sessionId>]`
+- `type <target> <text> [--session <sessionId>]`
+- `fill <target> <text> [--session <sessionId>]`
+- `hover <target> [--session <sessionId>]`
+- `select <target> <value> [--session <sessionId>]`
+- `check <target> [--session <sessionId>]`
+- `uncheck <target> [--session <sessionId>]`
+- `press <key> [target] [--session <sessionId>]`
+- `scroll <up|down|left|right> [pixels] [--target <target>] [--session <sessionId>]`
+- `scrollintoview <target> [--session <sessionId>]`
+- `wait <target|ms> [--text <text>] [--url <pattern>] [--load <state>] [--session <sessionId>]`
+- `get <text|value|html|title|url> [target] [--session <sessionId>]`
+- `find <role|text|label|placeholder|first|last|nth> ...`
+- `upload <target> <file...> [--session <sessionId>]`
+- `pdf <path> [--session <sessionId>]`
+- `screenshot <path> [--annotate] [--session <sessionId>]`
+- `close [--session <sessionId>]`
+- `sessions`
+- `current`
+
+## Example Session Flow
+
+`snapshot` produces compact output designed for agent consumption:
+
+```text
+session=s1 url=https://example.com/
+- heading "Example Domain" [ref=@e1]
+- paragraph "This domain is for use in illustrative examples in documents." [ref=@e2]
+- link "More information..." [ref=@e3]
+- checkbox "Accept terms" [checked] [ref=@e4]
+- select "Plan" [selected=Pro] [ref=@e5]
+```
+
+Agents can then use those refs:
+
+```bash
+gologin-agent-browser click @e3
+gologin-agent-browser type @e4 "hello world"
+gologin-agent-browser fill "input[name='email']" "test@example.com"
+gologin-agent-browser find role button click --name "Submit"
+gologin-agent-browser screenshot page.png --annotate
+```
+
+Targets can be either snapshot refs like `@e4` or raw Playwright/CSS selectors. `find` adds semantic locator flows similar to agent-browser.
+
+`open`, `current`, and `sessions` also expose session metadata in a shell-friendly form:
+
+```text
+session=s1 url=https://example.com snapshot=fresh proxy=http:1.2.3.4:8080 idleTimeoutMs=300000 shot=/tmp/page.png pdf=/tmp/page.pdf
+```
+
+When screenshots or PDFs are generated, `current` and `sessions` include the latest artifact paths as `shot=...` and `pdf=...`.
+
+Supported aliases:
+
+- `goto`, `navigate` -> `open`
+- `key` -> `press`
+- `scrollinto` -> `scrollintoview`
+- `quit`, `exit` -> `close`
+
+## Current Scope
+
+- Session persistence lasts as long as the local daemon is running. Restarting the daemon clears in-memory sessions and refs.
+- Idle timeout is a local daemon policy. It does not change GoLogin account-level cloud limits.
+- Snapshot and ref resolution are best-effort. Dynamic pages can invalidate refs after heavy DOM changes or navigation.
+- Snapshot output is compact and accessibility-informed, but it is not a full accessibility tree dump.
+- Annotated screenshots are based on the current snapshot/ref model, so labels are also best-effort on highly dynamic pages.
+- The daemon keeps only the latest snapshot ref map for each session.
+- Real browser sessions require a valid GoLogin Cloud Browser account and token. A profile id is optional.
+- Token-only mode works by provisioning a temporary cloud profile through the GoLogin API before connecting to Cloud Browser.
+- Proxy support is cloud-profile based. Temporary profiles can be created with a custom proxy definition, and existing GoLogin profiles can be reused with `--profile` if they already have a managed proxy attached.
+- Local Orbita is intentionally out of scope. This project targets GoLogin Cloud Browser only.
+- GoLogin cloud live-view URLs are not auto-fetched by default because the current endpoint can interfere with an active CDP session.
+- Playwright is the automation layer on top of GoLogin Cloud Browser. The browser runtime itself does not expose built-in agent actions such as `click()` or `type()`.
+
+## Live Smoke Check
+
+The project includes a smoke test path that only runs when `GOLOGIN_TOKEN` is present in the environment. If `GOLOGIN_PROFILE_ID` is also set, the smoke flow can reuse that profile; otherwise GoLogin can create a temporary session profile automatically. Secrets are never written into source files, tests, or examples.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+"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_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const check_1 = require("./commands/check");
+const click_1 = require("./commands/click");
+const close_1 = require("./commands/close");
+const current_1 = require("./commands/current");
+const dblclick_1 = require("./commands/dblclick");
+const fill_1 = require("./commands/fill");
+const find_1 = require("./commands/find");
+const focus_1 = require("./commands/focus");
+const get_1 = require("./commands/get");
+const hover_1 = require("./commands/hover");
+const open_1 = require("./commands/open");
+const pdf_1 = require("./commands/pdf");
+const press_1 = require("./commands/press");
+const screenshot_1 = require("./commands/screenshot");
+const scroll_1 = require("./commands/scroll");
+const scrollIntoView_1 = require("./commands/scrollIntoView");
+const sessions_1 = require("./commands/sessions");
+const snapshot_1 = require("./commands/snapshot");
+const select_1 = require("./commands/select");
+const type_1 = require("./commands/type");
+const uncheck_1 = require("./commands/uncheck");
+const upload_1 = require("./commands/upload");
+const wait_1 = require("./commands/wait");
+const config_1 = require("./lib/config");
+const errors_1 = require("./lib/errors");
+const utils_1 = require("./lib/utils");
+function printUsage() {
+    process.stderr.write([
+        "GoLogin Agent CLI",
+        "",
+        "Usage:",
+        "  gologin-agent-browser <command> [args] [options]",
+        "",
+        "Commands:",
+        "  open <url> [--profile <profileId>] [--session <sessionId>] [--idle-timeout-ms <ms>] [--proxy-host <host> --proxy-port <port> --proxy-mode <http|socks4|socks5>] (aliases: goto, navigate)",
+        "  snapshot [--session <sessionId>] [--interactive|-i]",
+        "  click <target> [--session <sessionId>]",
+        "  dblclick <target> [--session <sessionId>]",
+        "  focus <target> [--session <sessionId>]",
+        "  type <target> <text> [--session <sessionId>]",
+        "  fill <target> <text> [--session <sessionId>]",
+        "  hover <target> [--session <sessionId>]",
+        "  select <target> <value> [--session <sessionId>]",
+        "  check <target> [--session <sessionId>]",
+        "  uncheck <target> [--session <sessionId>]",
+        "  press <key> [target] [--session <sessionId>] (alias: key)",
+        "  scroll <up|down|left|right> [pixels] [--target <target>] [--session <sessionId>]",
+        "  scrollintoview <target> [--session <sessionId>] (alias: scrollinto)",
+        "  wait <target|ms> [--text <text>] [--url <pattern>] [--load <state>] [--session <sessionId>]",
+        "  get <text|value|html|title|url> [target] [--session <sessionId>]",
+        "  find <role|text|label|placeholder|first|last|nth> ... [--exact]",
+        "  upload <target> <file...> [--session <sessionId>]",
+        "  pdf <path> [--session <sessionId>]",
+        "  screenshot <path> [--annotate] [--session <sessionId>]",
+        "  close [--session <sessionId>] (aliases: quit, exit)",
+        "  sessions",
+        "  current",
+        "",
+        "Environment:",
+        "  GOLOGIN_TOKEN",
+        "  GOLOGIN_PROFILE_ID",
+        "  GOLOGIN_DAEMON_PORT",
+        "  GOLOGIN_CONNECT_BASE"
+    ].join("\n") + "\n");
+}
+function projectRootFromCli() {
+    return node_path_1.default.resolve(__dirname, "..");
+}
+function buildDaemonSpawnCommand(projectRoot) {
+    const distServerPath = node_path_1.default.join(projectRoot, "dist", "daemon", "server.js");
+    if (node_fs_1.default.existsSync(distServerPath)) {
+        return {
+            command: process.execPath,
+            args: [distServerPath]
+        };
+    }
+    const tsxCli = node_path_1.default.join(projectRoot, "node_modules", "tsx", "dist", "cli.mjs");
+    const srcServerPath = node_path_1.default.join(projectRoot, "src", "daemon", "server.ts");
+    if (node_fs_1.default.existsSync(tsxCli) && node_fs_1.default.existsSync(srcServerPath)) {
+        return {
+            command: process.execPath,
+            args: [tsxCli, srcServerPath]
+        };
+    }
+    throw new errors_1.AppError("DAEMON_UNREACHABLE", "Daemon entrypoint is missing. Run npm install and npm run build first.", 500);
+}
+function requestOverHttp(transport, method, requestPath, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body === undefined ? undefined : Buffer.from(JSON.stringify(body));
+        const options = transport.kind === "socket"
+            ? {
+                socketPath: transport.socketPath,
+                path: requestPath,
+                method,
+                headers: payload
+                    ? {
+                        "content-type": "application/json",
+                        "content-length": String(payload.length)
+                    }
+                    : undefined
+            }
+            : {
+                host: transport.host,
+                port: transport.port,
+                path: requestPath,
+                method,
+                headers: payload
+                    ? {
+                        "content-type": "application/json",
+                        "content-length": String(payload.length)
+                    }
+                    : undefined
+            };
+        const request = node_http_1.default.request(options, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => chunks.push(chunk));
+            response.on("end", () => {
+                const raw = chunks.length > 0 ? Buffer.concat(chunks).toString("utf8") : "{}";
+                const parsed = raw.length > 0 ? JSON.parse(raw) : undefined;
+                if ((response.statusCode ?? 500) >= 400) {
+                    if ((0, utils_1.isDaemonErrorResponse)(parsed)) {
+                        reject((0, errors_1.fromDaemonError)(parsed));
+                        return;
+                    }
+                    reject(new errors_1.AppError("INTERNAL_ERROR", `Daemon request failed with status ${response.statusCode}`, 500));
+                    return;
+                }
+                resolve(parsed);
+            });
+        });
+        request.on("error", (error) => reject(error));
+        if (payload) {
+            request.write(payload);
+        }
+        request.end();
+    });
+}
+async function probeTransport(transport) {
+    try {
+        await requestOverHttp(transport, "GET", "/health");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForDaemon(transports, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        for (const transport of transports) {
+            if (await probeTransport(transport)) {
+                return transport;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return undefined;
+}
+async function ensureDaemon(config) {
+    const transports = [];
+    if (process.platform !== "win32") {
+        transports.push({
+            kind: "socket",
+            socketPath: config.socketPath
+        });
+    }
+    transports.push({
+        kind: "http",
+        host: config.daemonHost,
+        port: config.daemonPort
+    });
+    for (const transport of transports) {
+        if (await probeTransport(transport)) {
+            return transport;
+        }
+    }
+    const projectRoot = projectRootFromCli();
+    const command = buildDaemonSpawnCommand(projectRoot);
+    const child = (0, node_child_process_1.spawn)(command.command, command.args, {
+        cwd: projectRoot,
+        detached: true,
+        stdio: "ignore",
+        env: process.env
+    });
+    child.unref();
+    const resolved = await waitForDaemon(transports, 5_000);
+    if (!resolved) {
+        throw new errors_1.AppError("DAEMON_UNREACHABLE", "Local daemon did not start in time", 503);
+    }
+    return resolved;
+}
+function createDaemonClient(transport) {
+    return {
+        transport,
+        async request(method, requestPath, body) {
+            return (await requestOverHttp(transport, method, requestPath, body));
+        }
+    };
+}
+async function runCommand(command, context, args) {
+    switch (command) {
+        case "open":
+            await (0, open_1.runOpenCommand)(context, args);
+            return;
+        case "snapshot":
+            await (0, snapshot_1.runSnapshotCommand)(context, args);
+            return;
+        case "click":
+            await (0, click_1.runClickCommand)(context, args);
+            return;
+        case "dblclick":
+            await (0, dblclick_1.runDoubleClickCommand)(context, args);
+            return;
+        case "focus":
+            await (0, focus_1.runFocusCommand)(context, args);
+            return;
+        case "type":
+            await (0, type_1.runTypeCommand)(context, args);
+            return;
+        case "fill":
+            await (0, fill_1.runFillCommand)(context, args);
+            return;
+        case "hover":
+            await (0, hover_1.runHoverCommand)(context, args);
+            return;
+        case "select":
+            await (0, select_1.runSelectCommand)(context, args);
+            return;
+        case "check":
+            await (0, check_1.runCheckCommand)(context, args);
+            return;
+        case "uncheck":
+            await (0, uncheck_1.runUncheckCommand)(context, args);
+            return;
+        case "press":
+            await (0, press_1.runPressCommand)(context, args);
+            return;
+        case "scroll":
+            await (0, scroll_1.runScrollCommand)(context, args);
+            return;
+        case "scrollintoview":
+            await (0, scrollIntoView_1.runScrollIntoViewCommand)(context, args);
+            return;
+        case "wait":
+            await (0, wait_1.runWaitCommand)(context, args);
+            return;
+        case "get":
+            await (0, get_1.runGetCommand)(context, args);
+            return;
+        case "find":
+            await (0, find_1.runFindCommand)(context, args);
+            return;
+        case "upload":
+            await (0, upload_1.runUploadCommand)(context, args);
+            return;
+        case "pdf":
+            await (0, pdf_1.runPdfCommand)(context, args);
+            return;
+        case "screenshot":
+            await (0, screenshot_1.runScreenshotCommand)(context, args);
+            return;
+        case "close":
+            await (0, close_1.runCloseCommand)(context, args);
+            return;
+        case "sessions":
+            await (0, sessions_1.runSessionsCommand)(context, args);
+            return;
+        case "current":
+            await (0, current_1.runCurrentCommand)(context, args);
+            return;
+    }
+}
+function normalizeCommand(commandArg) {
+    const aliases = {
+        goto: "open",
+        navigate: "open",
+        dblclick: "dblclick",
+        key: "press",
+        scrollinto: "scrollintoview",
+        quit: "close",
+        exit: "close"
+    };
+    if (aliases[commandArg]) {
+        return aliases[commandArg];
+    }
+    const directCommands = new Set([
+        "open",
+        "snapshot",
+        "click",
+        "dblclick",
+        "focus",
+        "type",
+        "fill",
+        "hover",
+        "select",
+        "check",
+        "uncheck",
+        "press",
+        "scroll",
+        "scrollintoview",
+        "wait",
+        "get",
+        "find",
+        "upload",
+        "pdf",
+        "screenshot",
+        "close",
+        "sessions",
+        "current"
+    ]);
+    return directCommands.has(commandArg) ? commandArg : undefined;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const commandArg = argv[0];
+    if (!commandArg || commandArg === "--help" || commandArg === "-h") {
+        printUsage();
+        process.exit(commandArg ? 0 : 1);
+    }
+    const command = normalizeCommand(commandArg);
+    if (!command) {
+        throw new errors_1.AppError("BAD_REQUEST", `Unknown command: ${commandArg}`, 400);
+    }
+    const config = (0, config_1.loadConfig)();
+    const transport = await ensureDaemon(config);
+    const client = createDaemonClient(transport);
+    const health = await client.request("GET", "/health");
+    if (!health.ok) {
+        throw new errors_1.AppError("DAEMON_UNREACHABLE", "Daemon health probe failed", 503);
+    }
+    const context = {
+        client,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        cwd: process.cwd()
+    };
+    await runCommand(command, context, argv.slice(1));
+}
+main().catch((error) => {
+    process.stderr.write(`${(0, errors_1.formatErrorLine)(error)}\n`);
+    process.exit(error instanceof errors_1.AppError ? 1 : 1);
+});

package/dist/commands/check.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../lib/types";
+export declare function runCheckCommand(context: CommandContext, argv: string[]): Promise<void>;

package/dist/commands/check.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCheckCommand = runCheckCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runCheckCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const target = parsed.positional[0];
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    if (!target) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser check <target> [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/check`, { target });
+    (0, shared_1.writeActionResult)(context, "checked", target, response);
+}

package/dist/commands/click.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../lib/types";
+export declare function runClickCommand(context: CommandContext, argv: string[]): Promise<void>;

package/dist/commands/click.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runClickCommand = runClickCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runClickCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const target = parsed.positional[0];
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    if (!target) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser click <target> [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/click`, { target });
+    (0, shared_1.writeActionResult)(context, "clicked", target, response);
+}

package/dist/commands/close.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../lib/types";
+export declare function runCloseCommand(context: CommandContext, argv: string[]): Promise<void>;

package/dist/commands/close.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCloseCommand = runCloseCommand;
+const utils_1 = require("../lib/utils");
+async function runCloseCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const resolvedSessionId = sessionId ??
+        (await context.client.request("GET", "/sessions/current")).sessionId;
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/close`);
+    context.stdout.write(`closed session=${response.sessionId}\n`);
+}

package/dist/commands/current.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../lib/types";
+export declare function runCurrentCommand(context: CommandContext, argv: string[]): Promise<void>;

package/dist/commands/current.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCurrentCommand = runCurrentCommand;
+const utils_1 = require("../lib/utils");
+async function runCurrentCommand(context, argv) {
+    (0, utils_1.parseArgs)(argv);
+    const response = await context.client.request("GET", "/sessions/current");
+    context.stdout.write(`${(0, utils_1.formatCurrentLine)(response)}\n`);
+}

package/dist/commands/dblclick.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../lib/types";
+export declare function runDoubleClickCommand(context: CommandContext, argv: string[]): Promise<void>;