1703 lines
46 KiB
TypeScript
1703 lines
46 KiB
TypeScript
#!/usr/bin/env tsx
|
||
"use strict";
|
||
|
||
import fs from "node:fs";
|
||
import fsp from "node:fs/promises";
|
||
import http from "node:http";
|
||
import os from "node:os";
|
||
import path from "node:path";
|
||
import { spawn, type ChildProcess } from "node:child_process";
|
||
import type { IncomingMessage } from "node:http";
|
||
|
||
const DEFAULT_VIEWPORT_WIDTH = 1365;
|
||
const DEFAULT_VIEWPORT_HEIGHT = 900;
|
||
const DEFAULT_WAIT_MS = 1500;
|
||
const DEFAULT_TIMEOUT_MS = 45000;
|
||
const DEFAULT_MAX_CHARS = 16000;
|
||
const DEFAULT_ACTION_TIMEOUT_MS = 15000;
|
||
const DEFAULT_ACTION_WAIT_MS = 300;
|
||
|
||
const ACTION_TYPES = new Set<string>([
|
||
"click",
|
||
"fill",
|
||
"type",
|
||
"press",
|
||
"select",
|
||
"check",
|
||
"uncheck",
|
||
"remove",
|
||
"wait",
|
||
"wait_for_selector",
|
||
"scroll",
|
||
"scroll_to",
|
||
]);
|
||
|
||
type ActionType =
|
||
| "click"
|
||
| "fill"
|
||
| "type"
|
||
| "press"
|
||
| "select"
|
||
| "check"
|
||
| "uncheck"
|
||
| "remove"
|
||
| "wait"
|
||
| "wait_for_selector"
|
||
| "scroll"
|
||
| "scroll_to";
|
||
|
||
type RawArgs = Record<string, string>;
|
||
|
||
interface NormalizedAction {
|
||
type: ActionType;
|
||
selector: string;
|
||
text: string;
|
||
value: string;
|
||
key: string;
|
||
exact: boolean;
|
||
index: number;
|
||
timeoutMs: number;
|
||
waitMsAfter: number;
|
||
waitForNavigation: boolean;
|
||
state?: string;
|
||
click_count?: unknown;
|
||
ms?: number;
|
||
x?: number;
|
||
y?: number;
|
||
}
|
||
|
||
interface Params {
|
||
url: string;
|
||
mode: "content" | "screenshot";
|
||
screenshotMode: "full" | "viewport" | "selector" | "region";
|
||
selector: string;
|
||
x: number | undefined;
|
||
y: number | undefined;
|
||
regionWidth: number | undefined;
|
||
regionHeight: number | undefined;
|
||
viewportWidth: number;
|
||
viewportHeight: number;
|
||
waitMs: number;
|
||
timeoutMs: number;
|
||
maxChars: number;
|
||
maxFullHeight: number;
|
||
actionTimeoutMs: number;
|
||
actions: NormalizedAction[];
|
||
output: string;
|
||
send: "auto" | "true" | "false";
|
||
}
|
||
|
||
interface ChromiumBrowser {
|
||
chrome: ChildProcess;
|
||
userDataDir: string;
|
||
websocketUrl: string;
|
||
}
|
||
|
||
interface ElementPoint {
|
||
x: number;
|
||
y: number;
|
||
description: string;
|
||
}
|
||
|
||
interface ExtractedLink {
|
||
text: string;
|
||
href: string;
|
||
}
|
||
|
||
interface ExtractedContent {
|
||
title: string;
|
||
url: string;
|
||
lang: string;
|
||
description: string;
|
||
text: string;
|
||
headings: string[];
|
||
links: ExtractedLink[];
|
||
}
|
||
|
||
interface Rect {
|
||
x: number;
|
||
y: number;
|
||
width: number;
|
||
height: number;
|
||
}
|
||
|
||
interface LayoutContentSize extends Rect {}
|
||
|
||
interface ScreenshotClip extends Rect {
|
||
scale: number;
|
||
truncated?: boolean;
|
||
rawHeight?: number;
|
||
}
|
||
|
||
interface SelectorState {
|
||
attached: boolean;
|
||
visible: boolean;
|
||
}
|
||
|
||
function stdout(message: string): void {
|
||
process.stdout.write(`${message}\n`);
|
||
}
|
||
|
||
function parseArgs(argv: string[]): RawArgs {
|
||
const result: RawArgs = {};
|
||
for (let index = 0; index < argv.length; index += 1) {
|
||
const token = argv[index];
|
||
if (!token.startsWith("--")) {
|
||
throw new Error(`存在不支持的参数: ${token}`);
|
||
}
|
||
|
||
const equalIndex = token.indexOf("=");
|
||
let key = token.slice(2);
|
||
let value: string;
|
||
if (equalIndex >= 0) {
|
||
key = token.slice(2, equalIndex);
|
||
value = token.slice(equalIndex + 1);
|
||
} else {
|
||
const next = argv[index + 1];
|
||
if (next === undefined || next.startsWith("--")) {
|
||
value = "true";
|
||
} else {
|
||
value = next;
|
||
index += 1;
|
||
}
|
||
}
|
||
|
||
result[key] = value;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function parseNumber(
|
||
value: unknown,
|
||
name: string,
|
||
fallback?: number,
|
||
): number | undefined {
|
||
if (value === undefined || value === "") {
|
||
return fallback;
|
||
}
|
||
const parsed = Number(value);
|
||
if (!Number.isFinite(parsed)) {
|
||
throw new Error(`${name} 必须是数字`);
|
||
}
|
||
return parsed;
|
||
}
|
||
|
||
function parseInteger(value: unknown, name: string, fallback?: number): number {
|
||
const parsed = parseNumber(value, name, fallback);
|
||
if (parsed === undefined || !Number.isInteger(parsed)) {
|
||
throw new Error(`${name} 必须是整数`);
|
||
}
|
||
return parsed;
|
||
}
|
||
|
||
function readActionsFile(filePath: string | undefined): string {
|
||
if (!filePath || !filePath.trim()) {
|
||
return "";
|
||
}
|
||
try {
|
||
return fs.readFileSync(filePath, "utf8");
|
||
} catch (error) {
|
||
throw new Error(`读取 actions_file 失败: ${errorMessage(error)}`);
|
||
}
|
||
}
|
||
|
||
function errorMessage(error: unknown): string {
|
||
if (error instanceof Error) {
|
||
return error.message;
|
||
}
|
||
return String(error);
|
||
}
|
||
|
||
function isPlainObject(value: unknown): value is Record<string, unknown> {
|
||
return typeof value === "object" && value !== null && !Array.isArray(value);
|
||
}
|
||
|
||
function parseJsonActions(
|
||
rawActions: string | undefined,
|
||
rawActionsFile: string | undefined,
|
||
): unknown[] {
|
||
const source =
|
||
rawActions !== undefined ? rawActions : readActionsFile(rawActionsFile);
|
||
if (source === undefined || source === "") {
|
||
return [];
|
||
}
|
||
|
||
let parsed: unknown;
|
||
try {
|
||
parsed = JSON.parse(source);
|
||
} catch (error) {
|
||
throw new Error(`actions 必须是合法 JSON: ${errorMessage(error)}`);
|
||
}
|
||
if (isPlainObject(parsed) && Array.isArray(parsed.actions)) {
|
||
parsed = parsed.actions;
|
||
}
|
||
if (!Array.isArray(parsed)) {
|
||
throw new Error("actions 必须是动作数组，或包含 actions 数组的对象");
|
||
}
|
||
return parsed;
|
||
}
|
||
|
||
function normalizeAction(
|
||
rawAction: unknown,
|
||
index: number,
|
||
defaultActionTimeoutMs: number,
|
||
): NormalizedAction {
|
||
if (!isPlainObject(rawAction)) {
|
||
throw new Error(`第 ${index + 1} 个 action 必须是对象`);
|
||
}
|
||
|
||
const type = String(rawAction.type ?? "").trim();
|
||
if (!ACTION_TYPES.has(type)) {
|
||
throw new Error(`第 ${index + 1} 个 action.type 不支持: ${type || "(空)"}`);
|
||
}
|
||
|
||
const action: NormalizedAction = {
|
||
type: type as ActionType,
|
||
selector:
|
||
rawAction.selector === undefined ? "" : String(rawAction.selector),
|
||
text: rawAction.text === undefined ? "" : String(rawAction.text),
|
||
value: rawAction.value === undefined ? "" : String(rawAction.value),
|
||
key: rawAction.key === undefined ? "" : String(rawAction.key),
|
||
exact: Boolean(rawAction.exact),
|
||
index: parseInteger(rawAction.index, `actions[${index}].index`, 0),
|
||
timeoutMs: parseInteger(
|
||
rawAction.timeout_ms,
|
||
`actions[${index}].timeout_ms`,
|
||
defaultActionTimeoutMs,
|
||
),
|
||
waitMsAfter: parseInteger(
|
||
rawAction.wait_ms_after,
|
||
`actions[${index}].wait_ms_after`,
|
||
DEFAULT_ACTION_WAIT_MS,
|
||
),
|
||
waitForNavigation: Boolean(rawAction.wait_for_navigation),
|
||
state: rawAction.state === undefined ? undefined : String(rawAction.state),
|
||
click_count: rawAction.click_count,
|
||
};
|
||
|
||
if (action.index < 0) {
|
||
throw new Error(`actions[${index}].index 不能小于 0`);
|
||
}
|
||
if (action.timeoutMs <= 0) {
|
||
throw new Error(`actions[${index}].timeout_ms 必须大于 0`);
|
||
}
|
||
if (action.waitMsAfter < 0) {
|
||
throw new Error(`actions[${index}].wait_ms_after 不能小于 0`);
|
||
}
|
||
|
||
if (type === "click" && !action.selector && !action.text) {
|
||
throw new Error(
|
||
`第 ${index + 1} 个 click action 必须提供 selector 或 text`,
|
||
);
|
||
}
|
||
if (
|
||
["fill", "select", "check", "uncheck"].includes(type) &&
|
||
!action.selector
|
||
) {
|
||
throw new Error(`第 ${index + 1} 个 ${type} action 必须提供 selector`);
|
||
}
|
||
if (type === "type" && !action.text) {
|
||
throw new Error(`第 ${index + 1} 个 type action 必须提供 text`);
|
||
}
|
||
if (type === "press" && !action.key) {
|
||
throw new Error(`第 ${index + 1} 个 press action 必须提供 key`);
|
||
}
|
||
if (type === "remove" && !action.selector && !action.text) {
|
||
throw new Error(`第 ${index + 1} 个 remove action 必须提供 selector 或 text`);
|
||
}
|
||
if (type === "wait_for_selector" && !action.selector) {
|
||
throw new Error("wait_for_selector action 必须提供 selector");
|
||
}
|
||
if (type === "wait") {
|
||
action.ms = parseInteger(rawAction.ms, `actions[${index}].ms`, undefined);
|
||
if (action.ms === undefined || action.ms < 0) {
|
||
throw new Error("wait action 必须提供大于等于 0 的 ms");
|
||
}
|
||
}
|
||
if (type === "scroll") {
|
||
action.x = parseNumber(rawAction.x, `actions[${index}].x`, 0);
|
||
action.y = parseNumber(rawAction.y, `actions[${index}].y`, 600);
|
||
}
|
||
if (type === "scroll_to") {
|
||
action.x = parseNumber(rawAction.x, `actions[${index}].x`, undefined);
|
||
action.y = parseNumber(rawAction.y, `actions[${index}].y`, undefined);
|
||
}
|
||
|
||
return action;
|
||
}
|
||
|
||
function parseActions(
|
||
raw: RawArgs,
|
||
actionTimeoutMs: number,
|
||
): NormalizedAction[] {
|
||
return parseJsonActions(raw.actions, raw.actions_file).map((action, index) =>
|
||
normalizeAction(action, index, actionTimeoutMs),
|
||
);
|
||
}
|
||
|
||
function validateUrl(value: string): string {
|
||
if (!value || !value.trim()) {
|
||
throw new Error("缺少网页链接");
|
||
}
|
||
let parsed: URL;
|
||
try {
|
||
parsed = new URL(value.trim());
|
||
} catch {
|
||
throw new Error(`网页链接格式不正确: ${value}`);
|
||
}
|
||
if (!["http:", "https:"].includes(parsed.protocol) || !parsed.hostname) {
|
||
throw new Error("网页链接必须是 http 或 https 地址");
|
||
}
|
||
return parsed.toString();
|
||
}
|
||
|
||
function normalizeParams(raw: RawArgs): Params {
|
||
const url = validateUrl(raw.url || "");
|
||
const mode = raw.mode || "content";
|
||
if (!["content", "screenshot"].includes(mode)) {
|
||
throw new Error("mode 只能是 content 或 screenshot");
|
||
}
|
||
|
||
const screenshotMode = raw.screenshot_mode || "full";
|
||
if (!["full", "viewport", "selector", "region"].includes(screenshotMode)) {
|
||
throw new Error(
|
||
"screenshot_mode 只能是 full、viewport、selector 或 region",
|
||
);
|
||
}
|
||
|
||
const viewportWidth = parseInteger(
|
||
raw.viewport_width || raw.width,
|
||
"width",
|
||
DEFAULT_VIEWPORT_WIDTH,
|
||
);
|
||
const viewportHeight = parseInteger(
|
||
raw.viewport_height || raw.height,
|
||
"height",
|
||
DEFAULT_VIEWPORT_HEIGHT,
|
||
);
|
||
const waitMs = parseInteger(raw.wait_ms, "wait_ms", DEFAULT_WAIT_MS);
|
||
const timeoutMs = parseInteger(
|
||
raw.timeout_ms,
|
||
"timeout_ms",
|
||
DEFAULT_TIMEOUT_MS,
|
||
);
|
||
const maxChars = parseInteger(raw.max_chars, "max_chars", DEFAULT_MAX_CHARS);
|
||
const maxFullHeight = parseInteger(
|
||
raw.max_full_height,
|
||
"max_full_height",
|
||
60000,
|
||
);
|
||
const actionTimeoutMs = parseInteger(
|
||
raw.action_timeout_ms,
|
||
"action_timeout_ms",
|
||
DEFAULT_ACTION_TIMEOUT_MS,
|
||
);
|
||
const actions = parseActions(raw, actionTimeoutMs);
|
||
|
||
if (viewportWidth <= 0 || viewportHeight <= 0) {
|
||
throw new Error("视口 width 和 height 必须大于 0");
|
||
}
|
||
if (waitMs < 0) {
|
||
throw new Error("wait_ms 不能小于 0");
|
||
}
|
||
if (timeoutMs <= 0) {
|
||
throw new Error("timeout_ms 必须大于 0");
|
||
}
|
||
if (maxChars <= 0) {
|
||
throw new Error("max_chars 必须大于 0");
|
||
}
|
||
if (maxFullHeight <= 0) {
|
||
throw new Error("max_full_height 必须大于 0");
|
||
}
|
||
if (actionTimeoutMs <= 0) {
|
||
throw new Error("action_timeout_ms 必须大于 0");
|
||
}
|
||
|
||
const send = raw.send || "auto";
|
||
if (!["auto", "true", "false"].includes(send)) {
|
||
throw new Error("send 只能是 auto、true 或 false");
|
||
}
|
||
|
||
const params: Params = {
|
||
url,
|
||
mode: mode as Params["mode"],
|
||
screenshotMode: screenshotMode as Params["screenshotMode"],
|
||
selector: raw.selector || "",
|
||
x: parseNumber(raw.x, "x"),
|
||
y: parseNumber(raw.y, "y"),
|
||
regionWidth: parseNumber(
|
||
raw.region_width || (screenshotMode === "region" ? raw.width : undefined),
|
||
"width",
|
||
),
|
||
regionHeight: parseNumber(
|
||
raw.region_height ||
|
||
(screenshotMode === "region" ? raw.height : undefined),
|
||
"height",
|
||
),
|
||
viewportWidth,
|
||
viewportHeight,
|
||
waitMs,
|
||
timeoutMs,
|
||
maxChars,
|
||
maxFullHeight,
|
||
actionTimeoutMs,
|
||
actions,
|
||
output: raw.output || "",
|
||
send: send as Params["send"],
|
||
};
|
||
|
||
if (
|
||
mode === "screenshot" &&
|
||
screenshotMode === "selector" &&
|
||
!params.selector.trim()
|
||
) {
|
||
throw new Error("selector 截图模式必须传 selector");
|
||
}
|
||
if (mode === "screenshot" && screenshotMode === "region") {
|
||
if (
|
||
params.x === undefined ||
|
||
params.y === undefined ||
|
||
params.regionWidth === undefined ||
|
||
params.regionHeight === undefined
|
||
) {
|
||
throw new Error("region 截图模式必须传 x、y、width、height");
|
||
}
|
||
if (params.regionWidth <= 0 || params.regionHeight <= 0) {
|
||
throw new Error("region 截图区域 width 和 height 必须大于 0");
|
||
}
|
||
}
|
||
|
||
return params;
|
||
}
|
||
|
||
function fileExists(filePath: string): boolean {
|
||
try {
|
||
fs.accessSync(filePath, fs.constants.X_OK);
|
||
return true;
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function findChromium(): string {
|
||
const candidates = [
|
||
process.env.CHROME_BIN,
|
||
process.env.CHROME_PATH,
|
||
"/usr/bin/chromium",
|
||
"/usr/bin/chromium-browser",
|
||
"/usr/bin/google-chrome",
|
||
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
|
||
"/Applications/Chromium.app/Contents/MacOS/Chromium",
|
||
].filter((candidate): candidate is string => Boolean(candidate));
|
||
|
||
for (const candidate of candidates) {
|
||
if (fileExists(candidate)) {
|
||
return candidate;
|
||
}
|
||
}
|
||
throw new Error("未找到 Chromium，请设置 CHROME_BIN 或 CHROME_PATH");
|
||
}
|
||
|
||
function wait(ms: number): Promise<void> {
|
||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||
}
|
||
|
||
function withTimeout<T>(
|
||
promise: Promise<T>,
|
||
ms: number,
|
||
message: string,
|
||
): Promise<T> {
|
||
let timer: ReturnType<typeof setTimeout>;
|
||
const timeout = new Promise<never>((_, reject) => {
|
||
timer = setTimeout(() => reject(new Error(message)), ms);
|
||
});
|
||
return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
|
||
}
|
||
|
||
function waitForProcessExit(
|
||
child: ChildProcess,
|
||
timeoutMs: number,
|
||
): Promise<void> {
|
||
if (child.exitCode !== null || child.signalCode !== null) {
|
||
return Promise.resolve();
|
||
}
|
||
return withTimeout(
|
||
new Promise<void>((resolve) => child.once("exit", () => resolve())),
|
||
timeoutMs,
|
||
"等待 Chromium 退出超时",
|
||
);
|
||
}
|
||
|
||
async function closeChromium(
|
||
client: CdpClient,
|
||
browser: ChromiumBrowser,
|
||
): Promise<void> {
|
||
try {
|
||
await withTimeout(client.send("Browser.close"), 1500, "关闭 Chromium 超时");
|
||
} catch {
|
||
if (
|
||
browser.chrome.exitCode === null &&
|
||
browser.chrome.signalCode === null
|
||
) {
|
||
browser.chrome.kill("SIGTERM");
|
||
}
|
||
}
|
||
|
||
try {
|
||
await waitForProcessExit(browser.chrome, 3000);
|
||
} catch {
|
||
if (
|
||
browser.chrome.exitCode === null &&
|
||
browser.chrome.signalCode === null
|
||
) {
|
||
browser.chrome.kill("SIGKILL");
|
||
}
|
||
await waitForProcessExit(browser.chrome, 3000).catch(() => null);
|
||
} finally {
|
||
client.close();
|
||
}
|
||
}
|
||
|
||
async function cleanupUserDataDir(userDataDir: string): Promise<void> {
|
||
try {
|
||
await fsp.rm(userDataDir, {
|
||
recursive: true,
|
||
force: true,
|
||
maxRetries: 8,
|
||
retryDelay: 200,
|
||
});
|
||
} catch (error) {
|
||
stdout(`清理 Chromium 临时目录失败，已忽略: ${errorMessage(error)}`);
|
||
}
|
||
}
|
||
|
||
async function launchChromium(params: Params): Promise<ChromiumBrowser> {
|
||
const chromeBin = findChromium();
|
||
const userDataDir = await fsp.mkdtemp(
|
||
path.join(os.tmpdir(), "web-page-chromium-"),
|
||
);
|
||
const args = [
|
||
"--headless=new",
|
||
"--no-sandbox",
|
||
"--disable-gpu",
|
||
"--disable-dev-shm-usage",
|
||
"--disable-background-networking",
|
||
"--disable-default-apps",
|
||
"--disable-extensions",
|
||
"--disable-sync",
|
||
"--hide-scrollbars",
|
||
"--no-first-run",
|
||
"--no-default-browser-check",
|
||
"--remote-debugging-port=0",
|
||
`--user-data-dir=${userDataDir}`,
|
||
`--window-size=${params.viewportWidth},${params.viewportHeight}`,
|
||
"about:blank",
|
||
];
|
||
|
||
const chrome = spawn(chromeBin, args, { stdio: ["ignore", "pipe", "pipe"] });
|
||
const childStdout = chrome.stdout;
|
||
const childStderr = chrome.stderr;
|
||
if (!childStdout || !childStderr) {
|
||
throw new Error("无法获取 Chromium 输出流");
|
||
}
|
||
|
||
let logBuffer = "";
|
||
const websocketUrlPromise = new Promise<string>((resolve, reject) => {
|
||
const onData = (chunk: Buffer): void => {
|
||
logBuffer += chunk.toString("utf8");
|
||
const match = logBuffer.match(/DevTools listening on (ws:\/\/[^\s]+)/);
|
||
if (match) {
|
||
resolve(match[1]);
|
||
}
|
||
};
|
||
childStdout.on("data", onData);
|
||
childStderr.on("data", onData);
|
||
chrome.once("error", reject);
|
||
chrome.once("exit", (code) => {
|
||
reject(
|
||
new Error(`Chromium 启动失败，退出码: ${code}; ${logBuffer.trim()}`),
|
||
);
|
||
});
|
||
});
|
||
|
||
const websocketUrl = await withTimeout(
|
||
websocketUrlPromise,
|
||
params.timeoutMs,
|
||
"等待 Chromium DevTools 地址超时",
|
||
);
|
||
|
||
return { chrome, userDataDir, websocketUrl };
|
||
}
|
||
|
||
interface PendingRequest {
|
||
resolve: (result: Record<string, unknown>) => void;
|
||
reject: (error: Error) => void;
|
||
}
|
||
|
||
interface CdpEventListener {
|
||
method: string;
|
||
sessionId?: string;
|
||
resolve: (params: Record<string, unknown>) => void;
|
||
}
|
||
|
||
interface CdpMessage {
|
||
id?: number;
|
||
method?: string;
|
||
sessionId?: string;
|
||
params?: Record<string, unknown>;
|
||
result?: Record<string, unknown>;
|
||
error?: { message?: string };
|
||
}
|
||
|
||
class CdpClient {
|
||
private readonly websocketUrl: string;
|
||
private nextId: number;
|
||
private readonly pending: Map<number, PendingRequest>;
|
||
private listeners: CdpEventListener[];
|
||
private ws: WebSocket | null;
|
||
|
||
constructor(websocketUrl: string) {
|
||
this.websocketUrl = websocketUrl;
|
||
this.nextId = 1;
|
||
this.pending = new Map();
|
||
this.listeners = [];
|
||
this.ws = null;
|
||
}
|
||
|
||
async connect(timeoutMs: number): Promise<void> {
|
||
if (typeof WebSocket === "undefined") {
|
||
throw new Error(
|
||
"当前 Node.js 缺少 WebSocket 支持，请使用 Node.js 22+ 或基础镜像中的 Node.js 24+",
|
||
);
|
||
}
|
||
|
||
const ws = new WebSocket(this.websocketUrl);
|
||
this.ws = ws;
|
||
ws.addEventListener("message", (event: MessageEvent) =>
|
||
this.handleMessage(event.data),
|
||
);
|
||
|
||
await withTimeout(
|
||
new Promise<void>((resolve, reject) => {
|
||
ws.addEventListener("open", () => resolve(), { once: true });
|
||
ws.addEventListener(
|
||
"error",
|
||
() => reject(new Error("连接 Chromium DevTools 失败")),
|
||
{ once: true },
|
||
);
|
||
}),
|
||
timeoutMs,
|
||
"连接 Chromium DevTools 超时",
|
||
);
|
||
}
|
||
|
||
private handleMessage(raw: unknown): void {
|
||
let rawText: string;
|
||
if (typeof raw === "string") {
|
||
rawText = raw;
|
||
} else if (Buffer.isBuffer(raw)) {
|
||
rawText = raw.toString("utf8");
|
||
} else if (raw instanceof ArrayBuffer) {
|
||
rawText = Buffer.from(raw).toString("utf8");
|
||
} else {
|
||
rawText = String(raw);
|
||
}
|
||
|
||
let message: CdpMessage;
|
||
try {
|
||
message = JSON.parse(rawText) as CdpMessage;
|
||
} catch {
|
||
return;
|
||
}
|
||
|
||
if (message.id !== undefined && this.pending.has(message.id)) {
|
||
const entry = this.pending.get(message.id);
|
||
this.pending.delete(message.id);
|
||
if (!entry) {
|
||
return;
|
||
}
|
||
if (message.error) {
|
||
entry.reject(
|
||
new Error(message.error.message || JSON.stringify(message.error)),
|
||
);
|
||
} else {
|
||
entry.resolve(message.result || {});
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (message.method) {
|
||
for (const listener of [...this.listeners]) {
|
||
if (listener.method !== message.method) {
|
||
continue;
|
||
}
|
||
if (listener.sessionId && listener.sessionId !== message.sessionId) {
|
||
continue;
|
||
}
|
||
listener.resolve(message.params || {});
|
||
this.listeners = this.listeners.filter((item) => item !== listener);
|
||
}
|
||
}
|
||
}
|
||
|
||
send<T extends Record<string, unknown> = Record<string, unknown>>(
|
||
method: string,
|
||
params: Record<string, unknown> = {},
|
||
sessionId?: string,
|
||
): Promise<T> {
|
||
const ws = this.ws;
|
||
if (!ws) {
|
||
return Promise.reject(new Error("Chromium DevTools 尚未连接"));
|
||
}
|
||
const id = this.nextId;
|
||
this.nextId += 1;
|
||
const payload: Record<string, unknown> = { id, method, params };
|
||
if (sessionId) {
|
||
payload.sessionId = sessionId;
|
||
}
|
||
|
||
return new Promise<T>((resolve, reject) => {
|
||
this.pending.set(id, {
|
||
resolve: (result) => resolve(result as T),
|
||
reject,
|
||
});
|
||
ws.send(JSON.stringify(payload));
|
||
});
|
||
}
|
||
|
||
waitForEvent(
|
||
method: string,
|
||
sessionId: string | undefined,
|
||
timeoutMs: number,
|
||
): Promise<Record<string, unknown>> {
|
||
return withTimeout(
|
||
new Promise<Record<string, unknown>>((resolve) => {
|
||
this.listeners.push({ method, sessionId, resolve });
|
||
}),
|
||
timeoutMs,
|
||
`等待事件 ${method} 超时`,
|
||
);
|
||
}
|
||
|
||
close(): void {
|
||
if (this.ws) {
|
||
this.ws.close();
|
||
}
|
||
}
|
||
}
|
||
|
||
async function createPage(client: CdpClient, params: Params): Promise<string> {
|
||
const target = await client.send<{ targetId: string }>(
|
||
"Target.createTarget",
|
||
{
|
||
url: "about:blank",
|
||
},
|
||
);
|
||
const attached = await client.send<{ sessionId: string }>(
|
||
"Target.attachToTarget",
|
||
{
|
||
targetId: target.targetId,
|
||
flatten: true,
|
||
},
|
||
);
|
||
const sessionId = attached.sessionId;
|
||
await client.send("Page.enable", {}, sessionId);
|
||
await client.send("Runtime.enable", {}, sessionId);
|
||
await client.send("Network.enable", {}, sessionId);
|
||
await client.send(
|
||
"Emulation.setDeviceMetricsOverride",
|
||
{
|
||
width: params.viewportWidth,
|
||
height: params.viewportHeight,
|
||
deviceScaleFactor: 1,
|
||
mobile: false,
|
||
},
|
||
sessionId,
|
||
);
|
||
return sessionId;
|
||
}
|
||
|
||
async function navigate(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
params: Params,
|
||
): Promise<void> {
|
||
const loadEvent = client
|
||
.waitForEvent("Page.loadEventFired", sessionId, params.timeoutMs)
|
||
.catch(() => null);
|
||
await client.send("Page.navigate", { url: params.url }, sessionId);
|
||
await loadEvent;
|
||
if (params.waitMs > 0) {
|
||
await wait(params.waitMs);
|
||
}
|
||
}
|
||
|
||
interface RuntimeEvaluateResult {
|
||
result?: { value?: unknown };
|
||
exceptionDetails?: { text?: string };
|
||
}
|
||
|
||
async function evaluate<T>(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
expression: string,
|
||
): Promise<T> {
|
||
const result = await client.send<Record<string, unknown>>(
|
||
"Runtime.evaluate",
|
||
{
|
||
expression,
|
||
awaitPromise: true,
|
||
returnByValue: true,
|
||
},
|
||
sessionId,
|
||
);
|
||
const evaluation = result as RuntimeEvaluateResult;
|
||
if (evaluation.exceptionDetails) {
|
||
throw new Error(evaluation.exceptionDetails.text || "页面脚本执行失败");
|
||
}
|
||
return (evaluation.result ? evaluation.result.value : undefined) as T;
|
||
}
|
||
|
||
async function getElementPoint(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<ElementPoint> {
|
||
const encodedAction = JSON.stringify(action);
|
||
const point = await evaluate<ElementPoint | null>(
|
||
client,
|
||
sessionId,
|
||
`(async () => {
|
||
const action = ${encodedAction};
|
||
const normalize = (value) => String(value || '').replace(/\s+/g, ' ').trim();
|
||
const isVisible = (el) => {
|
||
const style = window.getComputedStyle(el);
|
||
const rect = el.getBoundingClientRect();
|
||
return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && rect.width > 0 && rect.height > 0;
|
||
};
|
||
const textOf = (el) => normalize([
|
||
el.innerText,
|
||
el.value,
|
||
el.getAttribute('aria-label'),
|
||
el.getAttribute('title'),
|
||
el.getAttribute('alt'),
|
||
el.getAttribute('placeholder'),
|
||
].filter(Boolean).join(' '));
|
||
const matchesText = (el) => {
|
||
if (!action.text) return true;
|
||
const haystack = textOf(el);
|
||
return action.exact ? haystack === action.text : haystack.includes(action.text);
|
||
};
|
||
const candidates = action.selector
|
||
? Array.from(document.querySelectorAll(action.selector))
|
||
: Array.from(document.querySelectorAll('button, a, input, textarea, select, label, [role="button"], [onclick], [tabindex]'));
|
||
const matches = candidates.filter((el) => isVisible(el) && matchesText(el));
|
||
const el = matches[action.index || 0];
|
||
if (!el) {
|
||
return null;
|
||
}
|
||
el.scrollIntoView({ block: 'center', inline: 'center' });
|
||
await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||
const rect = el.getBoundingClientRect();
|
||
return {
|
||
x: Math.max(0, Math.min(window.innerWidth - 1, rect.left + rect.width / 2)),
|
||
y: Math.max(0, Math.min(window.innerHeight - 1, rect.top + rect.height / 2)),
|
||
description: action.selector || action.text || textOf(el),
|
||
};
|
||
})()`,
|
||
);
|
||
if (!point) {
|
||
const target = action.selector || `text=${action.text}`;
|
||
throw new Error(`未找到可操作元素: ${target}`);
|
||
}
|
||
return point;
|
||
}
|
||
|
||
async function clickElement(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
const point = await getElementPoint(client, sessionId, action);
|
||
const clickCount = Math.max(
|
||
1,
|
||
parseInteger(action.click_count, "click_count", 1),
|
||
);
|
||
await client.send(
|
||
"Input.dispatchMouseEvent",
|
||
{
|
||
type: "mouseMoved",
|
||
x: point.x,
|
||
y: point.y,
|
||
button: "none",
|
||
clickCount: 0,
|
||
},
|
||
sessionId,
|
||
);
|
||
for (let index = 0; index < clickCount; index += 1) {
|
||
await client.send(
|
||
"Input.dispatchMouseEvent",
|
||
{
|
||
type: "mousePressed",
|
||
x: point.x,
|
||
y: point.y,
|
||
button: "left",
|
||
buttons: 1,
|
||
clickCount: index + 1,
|
||
},
|
||
sessionId,
|
||
);
|
||
await client.send(
|
||
"Input.dispatchMouseEvent",
|
||
{
|
||
type: "mouseReleased",
|
||
x: point.x,
|
||
y: point.y,
|
||
button: "left",
|
||
buttons: 0,
|
||
clickCount: index + 1,
|
||
},
|
||
sessionId,
|
||
);
|
||
}
|
||
}
|
||
|
||
async function fillElement(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
const encodedAction = JSON.stringify(action);
|
||
const ok = await evaluate<boolean>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
const el = document.querySelectorAll(action.selector)[action.index || 0];
|
||
if (!el) return false;
|
||
el.scrollIntoView({ block: 'center', inline: 'center' });
|
||
el.focus();
|
||
const value = action.value;
|
||
if (el.isContentEditable) {
|
||
el.textContent = value;
|
||
} else if ('value' in el) {
|
||
el.value = value;
|
||
} else {
|
||
el.textContent = value;
|
||
}
|
||
el.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: value }));
|
||
el.dispatchEvent(new Event('change', { bubbles: true }));
|
||
return true;
|
||
})()`,
|
||
);
|
||
if (!ok) {
|
||
throw new Error(`未找到可填写元素: ${action.selector}`);
|
||
}
|
||
}
|
||
|
||
async function focusElement(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
if (!action.selector) {
|
||
return;
|
||
}
|
||
const encodedAction = JSON.stringify(action);
|
||
const ok = await evaluate<boolean>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
const el = document.querySelectorAll(action.selector)[action.index || 0];
|
||
if (!el) return false;
|
||
el.scrollIntoView({ block: 'center', inline: 'center' });
|
||
el.focus();
|
||
return document.activeElement === el || el.contains(document.activeElement);
|
||
})()`,
|
||
);
|
||
if (!ok) {
|
||
throw new Error(`未找到可聚焦元素: ${action.selector}`);
|
||
}
|
||
}
|
||
|
||
async function typeText(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
await focusElement(client, sessionId, action);
|
||
await client.send("Input.insertText", { text: action.text }, sessionId);
|
||
}
|
||
|
||
interface KeyDefinition {
|
||
key: string;
|
||
code: string;
|
||
text?: string;
|
||
windowsVirtualKeyCode: number;
|
||
}
|
||
|
||
function keyDefinition(key: string): KeyDefinition {
|
||
const special: Record<
|
||
string,
|
||
{ code: string; windowsVirtualKeyCode: number }
|
||
> = {
|
||
Enter: { code: "Enter", windowsVirtualKeyCode: 13 },
|
||
Tab: { code: "Tab", windowsVirtualKeyCode: 9 },
|
||
Escape: { code: "Escape", windowsVirtualKeyCode: 27 },
|
||
Backspace: { code: "Backspace", windowsVirtualKeyCode: 8 },
|
||
Delete: { code: "Delete", windowsVirtualKeyCode: 46 },
|
||
ArrowUp: { code: "ArrowUp", windowsVirtualKeyCode: 38 },
|
||
ArrowDown: { code: "ArrowDown", windowsVirtualKeyCode: 40 },
|
||
ArrowLeft: { code: "ArrowLeft", windowsVirtualKeyCode: 37 },
|
||
ArrowRight: { code: "ArrowRight", windowsVirtualKeyCode: 39 },
|
||
};
|
||
const found = special[key];
|
||
if (found) {
|
||
return { key, ...found };
|
||
}
|
||
if (key.length === 1) {
|
||
const upper = key.toUpperCase();
|
||
return {
|
||
key,
|
||
code: `Key${upper}`,
|
||
text: key,
|
||
windowsVirtualKeyCode: upper.charCodeAt(0),
|
||
};
|
||
}
|
||
return { key, code: key, windowsVirtualKeyCode: 0 };
|
||
}
|
||
|
||
async function pressKey(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
await focusElement(client, sessionId, action);
|
||
const key = keyDefinition(action.key);
|
||
await client.send(
|
||
"Input.dispatchKeyEvent",
|
||
{ type: "keyDown", ...key },
|
||
sessionId,
|
||
);
|
||
await client.send(
|
||
"Input.dispatchKeyEvent",
|
||
{ type: "keyUp", ...key },
|
||
sessionId,
|
||
);
|
||
}
|
||
|
||
async function selectElement(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
const encodedAction = JSON.stringify(action);
|
||
const ok = await evaluate<boolean>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
const el = document.querySelectorAll(action.selector)[action.index || 0];
|
||
if (!el || !(el instanceof HTMLSelectElement)) return false;
|
||
el.focus();
|
||
el.value = action.value;
|
||
el.dispatchEvent(new Event('input', { bubbles: true }));
|
||
el.dispatchEvent(new Event('change', { bubbles: true }));
|
||
return true;
|
||
})()`,
|
||
);
|
||
if (!ok) {
|
||
throw new Error(`未找到可选择的 select 元素: ${action.selector}`);
|
||
}
|
||
}
|
||
|
||
async function setChecked(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
checked: boolean,
|
||
): Promise<void> {
|
||
const encodedAction = JSON.stringify(action);
|
||
const ok = await evaluate<boolean>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
const el = document.querySelectorAll(action.selector)[action.index || 0];
|
||
if (!el || !('checked' in el)) return false;
|
||
el.focus();
|
||
el.checked = ${checked ? "true" : "false"};
|
||
el.dispatchEvent(new Event('input', { bubbles: true }));
|
||
el.dispatchEvent(new Event('change', { bubbles: true }));
|
||
return true;
|
||
})()`,
|
||
);
|
||
if (!ok) {
|
||
throw new Error(`未找到可勾选元素: ${action.selector}`);
|
||
}
|
||
}
|
||
|
||
async function removeElement(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
const encodedAction = JSON.stringify(action);
|
||
const ok = await evaluate<boolean>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
const normalize = (value) => String(value || '').replace(/\s+/g, ' ').trim();
|
||
const textOf = (el) => normalize([
|
||
el.innerText,
|
||
el.value,
|
||
el.getAttribute('aria-label'),
|
||
el.getAttribute('title'),
|
||
el.getAttribute('alt'),
|
||
el.getAttribute('placeholder'),
|
||
].filter(Boolean).join(' '));
|
||
const matchesText = (el) => {
|
||
if (!action.text) return true;
|
||
const haystack = textOf(el);
|
||
return action.exact ? haystack === action.text : haystack.includes(action.text);
|
||
};
|
||
const candidates = action.selector
|
||
? Array.from(document.querySelectorAll(action.selector))
|
||
: Array.from(document.querySelectorAll('body *'));
|
||
const matches = candidates.filter((el) => matchesText(el));
|
||
const el = matches[action.index || 0];
|
||
if (!el) return false;
|
||
el.remove();
|
||
return true;
|
||
})()`,
|
||
);
|
||
if (!ok) {
|
||
const target = action.selector || `text=${action.text}`;
|
||
throw new Error(`未找到可删除元素: ${target}`);
|
||
}
|
||
}
|
||
|
||
async function waitForSelector(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
const state = action.state || "visible";
|
||
if (!["attached", "visible", "hidden", "detached"].includes(state)) {
|
||
throw new Error(
|
||
"wait_for_selector.state 只能是 attached、visible、hidden 或 detached",
|
||
);
|
||
}
|
||
const startedAt = Date.now();
|
||
while (Date.now() - startedAt <= action.timeoutMs) {
|
||
const encodedAction = JSON.stringify(action);
|
||
const result = await evaluate<SelectorState>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
const el = document.querySelectorAll(action.selector)[action.index || 0];
|
||
if (!el) return { attached: false, visible: false };
|
||
const style = window.getComputedStyle(el);
|
||
const rect = el.getBoundingClientRect();
|
||
return {
|
||
attached: true,
|
||
visible: style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && rect.width > 0 && rect.height > 0,
|
||
};
|
||
})()`,
|
||
);
|
||
if (
|
||
(state === "attached" && result.attached) ||
|
||
(state === "visible" && result.visible) ||
|
||
(state === "hidden" && result.attached && !result.visible) ||
|
||
(state === "detached" && !result.attached)
|
||
) {
|
||
return;
|
||
}
|
||
await wait(100);
|
||
}
|
||
throw new Error(`等待 selector 超时: ${action.selector}`);
|
||
}
|
||
|
||
async function scrollPage(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
await evaluate<unknown>(
|
||
client,
|
||
sessionId,
|
||
`window.scrollBy(${JSON.stringify(action.x)}, ${JSON.stringify(action.y)})`,
|
||
);
|
||
}
|
||
|
||
async function scrollToTarget(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
const encodedAction = JSON.stringify(action);
|
||
const ok = await evaluate<boolean>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const action = ${encodedAction};
|
||
if (action.selector || action.text) {
|
||
const normalize = (value) => String(value || '').replace(/\s+/g, ' ').trim();
|
||
const textOf = (el) => normalize([el.innerText, el.value, el.getAttribute('aria-label'), el.getAttribute('title')].filter(Boolean).join(' '));
|
||
const candidates = action.selector
|
||
? Array.from(document.querySelectorAll(action.selector))
|
||
: Array.from(document.querySelectorAll('button, a, input, textarea, select, label, [role="button"], [onclick], [tabindex], main, article, section, div'));
|
||
const matches = candidates.filter((el) => {
|
||
if (!action.text) return true;
|
||
const haystack = textOf(el);
|
||
return action.exact ? haystack === action.text : haystack.includes(action.text);
|
||
});
|
||
const el = matches[action.index || 0];
|
||
if (!el) return false;
|
||
el.scrollIntoView({ block: 'center', inline: 'center' });
|
||
return true;
|
||
}
|
||
window.scrollTo(action.x || 0, action.y || 0);
|
||
return true;
|
||
})()`,
|
||
);
|
||
if (!ok) {
|
||
const target = action.selector || `text=${action.text}`;
|
||
throw new Error(`未找到可滚动到的元素: ${target}`);
|
||
}
|
||
}
|
||
|
||
async function runSingleAction(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
action: NormalizedAction,
|
||
): Promise<void> {
|
||
switch (action.type) {
|
||
case "click":
|
||
await clickElement(client, sessionId, action);
|
||
return;
|
||
case "fill":
|
||
await fillElement(client, sessionId, action);
|
||
return;
|
||
case "type":
|
||
await typeText(client, sessionId, action);
|
||
return;
|
||
case "press":
|
||
await pressKey(client, sessionId, action);
|
||
return;
|
||
case "select":
|
||
await selectElement(client, sessionId, action);
|
||
return;
|
||
case "check":
|
||
await setChecked(client, sessionId, action, true);
|
||
return;
|
||
case "uncheck":
|
||
await setChecked(client, sessionId, action, false);
|
||
return;
|
||
case "remove":
|
||
await removeElement(client, sessionId, action);
|
||
return;
|
||
case "wait":
|
||
await wait(action.ms ?? 0);
|
||
return;
|
||
case "wait_for_selector":
|
||
await waitForSelector(client, sessionId, action);
|
||
return;
|
||
case "scroll":
|
||
await scrollPage(client, sessionId, action);
|
||
return;
|
||
case "scroll_to":
|
||
await scrollToTarget(client, sessionId, action);
|
||
return;
|
||
default:
|
||
throw new Error(`不支持的 action.type: ${String(action.type)}`);
|
||
}
|
||
}
|
||
|
||
async function runActions(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
params: Params,
|
||
): Promise<void> {
|
||
if (!params.actions.length) {
|
||
return;
|
||
}
|
||
|
||
for (let index = 0; index < params.actions.length; index += 1) {
|
||
const action = params.actions[index];
|
||
try {
|
||
const loadEvent = action.waitForNavigation
|
||
? client
|
||
.waitForEvent("Page.loadEventFired", sessionId, action.timeoutMs)
|
||
.catch(() => null)
|
||
: null;
|
||
await withTimeout(
|
||
runSingleAction(client, sessionId, action),
|
||
action.timeoutMs,
|
||
`执行 action 超时: ${action.type}`,
|
||
);
|
||
if (loadEvent) {
|
||
await loadEvent;
|
||
}
|
||
if (action.waitMsAfter > 0) {
|
||
await wait(action.waitMsAfter);
|
||
}
|
||
} catch (error) {
|
||
throw new Error(
|
||
`第 ${index + 1} 个 action(${action.type}) 执行失败: ${errorMessage(error)}`,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
function cleanText(text: string): string {
|
||
return String(text || "")
|
||
.replace(/\u00a0/g, " ")
|
||
.split("\n")
|
||
.map((line) => line.trim().replace(/[ \t]+/g, " "))
|
||
.filter((line, index, lines) => line || lines[index - 1])
|
||
.join("\n")
|
||
.trim();
|
||
}
|
||
|
||
async function extractContent(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
params: Params,
|
||
): Promise<string> {
|
||
const data = await evaluate<ExtractedContent>(
|
||
client,
|
||
sessionId,
|
||
`(() => {
|
||
const textOf = (node) => (node && node.innerText ? node.innerText.trim() : '');
|
||
const meta = (selector) => {
|
||
const el = document.querySelector(selector);
|
||
return el ? (el.getAttribute('content') || '').trim() : '';
|
||
};
|
||
const candidates = Array.from(document.querySelectorAll('article, main, [role="main"], #content, .content, .article, .post, .entry-content'));
|
||
let root = document.body;
|
||
const bodyLength = textOf(document.body).length;
|
||
let bestLength = 0;
|
||
for (const candidate of candidates) {
|
||
const length = textOf(candidate).length;
|
||
if (length > bestLength) {
|
||
root = candidate;
|
||
bestLength = length;
|
||
}
|
||
}
|
||
if (bestLength < bodyLength * 0.25) {
|
||
root = document.body;
|
||
}
|
||
const headings = Array.from(document.querySelectorAll('h1, h2, h3'))
|
||
.map((el) => el.innerText.trim())
|
||
.filter(Boolean)
|
||
.slice(0, 30);
|
||
const links = Array.from(document.querySelectorAll('a[href]'))
|
||
.map((el) => ({ text: el.innerText.trim().replace(/\s+/g, ' '), href: el.href }))
|
||
.filter((item) => item.text && item.href && /^https?:/.test(item.href))
|
||
.slice(0, 40);
|
||
return {
|
||
title: document.title || '',
|
||
url: location.href,
|
||
lang: document.documentElement.lang || '',
|
||
description: meta('meta[name="description"]') || meta('meta[property="og:description"]'),
|
||
text: textOf(root) || textOf(document.body),
|
||
headings,
|
||
links,
|
||
};
|
||
})()`,
|
||
);
|
||
|
||
const text = cleanText(data.text || "");
|
||
const truncated = text.length > params.maxChars;
|
||
const body = truncated
|
||
? `${text.slice(0, params.maxChars)}\n\n[内容过长，已截断到 ${params.maxChars} 字]`
|
||
: text;
|
||
const headings = [...new Set(data.headings || [])].slice(0, 20);
|
||
const links: ExtractedLink[] = [];
|
||
const seenLinks = new Set<string>();
|
||
for (const link of data.links || []) {
|
||
const key = `${link.text}\t${link.href}`;
|
||
if (seenLinks.has(key)) {
|
||
continue;
|
||
}
|
||
seenLinks.add(key);
|
||
links.push(link);
|
||
if (links.length >= 20) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
const parts = [
|
||
`标题：${data.title || "(无标题)"}`,
|
||
`URL：${data.url || params.url}`,
|
||
];
|
||
if (data.lang) {
|
||
parts.push(`语言：${data.lang}`);
|
||
}
|
||
if (data.description) {
|
||
parts.push(`页面描述：${cleanText(data.description)}`);
|
||
}
|
||
if (headings.length) {
|
||
parts.push(
|
||
`主要标题：\n${headings.map((heading) => `- ${heading}`).join("\n")}`,
|
||
);
|
||
}
|
||
parts.push(`正文：\n${body || "(未抽取到可见正文)"}`);
|
||
if (links.length) {
|
||
parts.push(
|
||
`主要链接：\n${links.map((link) => `- ${link.text}: ${link.href}`).join("\n")}`,
|
||
);
|
||
}
|
||
return parts.join("\n\n");
|
||
}
|
||
|
||
async function getLayoutMetrics(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
): Promise<LayoutContentSize> {
|
||
const metrics = await client.send<{
|
||
cssContentSize?: LayoutContentSize;
|
||
contentSize?: LayoutContentSize;
|
||
}>("Page.getLayoutMetrics", {}, sessionId);
|
||
return (
|
||
metrics.cssContentSize ||
|
||
metrics.contentSize || { x: 0, y: 0, width: 0, height: 0 }
|
||
);
|
||
}
|
||
|
||
async function getSelectorClip(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
selector: string,
|
||
): Promise<Rect> {
|
||
const encodedSelector = JSON.stringify(selector);
|
||
const rect = await evaluate<Rect | null>(
|
||
client,
|
||
sessionId,
|
||
`(async () => {
|
||
const el = document.querySelector(${encodedSelector});
|
||
if (!el) return null;
|
||
el.scrollIntoView({ block: 'center', inline: 'center' });
|
||
await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||
const r = el.getBoundingClientRect();
|
||
return { x: r.left + window.scrollX, y: r.top + window.scrollY, width: r.width, height: r.height };
|
||
})()`,
|
||
);
|
||
if (!rect) {
|
||
throw new Error(`未找到 selector 对应元素: ${selector}`);
|
||
}
|
||
if (rect.width <= 0 || rect.height <= 0) {
|
||
throw new Error(`selector 对应元素尺寸为空: ${selector}`);
|
||
}
|
||
return rect;
|
||
}
|
||
|
||
async function getScreenshotClip(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
params: Params,
|
||
): Promise<ScreenshotClip> {
|
||
if (params.screenshotMode === "region") {
|
||
if (
|
||
params.x === undefined ||
|
||
params.y === undefined ||
|
||
params.regionWidth === undefined ||
|
||
params.regionHeight === undefined
|
||
) {
|
||
throw new Error("region 截图模式必须传 x、y、width、height");
|
||
}
|
||
return {
|
||
x: params.x,
|
||
y: params.y,
|
||
width: params.regionWidth,
|
||
height: params.regionHeight,
|
||
scale: 1,
|
||
};
|
||
}
|
||
if (params.screenshotMode === "selector") {
|
||
const rect = await getSelectorClip(client, sessionId, params.selector);
|
||
return { ...rect, scale: 1 };
|
||
}
|
||
if (params.screenshotMode === "viewport") {
|
||
return {
|
||
x: 0,
|
||
y: 0,
|
||
width: params.viewportWidth,
|
||
height: params.viewportHeight,
|
||
scale: 1,
|
||
};
|
||
}
|
||
|
||
const contentSize = await getLayoutMetrics(client, sessionId);
|
||
const width = Math.max(
|
||
1,
|
||
Math.ceil(contentSize.width || params.viewportWidth),
|
||
);
|
||
const rawHeight = Math.max(
|
||
1,
|
||
Math.ceil(contentSize.height || params.viewportHeight),
|
||
);
|
||
const height = Math.min(rawHeight, params.maxFullHeight);
|
||
return {
|
||
x: 0,
|
||
y: 0,
|
||
width,
|
||
height,
|
||
scale: 1,
|
||
truncated: rawHeight > height,
|
||
rawHeight,
|
||
};
|
||
}
|
||
|
||
interface ScreenshotResult {
|
||
output: string;
|
||
clip: ScreenshotClip;
|
||
}
|
||
|
||
async function captureScreenshot(
|
||
client: CdpClient,
|
||
sessionId: string,
|
||
params: Params,
|
||
): Promise<ScreenshotResult> {
|
||
const clip = await getScreenshotClip(client, sessionId, params);
|
||
const result = await client.send<{ data?: string }>(
|
||
"Page.captureScreenshot",
|
||
{
|
||
format: "png",
|
||
fromSurface: true,
|
||
captureBeyondViewport: true,
|
||
clip: {
|
||
x: Math.max(0, clip.x),
|
||
y: Math.max(0, clip.y),
|
||
width: Math.max(1, clip.width),
|
||
height: Math.max(1, clip.height),
|
||
scale: 1,
|
||
},
|
||
},
|
||
sessionId,
|
||
);
|
||
if (!result.data) {
|
||
throw new Error("Chromium 未返回截图数据");
|
||
}
|
||
const output =
|
||
params.output ||
|
||
path.join(os.tmpdir(), `web-page-screenshot-${Date.now()}.png`);
|
||
await fsp.mkdir(path.dirname(output), { recursive: true });
|
||
await fsp.writeFile(output, Buffer.from(result.data, "base64"));
|
||
return { output, clip };
|
||
}
|
||
|
||
function postJson(
|
||
url: string,
|
||
body: Record<string, unknown>,
|
||
timeoutMs: number,
|
||
): Promise<string> {
|
||
return new Promise<string>((resolve, reject) => {
|
||
const parsed = new URL(url);
|
||
const payload = Buffer.from(JSON.stringify(body), "utf8");
|
||
const request = http.request(
|
||
{
|
||
hostname: parsed.hostname,
|
||
port: parsed.port,
|
||
path: parsed.pathname + parsed.search,
|
||
method: "POST",
|
||
headers: {
|
||
"Content-Type": "application/json",
|
||
"Content-Length": payload.length,
|
||
},
|
||
timeout: timeoutMs,
|
||
},
|
||
(response: IncomingMessage) => {
|
||
const chunks: Buffer[] = [];
|
||
response.on("data", (chunk: Buffer) => chunks.push(chunk));
|
||
response.on("end", () => {
|
||
const text = Buffer.concat(chunks).toString("utf8");
|
||
const statusCode = response.statusCode ?? 0;
|
||
if (statusCode < 200 || statusCode >= 300) {
|
||
reject(new Error(`HTTP ${statusCode}: ${text}`));
|
||
return;
|
||
}
|
||
resolve(text);
|
||
});
|
||
},
|
||
);
|
||
request.on("error", reject);
|
||
request.on("timeout", () =>
|
||
request.destroy(new Error("请求机器人客户端超时")),
|
||
);
|
||
request.write(payload);
|
||
request.end();
|
||
});
|
||
}
|
||
|
||
async function maybeSendScreenshot(
|
||
params: Params,
|
||
filePath: string,
|
||
): Promise<boolean> {
|
||
if (params.send === "false") {
|
||
return false;
|
||
}
|
||
const clientPort = (process.env.ROBOT_WECHAT_CLIENT_PORT || "").trim();
|
||
const toWxid = (process.env.ROBOT_FROM_WX_ID || "").trim();
|
||
if (!clientPort || !toWxid) {
|
||
if (params.send === "true") {
|
||
throw new Error(
|
||
"环境变量 ROBOT_WECHAT_CLIENT_PORT 或 ROBOT_FROM_WX_ID 未配置",
|
||
);
|
||
}
|
||
return false;
|
||
}
|
||
const sendUrl = `http://127.0.0.1:${clientPort}/api/v1/robot/message/send/image/local`;
|
||
await postJson(
|
||
sendUrl,
|
||
{ to_wxid: toWxid, file_path: filePath },
|
||
params.timeoutMs,
|
||
);
|
||
return true;
|
||
}
|
||
|
||
async function run(): Promise<void> {
|
||
const params = normalizeParams(parseArgs(process.argv.slice(2)));
|
||
const browser = await launchChromium(params);
|
||
const client = new CdpClient(browser.websocketUrl);
|
||
try {
|
||
await client.connect(params.timeoutMs);
|
||
const sessionId = await createPage(client, params);
|
||
await navigate(client, sessionId, params);
|
||
await runActions(client, sessionId, params);
|
||
|
||
if (params.mode === "content") {
|
||
stdout(await extractContent(client, sessionId, params));
|
||
return;
|
||
}
|
||
|
||
const screenshot = await captureScreenshot(client, sessionId, params);
|
||
const sent = await maybeSendScreenshot(params, screenshot.output);
|
||
if (sent) {
|
||
const suffix = screenshot.clip.truncated
|
||
? `，页面过长，已截取前 ${Math.round(screenshot.clip.height)}px / ${Math.round(screenshot.clip.rawHeight ?? screenshot.clip.height)}px`
|
||
: "";
|
||
stdout(`页面截图已发送${suffix}`);
|
||
} else {
|
||
const suffix = screenshot.clip.truncated
|
||
? `（页面过长，已截取前 ${Math.round(screenshot.clip.height)}px / ${Math.round(screenshot.clip.rawHeight ?? screenshot.clip.height)}px）`
|
||
: "";
|
||
stdout(`页面截图已保存: ${screenshot.output}${suffix}`);
|
||
}
|
||
} finally {
|
||
await closeChromium(client, browser);
|
||
await cleanupUserDataDir(browser.userDataDir);
|
||
}
|
||
}
|
||
|
||
run().catch((error: unknown) => {
|
||
stdout(
|
||
`执行失败: ${error instanceof Error && error.stack ? error.stack : String(error)}`,
|
||
);
|
||
process.exit(1);
|
||
});
|