gologin-web-access 0.3.0

package/dist/internal-agent/lib/errors.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+exports.isDaemonErrorPayload = isDaemonErrorPayload;
+exports.serializeError = serializeError;
+exports.fromDaemonError = fromDaemonError;
+exports.formatErrorLine = formatErrorLine;
+class AppError extends Error {
+    code;
+    status;
+    details;
+    constructor(code, message, status = 500, details) {
+        super(message);
+        this.name = "AppError";
+        this.code = code;
+        this.status = status;
+        this.details = details;
+    }
+}
+exports.AppError = AppError;
+function isDaemonErrorPayload(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.code === "string" &&
+        typeof candidate.message === "string" &&
+        typeof candidate.status === "number");
+}
+function serializeError(error) {
+    if (error instanceof AppError) {
+        return {
+            code: error.code,
+            message: error.message,
+            status: error.status,
+            details: error.details
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            code: "INTERNAL_ERROR",
+            message: error.message,
+            status: 500
+        };
+    }
+    return {
+        code: "INTERNAL_ERROR",
+        message: String(error),
+        status: 500
+    };
+}
+function fromDaemonError(payload) {
+    return new AppError(payload.code, payload.message, payload.status, payload.details);
+}
+function formatErrorLine(error) {
+    if (error instanceof AppError) {
+        return `${error.code}: ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `${error.name}: ${error.message}`;
+    }
+    return `INTERNAL_ERROR: ${String(error)}`;
+}

package/dist/internal-agent/lib/types.js

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

package/dist/internal-agent/lib/utils.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.getFlagString = getFlagString;
+exports.getFlagBoolean = getFlagBoolean;
+exports.generateSessionId = generateSessionId;
+exports.ensureAbsolutePath = ensureAbsolutePath;
+exports.isRefTarget = isRefTarget;
+exports.isNumericToken = isNumericToken;
+exports.formatSnapshotItem = formatSnapshotItem;
+exports.formatProxyLabel = formatProxyLabel;
+exports.formatSessionLine = formatSessionLine;
+exports.formatCurrentLine = formatCurrentLine;
+exports.writeJsonResponse = writeJsonResponse;
+exports.readJsonBody = readJsonBody;
+exports.appendLog = appendLog;
+exports.buildRefDisplayText = buildRefDisplayText;
+exports.makeTransportLabel = makeTransportLabel;
+exports.isDaemonErrorResponse = isDaemonErrorResponse;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    const booleanFlags = new Set(["interactive", "exact", "annotate", "press-escape", "json", "clear"]);
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "-i") {
+            flags.interactive = true;
+            continue;
+        }
+        if (!token.startsWith("--")) {
+            positional.push(token);
+            continue;
+        }
+        const flagName = token.slice(2);
+        if (booleanFlags.has(flagName)) {
+            flags[flagName] = true;
+            continue;
+        }
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            throw new errors_1.AppError("BAD_REQUEST", `Missing value for ${token}`, 400);
+        }
+        flags[flagName] = next;
+        index += 1;
+    }
+    return { positional, flags };
+}
+function getFlagString(parsed, name) {
+    const value = parsed.flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function getFlagBoolean(parsed, name) {
+    return parsed.flags[name] === true;
+}
+function generateSessionId(existingIds) {
+    const existing = new Set(existingIds);
+    let counter = 1;
+    while (existing.has(`s${counter}`)) {
+        counter += 1;
+    }
+    return `s${counter}`;
+}
+function ensureAbsolutePath(baseDir, targetPath) {
+    return node_path_1.default.isAbsolute(targetPath) ? targetPath : node_path_1.default.resolve(baseDir, targetPath);
+}
+function isRefTarget(target) {
+    return /^@e\d+$/.test(target);
+}
+function isNumericToken(token) {
+    return /^-?\d+$/.test(token);
+}
+function formatSnapshotItem(item) {
+    const flags = item.flags && item.flags.length > 0 ? ` ${item.flags.map((flag) => `[${flag}]`).join(" ")}` : "";
+    return `- ${item.kind} "${item.text}"${flags} [ref=${item.ref}]`;
+}
+function formatProxyLabel(proxy) {
+    if (!proxy) {
+        return undefined;
+    }
+    if (proxy.mode === "none") {
+        return undefined;
+    }
+    if (proxy.mode === "gologin") {
+        return proxy.country ? `gologin:${proxy.country}` : "gologin";
+    }
+    if (proxy.host && proxy.port) {
+        return `${proxy.mode}:${proxy.host}:${proxy.port}`;
+    }
+    return proxy.mode;
+}
+function formatSessionLine(session) {
+    const prefix = session.active ? "*" : "-";
+    const profile = session.profileId ? ` profile=${session.profileId}` : "";
+    const snapshotState = session.hasSnapshot ? (session.staleSnapshot ? "stale" : "fresh") : "none";
+    const proxy = formatProxyLabel(session.proxy);
+    const proxyToken = proxy ? ` proxy=${proxy}` : "";
+    const idleTimeout = session.idleTimeoutMs !== undefined ? ` idleTimeoutMs=${session.idleTimeoutMs}` : "";
+    const liveView = session.liveViewUrl ? ` liveview=${session.liveViewUrl}` : "";
+    const screenshot = session.lastScreenshotPath ? ` shot=${session.lastScreenshotPath}` : "";
+    const pdf = session.lastPdfPath ? ` pdf=${session.lastPdfPath}` : "";
+    return `${prefix} session=${session.sessionId}${profile} url=${session.url} snapshot=${snapshotState}${proxyToken}${idleTimeout}${liveView}${screenshot}${pdf}`;
+}
+function formatCurrentLine(session) {
+    const profile = session.profileId ? ` profile=${session.profileId}` : "";
+    const snapshotState = session.hasSnapshot ? (session.staleSnapshot ? "stale" : "fresh") : "none";
+    const proxy = formatProxyLabel(session.proxy);
+    const proxyToken = proxy ? ` proxy=${proxy}` : "";
+    const idleTimeout = session.idleTimeoutMs !== undefined ? ` idleTimeoutMs=${session.idleTimeoutMs}` : "";
+    const liveView = session.liveViewUrl ? ` liveview=${session.liveViewUrl}` : "";
+    const screenshot = session.lastScreenshotPath ? ` shot=${session.lastScreenshotPath}` : "";
+    const pdf = session.lastPdfPath ? ` pdf=${session.lastPdfPath}` : "";
+    return `session=${session.sessionId}${profile} url=${session.url} snapshot=${snapshotState}${proxyToken}${idleTimeout}${liveView}${screenshot}${pdf}`;
+}
+function writeJsonResponse(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(JSON.stringify(payload));
+}
+function readJsonBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => {
+            if (chunks.length === 0) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            }
+            catch {
+                reject(new errors_1.AppError("BAD_REQUEST", "Request body must be valid JSON", 400));
+            }
+        });
+        request.on("error", reject);
+    });
+}
+function appendLog(logPath, line) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(logPath), { recursive: true });
+    node_fs_1.default.appendFileSync(logPath, `${new Date().toISOString()} ${line}\n`, "utf8");
+}
+function buildRefDisplayText(descriptor) {
+    return descriptor.accessibleName ?? descriptor.text ?? descriptor.placeholder ?? descriptor.name ?? "";
+}
+function makeTransportLabel(transport) {
+    if (transport.kind === "socket") {
+        return `socket:${transport.socketPath}`;
+    }
+    return `http://${transport.host}:${transport.port}`;
+}
+function isDaemonErrorResponse(payload) {
+    if (!payload || typeof payload !== "object") {
+        return false;
+    }
+    const value = payload;
+    return (typeof value.code === "string" &&
+        typeof value.message === "string" &&
+        typeof value.status === "number");
+}

package/dist/jobRunner.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+const jobRegistry_1 = require("./lib/jobRegistry");
+const selfCli_1 = require("./lib/selfCli");
+async function main() {
+    const [jobId, command, ...args] = process.argv.slice(2);
+    if (!jobId || !command) {
+        throw new Error("Usage: jobRunner <jobId> <command> [args...]");
+    }
+    const config = await (0, config_1.loadConfig)();
+    await (0, jobRegistry_1.markJobRunning)(config, jobId);
+    const result = await (0, selfCli_1.runSelfCommandCapture)([command, ...args]);
+    if (result.exitCode === 0) {
+        await (0, jobRegistry_1.finalizeJob)(config, jobId, {
+            status: "ok",
+            output: result.stdout,
+            errorOutput: result.stderr,
+            result: tryParseJson(result.stdout)
+        });
+        return;
+    }
+    await (0, jobRegistry_1.finalizeJob)(config, jobId, {
+        status: "failed",
+        output: result.stdout,
+        errorOutput: result.stderr,
+        error: result.stderr.trim() || result.stdout.trim() || `Command exited with code ${result.exitCode}`
+    });
+    process.exit(result.exitCode);
+}
+function tryParseJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+void main().catch(async (error) => {
+    const [jobId] = process.argv.slice(2);
+    if (jobId) {
+        const config = await (0, config_1.loadConfig)().catch(() => undefined);
+        if (config) {
+            await (0, jobRegistry_1.finalizeJob)(config, jobId, {
+                status: "failed",
+                error: error instanceof Error ? error.message : String(error)
+            }).catch(() => undefined);
+        }
+    }
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/lib/agentCli.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentCommand = runAgentCommand;
+exports.runAgentCommandCapture = runAgentCommandCapture;
+exports.isDaemonReachable = isDaemonReachable;
+exports.agentCliAvailable = agentCliAvailable;
+exports.inspectAgentCli = inspectAgentCli;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+async function runAgentCommand(args, config) {
+    const invocation = await resolveAgentCliInvocation();
+    const exitCode = await spawnAndWait(invocation, args, config);
+    if (exitCode !== 0) {
+        throw new errors_1.SilentExitError(exitCode);
+    }
+}
+async function runAgentCommandCapture(args, config) {
+    const invocation = await resolveAgentCliInvocation();
+    return spawnAndCapture(invocation, args, config);
+}
+async function isDaemonReachable(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/health`);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function agentCliAvailable() {
+    try {
+        await resolveAgentCliInvocation();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function inspectAgentCli() {
+    try {
+        return await resolveAgentCliInvocation();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveAgentCliInvocation() {
+    const projectRoot = resolveProjectRoot();
+    const distCli = path_1.default.join(projectRoot, "dist", "internal-agent", "cli.js");
+    if (await exists(distCli)) {
+        return {
+            command: process.execPath,
+            args: [distCli],
+            cwd: projectRoot,
+            source: "internal-bundled",
+            version: await readPackageVersion(projectRoot),
+        };
+    }
+    const tsxCli = path_1.default.join(projectRoot, "node_modules", "tsx", "dist", "cli.mjs");
+    const srcCli = path_1.default.join(projectRoot, "src", "internal-agent", "cli.ts");
+    if ((await exists(tsxCli)) && (await exists(srcCli))) {
+        return {
+            command: process.execPath,
+            args: [tsxCli, srcCli],
+            cwd: projectRoot,
+            source: "internal-source",
+            version: await readPackageVersion(projectRoot),
+        };
+    }
+    throw new errors_1.CliError("Gologin Agent CLI is not available.", 1, `Internal browser runtime is missing from this gologin-web-access install at ${projectRoot}. Reinstall the package and rebuild it.`);
+}
+function resolveProjectRoot() {
+    return path_1.default.resolve(__dirname, "..", "..");
+}
+function spawnAndWait(invocation, args, config) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(invocation.command, [...invocation.args, ...args], {
+            cwd: invocation.cwd,
+            env: buildAgentEnv(config),
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                reject(new errors_1.CliError(`Gologin Agent CLI terminated by signal ${signal}.`));
+                return;
+            }
+            resolve(code ?? 1);
+        });
+    });
+}
+function spawnAndCapture(invocation, args, config) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(invocation.command, [...invocation.args, ...args], {
+            cwd: invocation.cwd,
+            env: buildAgentEnv(config),
+            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 errors_1.CliError(`Gologin Agent CLI terminated by signal ${signal}.`));
+                return;
+            }
+            resolve({
+                exitCode: code ?? 1,
+                stdout,
+                stderr,
+            });
+        });
+    });
+}
+function buildAgentEnv(config) {
+    const env = {
+        ...process.env,
+        GOLOGIN_DAEMON_PORT: String(config.daemonPort),
+    };
+    if (config.cloudToken) {
+        env.GOLOGIN_TOKEN = config.cloudToken;
+    }
+    if (config.defaultProfileId) {
+        env.GOLOGIN_PROFILE_ID = config.defaultProfileId;
+    }
+    return env;
+}
+async function exists(targetPath) {
+    try {
+        await fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readPackageVersion(packageRoot) {
+    const packageJsonPath = path_1.default.join(packageRoot, "package.json");
+    try {
+        const raw = await fs_1.promises.readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/browserRead.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrapeReadableContentViaBrowser = scrapeReadableContentViaBrowser;
+exports.scrapeRenderedHtmlViaBrowser = scrapeRenderedHtmlViaBrowser;
+const crypto_1 = require("crypto");
+const config_1 = require("../config");
+const agentCli_1 = require("./agentCli");
+const errors_1 = require("./errors");
+async function scrapeReadableContentViaBrowser(url, config, options = {}) {
+    return withBrowserSession(url, config, options, async (sessionId) => {
+        const evaluated = await (0, agentCli_1.runAgentCommandCapture)(["eval", buildReadableExtractionExpression(), "--json", "--session", sessionId], config);
+        ensureBrowserCommandOk("eval", evaluated, url);
+        return JSON.parse(evaluated.stdout.trim());
+    });
+}
+async function scrapeRenderedHtmlViaBrowser(url, config, options = {}) {
+    return withBrowserSession(url, config, options, async (sessionId) => {
+        const evaluated = await (0, agentCli_1.runAgentCommandCapture)(["eval", "document.documentElement?.outerHTML || ''", "--json", "--session", sessionId], config);
+        ensureBrowserCommandOk("eval", evaluated, url);
+        return {
+            html: JSON.parse(evaluated.stdout.trim()),
+        };
+    });
+}
+async function withBrowserSession(url, config, options, handler) {
+    const sessionId = `read-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+    const openArgs = ["open", url, "--session", sessionId];
+    const profileId = (0, config_1.resolveProfileId)(config, options.profile);
+    if (profileId) {
+        openArgs.push("--profile", profileId);
+    }
+    const open = await (0, agentCli_1.runAgentCommandCapture)(openArgs, config);
+    ensureBrowserCommandOk("open", open, url);
+    try {
+        return await handler(sessionId);
+    }
+    finally {
+        await (0, agentCli_1.runAgentCommandCapture)(["close", "--session", sessionId], config).catch(() => undefined);
+    }
+}
+function ensureBrowserCommandOk(step, response, url) {
+    if (response.exitCode === 0) {
+        return;
+    }
+    const message = response.stderr.trim() || response.stdout.trim() || `Browser command failed for ${url}`;
+    throw new errors_1.CliError(`Browser read ${step} failed.`, 1, message);
+}
+function buildReadableExtractionExpression() {
+    return `(() => {
+    const candidates = [
+      ["#content-area", document.querySelector("#content-area")],
+      ["main article", document.querySelector("main article")],
+      ["article", document.querySelector("article")],
+      ["main .prose", document.querySelector("main .prose")],
+      ["main", document.querySelector("main")],
+      ["[role='main']", document.querySelector("[role='main']")],
+      [".mintlify-content", document.querySelector(".mintlify-content")],
+      [".docs-content", document.querySelector(".docs-content")],
+      [".content", document.querySelector(".content")],
+      [".prose", document.querySelector(".prose")],
+      ["body", document.body],
+    ];
+
+    function normalizeText(value) {
+      return (value || "").replace(/\\s+/g, " ").trim();
+    }
+
+    function scoreNode(node, selector) {
+      if (!node) return { score: -Infinity, text: "" };
+      const text = normalizeText(node.innerText);
+      if (!text) return { score: -Infinity, text: "" };
+      const headings = node.querySelectorAll("h1, h2, h3").length;
+      const paragraphs = node.querySelectorAll("p, li").length;
+      const codeBlocks = node.querySelectorAll("pre, code").length;
+      const links = node.querySelectorAll("a[href]").length;
+      let score = Math.min(text.length, 12000) + headings * 180 + paragraphs * 120 + codeBlocks * 80 - links * 8;
+      if (/^(#content-area|article|main|\\[role='main'\\])/.test(selector)) {
+        score += 400;
+      }
+      return { score, text };
+    }
+
+    for (const [selector, node] of candidates) {
+      if (!node) continue;
+      const scored = scoreNode(node, selector);
+      const headings = node.querySelectorAll("h1, h2, h3").length;
+      const paragraphs = node.querySelectorAll("p, li").length;
+      if (selector !== "body" && scored.text.length >= 600 && (headings >= 1 || paragraphs >= 3)) {
+        const clone = node.cloneNode(true);
+        clone.querySelectorAll("script, style, nav, aside, form, button, svg, dialog, [role='button'], [aria-label='More actions'], .sr-only").forEach((element) => element.remove());
+        return {
+          selector,
+          html: clone.outerHTML || "",
+          text: normalizeText(clone.innerText),
+        };
+      }
+    }
+
+    const seen = new Set();
+    let best = { selector: "body", node: document.body, html: document.body?.outerHTML || "", text: normalizeText(document.body?.innerText), score: -Infinity };
+
+    for (const [selector, node] of candidates) {
+      if (!node || seen.has(node)) continue;
+      seen.add(node);
+      const scored = scoreNode(node, selector);
+      if (scored.score > best.score) {
+        const clone = node.cloneNode(true);
+        clone.querySelectorAll("script, style, nav, aside, form, button, svg, dialog, [role='button'], [aria-label='More actions'], .sr-only").forEach((element) => element.remove());
+        best = {
+          selector,
+          node,
+          html: clone.outerHTML || "",
+          text: normalizeText(clone.innerText),
+          score: scored.score,
+        };
+      }
+    }
+
+    return {
+      selector: best.selector,
+      html: best.html,
+      text: best.text,
+    };
+  })()`;
+}

package/dist/lib/browserStructured.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrapeJsonViaBrowser = scrapeJsonViaBrowser;
+const crypto_1 = require("crypto");
+const config_1 = require("../config");
+const agentCli_1 = require("./agentCli");
+const errors_1 = require("./errors");
+const MAX_HEADINGS = 50;
+const MAX_LINKS = 100;
+async function scrapeJsonViaBrowser(url, config, options = {}) {
+    const sessionId = `structured-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+    const openArgs = ["open", url, "--session", sessionId];
+    const profileId = (0, config_1.resolveProfileId)(config, options.profile);
+    if (profileId) {
+        openArgs.push("--profile", profileId);
+    }
+    const open = await (0, agentCli_1.runAgentCommandCapture)(openArgs, config);
+    ensureBrowserCommandOk("open", open, url);
+    try {
+        const evaluated = await (0, agentCli_1.runAgentCommandCapture)(["eval", buildStructuredExtractionExpression(), "--json", "--session", sessionId], config);
+        ensureBrowserCommandOk("eval", evaluated, url);
+        return JSON.parse(evaluated.stdout.trim());
+    }
+    finally {
+        await (0, agentCli_1.runAgentCommandCapture)(["close", "--session", sessionId], config).catch(() => undefined);
+    }
+}
+function ensureBrowserCommandOk(step, response, url) {
+    if (response.exitCode === 0) {
+        return;
+    }
+    const message = response.stderr.trim() || response.stdout.trim() || `Browser command failed for ${url}`;
+    throw new errors_1.CliError(`Browser structured extraction ${step} failed.`, 1, message);
+}
+function buildStructuredExtractionExpression() {
+    return `(() => {
+    const meta = {};
+    for (const node of Array.from(document.querySelectorAll("meta[name], meta[property]"))) {
+      const name = node.getAttribute("name") || node.getAttribute("property");
+      const content = node.getAttribute("content");
+      if (!name || !content) continue;
+      meta[name] = content.trim();
+    }
+
+    const headingsByLevel = { h1: [], h2: [], h3: [], h4: [], h5: [], h6: [] };
+    const headings = [];
+    for (const node of Array.from(document.querySelectorAll("h1, h2, h3, h4, h5, h6")).slice(0, ${MAX_HEADINGS})) {
+      const text = (node.textContent || "").replace(/\\s+/g, " ").trim();
+      if (!text) continue;
+      const level = node.tagName.toLowerCase();
+      if (headingsByLevel[level]) {
+        headingsByLevel[level].push(text);
+      }
+      headings.push(text);
+    }
+
+    const links = [];
+    for (const node of Array.from(document.querySelectorAll("a[href]")).slice(0, ${MAX_LINKS})) {
+      const href = (node.href || node.getAttribute("href") || "").trim();
+      if (!href) continue;
+      const text = (node.textContent || "").replace(/\\s+/g, " ").trim();
+      links.push({ href, text });
+    }
+
+    const canonicalHref = document.querySelector('link[rel="canonical"]')?.getAttribute("href") || null;
+
+    return {
+      title: document.title || null,
+      description: meta.description || meta["og:description"] || null,
+      canonical: canonicalHref,
+      meta,
+      headings,
+      headingsByLevel,
+      links
+    };
+  })()`;
+}