gologin-web-access 0.3.0

package/dist/commands/tabFocus.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTabFocusCommand = buildTabFocusCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildTabFocusCommand() {
+    const command = new commander_1.Command("tabfocus")
+        .alias("tabswitch")
+        .description("Focus a specific tab in the active Cloud Browser session.")
+        .argument("<index>", "1-based tab index")
+        .action(async (index, options) => {
+        await (0, shared_1.runBrowserCommand)(["tabfocus", index], { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/tabOpen.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTabOpenCommand = buildTabOpenCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildTabOpenCommand() {
+    const command = new commander_1.Command("tabopen")
+        .alias("tabnew")
+        .description("Open a new tab in the active Cloud Browser session.")
+        .argument("[url]", "Optional URL to open in the new tab")
+        .action(async (url, options) => {
+        const args = ["tabopen"];
+        if (url) {
+            args.push(url);
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/tabs.js

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

package/dist/commands/type.js

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

package/dist/commands/uncheck.js

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

package/dist/commands/upload.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUploadCommand = buildUploadCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildUploadCommand() {
+    const command = new commander_1.Command("upload")
+        .description("Upload one or more files to an element by snapshot ref.")
+        .argument("<ref>", "Snapshot ref, for example e2")
+        .argument("<files...>", "One or more files to upload")
+        .action(async (ref, files, options) => {
+        await (0, shared_1.runBrowserCommand)(["upload", ref, ...files.map(shared_1.resolveOutputPath)], { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/commands/wait.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWaitCommand = buildWaitCommand;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+function buildWaitCommand() {
+    const command = new commander_1.Command("wait")
+        .description("Wait for a target, text, URL pattern, load state, or timeout.")
+        .argument("<targetOrMs>", "Target ref or timeout in milliseconds")
+        .option("--text <text>", "Wait for matching text")
+        .option("--url <pattern>", "Wait for URL pattern")
+        .option("--load <state>", "load, domcontentloaded, or networkidle")
+        .action(async (targetOrMs, options) => {
+        const args = ["wait", targetOrMs];
+        if (options.text) {
+            args.push("--text", options.text);
+        }
+        if (options.url) {
+            args.push("--url", options.url);
+        }
+        if (options.load) {
+            args.push("--load", options.load);
+        }
+        await (0, shared_1.runBrowserCommand)(args, { session: options.session });
+    });
+    return (0, shared_1.addSessionOption)(command);
+}

package/dist/config.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_NAMES = exports.DEFAULT_DAEMON_PORT = void 0;
+exports.getDefaultConfigPath = getDefaultConfigPath;
+exports.loadConfig = loadConfig;
+exports.initConfigFile = initConfigFile;
+exports.requireWebUnlockerKey = requireWebUnlockerKey;
+exports.requireCloudToken = requireCloudToken;
+exports.resolveProfileId = resolveProfileId;
+exports.getRecommendedCredentialStatus = getRecommendedCredentialStatus;
+exports.getMaskedConfigRows = getMaskedConfigRows;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./lib/errors");
+const output_1 = require("./lib/output");
+const CONFIG_DIR = ".gologin-web-access";
+const LEGACY_CONFIG_DIR = ".gologin-web";
+const CONFIG_FILENAME = "config.json";
+exports.DEFAULT_DAEMON_PORT = 4590;
+exports.ENV_NAMES = {
+    webUnlockerApiKey: "GOLOGIN_WEB_UNLOCKER_API_KEY",
+    cloudToken: "GOLOGIN_CLOUD_TOKEN",
+    defaultProfileId: "GOLOGIN_DEFAULT_PROFILE_ID",
+    daemonPort: "GOLOGIN_DAEMON_PORT",
+};
+const LEGACY_ENV_NAMES = {
+    webUnlockerApiKey: ["GOLOGIN_WEBUNLOCKER_API_KEY"],
+    cloudToken: ["GOLOGIN_TOKEN"],
+    defaultProfileId: ["GOLOGIN_PROFILE_ID"],
+    daemonPort: [],
+};
+function getDefaultConfigPath() {
+    return path_1.default.join(os_1.default.homedir(), CONFIG_DIR, CONFIG_FILENAME);
+}
+async function loadConfig() {
+    const configPath = await resolveConfigPath();
+    const stateDir = path_1.default.dirname(configPath);
+    const fileConfig = await readConfigFile(configPath);
+    const webUnlockerEnv = firstEnvValue(exports.ENV_NAMES.webUnlockerApiKey, LEGACY_ENV_NAMES.webUnlockerApiKey);
+    const cloudTokenEnv = firstEnvValue(exports.ENV_NAMES.cloudToken, LEGACY_ENV_NAMES.cloudToken);
+    const profileEnv = firstEnvValue(exports.ENV_NAMES.defaultProfileId, LEGACY_ENV_NAMES.defaultProfileId);
+    const daemonPortEnv = firstEnvValue(exports.ENV_NAMES.daemonPort, LEGACY_ENV_NAMES.daemonPort);
+    const webUnlockerApiKey = pickString(webUnlockerEnv, fileConfig.webUnlockerApiKey);
+    const cloudToken = pickString(cloudTokenEnv, fileConfig.cloudToken);
+    const defaultProfileId = pickString(profileEnv, fileConfig.defaultProfileId);
+    const daemonPort = pickNumber(daemonPortEnv, fileConfig.daemonPort, exports.DEFAULT_DAEMON_PORT);
+    return {
+        configPath,
+        stateDir,
+        jobsDir: path_1.default.join(stateDir, "jobs"),
+        trackingDir: path_1.default.join(stateDir, "tracking"),
+        artifactsDir: path_1.default.join(stateDir, "artifacts"),
+        webUnlockerApiKey,
+        cloudToken,
+        defaultProfileId,
+        daemonPort,
+        sources: {
+            webUnlockerApiKey: resolveSource(webUnlockerEnv, fileConfig.webUnlockerApiKey),
+            cloudToken: resolveSource(cloudTokenEnv, fileConfig.cloudToken),
+            defaultProfileId: resolveSource(profileEnv, fileConfig.defaultProfileId),
+            daemonPort: resolveNumberSource(daemonPortEnv, fileConfig.daemonPort),
+        },
+    };
+}
+async function initConfigFile(overrides, options = {}) {
+    const configPath = getDefaultConfigPath();
+    const directory = path_1.default.dirname(configPath);
+    await fs_1.promises.mkdir(directory, { recursive: true });
+    const fileExists = await exists(configPath);
+    if (fileExists && !options.force) {
+        const existing = await readConfigFile(configPath);
+        return {
+            path: configPath,
+            config: existing,
+            created: false,
+        };
+    }
+    const nextConfig = {
+        webUnlockerApiKey: overrides.webUnlockerApiKey,
+        cloudToken: overrides.cloudToken,
+        defaultProfileId: overrides.defaultProfileId,
+        daemonPort: overrides.daemonPort ?? exports.DEFAULT_DAEMON_PORT,
+    };
+    await fs_1.promises.writeFile(configPath, JSON.stringify(nextConfig, null, 2) + "\n", "utf8");
+    return {
+        path: configPath,
+        config: nextConfig,
+        created: true,
+    };
+}
+function requireWebUnlockerKey(config) {
+    if (!config.webUnlockerApiKey) {
+        throw new errors_1.MissingCredentialError(exports.ENV_NAMES.webUnlockerApiKey, "scraping commands like `gologin-web-access scrape`");
+    }
+    return config.webUnlockerApiKey;
+}
+function requireCloudToken(config) {
+    if (!config.cloudToken) {
+        throw new errors_1.MissingCredentialError(exports.ENV_NAMES.cloudToken, "browser commands like `gologin-web-access open`");
+    }
+    return config.cloudToken;
+}
+function resolveProfileId(config, explicitProfileId) {
+    return explicitProfileId || config.defaultProfileId;
+}
+function getRecommendedCredentialStatus(config) {
+    const missing = [];
+    if (!config.webUnlockerApiKey) {
+        missing.push(exports.ENV_NAMES.webUnlockerApiKey);
+    }
+    if (!config.cloudToken) {
+        missing.push(exports.ENV_NAMES.cloudToken);
+    }
+    if (missing.length === 0) {
+        return {
+            ready: true,
+            missing,
+            detail: "complete (Web Unlocker + Cloud Browser configured)",
+        };
+    }
+    return {
+        ready: false,
+        missing,
+        detail: `incomplete - missing ${missing.join(" and ")}`,
+    };
+}
+function getMaskedConfigRows(config) {
+    const recommended = getRecommendedCredentialStatus(config);
+    return [
+        {
+            label: "Config file",
+            value: config.configPath,
+        },
+        {
+            label: exports.ENV_NAMES.webUnlockerApiKey,
+            value: describeValue(config.webUnlockerApiKey, config.sources.webUnlockerApiKey),
+        },
+        {
+            label: exports.ENV_NAMES.cloudToken,
+            value: describeValue(config.cloudToken, config.sources.cloudToken),
+        },
+        {
+            label: "Recommended setup",
+            value: recommended.detail,
+        },
+        {
+            label: exports.ENV_NAMES.defaultProfileId,
+            value: describePlainValue(config.defaultProfileId, config.sources.defaultProfileId),
+        },
+        {
+            label: exports.ENV_NAMES.daemonPort,
+            value: `${config.daemonPort} (${config.sources.daemonPort})`,
+        },
+    ];
+}
+async function readConfigFile(configPath) {
+    try {
+        const raw = await fs_1.promises.readFile(configPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            webUnlockerApiKey: normalizeString(parsed.webUnlockerApiKey),
+            cloudToken: normalizeString(parsed.cloudToken),
+            defaultProfileId: normalizeString(parsed.defaultProfileId),
+            daemonPort: parsed.daemonPort,
+        };
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+async function resolveConfigPath() {
+    const currentPath = getDefaultConfigPath();
+    if (await exists(currentPath)) {
+        return currentPath;
+    }
+    const legacyPath = path_1.default.join(os_1.default.homedir(), LEGACY_CONFIG_DIR, CONFIG_FILENAME);
+    if (await exists(legacyPath)) {
+        return legacyPath;
+    }
+    return currentPath;
+}
+function pickString(envValue, fileValue) {
+    return normalizeString(envValue) ?? normalizeString(fileValue);
+}
+function pickNumber(envValue, fileValue, fallback) {
+    if (normalizeString(envValue)) {
+        const parsed = Number(envValue);
+        if (!Number.isNaN(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    if (typeof fileValue === "number" && fileValue > 0) {
+        return fileValue;
+    }
+    return fallback;
+}
+function normalizeString(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function firstEnvValue(primary, legacyNames) {
+    const candidates = [primary, ...legacyNames];
+    for (const name of candidates) {
+        const value = normalizeString(process.env[name]);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function resolveSource(envValue, fileValue) {
+    if (normalizeString(envValue)) {
+        return "env";
+    }
+    if (normalizeString(fileValue)) {
+        return "file";
+    }
+    return "unset";
+}
+function resolveNumberSource(envValue, fileValue) {
+    if (normalizeString(envValue)) {
+        return "env";
+    }
+    if (typeof fileValue === "number") {
+        return "file";
+    }
+    return "default";
+}
+function describeValue(value, source) {
+    if (!value) {
+        return "missing";
+    }
+    return `${(0, output_1.maskSecret)(value)} (${source})`;
+}
+function describePlainValue(value, source) {
+    if (!value) {
+        return "missing";
+    }
+    return `${value} (${source})`;
+}
+async function exists(targetPath) {
+    try {
+        await fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/doctor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const config_1 = require("./config");
+const cloudApi_1 = require("./lib/cloudApi");
+const agentCli_1 = require("./lib/agentCli");
+const output_1 = require("./lib/output");
+async function runDoctor(options = {}) {
+    const config = await (0, config_1.loadConfig)();
+    const checks = [];
+    const daemonReachable = await (0, agentCli_1.isDaemonReachable)(config.daemonPort);
+    const agentCli = await (0, agentCli_1.inspectAgentCli)();
+    const recommended = (0, config_1.getRecommendedCredentialStatus)(config);
+    checks.push({
+        name: "Web Unlocker API key",
+        status: config.webUnlockerApiKey ? "ok" : "warn",
+        detail: config.webUnlockerApiKey ? `configured via ${config.sources.webUnlockerApiKey}` : "missing",
+    });
+    checks.push({
+        name: "Cloud Browser token",
+        status: config.cloudToken ? "ok" : "warn",
+        detail: config.cloudToken ? `configured via ${config.sources.cloudToken}` : "missing",
+    });
+    checks.push({
+        name: "Recommended full setup",
+        status: recommended.ready ? "ok" : "warn",
+        detail: recommended.ready
+            ? "both GOLOGIN_WEB_UNLOCKER_API_KEY and GOLOGIN_CLOUD_TOKEN are configured"
+            : `missing ${recommended.missing.join(" and ")}`,
+    });
+    checks.push({
+        name: "Embedded browser runtime",
+        status: agentCli ? "ok" : "error",
+        detail: agentCli
+            ? `${agentCli.source}${agentCli.version ? ` v${agentCli.version}` : ""} at ${agentCli.cwd}`
+            : "missing embedded Cloud Browser runtime inside this gologin-web-access install",
+    });
+    if (!config.defaultProfileId) {
+        checks.push({
+            name: "Default profile",
+            status: "warn",
+            detail: "missing",
+        });
+    }
+    else if (!config.cloudToken) {
+        checks.push({
+            name: "Default profile",
+            status: "warn",
+            detail: `${config.defaultProfileId} configured, but Cloud Browser token is missing so existence could not be verified`,
+        });
+    }
+    else {
+        try {
+            const profile = await (0, cloudApi_1.getProfile)(config.defaultProfileId, config.cloudToken);
+            checks.push({
+                name: "Default profile",
+                status: profile ? "ok" : "error",
+                detail: profile ? `${profile.id}${profile.name ? ` (${profile.name})` : ""}` : `${config.defaultProfileId} not found`,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "profile lookup failed";
+            checks.push({
+                name: "Default profile",
+                status: "error",
+                detail: message,
+            });
+        }
+    }
+    checks.push({
+        name: "Daemon",
+        status: daemonReachable ? "ok" : "warn",
+        detail: daemonReachable
+            ? `running on 127.0.0.1:${config.daemonPort}`
+            : `not running on 127.0.0.1:${config.daemonPort}`,
+    });
+    if (options.json) {
+        (0, output_1.printJson)({
+            configPath: config.configPath,
+            agentCli,
+            checks,
+        });
+        return;
+    }
+    (0, output_1.printText)((0, output_1.formatDoctorChecks)(checks));
+}