gologin-web-access 0.3.0

package/dist/commands/reload.js

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

package/dist/commands/run.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRunCommand = buildRunCommand;
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const jobRegistry_1 = require("../lib/jobRegistry");
+const runbooks_1 = require("../lib/runbooks");
+const output_1 = require("../lib/output");
+function buildRunCommand() {
+    return new commander_1.Command("run")
+        .description("Execute a JSON runbook through gologin-web-access commands.")
+        .argument("<runbookPath>", "Path to the runbook JSON file")
+        .option("--session <id>", "Default session id for browser commands")
+        .option("--profile <id>", "Default profile id for browser commands that open sessions")
+        .option("--vars <path>", "Path to a JSON variables file")
+        .option("--name <name>", "Override the stored job name")
+        .option("--continue-on-error", "Continue after failed steps")
+        .option("--json", "Print the final job record as JSON")
+        .action(async (runbookPath, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const runbook = (0, runbooks_1.loadRunbookDefinition)(process.cwd(), runbookPath);
+        const variables = options.vars ? (0, runbooks_1.loadVariablesFile)(process.cwd(), options.vars) : undefined;
+        const absoluteRunbookPath = path_1.default.resolve(runbookPath);
+        const job = await (0, jobRegistry_1.createJob)(config, {
+            kind: "run",
+            name: options.name ?? path_1.default.basename(absoluteRunbookPath, path_1.default.extname(absoluteRunbookPath)),
+            cwd: process.cwd(),
+            args: process.argv.slice(2),
+            metadata: {
+                runbookPath: absoluteRunbookPath,
+                sessionId: options.session,
+                profileId: options.profile
+            }
+        });
+        await (0, jobRegistry_1.markJobRunning)(config, job.jobId);
+        try {
+            const execution = await (0, runbooks_1.executeRunbook)(runbook, {
+                cwd: process.cwd(),
+                sessionId: options.session,
+                profileId: options.profile,
+                variables,
+                continueOnError: options.continueOnError === true
+            });
+            const failed = execution.steps.filter((step) => step.status === "failed").length;
+            const output = execution.steps
+                .map((step) => [`step=${step.command} status=${step.status} durationMs=${step.durationMs}`, step.stdout.trim(), step.stderr.trim()].filter(Boolean).join("\n"))
+                .join("\n\n");
+            const record = await (0, jobRegistry_1.finalizeJob)(config, job.jobId, {
+                status: failed > 0 ? "partial" : "ok",
+                output,
+                result: execution
+            });
+            if (options.json) {
+                (0, output_1.printJson)(record);
+                return;
+            }
+            (0, output_1.printText)(output);
+        }
+        catch (error) {
+            const record = await (0, jobRegistry_1.finalizeJob)(config, job.jobId, {
+                status: "failed",
+                error: error instanceof Error ? error.message : String(error)
+            });
+            if (options.json) {
+                (0, output_1.printJson)(record);
+                process.exitCode = 1;
+                return;
+            }
+            throw error;
+        }
+    });
+}

package/dist/commands/scrape.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScrapeCommand = buildScrapeCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const shared_1 = require("./shared");
+const output_1 = require("../lib/output");
+const unlocker_1 = require("../lib/unlocker");
+function buildScrapeCommand() {
+    return (0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("scrape")
+        .description("Fetch rendered HTML through Gologin Web Unlocker.")
+        .argument("<url>", "URL to scrape")
+        .action(async (url, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const apiKey = (0, config_1.requireWebUnlockerKey)(config);
+        const result = await (0, unlocker_1.scrapeRenderedHtml)(url, apiKey, (0, shared_1.normalizeUnlockerRequestOptions)(options));
+        (0, output_1.printText)(result.content);
+    }));
+}

package/dist/commands/scrapeJson.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScrapeJsonCommand = buildScrapeJsonCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const output_1 = require("../lib/output");
+const structuredScrape_1 = require("../lib/structuredScrape");
+const shared_1 = require("./shared");
+function buildScrapeJsonCommand() {
+    return (0, shared_1.addProfileOption)((0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("scrape-json")
+        .description("Fetch a page through Web Unlocker and print a structured JSON envelope.")
+        .argument("<url>", "URL to scrape")
+        .option("--fallback <mode>", "none or browser structured fallback for JS-heavy pages", "none")
+        .action(async (url, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const apiKey = (0, config_1.requireWebUnlockerKey)(config);
+        const envelope = await (0, structuredScrape_1.scrapeStructuredJson)(url, config, apiKey, {
+            fallback: (0, structuredScrape_1.normalizeStructuredFallbackMode)(options.fallback),
+            profile: options.profile,
+            request: (0, shared_1.normalizeUnlockerRequestOptions)(options),
+        });
+        (0, output_1.printJson)(envelope);
+    })));
+}

package/dist/commands/scrapeMarkdown.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScrapeMarkdownCommand = buildScrapeMarkdownCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const readSource_1 = require("../lib/readSource");
+const shared_1 = require("./shared");
+const output_1 = require("../lib/output");
+function buildScrapeMarkdownCommand() {
+    return (0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("scrape-markdown")
+        .description("Fetch a page through Web Unlocker and print Markdown.")
+        .argument("<url>", "URL to scrape")
+        .option("--source <source>", "Read source: auto, unlocker, or browser", "auto")
+        .action(async (url, 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 result = await (0, readSource_1.readMarkdownContent)(url, config, apiKey, {
+            source,
+            request: (0, shared_1.normalizeUnlockerRequestOptions)(options),
+        });
+        emitReadNotice(result.fallbackAttempted, result.fallbackUsed, result.fallbackReason);
+        (0, output_1.printText)(result.content);
+    }));
+}
+function emitReadNotice(fallbackAttempted, fallbackUsed, fallbackReason) {
+    if (!fallbackAttempted) {
+        return;
+    }
+    if (fallbackUsed) {
+        process.stderr.write(`JS-rendered page detected, retrying with browser. ${fallbackReason ?? ""}\n`);
+        return;
+    }
+    if (fallbackReason) {
+        process.stderr.write(`${fallbackReason}\n`);
+    }
+}

package/dist/commands/scrapeScreenshot.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.buildScrapeScreenshotCommand = buildScrapeScreenshotCommand;
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const agentCli_1 = require("../lib/agentCli");
+function buildScrapeScreenshotCommand() {
+    return new commander_1.Command("scrape-screenshot")
+        .description("Capture a full-page screenshot of a URL through Gologin Cloud Browser in one command.")
+        .argument("<url>", "URL to capture")
+        .argument("[outputPath]", "Destination PNG path")
+        .option("--profile <id>", "Gologin profile ID to use")
+        .option("--annotate", "Annotate the screenshot with snapshot refs")
+        .option("--press-escape", "Press Escape before capturing")
+        .option("--keep-open", "Leave the browser session open instead of auto-closing it")
+        .action(async (url, outputPath, options) => {
+        const config = await (0, config_1.loadConfig)();
+        (0, config_1.requireCloudToken)(config);
+        const sessionId = `shot-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+        const resolvedProfile = (0, config_1.resolveProfileId)(config, options.profile);
+        const resolvedOutputPath = path_1.default.resolve(outputPath ?? defaultScreenshotPath(url));
+        const openArgs = ["open", url, "--session", sessionId];
+        if (resolvedProfile) {
+            openArgs.push("--profile", resolvedProfile);
+        }
+        const screenshotArgs = ["screenshot", resolvedOutputPath, "--session", sessionId];
+        if (options.annotate) {
+            screenshotArgs.push("--annotate");
+        }
+        if (options.pressEscape) {
+            screenshotArgs.push("--press-escape");
+        }
+        const openResult = await (0, agentCli_1.runAgentCommandCapture)(openArgs, config);
+        if (openResult.exitCode !== 0) {
+            throw new Error(openResult.stderr || openResult.stdout || "Failed to open Cloud Browser session");
+        }
+        try {
+            const shotResult = await (0, agentCli_1.runAgentCommandCapture)(screenshotArgs, config);
+            if (shotResult.exitCode !== 0) {
+                throw new Error(shotResult.stderr || shotResult.stdout || "Failed to capture screenshot");
+            }
+            process.stdout.write(`${resolvedOutputPath}\n`);
+        }
+        finally {
+            if (!options.keepOpen) {
+                await (0, agentCli_1.runAgentCommandCapture)(["close", "--session", sessionId], config).catch(() => undefined);
+            }
+        }
+    });
+}
+function defaultScreenshotPath(url) {
+    try {
+        const parsed = new URL(url);
+        const hostname = parsed.hostname.replace(/[^a-z0-9.-]+/gi, "-");
+        return `${hostname || "page"}.png`;
+    }
+    catch {
+        return "page.png";
+    }
+}

package/dist/commands/scrapeText.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScrapeTextCommand = buildScrapeTextCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const readSource_1 = require("../lib/readSource");
+const shared_1 = require("./shared");
+const output_1 = require("../lib/output");
+function buildScrapeTextCommand() {
+    return (0, shared_1.addUnlockerRequestOptions)(new commander_1.Command("scrape-text")
+        .description("Fetch a page through Web Unlocker and print plain text.")
+        .argument("<url>", "URL to scrape")
+        .option("--source <source>", "Read source: auto, unlocker, or browser", "auto")
+        .action(async (url, 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 result = await (0, readSource_1.readTextContent)(url, config, apiKey, {
+            source,
+            request: (0, shared_1.normalizeUnlockerRequestOptions)(options),
+        });
+        emitReadNotice(result.fallbackAttempted, result.fallbackUsed, result.fallbackReason);
+        (0, output_1.printText)(result.content);
+    }));
+}
+function emitReadNotice(fallbackAttempted, fallbackUsed, fallbackReason) {
+    if (!fallbackAttempted) {
+        return;
+    }
+    if (fallbackUsed) {
+        process.stderr.write(`JS-rendered page detected, retrying with browser. ${fallbackReason ?? ""}\n`);
+        return;
+    }
+    if (fallbackReason) {
+        process.stderr.write(`${fallbackReason}\n`);
+    }
+}

package/dist/commands/screenshot.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScreenshotCommand = buildScreenshotCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildScreenshotCommand() {
+    const command = new commander_1.Command("screenshot")
+        .description("Save a full-page screenshot for the current session.")
+        .argument("<targetPath>", "Where to write the screenshot file")
+        .option("--annotate", "Annotate the screenshot with refs")
+        .option("--press-escape", "Press escape before taking the screenshot")
+        .action(async (targetPath, options) => {
+        const args = ["screenshot", (0, shared_1.resolveOutputPath)(targetPath)];
+        if (options.annotate) {
+            args.push("--annotate");
+        }
+        if (options.pressEscape) {
+            args.push("--press-escape");
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/scroll.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScrollCommand = buildScrollCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildScrollCommand() {
+    const command = new commander_1.Command("scroll")
+        .description("Scroll the page or a target element.")
+        .argument("<direction>", "up, down, left, or right")
+        .argument("[pixels]", "Optional number of pixels")
+        .option("--target <ref>", "Optional snapshot ref target")
+        .action(async (direction, pixels, options) => {
+        const args = ["scroll", direction];
+        if (pixels) {
+            args.push(pixels);
+        }
+        if (options.target) {
+            args.push("--target", options.target);
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/scrollIntoView.js

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

package/dist/commands/search.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSearchCommand = buildSearchCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const output_1 = require("../lib/output");
+const search_1 = require("../lib/search");
+function buildSearchCommand() {
+    return new commander_1.Command("search")
+        .description("Search the web through Gologin and return structured results with automatic fallback.")
+        .argument("<query>", "Search query")
+        .option("--limit <count>", "Maximum number of results", "10")
+        .option("--country <country>", "Country code for Google search", "us")
+        .option("--language <language>", "Language for Google search", "en")
+        .option("--source <mode>", "Search path: auto, unlocker, or browser", "auto")
+        .action(async (query, options) => {
+        const config = await (0, config_1.loadConfig)();
+        const result = await (0, search_1.searchWeb)(query, config, {
+            limit: normalizeLimit(options.limit),
+            country: options.country,
+            language: options.language,
+            source: normalizeSource(options.source),
+        });
+        (0, output_1.printJson)(result);
+    });
+}
+function normalizeLimit(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return 10;
+    }
+    return Math.min(Math.floor(parsed), 100);
+}
+function normalizeSource(value) {
+    if (value === "auto" || value === "unlocker" || value === "browser") {
+        return value;
+    }
+    throw new Error(`Unsupported search source: ${value}`);
+}

package/dist/commands/searchBrowser.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSearchBrowserCommand = buildSearchBrowserCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildSearchBrowserCommand() {
+    const command = new commander_1.Command("search-browser")
+        .description("Open a Google search results page inside Gologin Cloud Browser.")
+        .argument("<query>", "Search query")
+        .option("--country <country>", "Country code for Google search", "us")
+        .option("--language <language>", "Language for Google search", "en")
+        .option("--idle-timeout-ms <ms>", "Idle timeout for the browser session")
+        .option("--proxy-country <country>", "Request a country-based proxy when supported")
+        .option("--proxy-mode <mode>", "Custom proxy mode: http, socks4, or socks5")
+        .option("--proxy-host <host>", "Custom proxy host")
+        .option("--proxy-port <port>", "Custom proxy port")
+        .option("--proxy-user <username>", "Custom proxy username")
+        .option("--proxy-pass <password>", "Custom proxy password")
+        .action(async (query, options) => {
+        const url = new URL("https://www.google.com/search");
+        url.searchParams.set("q", query);
+        url.searchParams.set("hl", options.language);
+        url.searchParams.set("gl", options.country.toLowerCase());
+        await (0, shared_1.runOpenLikeCommand)(url.toString(), options);
+    });
+    (0, shared_1.addProfileOption)(command);
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/select.js

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

package/dist/commands/sessions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionsCommand = buildSessionsCommand;
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const agentCli_1 = require("../lib/agentCli");
+function buildSessionsCommand() {
+    return new commander_1.Command("sessions")
+        .description("List active daemon-backed browser sessions.")
+        .action(async () => {
+        const config = await (0, config_1.loadConfig)();
+        await (0, agentCli_1.runAgentCommand)(["sessions"], config);
+    });
+}

package/dist/commands/shared.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSessionOption = addSessionOption;
+exports.addProfileOption = addProfileOption;
+exports.runBrowserCommand = runBrowserCommand;
+exports.runOpenLikeCommand = runOpenLikeCommand;
+exports.resolveOutputPath = resolveOutputPath;
+exports.addUnlockerRequestOptions = addUnlockerRequestOptions;
+exports.normalizeUnlockerRequestOptions = normalizeUnlockerRequestOptions;
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const agentCli_1 = require("../lib/agentCli");
+function addSessionOption(command) {
+    return command.option("--session <id>", "Session ID. Defaults to the current session.");
+}
+function addProfileOption(command) {
+    return command.option("--profile <id>", "Gologin profile ID to use");
+}
+async function runBrowserCommand(commandArgs, options) {
+    const config = await (0, config_1.loadConfig)();
+    if (options?.requiresToken !== false) {
+        (0, config_1.requireCloudToken)(config);
+    }
+    const args = [...commandArgs];
+    if (options?.session) {
+        args.push("--session", options.session);
+    }
+    await (0, agentCli_1.runAgentCommand)(args, config);
+}
+async function runOpenLikeCommand(url, options) {
+    const config = await (0, config_1.loadConfig)();
+    (0, config_1.requireCloudToken)(config);
+    const args = ["open", url];
+    const profileId = (0, config_1.resolveProfileId)(config, options.profile);
+    if (profileId) {
+        args.push("--profile", profileId);
+    }
+    if (options.session) {
+        args.push("--session", options.session);
+    }
+    if (options.idleTimeoutMs) {
+        args.push("--idle-timeout-ms", options.idleTimeoutMs);
+    }
+    if (options.proxyCountry) {
+        args.push("--proxy-country", options.proxyCountry);
+    }
+    if (options.proxyMode) {
+        args.push("--proxy-mode", options.proxyMode);
+    }
+    if (options.proxyHost) {
+        args.push("--proxy-host", options.proxyHost);
+    }
+    if (options.proxyPort) {
+        args.push("--proxy-port", options.proxyPort);
+    }
+    if (options.proxyUser) {
+        args.push("--proxy-user", options.proxyUser);
+    }
+    if (options.proxyPass) {
+        args.push("--proxy-pass", options.proxyPass);
+    }
+    await (0, agentCli_1.runAgentCommand)(args, config);
+}
+function resolveOutputPath(targetPath) {
+    return path_1.default.resolve(targetPath);
+}
+function addUnlockerRequestOptions(command) {
+    return command
+        .option("--retry <count>", "Retry attempts for timeout, 429, and 5xx responses")
+        .option("--backoff-ms <ms>", "Base exponential backoff in milliseconds for retried requests")
+        .option("--timeout-ms <ms>", "Per-request timeout in milliseconds");
+}
+function normalizeUnlockerRequestOptions(options) {
+    return {
+        maxRetries: normalizeOptionalNonNegativeInt(options.retry),
+        backoffMs: normalizeOptionalNonNegativeInt(options.backoffMs),
+        timeoutMs: normalizeOptionalPositiveInt(options.timeoutMs),
+    };
+}
+function normalizeOptionalNonNegativeInt(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error(`Expected a non-negative integer, got: ${value}`);
+    }
+    return Math.floor(parsed);
+}
+function normalizeOptionalPositiveInt(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Expected a positive integer, got: ${value}`);
+    }
+    return Math.floor(parsed);
+}

package/dist/commands/snapshot.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSnapshotCommand = buildSnapshotCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildSnapshotCommand() {
+    const command = new commander_1.Command("snapshot")
+        .description("Capture the current page state and assign clickable refs.")
+        .option("-i, --interactive", "Use the agent interactive snapshot format")
+        .action(async (options) => {
+        const args = ["snapshot"];
+        if (options.interactive) {
+            args.push("--interactive");
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/storageClear.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStorageClearCommand = buildStorageClearCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildStorageClearCommand() {
+    const command = new commander_1.Command("storage-clear")
+        .description("Clear localStorage/sessionStorage in the active Cloud Browser tab.")
+        .option("--scope <scope>", "Storage scope: local, session, or both")
+        .action(async (options) => {
+        const args = ["storage-clear"];
+        if (options.scope) {
+            args.push("--scope", options.scope);
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/storageExport.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStorageExportCommand = buildStorageExportCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildStorageExportCommand() {
+    const command = new commander_1.Command("storage-export")
+        .description("Export localStorage/sessionStorage from the active Cloud Browser tab.")
+        .argument("[outputPath]", "Optional path for the exported storage JSON")
+        .option("--scope <scope>", "Storage scope: local, session, or both")
+        .option("--json", "Print storage state as JSON")
+        .action(async (outputPath, options) => {
+        const args = ["storage-export"];
+        if (outputPath) {
+            args.push(outputPath);
+        }
+        if (options.scope) {
+            args.push("--scope", options.scope);
+        }
+        if (options.json) {
+            args.push("--json");
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/storageImport.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStorageImportCommand = buildStorageImportCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildStorageImportCommand() {
+    const command = new commander_1.Command("storage-import")
+        .description("Import localStorage/sessionStorage into the active Cloud Browser tab.")
+        .argument("<storagePath>", "Path to the storage JSON file")
+        .option("--scope <scope>", "Storage scope: local, session, or both")
+        .option("--clear", "Clear existing storage before importing")
+        .action(async (storagePath, options) => {
+        const args = ["storage-import", storagePath];
+        if (options.scope) {
+            args.push("--scope", options.scope);
+        }
+        if (options.clear) {
+            args.push("--clear");
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/tabClose.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTabCloseCommand = buildTabCloseCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildTabCloseCommand() {
+    const command = new commander_1.Command("tabclose")
+        .description("Close the current tab or a specific tab in the active Cloud Browser session.")
+        .argument("[index]", "Optional 1-based tab index")
+        .action(async (index, options) => {
+        const args = ["tabclose"];
+        if (index) {
+            args.push(index);
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}