gologin-agent-browser-cli 0.1.0

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/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/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/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,20 @@
+"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");
+    if (!inputPath) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser screenshot <path> [--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 });
+    const annotated = response.annotated ? " annotated=yes" : "";
+    context.stdout.write(`screenshot=${response.path} session=${response.sessionId}${annotated}\n`);
+}

package/dist/commands/scroll.d.ts

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

package/dist/commands/scroll.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScrollCommand = runScrollCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+const SCROLL_DIRECTIONS = new Set(["up", "down", "left", "right"]);
+async function runScrollCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const direction = parsed.positional[0];
+    const maybePixels = parsed.positional[1];
+    const target = (0, utils_1.getFlagString)(parsed, "target");
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    if (!direction || !SCROLL_DIRECTIONS.has(direction)) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser scroll <up|down|left|right> [pixels] [--target <target>] [--session <sessionId>]", 400);
+    }
+    if (maybePixels && !(0, utils_1.isNumericToken)(maybePixels)) {
+        throw new errors_1.AppError("BAD_REQUEST", "scroll pixels must be a number", 400);
+    }
+    const pixels = maybePixels ? Number(maybePixels) : undefined;
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/scroll`, { direction, pixels, target });
+    const targetSuffix = response.target ? ` target=${response.target}` : "";
+    context.stdout.write(`scrolled direction=${response.direction} pixels=${response.pixels}${targetSuffix} session=${response.sessionId} url=${response.url}\n`);
+}

package/dist/commands/scrollIntoView.d.ts

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

package/dist/commands/scrollIntoView.js

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

package/dist/commands/select.d.ts

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

package/dist/commands/select.js

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

package/dist/commands/sessions.d.ts

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

package/dist/commands/sessions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSessionsCommand = runSessionsCommand;
+const utils_1 = require("../lib/utils");
+async function runSessionsCommand(context, argv) {
+    (0, utils_1.parseArgs)(argv);
+    const response = await context.client.request("GET", "/sessions");
+    if (response.sessions.length === 0) {
+        context.stdout.write("no sessions\n");
+        return;
+    }
+    for (const session of response.sessions) {
+        context.stdout.write(`${(0, utils_1.formatSessionLine)(session)}\n`);
+    }
+}

package/dist/commands/shared.d.ts

@@ -0,0 +1,3 @@
+import type { ActionResponse, CommandContext } from "../lib/types";
+export declare function resolveSessionId(context: CommandContext, explicitSessionId?: string): Promise<string>;
+export declare function writeActionResult(context: CommandContext, verb: string, target: string, response: ActionResponse): void;

package/dist/commands/shared.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionId = resolveSessionId;
+exports.writeActionResult = writeActionResult;
+async function resolveSessionId(context, explicitSessionId) {
+    if (explicitSessionId) {
+        return explicitSessionId;
+    }
+    return (await context.client.request("GET", "/sessions/current")).sessionId;
+}
+function writeActionResult(context, verb, target, response) {
+    context.stdout.write(`${verb} target=${target} session=${response.sessionId} url=${response.url} snapshot=${response.staleSnapshot ? "stale" : "fresh"}\n`);
+}

package/dist/commands/snapshot.d.ts

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

package/dist/commands/snapshot.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSnapshotCommand = runSnapshotCommand;
+const utils_1 = require("../lib/utils");
+async function runSnapshotCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const interactive = (0, utils_1.getFlagBoolean)(parsed, "interactive");
+    const resolvedSessionId = sessionId ??
+        (await context.client.request("GET", "/sessions/current")).sessionId;
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/snapshot`, interactive ? { interactive: true } : {});
+    context.stdout.write(`session=${response.sessionId} url=${response.url}\n`);
+    for (const item of response.items) {
+        context.stdout.write(`${(0, utils_1.formatSnapshotItem)(item)}\n`);
+    }
+}

package/dist/commands/type.d.ts

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

package/dist/commands/type.js

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

package/dist/commands/uncheck.d.ts

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

package/dist/commands/uncheck.js

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

package/dist/commands/upload.d.ts

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

package/dist/commands/upload.js

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

package/dist/commands/wait.d.ts

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

package/dist/commands/wait.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWaitCommand = runWaitCommand;
+const errors_1 = require("../lib/errors");
+const utils_1 = require("../lib/utils");
+const shared_1 = require("./shared");
+async function runWaitCommand(context, argv) {
+    const parsed = (0, utils_1.parseArgs)(argv);
+    const first = parsed.positional[0];
+    const sessionId = (0, utils_1.getFlagString)(parsed, "session");
+    const text = (0, utils_1.getFlagString)(parsed, "text");
+    const urlPattern = (0, utils_1.getFlagString)(parsed, "url");
+    const loadState = (0, utils_1.getFlagString)(parsed, "load");
+    const body = {};
+    if (first) {
+        if ((0, utils_1.isNumericToken)(first)) {
+            body.timeoutMs = Number(first);
+        }
+        else {
+            body.target = first;
+        }
+    }
+    if (text) {
+        body.text = text;
+    }
+    if (urlPattern) {
+        body.urlPattern = urlPattern;
+    }
+    if (loadState === "load" || loadState === "domcontentloaded" || loadState === "networkidle") {
+        body.loadState = loadState;
+    }
+    else if (loadState) {
+        throw new errors_1.AppError("BAD_REQUEST", "wait --load must be load, domcontentloaded, or networkidle", 400);
+    }
+    if (!body.target && !body.text && !body.urlPattern && !body.loadState && body.timeoutMs === undefined) {
+        throw new errors_1.AppError("BAD_REQUEST", "Usage: gologin-agent-browser wait <target|ms> [--text <text>] [--url <pattern>] [--load <state>] [--session <sessionId>]", 400);
+    }
+    const resolvedSessionId = await (0, shared_1.resolveSessionId)(context, sessionId);
+    const response = await context.client.request("POST", `/sessions/${resolvedSessionId}/wait`, body);
+    context.stdout.write(`waited session=${response.sessionId} url=${response.url} for=${response.waitedFor}\n`);
+}