gologin-web-access 0.3.0

package/dist/commands/batchChangeTrack.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBatchChangeTrackCommand = buildBatchChangeTrackCommand;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const changeTracking_1 = require("../lib/changeTracking");
+const concurrency_1 = require("../lib/concurrency");
+const output_1 = require("../lib/output");
+const shared_1 = require("./shared");
+function buildBatchChangeTrackCommand() {
+    return (0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("batch-change-track")
+        .description("Track multiple pages over time and report which ones are new, same, or changed.")
+        .argument("<urls...>", "One or more URLs")
+        .option("--format <format>", "html, markdown, text, or json", "markdown")
+        .option("--concurrency <count>", "Number of concurrent requests", "4")
+        .option("--output <path>", "Write the full batch result JSON to a file")
+        .option("--summary", "Print one-line status counts to stderr after the JSON output")
+        .action(async (urls, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const apiKey = (0, config_1.requireWebUnlockerKey)(config);
+        const format = (0, changeTracking_1.normalizeTrackingFormat)(options.format);
+        const concurrency = Math.max(1, Number(options.concurrency) || 4);
+        const requestOptions = (0, shared_1.normalizeUnlockerRequestOptions)(options);
+        const results = await (0, concurrency_1.mapWithConcurrency)(urls, concurrency, async (url) => {
+            try {
+                const key = (0, changeTracking_1.buildTrackingKey)(url);
+                const snapshot = await (0, changeTracking_1.scrapeForTracking)(url, apiKey, format, requestOptions);
+                const result = await (0, changeTracking_1.compareAndPersistSnapshot)(config, {
+                    key,
+                    url,
+                    format,
+                    title: snapshot.title,
+                    content: snapshot.content,
+                });
+                return {
+                    ok: true,
+                    ...result,
+                    request: snapshot.request,
+                };
+            }
+            catch (error) {
+                return {
+                    url,
+                    ok: false,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                    status: extractStatusCode(error),
+                    request: extractRequestMeta(error),
+                };
+            }
+        });
+        if (options.output) {
+            const outputPath = path_1.default.resolve(options.output);
+            await fs_1.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+            await fs_1.promises.writeFile(outputPath, `${JSON.stringify(results, null, 2)}\n`, "utf8");
+            process.stdout.write(`${outputPath}\n`);
+        }
+        else {
+            (0, output_1.printJson)(results);
+        }
+        if (options.summary) {
+            process.stderr.write(formatBatchChangeTrackSummary(results) + "\n");
+        }
+        if (results.some((result) => !result.ok)) {
+            process.exitCode = 1;
+        }
+    }));
+}
+function formatBatchChangeTrackSummary(results) {
+    const requested = results.length;
+    const failed = results.filter((result) => !result.ok).length;
+    const successful = results.filter((result) => result.ok);
+    const created = successful.filter((result) => result.status === "new").length;
+    const same = successful.filter((result) => result.status === "same").length;
+    const changed = successful.filter((result) => result.status === "changed").length;
+    return `Summary: ${requested} requested, ${created} new, ${same} same, ${changed} changed, ${failed} failed.`;
+}
+function extractStatusCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "status" in error &&
+        typeof error.status === "number") {
+        return error.status;
+    }
+    return undefined;
+}
+function extractRequestMeta(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "request" in error &&
+        typeof error.request === "object") {
+        return error.request;
+    }
+    return undefined;
+}

package/dist/commands/batchExtract.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBatchExtractCommand = buildBatchExtractCommand;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const extractRunner_1 = require("../lib/extractRunner");
+const concurrency_1 = require("../lib/concurrency");
+const output_1 = require("../lib/output");
+const readSource_1 = require("../lib/readSource");
+const shared_1 = require("./shared");
+function buildBatchExtractCommand() {
+    return (0, shared_1.addProfileOption)((0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("batch-extract")
+        .description("Extract structured data from multiple pages using one selector schema.")
+        .argument("<urls...>", "One or more URLs")
+        .requiredOption("--schema <path>", "Path to a JSON extraction schema")
+        .option("--source <source>", "Read source: auto, unlocker, or browser", "auto")
+        .option("--concurrency <count>", "Number of concurrent requests", "4")
+        .option("--output <path>", "Write the full batch result JSON to a file")
+        .option("--summary", "Print one-line summary stats to stderr after the JSON output")
+        .action(async (urls, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const source = (0, readSource_1.normalizeReadSourceMode)(options.source, "auto");
+        const apiKey = source === "browser" ? "" : (0, config_1.requireWebUnlockerKey)(config);
+        const schema = await readSchema(path_1.default.resolve(options.schema));
+        const concurrency = Math.max(1, Number(options.concurrency) || 4);
+        const request = (0, shared_1.normalizeUnlockerRequestOptions)(options);
+        const results = await (0, concurrency_1.mapWithConcurrency)(urls, concurrency, async (url) => {
+            try {
+                return {
+                    ok: true,
+                    ...(await (0, extractRunner_1.extractUrlWithSchema)(url, config, apiKey, schema, {
+                        source,
+                        request,
+                        profile: options.profile,
+                    })),
+                };
+            }
+            catch (error) {
+                return {
+                    url,
+                    ok: false,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                    status: extractStatusCode(error),
+                    request: extractRequestMeta(error),
+                };
+            }
+        });
+        if (options.output) {
+            const outputPath = path_1.default.resolve(options.output);
+            await fs_1.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+            await fs_1.promises.writeFile(outputPath, `${JSON.stringify(results, null, 2)}\n`, "utf8");
+            process.stdout.write(`${outputPath}\n`);
+        }
+        else {
+            (0, output_1.printJson)(results);
+        }
+        if (options.summary) {
+            process.stderr.write(formatBatchExtractSummary(results) + "\n");
+        }
+        if (results.some((result) => !result.ok)) {
+            process.exitCode = 1;
+        }
+    })));
+}
+async function readSchema(schemaPath) {
+    const raw = await fs_1.promises.readFile(schemaPath, "utf8");
+    return JSON.parse(raw);
+}
+function formatBatchExtractSummary(results) {
+    const requested = results.length;
+    const ok = results.filter((result) => result.ok).length;
+    const failed = requested - ok;
+    return `Summary: ${requested} requested, ${ok} ok, ${failed} failed.`;
+}
+function extractStatusCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "status" in error &&
+        typeof error.status === "number") {
+        return error.status;
+    }
+    return undefined;
+}
+function extractRequestMeta(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "request" in error &&
+        typeof error.request === "object") {
+        return error.request;
+    }
+    return undefined;
+}

package/dist/commands/batchScrape.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBatchScrapeCommand = buildBatchScrapeCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const output_1 = require("../lib/output");
+const readSource_1 = require("../lib/readSource");
+const structuredScrape_1 = require("../lib/structuredScrape");
+const unlocker_1 = require("../lib/unlocker");
+const shared_1 = require("./shared");
+function buildBatchScrapeCommand() {
+    return (0, shared_1.addProfileOption)((0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("batch-scrape")
+        .description("Fetch multiple pages through Web Unlocker and print a JSON array of results.")
+        .argument("<urls...>", "One or more URLs")
+        .option("--format <format>", "html, markdown, text, or json", "html")
+        .option("--concurrency <count>", "Number of concurrent requests", "4")
+        .option("--fallback <mode>", "Structured scrape fallback: none or browser", "none")
+        .option("--source <source>", "Read source for --only-main-content mode: auto, unlocker, or browser", "auto")
+        .option("--only-main-content", "For html, markdown, or text formats, isolate the most readable content block per page")
+        .option("--summary", "Print one-line summary stats to stderr after the JSON output")
+        .action(async (urls, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const format = normalizeFormat(options.format);
+        const source = (0, readSource_1.normalizeReadSourceMode)(options.source, "auto");
+        const usingBrowserOnlyMainContent = Boolean(options.onlyMainContent) && format !== "json" && source === "browser";
+        const apiKey = usingBrowserOnlyMainContent ? "" : (0, config_1.requireWebUnlockerKey)(config);
+        const concurrency = Math.max(1, Number(options.concurrency) || 4);
+        const requestOptions = (0, shared_1.normalizeUnlockerRequestOptions)(options);
+        const fallback = (0, structuredScrape_1.normalizeStructuredFallbackMode)(options.fallback);
+        const results = await mapWithConcurrency(urls, concurrency, async (url) => {
+            try {
+                const output = await formatOutput(url, config, apiKey, format, requestOptions, fallback, {
+                    source,
+                    onlyMainContent: Boolean(options.onlyMainContent),
+                    profile: options.profile,
+                });
+                return {
+                    url,
+                    ok: true,
+                    format,
+                    output,
+                };
+            }
+            catch (error) {
+                const request = extractRequestMeta(error);
+                return {
+                    url,
+                    ok: false,
+                    format,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                    status: extractStatusCode(error),
+                    request,
+                };
+            }
+        });
+        (0, output_1.printJson)(results);
+        if (options.summary) {
+            process.stderr.write(formatBatchSummary(results) + "\n");
+        }
+        if (results.some((result) => !result.ok)) {
+            process.exitCode = 1;
+        }
+    })));
+}
+function normalizeFormat(value) {
+    if (value === "html" || value === "markdown" || value === "text" || value === "json") {
+        return value;
+    }
+    throw new Error(`Unsupported batch scrape format: ${value}`);
+}
+async function formatOutput(url, config, apiKey, format, requestOptions, fallback, options) {
+    if (options.onlyMainContent && format !== "json") {
+        const readOptions = {
+            source: options.source,
+            profile: options.profile,
+            request: requestOptions,
+        };
+        switch (format) {
+            case "html":
+                return (await (0, readSource_1.readHtmlContent)(url, config, apiKey, readOptions)).content;
+            case "markdown":
+                return (await (0, readSource_1.readMarkdownContent)(url, config, apiKey, readOptions)).content;
+            case "text":
+                return (await (0, readSource_1.readTextContent)(url, config, apiKey, readOptions)).content;
+            default:
+                break;
+        }
+    }
+    switch (format) {
+        case "html":
+            return (await (0, unlocker_1.scrapeRenderedHtml)(url, apiKey, requestOptions)).content;
+        case "markdown":
+            return (await (0, unlocker_1.scrapeMarkdown)(url, apiKey, requestOptions)).markdown;
+        case "text":
+            return (await (0, unlocker_1.scrapeText)(url, apiKey, requestOptions)).text;
+        case "json":
+            return await (0, structuredScrape_1.scrapeStructuredJson)(url, config, apiKey, {
+                fallback,
+                request: requestOptions,
+            });
+        default:
+            return (await (0, unlocker_1.scrapeRenderedHtml)(url, apiKey, requestOptions)).content;
+    }
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    }));
+    return results;
+}
+function formatBatchSummary(results) {
+    const requested = results.length;
+    const ok = results.filter((result) => result.ok).length;
+    const failed = requested - ok;
+    return `Summary: ${requested} requested, ${ok} ok, ${failed} failed.`;
+}
+function extractStatusCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "status" in error &&
+        typeof error.status === "number") {
+        return error.status;
+    }
+    return undefined;
+}
+function extractRequestMeta(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "request" in error &&
+        typeof error.request === "object") {
+        return error.request;
+    }
+    return undefined;
+}

package/dist/commands/changeTrack.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChangeTrackCommand = buildChangeTrackCommand;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const changeTracking_1 = require("../lib/changeTracking");
+const output_1 = require("../lib/output");
+const shared_1 = require("./shared");
+function buildChangeTrackCommand() {
+    return (0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("change-track")
+        .description("Track a page over time and report whether it changed since the last snapshot.")
+        .argument("<url>", "Target URL")
+        .option("--format <format>", "html, markdown, text, or json", "markdown")
+        .option("--key <key>", "Custom tracking key instead of deriving one from the URL")
+        .option("--json", "Print JSON output")
+        .option("--output <path>", "Write the current tracking result to a file")
+        .action(async (url, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const apiKey = (0, config_1.requireWebUnlockerKey)(config);
+        const format = (0, changeTracking_1.normalizeTrackingFormat)(options.format);
+        const key = (0, changeTracking_1.buildTrackingKey)(url, options.key);
+        const snapshot = await (0, changeTracking_1.scrapeForTracking)(url, apiKey, format, (0, shared_1.normalizeUnlockerRequestOptions)(options));
+        const result = await (0, changeTracking_1.compareAndPersistSnapshot)(config, {
+            key,
+            url,
+            format,
+            title: snapshot.title,
+            content: snapshot.content
+        });
+        if (options.output) {
+            const outputPath = path_1.default.resolve(options.output);
+            await fs_1.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+            await fs_1.promises.writeFile(outputPath, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+            process.stdout.write(`${outputPath}\n`);
+            return;
+        }
+        if (options.json) {
+            (0, output_1.printJson)({
+                ...result,
+                request: snapshot.request,
+            });
+            return;
+        }
+        const lines = [
+            `key=${result.key}`,
+            `url=${result.url}`,
+            `format=${result.format}`,
+            `status=${result.status}`,
+            `currentHash=${result.currentHash}`
+        ];
+        if (result.previousHash) {
+            lines.push(`previousHash=${result.previousHash}`);
+        }
+        if (result.diff) {
+            lines.push("");
+            lines.push(result.diff);
+        }
+        (0, output_1.printText)(lines.join("\n"));
+    }));
+}

package/dist/commands/check.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCheckCommand = buildCheckCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildCheckCommand() {
+    const command = new commander_1.Command("check")
+        .description("Check an element by snapshot ref.")
+        .argument("<ref>", "Snapshot ref, for example e2")
+        .action(async (ref, options) => {
+        await (0, shared_1.runBrowserCommand)(["check", ref], { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/click.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClickCommand = buildClickCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildClickCommand() {
+    const command = new commander_1.Command("click")
+        .description("Click an element by snapshot ref.")
+        .argument("<ref>", "Snapshot ref, for example e3")
+        .action(async (ref, options) => {
+        await (0, shared_1.runBrowserCommand)(["click", ref], { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/close.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCloseCommand = buildCloseCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const agentCli_1 = require("../lib/agentCli");
+function buildCloseCommand() {
+    return new commander_1.Command("close")
+        .description("Close the current browser session or a specific session.")
+        .option("--session <id>", "Session ID. Defaults to the current session.")
+        .action(async (options) => {
+        const config = await (0, config_1.loadConfig)();
+        const args = ["close"];
+        if (options.session) {
+            args.push("--session", options.session);
+        }
+        await (0, agentCli_1.runAgentCommand)(args, config);
+    });
+}

package/dist/commands/configInit.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigInitCommand = buildConfigInitCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const cloudApi_1 = require("../lib/cloudApi");
+const output_1 = require("../lib/output");
+const unlocker_1 = require("../lib/unlocker");
+function buildConfigInitCommand() {
+    return new commander_1.Command("init")
+        .description("Write ~/.gologin-web-access/config.json with current values or placeholders. Recommended: persist both Web Unlocker and Cloud Browser credentials.")
+        .option("--web-unlocker-api-key <key>", "Persist a Web Unlocker API key")
+        .option("--web-unlocker-key <key>", "Alias for --web-unlocker-api-key")
+        .option("--cloud-token <token>", "Persist a Cloud Browser token")
+        .option("--default-profile-id <id>", "Persist a default Gologin profile ID")
+        .option("--daemon-port <port>", "Persist a daemon port", String(config_1.DEFAULT_DAEMON_PORT))
+        .option("--no-validate", "Skip live key validation after writing config")
+        .option("--force", "Overwrite an existing config file")
+        .action(async (options) => {
+        const webUnlockerApiKey = options.webUnlockerApiKey ?? options.webUnlockerKey ?? process.env[config_1.ENV_NAMES.webUnlockerApiKey];
+        const result = await (0, config_1.initConfigFile)({
+            webUnlockerApiKey,
+            cloudToken: options.cloudToken ?? process.env[config_1.ENV_NAMES.cloudToken],
+            defaultProfileId: options.defaultProfileId ?? process.env[config_1.ENV_NAMES.defaultProfileId],
+            daemonPort: Number(options.daemonPort ?? process.env[config_1.ENV_NAMES.daemonPort] ?? config_1.DEFAULT_DAEMON_PORT),
+        }, {
+            force: options.force,
+        });
+        if (!result.created) {
+            (0, output_1.printText)(`Config already exists at ${result.path}. Use --force to overwrite it.`);
+            return;
+        }
+        (0, output_1.printKeyValueRows)([
+            { label: "Config file", value: result.path },
+            {
+                label: "Web Unlocker key",
+                value: result.config.webUnlockerApiKey ? "written" : "left empty",
+            },
+            {
+                label: "Cloud token",
+                value: result.config.cloudToken ? "written" : "left empty",
+            },
+            {
+                label: "Default profile",
+                value: result.config.defaultProfileId ?? "not set",
+            },
+            {
+                label: "Daemon port",
+                value: String(result.config.daemonPort ?? config_1.DEFAULT_DAEMON_PORT),
+            },
+        ]);
+        if (!result.config.webUnlockerApiKey || !result.config.cloudToken) {
+            (0, output_1.printText)("Recommended next step: configure both GOLOGIN_WEB_UNLOCKER_API_KEY and GOLOGIN_CLOUD_TOKEN so agents can use scraping and browser flows without asking again.");
+        }
+        if (options.validate === false) {
+            return;
+        }
+        const validationRows = [];
+        if (result.config.webUnlockerApiKey) {
+            const validation = await (0, unlocker_1.validateWebUnlockerKey)(result.config.webUnlockerApiKey);
+            validationRows.push({
+                label: "Web Unlocker validation",
+                value: validation.ok ? "ok" : `failed${validation.status ? ` (${validation.status})` : ""}: ${validation.detail}`,
+            });
+        }
+        if (result.config.cloudToken) {
+            const validation = await (0, cloudApi_1.validateCloudToken)(result.config.cloudToken);
+            validationRows.push({
+                label: "Cloud token validation",
+                value: validation.ok ? "ok" : `failed${validation.status ? ` (${validation.status})` : ""}: ${validation.detail}`,
+            });
+        }
+        if (validationRows.length > 0) {
+            (0, output_1.printKeyValueRows)(validationRows);
+        }
+    });
+}

package/dist/commands/configShow.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigShowCommand = buildConfigShowCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const output_1 = require("../lib/output");
+function buildConfigShowCommand() {
+    return new commander_1.Command("show")
+        .description("Show merged Gologin CLI configuration and whether the recommended two-key setup is complete.")
+        .option("--json", "Print JSON output")
+        .action(async (options) => {
+        const config = await (0, config_1.loadConfig)();
+        const rows = (0, config_1.getMaskedConfigRows)(config);
+        if (options.json) {
+            (0, output_1.printJson)({
+                configPath: config.configPath,
+                values: rows,
+            });
+            return;
+        }
+        (0, output_1.printKeyValueRows)(rows);
+    });
+}

package/dist/commands/cookies.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCookiesCommand = buildCookiesCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildCookiesCommand() {
+    const command = new commander_1.Command("cookies")
+        .description("Export cookies from the active Cloud Browser session.")
+        .option("--output <path>", "Write cookies JSON to a file")
+        .option("--json", "Print cookies as JSON")
+        .action(async (options) => {
+        const args = ["cookies"];
+        if (options.output) {
+            args.push("--output", options.output);
+        }
+        if (options.json) {
+            args.push("--json");
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/cookiesClear.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCookiesClearCommand = buildCookiesClearCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildCookiesClearCommand() {
+    const command = new commander_1.Command("cookies-clear")
+        .description("Clear cookies from the active Cloud Browser session.")
+        .action(async (options) => {
+        await (0, shared_1.runBrowserCommand)(["cookies-clear"], { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/cookiesImport.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCookiesImportCommand = buildCookiesImportCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildCookiesImportCommand() {
+    const command = new commander_1.Command("cookies-import")
+        .description("Import cookies into the active Cloud Browser session.")
+        .argument("<cookiesPath>", "Path to a cookies JSON file")
+        .action(async (cookiesPath, options) => {
+        await (0, shared_1.runBrowserCommand)(["cookies-import", cookiesPath], { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}