gologin-agent-browser-cli 0.2.0

package/dist/commands/back.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBackCommand = runBackCommand;
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runBackCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/back`);
+    context.stdout.write(`session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

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/cookies.d.ts

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

package/dist/commands/cookies.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCookiesCommand = runCookiesCommand;
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runCookiesCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const outputPath = (0, utils_1.getFlagString)(parsed, "output");
+    const json = (0, utils_1.getFlagBoolean)(parsed, "json");
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("GET", `/sessions/${resolvedSessionId}/cookies`);
+    if (outputPath) {
+        const savedPath = (0, shared_1.writeJsonFile)(context, outputPath, response.cookies);
+        context.stdout.write(`${savedPath}\n`);
+        return;
+    }
+    if (json) {
+        (0, shared_1.writeJsonStdout)(context, response.cookies);
+        return;
+    }
+    context.stdout.write(`${JSON.stringify(response.cookies, null, 2)}\n`);
+}

package/dist/commands/cookiesClear.d.ts

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

package/dist/commands/cookiesClear.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCookiesClearCommand = runCookiesClearCommand;
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runCookiesClearCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/cookies-clear`);
+    context.stdout.write(`cleared=${response.cleared} session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

package/dist/commands/cookiesImport.d.ts

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

package/dist/commands/cookiesImport.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCookiesImportCommand = runCookiesImportCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runCookiesImportCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const cookiesPath = parsed.positional[0];
+    if (!cookiesPath) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser cookies-import <cookies.json> [--session <sessionId>]", 400);
+    }
+    const cookies = (0, shared_1.readJsonFile)(context, cookiesPath);
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/cookies-import`, { cookies });
+    context.stdout.write(`imported=${response.imported} session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\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>;

package/dist/commands/dblclick.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoubleClickCommand = runDoubleClickCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runDoubleClickCommand(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 dblclick <target> [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/dblclick`, { target });
+    (0, shared_1.writeActionResult)(context, "double-clicked", target, response);
+}

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctorCommand = runDoctorCommand;
+const daemon_1 = require("../lib/daemon");
+const utils_1 = require("../lib/utils");
+function writeJson(context, payload) {
+    context.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+function writeDoctorReport(context, report) {
+    context.stdout.write(`ok=${report.ok}\n`);
+    context.stdout.write(`tokenConfigured=${report.tokenConfigured}\n`);
+    if (report.defaultProfileId) {
+        context.stdout.write(`defaultProfileId=${report.defaultProfileId}\n`);
+    }
+    context.stdout.write(`connectBase=${report.connectBase}\n`);
+    context.stdout.write(`configPath=${report.configPath}\n`);
+    context.stdout.write(`daemonLogPath=${report.daemonLogPath}\n`);
+    for (const transport of report.transports) {
+        context.stdout.write(`transport=${transport.label} reachable=${transport.reachable}\n`);
+    }
+}
+async function runDoctorCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const json = (0, utils_1.getFlagBoolean)(parsed, "json");
+    const report = await (0, daemon_1.inspectDaemon)(context.config);
+    if (json) {
+        writeJson(context, report);
+        return;
+    }
+    writeDoctorReport(context, report);
+}

package/dist/commands/eval.d.ts

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

package/dist/commands/eval.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEvalCommand = runEvalCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runEvalCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const json = (0, utils_1.getFlagBoolean)(parsed, "json");
+    const expression = parsed.positional.join(" ").trim();
+    if (!expression) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser eval <expression> [--json] [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/eval`, { expression });
+    if (json) {
+        (0, shared_1.writeJsonStdout)(context, response.value);
+        return;
+    }
+    if (typeof response.value === "string") {
+        context.stdout.write(`${response.value}\n`);
+        return;
+    }
+    if (response.value === undefined) {
+        context.stdout.write("undefined\n");
+        return;
+    }
+    context.stdout.write(`${JSON.stringify(response.value)}\n`);
+}

package/dist/commands/fill.d.ts

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

package/dist/commands/fill.js

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

package/dist/commands/find.d.ts

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

package/dist/commands/find.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFindCommand = runFindCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+const ACTIONS = new Set(["click", "fill", "type", "hover", "text"]);
+function parseFindLocator(positional) {
+    const mode = positional[0];
+    if (mode === "role") {
+        const role = positional[1];
+        const action = positional[2];
+        const value = positional.slice(3).join(" ") || undefined;
+        if (!role || !action || !ACTIONS.has(action)) {
+            throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser find role <role> <action> [value] [--name <name>]", 400);
+        }
+        return { locator: { strategy: "role", role }, action, value };
+    }
+    if (mode === "text") {
+        const text = positional[1];
+        const action = positional[2];
+        const value = positional.slice(3).join(" ") || undefined;
+        if (!text || !action || !ACTIONS.has(action)) {
+            throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser find text <text> <action> [value]", 400);
+        }
+        return { locator: { strategy: "text", text }, action, value };
+    }
+    if (mode === "label") {
+        const label = positional[1];
+        const action = positional[2];
+        const value = positional.slice(3).join(" ") || undefined;
+        if (!label || !action || !ACTIONS.has(action)) {
+            throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser find label <label> <action> [value]", 400);
+        }
+        return { locator: { strategy: "label", label }, action, value };
+    }
+    if (mode === "placeholder") {
+        const placeholder = positional[1];
+        const action = positional[2];
+        const value = positional.slice(3).join(" ") || undefined;
+        if (!placeholder || !action || !ACTIONS.has(action)) {
+            throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser find placeholder <placeholder> <action> [value]", 400);
+        }
+        return { locator: { strategy: "placeholder", placeholder }, action, value };
+    }
+    if (mode === "first" || mode === "last") {
+        const selector = positional[1];
+        const action = positional[2];
+        const value = positional.slice(3).join(" ") || undefined;
+        if (!selector || !action || !ACTIONS.has(action)) {
+            throw new errors_1.AppError("BAD_REQUEST", `Usage: gologin-agent-browser find ${mode} <selector> <action> [value]`, 400);
+        }
+        return { locator: { strategy: mode, selector }, action, value };
+    }
+    if (mode === "nth") {
+        const nth = positional[1];
+        const selector = positional[2];
+        const action = positional[3];
+        const value = positional.slice(4).join(" ") || undefined;
+        if (!nth || !selector || !action || !ACTIONS.has(action) || Number.isNaN(Number(nth))) {
+            throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser find nth <n> <selector> <action> [value]", 400);
+        }
+        return { locator: { strategy: "nth", selector, nth: Number(nth) }, action, value };
+    }
+    throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser find <role|text|label|placeholder|first|last|nth> ...", 400);
+}
+async function runFindCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const name = (0, utils_1.getFlagString)(parsed, "name");
+    const exact = (0, utils_1.getFlagBoolean)(parsed, "exact");
+    const { locator, action, value } = parseFindLocator(parsed.positional);
+    if (locator.strategy === "role" && name) {
+        locator.name = name;
+    }
+    if (exact) {
+        locator.exact = true;
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/find`, { locator, action, value });
+    if (action === "text") {
+        context.stdout.write(`${response.value ?? ""}\n`);
+        return;
+    }
+    context.stdout.write(`find ${action} session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

package/dist/commands/focus.d.ts

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

package/dist/commands/focus.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFocusCommand = runFocusCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runFocusCommand(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 focus <target> [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/focus`, { target });
+    (0, shared_1.writeActionResult)(context, "focused", target, response);
+}

package/dist/commands/forward.d.ts

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

package/dist/commands/forward.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runForwardCommand = runForwardCommand;
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runForwardCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/forward`);
+    context.stdout.write(`session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

package/dist/commands/get.d.ts

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

package/dist/commands/get.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGetCommand = runGetCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+const GET_KINDS = new Set(["text", "value", "html", "title", "url"]);
+async function runGetCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const kind = parsed.positional[0];
+    const target = parsed.positional[1];
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    if (!kind || !GET_KINDS.has(kind)) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser get <text|value|html|title|url> [target] [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/get`, { kind, target });
+    context.stdout.write(`${response.value}\n`);
+}

package/dist/commands/hover.d.ts

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

package/dist/commands/hover.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHoverCommand = runHoverCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runHoverCommand(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 hover <target> [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/hover`, { target });
+    (0, shared_1.writeActionResult)(context, "hovered", target, response);
+}

package/dist/commands/open.d.ts

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

package/dist/commands/open.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOpenCommand = runOpenCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+function parseIdleTimeout(value) {
+    if (!value) {
+        return undefined;
+    }
+    const timeout = Number(value);
+    if (!Number.isInteger(timeout) || timeout <= 0) {
+        throw new errors_1.AppError("BAD_REQUEST", "--idle-timeout-ms must be a positive integer", 400);
+    }
+    return timeout;
+}
+function parseProxy(parsed) {
+    const country = (0, utils_1.getFlagString)(parsed, "proxy-country");
+    const mode = (0, utils_1.getFlagString)(parsed, "proxy-mode");
+    const host = (0, utils_1.getFlagString)(parsed, "proxy-host");
+    const portRaw = (0, utils_1.getFlagString)(parsed, "proxy-port");
+    const username = (0, utils_1.getFlagString)(parsed, "proxy-user");
+    const password = (0, utils_1.getFlagString)(parsed, "proxy-pass");
+    if (country) {
+        throw new errors_1.AppError("BAD_REQUEST", "--proxy-country is not available for temporary cloud profiles yet; use a preconfigured --profile or a custom proxy host/port", 400);
+    }
+    if (host || portRaw || username || password || mode) {
+        const port = Number(portRaw);
+        if (!host || !portRaw || !Number.isInteger(port) || port <= 0) {
+            throw new errors_1.AppError("BAD_REQUEST", "Custom proxy requires --proxy-host and a valid --proxy-port", 400);
+        }
+        const resolvedMode = mode ?? "http";
+        if (!["http", "socks4", "socks5"].includes(resolvedMode)) {
+            throw new errors_1.AppError("BAD_REQUEST", "--proxy-mode must be one of http, socks4, or socks5", 400);
+        }
+        return {
+            mode: resolvedMode,
+            host,
+            port,
+            username,
+            password
+        };
+    }
+    return undefined;
+}
+async function runOpenCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const url = parsed.positional[0];
+    const profileId = (0, utils_1.getFlagString)(parsed, "profile");
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const proxy = parseProxy(parsed);
+    const idleTimeoutMs = parseIdleTimeout((0, utils_1.getFlagString)(parsed, "idle-timeout-ms"));
+    if (!url) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser open <url> [--profile <profileId>] [--session <sessionId>] [--idle-timeout-ms <ms>] [--proxy-host <host> --proxy-port <port>]", 400);
+    }
+    const response = await context.client.request("POST", "/sessions/open", {
+        url,
+        profileId,
+        sessionId,
+        proxy,
+        idleTimeoutMs
+    });
+    const proxyLabel = (0, utils_1.formatProxyLabel)(response.proxy);
+    const proxyToken = proxyLabel ? ` proxy=${proxyLabel}` : "";
+    const liveView = response.liveViewUrl ? ` liveview=${response.liveViewUrl}` : "";
+    const idleTimeout = response.idleTimeoutMs !== undefined ? ` idleTimeoutMs=${response.idleTimeoutMs}` : "";
+    context.stdout.write(`session=${response.sessionId} url=${response.url}${proxyToken}${idleTimeout}${liveView}\n`);
+}

package/dist/commands/pdf.d.ts

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

package/dist/commands/pdf.js

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

package/dist/commands/press.d.ts

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

package/dist/commands/press.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPressCommand = runPressCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runPressCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const key = parsed.positional[0];
+    const target = parsed.positional[1];
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    if (!key) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser press <key> [target] [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/press`, { key, target });
+    const targetSuffix = target ? ` target=${target}` : "";
+    context.stdout.write(`pressed key=${key}${targetSuffix} session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

package/dist/commands/reload.d.ts

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

package/dist/commands/reload.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReloadCommand = runReloadCommand;
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runReloadCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/reload`);
+    context.stdout.write(`session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

package/dist/commands/screenshot.d.ts

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

package/dist/commands/screenshot.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScreenshotCommand = runScreenshotCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runScreenshotCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const inputPath = parsed.positional[0];
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const annotate = (0, utils_1.getFlagBoolean)(parsed, "annotate");
+    const pressEscape = (0, utils_1.getFlagBoolean)(parsed, "press-escape");
+    if (!inputPath) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser screenshot <path> [--annotate] [--press-escape] [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const targetPath = (0, utils_1.ensureAbsolutePath)(context.cwd, inputPath);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/screenshot`, { path: targetPath, annotate, pressEscape });
+    const annotated = response.annotated ? " annotated=yes" : "";
+    const escaped = response.pressedEscape ? " escape=yes" : "";
+    context.stdout.write(`screenshot=${response.path} session=${response.sessionId}${annotated}${escaped}\n`);
+}