gologin-web-access 0.3.0

package/dist/lib/selfCli.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectRoot = resolveProjectRoot;
+exports.resolveSelfCliInvocation = resolveSelfCliInvocation;
+exports.runSelfCommandCapture = runSelfCommandCapture;
+exports.spawnDetachedSelfCommand = spawnDetachedSelfCommand;
+exports.resolveNodeScriptInvocation = resolveNodeScriptInvocation;
+exports.spawnDetachedNodeInvocation = spawnDetachedNodeInvocation;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+function resolveProjectRoot() {
+    return path_1.default.resolve(__dirname, "..", "..");
+}
+async function exists(targetPath) {
+    try {
+        await fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveSelfCliInvocation(env = process.env) {
+    const projectRoot = resolveProjectRoot();
+    const preferSource = env.GOLOGIN_WEB_ACCESS_USE_SOURCE_CLI === "1";
+    const distCli = path_1.default.join(projectRoot, "dist", "cli.js");
+    const tsxCli = path_1.default.join(projectRoot, "node_modules", "tsx", "dist", "cli.mjs");
+    const srcCli = path_1.default.join(projectRoot, "src", "cli.ts");
+    if (preferSource && (await exists(tsxCli)) && (await exists(srcCli))) {
+        return {
+            command: process.execPath,
+            args: [tsxCli, srcCli],
+            cwd: projectRoot
+        };
+    }
+    if (await exists(distCli)) {
+        return {
+            command: process.execPath,
+            args: [distCli],
+            cwd: projectRoot
+        };
+    }
+    if ((await exists(tsxCli)) && (await exists(srcCli))) {
+        return {
+            command: process.execPath,
+            args: [tsxCli, srcCli],
+            cwd: projectRoot
+        };
+    }
+    throw new Error(`Unable to resolve gologin-web-access CLI from ${projectRoot}`);
+}
+async function runSelfCommandCapture(args, options = {}) {
+    const childEnv = {
+        ...process.env,
+        ...options.env
+    };
+    const invocation = await resolveSelfCliInvocation(childEnv);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(invocation.command, [...invocation.args, ...args], {
+            cwd: options.cwd ?? invocation.cwd,
+            env: childEnv,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                reject(new Error(`gologin-web-access exited via signal ${signal}`));
+                return;
+            }
+            resolve({
+                exitCode: code ?? 1,
+                stdout,
+                stderr
+            });
+        });
+    });
+}
+async function spawnDetachedSelfCommand(args, options = {}) {
+    const invocation = await resolveSelfCliInvocation();
+    const child = (0, child_process_1.spawn)(invocation.command, [...invocation.args, ...args], {
+        cwd: options.cwd ?? invocation.cwd,
+        env: {
+            ...process.env,
+            ...options.env
+        },
+        detached: true,
+        stdio: "ignore"
+    });
+    child.unref();
+}
+async function resolveNodeScriptInvocation(scriptBasename) {
+    const projectRoot = resolveProjectRoot();
+    const distScript = path_1.default.join(projectRoot, "dist", `${scriptBasename}.js`);
+    if (await exists(distScript)) {
+        return {
+            command: process.execPath,
+            args: [distScript],
+            cwd: projectRoot
+        };
+    }
+    const tsxCli = path_1.default.join(projectRoot, "node_modules", "tsx", "dist", "cli.mjs");
+    const srcScript = path_1.default.join(projectRoot, "src", `${scriptBasename}.ts`);
+    if ((await exists(tsxCli)) && (await exists(srcScript))) {
+        return {
+            command: process.execPath,
+            args: [tsxCli, srcScript],
+            cwd: projectRoot
+        };
+    }
+    throw new Error(`Unable to resolve script ${scriptBasename} from ${projectRoot}`);
+}
+async function spawnDetachedNodeInvocation(scriptBasename, args, options = {}) {
+    const invocation = await resolveNodeScriptInvocation(scriptBasename);
+    const child = (0, child_process_1.spawn)(invocation.command, [...invocation.args, ...args], {
+        cwd: options.cwd ?? invocation.cwd,
+        env: {
+            ...process.env,
+            ...options.env
+        },
+        detached: true,
+        stdio: "ignore"
+    });
+    child.unref();
+}

package/dist/lib/structuredScrape.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrapeStructuredJson = scrapeStructuredJson;
+exports.makeStructuredScrapeEnvelope = makeStructuredScrapeEnvelope;
+exports.normalizeStructuredFallbackMode = normalizeStructuredFallbackMode;
+exports.shouldUseBrowserFallback = shouldUseBrowserFallback;
+const config_1 = require("../config");
+const browserStructured_1 = require("./browserStructured");
+const unlocker_1 = require("./unlocker");
+async function scrapeStructuredJson(url, config, apiKey, options = {}) {
+    const result = await (0, unlocker_1.scrapeJson)(url, apiKey, options.request);
+    const fallbackMode = options.fallback ?? "none";
+    let data = result.data;
+    let renderSource = "unlocker";
+    let fallbackAttempted = false;
+    let fallbackUsed = false;
+    let fallbackReason;
+    if (fallbackMode === "browser" && shouldUseBrowserFallback(data)) {
+        fallbackAttempted = true;
+        (0, config_1.requireCloudToken)(config);
+        const browserData = await (0, browserStructured_1.scrapeJsonViaBrowser)(url, config, {
+            profile: options.profile,
+        });
+        if (isBrowserDataBetter(data, browserData)) {
+            data = browserData;
+            renderSource = "browser";
+            fallbackUsed = true;
+            fallbackReason = "unlocker structured data looked incomplete";
+        }
+        else {
+            fallbackReason = "browser fallback did not improve structured output";
+        }
+    }
+    return makeStructuredScrapeEnvelope(url, result, data, {
+        renderSource,
+        fallbackAttempted,
+        fallbackUsed,
+        fallbackReason,
+    });
+}
+function makeStructuredScrapeEnvelope(url, result, data, options = {}) {
+    return {
+        url,
+        status: result.status,
+        renderSource: options.renderSource ?? "unlocker",
+        fallbackAttempted: options.fallbackAttempted ?? false,
+        fallbackUsed: options.fallbackUsed ?? false,
+        fallbackReason: options.fallbackReason,
+        request: result.request,
+        data,
+    };
+}
+function normalizeStructuredFallbackMode(value) {
+    if (!value || value === "none") {
+        return "none";
+    }
+    if (value === "browser") {
+        return "browser";
+    }
+    throw new Error(`Unsupported scrape-json fallback mode: ${value}`);
+}
+function shouldUseBrowserFallback(data) {
+    const firstH1 = data.headingsByLevel.h1[0];
+    if (!firstH1) {
+        return true;
+    }
+    return looksSuspiciousHeadingText(firstH1);
+}
+function looksSuspiciousHeadingText(value) {
+    return /function\s*\(|window\.|document\.|const\s+|let\s+|var\s+|=>|import\s+/i.test(value) || value.length > 240;
+}
+function isBrowserDataBetter(current, candidate) {
+    if (candidate.headingsByLevel.h1.length > current.headingsByLevel.h1.length) {
+        return true;
+    }
+    if (!current.title && Boolean(candidate.title)) {
+        return true;
+    }
+    if (candidate.headings.length > current.headings.length) {
+        return true;
+    }
+    return false;
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/unlocker.js

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrapeRenderedHtml = scrapeRenderedHtml;
+exports.scrapeText = scrapeText;
+exports.scrapeMarkdown = scrapeMarkdown;
+exports.scrapeJson = scrapeJson;
+exports.validateWebUnlockerKey = validateWebUnlockerKey;
+exports.htmlToText = htmlToText;
+exports.htmlToMarkdown = htmlToMarkdown;
+exports.htmlToStructuredData = htmlToStructuredData;
+const errors_1 = require("./errors");
+const DEFAULT_BASE_URL = "https://parsing.webunlocker.gologin.com";
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_MAX_RETRIES = 2;
+const MAX_EXTRACTED_LINKS = 100;
+const MAX_EXTRACTED_HEADINGS = 50;
+class WebUnlockerClient {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    maxRetries;
+    backoffMs;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.backoffMs = options.backoffMs ?? 250;
+        if (!this.apiKey.trim()) {
+            throw new Error("apiKey is required");
+        }
+    }
+    async scrape(url, options = {}) {
+        assertValidTargetUrl(url);
+        const requestUrl = new URL("/v1/scrape", this.baseUrl);
+        requestUrl.searchParams.set("url", url);
+        const { response, request } = await fetchWithRetry(requestUrl.toString(), {
+            headers: {
+                apikey: this.apiKey,
+            },
+            timeoutMs: options.timeoutMs ?? this.timeoutMs,
+            maxRetries: options.maxRetries ?? this.maxRetries,
+            backoffMs: options.backoffMs ?? this.backoffMs,
+        });
+        if (!response.ok) {
+            const body = await safeReadText(response, this.timeoutMs);
+            throw new errors_1.HttpError(`Web Unlocker request failed with status ${response.status}.`, response.status, body ? truncate(body, 300) : undefined);
+        }
+        const content = await readResponseTextWithTimeout(response, this.timeoutMs);
+        return {
+            success: true,
+            url,
+            content,
+            contentType: response.headers.get("content-type"),
+            status: response.status,
+            headers: headersToRecord(response.headers),
+            request,
+        };
+    }
+}
+async function scrapeRenderedHtml(url, apiKey, options = {}) {
+    return createWebUnlockerClient(apiKey).scrape(url, options);
+}
+async function scrapeText(url, apiKey, options = {}) {
+    const scraped = await createWebUnlockerClient(apiKey).scrape(url, options);
+    return {
+        ...scraped,
+        text: htmlToText(scraped.content),
+    };
+}
+async function scrapeMarkdown(url, apiKey, options = {}) {
+    const scraped = await createWebUnlockerClient(apiKey).scrape(url, options);
+    return {
+        ...scraped,
+        markdown: htmlToMarkdown(scraped.content),
+    };
+}
+async function scrapeJson(url, apiKey, options = {}) {
+    const scraped = await createWebUnlockerClient(apiKey).scrape(url, options);
+    return {
+        ...scraped,
+        data: htmlToStructuredData(scraped.content),
+    };
+}
+async function validateWebUnlockerKey(apiKey) {
+    try {
+        await scrapeRenderedHtml("https://example.com", apiKey, {
+            timeoutMs: 8_000,
+            maxRetries: 0,
+        });
+        return { ok: true };
+    }
+    catch (error) {
+        if (error instanceof errors_1.HttpError) {
+            return {
+                ok: false,
+                status: error.status,
+                detail: error.hint ?? error.message,
+            };
+        }
+        return {
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function createWebUnlockerClient(apiKey) {
+    return new WebUnlockerClient({ apiKey });
+}
+async function fetchWithRetry(url, options) {
+    const attempts = [];
+    let lastError;
+    let lastStatusError;
+    for (let attempt = 0; attempt <= options.maxRetries; attempt += 1) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                headers: options.headers,
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (response.ok) {
+                attempts.push({
+                    attempt: attempt + 1,
+                    status: response.status,
+                    retriable: false,
+                });
+                return {
+                    response,
+                    request: buildScrapeRequestMeta(attempts),
+                };
+            }
+            const body = await safeReadText(response, options.timeoutMs);
+            const error = new errors_1.HttpError(`Web Unlocker request failed with status ${response.status}.`, response.status, body ? truncate(body, 300) : undefined);
+            const retriable = attempt < options.maxRetries && isRetriableStatus(response.status);
+            attempts.push({
+                attempt: attempt + 1,
+                status: response.status,
+                error: error.message,
+                retriable,
+            });
+            lastStatusError = error;
+            if (!retriable) {
+                throw attachRequestMeta(error, attempts);
+            }
+            await sleep(computeBackoffDelay(options.backoffMs, attempt));
+            continue;
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            lastError = error;
+            if (error instanceof errors_1.HttpError) {
+                throw error;
+            }
+            const normalizedError = error instanceof Error && error.name === "AbortError"
+                ? new errors_1.HttpError("Web Unlocker request timed out.", 408)
+                : error instanceof Error
+                    ? new errors_1.HttpError(error.message, 500)
+                    : new errors_1.HttpError("Web Unlocker request failed.", 500);
+            const retriable = attempt < options.maxRetries;
+            attempts.push({
+                attempt: attempt + 1,
+                status: normalizedError.status,
+                error: normalizedError.message,
+                retriable,
+            });
+            if (attempt === options.maxRetries) {
+                throw attachRequestMeta(normalizedError, attempts);
+            }
+            await sleep(computeBackoffDelay(options.backoffMs, attempt));
+        }
+    }
+    if (lastStatusError) {
+        throw attachRequestMeta(lastStatusError, attempts);
+    }
+    if (lastError instanceof Error && lastError.name === "AbortError") {
+        throw attachRequestMeta(new errors_1.HttpError("Web Unlocker request timed out.", 408), attempts);
+    }
+    throw attachRequestMeta(lastError instanceof Error
+        ? new errors_1.HttpError(lastError.message, 500)
+        : new errors_1.HttpError("Web Unlocker request failed.", 500), attempts);
+}
+function buildScrapeRequestMeta(attempts) {
+    return {
+        attemptCount: attempts.length,
+        retryCount: Math.max(0, attempts.length - 1),
+        attempts: attempts.map((attempt) => ({ ...attempt })),
+    };
+}
+function attachRequestMeta(error, attempts) {
+    return Object.assign(error, {
+        request: buildScrapeRequestMeta(attempts),
+    });
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+function headersToRecord(headers) {
+    const record = {};
+    headers.forEach((value, key) => {
+        record[key] = value;
+    });
+    return record;
+}
+function assertValidTargetUrl(url) {
+    if (!url.trim()) {
+        throw new Error("url is required");
+    }
+    try {
+        new URL(url);
+    }
+    catch {
+        throw new Error("url must be a valid absolute URL");
+    }
+}
+async function safeReadText(response, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    try {
+        return await readResponseTextWithTimeout(response, timeoutMs);
+    }
+    catch {
+        return "";
+    }
+}
+async function readResponseTextWithTimeout(response, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            response.text(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    void response.body?.cancel().catch(() => undefined);
+                    reject(new errors_1.HttpError("Web Unlocker response body timed out.", 408));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function truncate(value, maxLength = 300) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength)}...`;
+}
+function htmlToText(html) {
+    const withoutScripts = html
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gis, " ")
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gis, " ");
+    const withBreaks = withoutScripts
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|section|article|li|tr|h1|h2|h3|h4|h5|h6)>/gi, "\n");
+    const stripped = withBreaks.replace(/<[^>]+>/g, " ");
+    const decoded = decodeHtmlEntities(stripped);
+    return decoded
+        .replace(/\r/g, "")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/[ \t]{2,}/g, " ")
+        .trim();
+}
+function htmlToMarkdown(html) {
+    let markdown = html
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gis, "")
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gis, "")
+        .replace(/<!--[\s\S]*?-->/g, "");
+    markdown = markdown.replace(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, text) => `${"#".repeat(Number(level))} ${cleanInlineHtml(text)}\n\n`);
+    markdown = markdown.replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text) => `[${cleanInlineHtml(text)}](${href})`);
+    markdown = markdown
+        .replace(/<(strong|b)\b[^>]*>([\s\S]*?)<\/\1>/gi, (_, __, text) => `**${cleanInlineHtml(text)}**`)
+        .replace(/<(em|i)\b[^>]*>([\s\S]*?)<\/\1>/gi, (_, __, text) => `*${cleanInlineHtml(text)}*`)
+        .replace(/<code\b[^>]*>([\s\S]*?)<\/code>/gi, (_, text) => `\`${cleanInlineHtml(text)}\``)
+        .replace(/<li\b[^>]*>([\s\S]*?)<\/li>/gi, (_, text) => `- ${cleanInlineHtml(text)}\n`)
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|section|article|ul|ol|table|tr)>/gi, "\n\n")
+        .replace(/<[^>]+>/g, " ");
+    return decodeHtmlEntities(markdown)
+        .replace(/\r/g, "")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/[ \t]{2,}/g, " ")
+        .trim();
+}
+function htmlToStructuredData(html) {
+    const titleMatch = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+    const canonicalMatch = html.match(/<link\b[^>]*rel=["']canonical["'][^>]*>/i);
+    const meta = {};
+    const metaTagMatches = html.match(/<meta\b[^>]*>/gi) ?? [];
+    for (const tag of metaTagMatches) {
+        const name = getTagAttr(tag, "name") || getTagAttr(tag, "property");
+        const content = getTagAttr(tag, "content");
+        if (!name || !content) {
+            continue;
+        }
+        meta[name] = decodeHtmlEntities(content).trim();
+    }
+    const headingsByLevel = createEmptyHeadingBuckets();
+    const headings = [];
+    for (const match of Array.from(html.matchAll(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi)).slice(0, MAX_EXTRACTED_HEADINGS)) {
+        const level = Number(match[1]);
+        const text = cleanInlineHtml(match[2]);
+        if (!text) {
+            continue;
+        }
+        const bucketName = `h${level}`;
+        headingsByLevel[bucketName].push(text);
+        headings.push(text);
+    }
+    const links = Array.from(html.matchAll(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi))
+        .slice(0, MAX_EXTRACTED_LINKS)
+        .map((match) => ({
+        href: decodeHtmlEntities(match[1]).trim(),
+        text: decodeHtmlEntities(match[2].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ")).trim(),
+    }))
+        .filter((link) => link.href.length > 0);
+    const canonical = canonicalMatch ? getTagAttr(canonicalMatch[0], "href") ?? null : null;
+    const title = titleMatch ? decodeHtmlEntities(titleMatch[1]).trim() : null;
+    const description = meta.description ?? meta["og:description"] ?? null;
+    return {
+        title,
+        description,
+        canonical: canonical ? decodeHtmlEntities(canonical).trim() : null,
+        meta,
+        headings,
+        headingsByLevel,
+        links,
+    };
+}
+function cleanInlineHtml(value) {
+    return decodeHtmlEntities(stripScriptAndStyleBlocks(value).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ")).trim();
+}
+function getTagAttr(tag, attrName) {
+    const regex = new RegExp(`${attrName}\\s*=\\s*["']([^"']*)["']`, "i");
+    const match = tag.match(regex);
+    return match ? match[1] : null;
+}
+function decodeHtmlEntities(value) {
+    const namedEntities = {
+        "&amp;": "&",
+        "&lt;": "<",
+        "&gt;": ">",
+        "&quot;": "\"",
+        "&#39;": "'",
+        "&nbsp;": " ",
+    };
+    let decoded = value;
+    for (const [entity, plain] of Object.entries(namedEntities)) {
+        decoded = decoded.split(entity).join(plain);
+    }
+    decoded = decoded.replace(/&#(\d+);/g, (_, num) => String.fromCharCode(Number(num)));
+    decoded = decoded.replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    return decoded;
+}
+function stripScriptAndStyleBlocks(value) {
+    return value
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gis, " ")
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gis, " ");
+}
+function createEmptyHeadingBuckets() {
+    return {
+        h1: [],
+        h2: [],
+        h3: [],
+        h4: [],
+        h5: [],
+        h6: [],
+    };
+}
+function isRetriableStatus(status) {
+    return status === 408 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function computeBackoffDelay(baseDelayMs, attempt) {
+    return Math.max(0, baseDelayMs) * Math.pow(2, attempt);
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "gologin-web-access",
+  "version": "0.3.0",
+  "description": "Unified web access CLI for developers and AI agents to read and interact with the web using Gologin Web Unlocker and Cloud Browser.",
+  "main": "dist/cli.js",
+  "bin": {
+    "gologin-web-access": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "prepare": "npm run build",
+    "test": "tsx --test tests/**/*.test.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "release:check": "npm run typecheck && npm test && npm run build && npm pack --dry-run",
+    "prepublishOnly": "npm run release:check"
+  },
+  "dependencies": {
+    "cheerio": "^1.1.2",
+    "commander": "^14.0.1",
+    "diff": "^8.0.2",
+    "mammoth": "^1.11.0",
+    "pdf-parse": "^2.4.5",
+    "playwright": "^1.58.2",
+    "xlsx": "^0.18.5"
+  },
+  "keywords": [
+    "gologin",
+    "web-access",
+    "cli",
+    "webunlocker",
+    "scraping",
+    "cloud-browser",
+    "browser-automation",
+    "agent"
+  ],
+  "author": "Gologin",
+  "license": "MIT",
+  "homepage": "https://gologin.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GologinLabs/gologin-web-access.git"
+  },
+  "bugs": {
+    "url": "https://github.com/GologinLabs/gologin-web-access/issues"
+  },
+  "packageManager": "npm@10",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.10",
+    "tsx": "^4.20.5",
+    "typescript": "^5.8.2"
+  }
+}