gologin-web-access 0.3.0

package/dist/internal-agent/cli.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHelpRequest = isHelpRequest;
+exports.main = main;
+const back_1 = require("./commands/back");
+const check_1 = require("./commands/check");
+const click_1 = require("./commands/click");
+const close_1 = require("./commands/close");
+const cookies_1 = require("./commands/cookies");
+const cookiesClear_1 = require("./commands/cookiesClear");
+const cookiesImport_1 = require("./commands/cookiesImport");
+const current_1 = require("./commands/current");
+const doctor_1 = require("./commands/doctor");
+const dblclick_1 = require("./commands/dblclick");
+const eval_1 = require("./commands/eval");
+const fill_1 = require("./commands/fill");
+const find_1 = require("./commands/find");
+const focus_1 = require("./commands/focus");
+const forward_1 = require("./commands/forward");
+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 reload_1 = require("./commands/reload");
+const screenshot_1 = require("./commands/screenshot");
+const scroll_1 = require("./commands/scroll");
+const scrollIntoView_1 = require("./commands/scrollIntoView");
+const storageClear_1 = require("./commands/storageClear");
+const storageExport_1 = require("./commands/storageExport");
+const storageImport_1 = require("./commands/storageImport");
+const sessions_1 = require("./commands/sessions");
+const snapshot_1 = require("./commands/snapshot");
+const select_1 = require("./commands/select");
+const tabClose_1 = require("./commands/tabClose");
+const tabFocus_1 = require("./commands/tabFocus");
+const tabOpen_1 = require("./commands/tabOpen");
+const tabs_1 = require("./commands/tabs");
+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 daemon_1 = require("./lib/daemon");
+const config_1 = require("./lib/config");
+const errors_1 = require("./lib/errors");
+const commandUsage = {
+    open: "open <url> [--profile <profileId>] [--session <sessionId>] [--idle-timeout-ms <ms>] [--proxy-host <host> --proxy-port <port> --proxy-mode <http|socks4|socks5>] (aliases: goto, navigate)",
+    doctor: "doctor [--json]",
+    tabs: "tabs [--session <sessionId>]",
+    tabopen: "tabopen [url] [--session <sessionId>] (alias: tabnew)",
+    tabfocus: "tabfocus <index> [--session <sessionId>] (alias: tabswitch)",
+    tabclose: "tabclose [index] [--session <sessionId>]",
+    cookies: "cookies [--session <sessionId>] [--output <path>] [--json]",
+    "cookies-import": "cookies-import <cookies.json> [--session <sessionId>]",
+    "cookies-clear": "cookies-clear [--session <sessionId>]",
+    "storage-export": "storage-export [path] [--scope <local|session|both>] [--session <sessionId>] [--json]",
+    "storage-import": "storage-import <storage.json> [--scope <local|session|both>] [--clear] [--session <sessionId>]",
+    "storage-clear": "storage-clear [--scope <local|session|both>] [--session <sessionId>]",
+    eval: "eval <expression> [--json] [--session <sessionId>] (alias: js)",
+    snapshot: "snapshot [--session <sessionId>] [--interactive|-i]",
+    click: "click <target> [--session <sessionId>]",
+    dblclick: "dblclick <target> [--session <sessionId>]",
+    focus: "focus <target> [--session <sessionId>]",
+    type: "type <target> <text> [--session <sessionId>]",
+    fill: "fill <target> <text> [--session <sessionId>]",
+    hover: "hover <target> [--session <sessionId>]",
+    select: "select <target> <value> [--session <sessionId>]",
+    check: "check <target> [--session <sessionId>]",
+    uncheck: "uncheck <target> [--session <sessionId>]",
+    press: "press <key> [target] [--session <sessionId>] (alias: key)",
+    scroll: "scroll <up|down|left|right> [pixels] [--target <target>] [--session <sessionId>]",
+    scrollintoview: "scrollintoview <target> [--session <sessionId>] (alias: scrollinto)",
+    wait: "wait <target|ms> [--text <text>] [--url <pattern>] [--load <state>] [--session <sessionId>]",
+    get: "get <text|value|html|title|url> [target] [--session <sessionId>]",
+    back: "back [--session <sessionId>]",
+    forward: "forward [--session <sessionId>]",
+    reload: "reload [--session <sessionId>]",
+    find: "find <role|text|label|placeholder|first|last|nth> ... [--exact]",
+    upload: "upload <target> <file...> [--session <sessionId>]",
+    pdf: "pdf <path> [--session <sessionId>]",
+    screenshot: "screenshot <path> [--annotate] [--press-escape] [--session <sessionId>]",
+    close: "close [--session <sessionId>] (aliases: quit, exit)",
+    sessions: "sessions",
+    current: "current"
+};
+function printUsage() {
+    process.stderr.write([
+        "Gologin Web Access Browser Runtime",
+        "",
+        "Usage:",
+        "  gologin-web-access <command> [args] [options]",
+        "",
+        "Commands:",
+        ...Object.values(commandUsage).map((usage) => `  ${usage}`),
+        "",
+        "Environment:",
+        "  GOLOGIN_TOKEN",
+        "  GOLOGIN_PROFILE_ID",
+        "  GOLOGIN_DAEMON_PORT",
+        "  GOLOGIN_CONNECT_BASE"
+    ].join("\n") + "\n");
+}
+function printCommandUsage(command) {
+    process.stderr.write([
+        "Usage:",
+        `  gologin-web-access ${commandUsage[command]}`,
+        "",
+        "Tip:",
+        "  Use --json when you want machine-readable output."
+    ].join("\n") + "\n");
+}
+function commandRequiresDaemon(command) {
+    return command !== "doctor";
+}
+function isHelpRequest(argv) {
+    return argv.includes("--help") || argv.includes("-h");
+}
+async function runCommand(command, context, args) {
+    switch (command) {
+        case "open":
+            await (0, open_1.runOpenCommand)(context, args);
+            return;
+        case "doctor":
+            await (0, doctor_1.runDoctorCommand)(context, args);
+            return;
+        case "tabs":
+            await (0, tabs_1.runTabsCommand)(context, args);
+            return;
+        case "tabopen":
+            await (0, tabOpen_1.runTabOpenCommand)(context, args);
+            return;
+        case "tabfocus":
+            await (0, tabFocus_1.runTabFocusCommand)(context, args);
+            return;
+        case "tabclose":
+            await (0, tabClose_1.runTabCloseCommand)(context, args);
+            return;
+        case "cookies":
+            await (0, cookies_1.runCookiesCommand)(context, args);
+            return;
+        case "cookies-import":
+            await (0, cookiesImport_1.runCookiesImportCommand)(context, args);
+            return;
+        case "cookies-clear":
+            await (0, cookiesClear_1.runCookiesClearCommand)(context, args);
+            return;
+        case "storage-export":
+            await (0, storageExport_1.runStorageExportCommand)(context, args);
+            return;
+        case "storage-import":
+            await (0, storageImport_1.runStorageImportCommand)(context, args);
+            return;
+        case "storage-clear":
+            await (0, storageClear_1.runStorageClearCommand)(context, args);
+            return;
+        case "eval":
+            await (0, eval_1.runEvalCommand)(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 "back":
+            await (0, back_1.runBackCommand)(context, args);
+            return;
+        case "forward":
+            await (0, forward_1.runForwardCommand)(context, args);
+            return;
+        case "reload":
+            await (0, reload_1.runReloadCommand)(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",
+        tabnew: "tabopen",
+        tabswitch: "tabfocus",
+        js: "eval",
+        key: "press",
+        scrollinto: "scrollintoview",
+        quit: "close",
+        exit: "close"
+    };
+    if (aliases[commandArg]) {
+        return aliases[commandArg];
+    }
+    const directCommands = new Set([
+        "open",
+        "doctor",
+        "tabs",
+        "tabopen",
+        "tabfocus",
+        "tabclose",
+        "cookies",
+        "cookies-import",
+        "cookies-clear",
+        "storage-export",
+        "storage-import",
+        "storage-clear",
+        "eval",
+        "snapshot",
+        "click",
+        "dblclick",
+        "focus",
+        "type",
+        "fill",
+        "hover",
+        "select",
+        "check",
+        "uncheck",
+        "press",
+        "scroll",
+        "scrollintoview",
+        "wait",
+        "get",
+        "back",
+        "forward",
+        "reload",
+        "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);
+    }
+    if (isHelpRequest(argv.slice(1))) {
+        printCommandUsage(command);
+        process.exit(0);
+    }
+    const config = (0, config_1.loadConfig)();
+    const client = commandRequiresDaemon(command)
+        ? await (0, daemon_1.createHealthyDaemonClient)(config)
+        : {
+            transport: {
+                kind: "http",
+                host: config.daemonHost,
+                port: config.daemonPort
+            },
+            async request() {
+                throw new errors_1.AppError("DAEMON_UNREACHABLE", "This command should not call the daemon client", 500);
+            }
+        };
+    const context = {
+        config,
+        client,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        cwd: process.cwd()
+    };
+    await runCommand(command, context, argv.slice(1));
+}
+if (require.main === module) {
+    main().catch((error) => {
+        process.stderr.write(`${(0, errors_1.formatErrorLine)(error)}\n`);
+        process.exit(error instanceof errors_1.AppError ? 1 : 1);
+    });
+}

package/dist/internal-agent/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/internal-agent/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-web-access 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/internal-agent/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-web-access 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/internal-agent/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/internal-agent/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/internal-agent/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/internal-agent/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-web-access 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/internal-agent/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/internal-agent/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-web-access 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/internal-agent/commands/doctor.js

@@ -0,0 +1,53 @@
+"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`);
+    if (report.currentProjectRoot) {
+        context.stdout.write(`currentProjectRoot=${report.currentProjectRoot}\n`);
+    }
+    if (report.currentVersion) {
+        context.stdout.write(`currentVersion=${report.currentVersion}\n`);
+    }
+    for (const transport of report.transports) {
+        const parts = [`transport=${transport.label}`, `reachable=${transport.reachable}`];
+        if (transport.pid !== undefined) {
+            parts.push(`pid=${transport.pid}`);
+        }
+        if (transport.projectRoot) {
+            parts.push(`projectRoot=${transport.projectRoot}`);
+        }
+        if (transport.version) {
+            parts.push(`version=${transport.version}`);
+        }
+        if (transport.startedAt) {
+            parts.push(`startedAt=${transport.startedAt}`);
+        }
+        if (transport.matchesCurrentBuild !== undefined) {
+            parts.push(`matchesCurrentBuild=${transport.matchesCurrentBuild}`);
+        }
+        context.stdout.write(`${parts.join(" ")}\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/internal-agent/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-web-access 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/internal-agent/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-web-access 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);
+}