node-karin 1.15.5 → 1.16.1

package/dist/server-DT64D-m-.mjs

@@ -0,0 +1,38 @@
+import { g as WS_CONNECTION_PUPPETEER, r as listeners } from "./internal-DupfycKE.mjs";
+import { t as WebSocketRender } from "./ws-CcoWd3Ar.mjs";
+
+//#region src/adapter/render/connect/server.ts
+/**
+* @description WebSocket服务端渲染
+* @class WebSocketServerRenderer
+*/
+var WebSocketServerRenderer = class extends WebSocketRender {
+	/** 请求实例 */
+	request;
+	constructor(socket, request) {
+		super(socket);
+		this.request = request;
+	}
+	connection() {
+		const url = `ws://${this.request.headers.host}${this.request.url}`;
+		if (process.env.WS_SERVER_AUTH_KEY) {
+			const token = this.request.headers["authorization"];
+			if (!token || !this.auth(process.env.WS_SERVER_AUTH_KEY, token)) {
+				logger.error(`[WebSocket] 鉴权失败: authorization: ${token} url: ${url}`);
+				this.socket.close();
+				return false;
+			}
+		}
+		logger.info(`[WebSocket] 连接成功: url: ${url}`);
+		return true;
+	}
+};
+listeners.on(WS_CONNECTION_PUPPETEER, (socket, request, call) => {
+	call();
+	const server = new WebSocketServerRenderer(socket, request);
+	if (!server.connection()) return;
+	server.init();
+});
+
+//#endregion
+export {  };

package/dist/snapka-BTlnZOyI.mjs

@@ -0,0 +1,450 @@
+import { i as getRenderCfg } from "./file-ZGuqNDd-.mjs";
+import { r as listeners, x as isPublic, y as WS_SNAPKA } from "./internal-DupfycKE.mjs";
+import { o as registerRender, u as unregisterRender } from "./cache-CPcPeo6N.mjs";
+import { t as renderTemplate } from "./template-Djk6y0uC.mjs";
+import path from "node:path";
+import fs from "node:fs";
+import { URL, fileURLToPath } from "node:url";
+import axios from "axios";
+import lodash from "lodash";
+import crypto from "node:crypto";
+import { WebSocket } from "ws";
+
+//#region src/adapter/snapka/key.ts
+/**
+* 创建ws响应key 用于收到响应后发布事件
+* @param echo 请求唯一标识符
+*/
+const createWsResponseKey = (echo) => {
+	return `_response:${echo}`;
+};
+
+//#endregion
+//#region src/adapter/snapka/request.ts
+/** 索引 */
+let index = 0;
+/**
+* 创建请求错误
+* @param options 请求选项
+* @param errorType 错误类型
+* @param cause 错误原因
+* @returns Error实例
+*/
+const createRequestError = (options, errorType, cause) => {
+	return new Error(`[sendRequest] 请求错误:
+  options: ${options}\n  error: ${errorType}`, { cause });
+};
+/**
+* 发送ws请求
+* @description 开启监听响应 你需要自己往`listeners` `emit` 响应事件
+* @param socket WebSocket
+* @param data 发送的结构体
+* @param options 请求参数
+* @returns 响应数据
+* ```ts
+* import { listeners } from '@/core/internal'
+* import { createWsResponseKey } from './key'
+*
+* const { echo, data } = result
+* const key = createWsResponseKey(echo)
+* listeners.emit(key, data)
+* ```
+*/
+const sendWsRequest = (socket, data, options = {
+	timeout: 60 * 1e3,
+	onRequest: true
+}) => {
+	return new Promise((resolve, reject) => {
+		/** 超时时间 */
+		const timeout = options?.timeout ?? 60 * 1e3;
+		/** 检查WebSocket连接状态 */
+		if (socket.readyState !== socket.OPEN) return reject(createRequestError(JSON.stringify(data), `WebSocket未连接，当前状态: ${socket.readyState}`));
+		if (options.onRequest) {
+			/** 递增并检查索引是否需要重置 */
+			if (index >= Number.MAX_SAFE_INTEGER) index = 0;
+			const echo = (++index).toString();
+			const key = createWsResponseKey(echo);
+			const str = JSON.stringify({
+				...data,
+				echo
+			});
+			/**
+			* 监听响应函数
+			* @param data 响应数据
+			*/
+			const result = (data) => {
+				clearTimeout(timer);
+				if (data?.status === "ok") return resolve(data.data);
+				reject(createRequestError(str, "请求失败", data));
+			};
+			/**
+			* 超时函数
+			*/
+			const timer = setTimeout(() => {
+				listeners.off(key, result);
+				reject(createRequestError(str, `请求超时 ${timeout}ms`));
+			}, timeout);
+			listeners.once(key, result);
+			try {
+				socket.send(str);
+			} catch (error) {
+				clearTimeout(timer);
+				listeners.off(key, result);
+				reject(createRequestError(str, "发送失败", error));
+			}
+			return;
+		}
+		try {
+			socket.send(JSON.stringify(data));
+			resolve(void 0);
+		} catch (error) {
+			reject(createRequestError(JSON.stringify(data), "发送失败", error));
+		}
+	});
+};
+/**
+* puppeteer-server 发送截图请求
+* @param socket WebSocket
+* @param params 发送的结构体
+* @param timeout 请求超时时间
+* @returns 响应数据
+*/
+const sendWsScreenshotRequest = (socket, params, timeout = 60 * 1e3) => {
+	return sendWsRequest(socket, {
+		params,
+		type: "request",
+		action: params.data ? "render" : "screenshot"
+	}, {
+		onRequest: true,
+		timeout
+	});
+};
+
+//#endregion
+//#region src/adapter/snapka/client.ts
+/** 前缀 */
+const PREFIX = "[snapka-ws-clinet] ";
+/** 客户端缓存 */
+const snapkaMap$1 = /* @__PURE__ */ new Map();
+/**
+* 创建snapka客户端
+* @param clientOptions 客户端配置
+* @returns 客户端
+*/
+const createSnapkaClient = (clientOptions) => {
+	let index = -1;
+	let isReconnect = true;
+	let reconnectTimer;
+	/** 客户端配置 */
+	const { enable, url, token, reconnectTime = 5e3, heartbeatTime = 3e4, isSnapka = false } = clientOptions;
+	/** 如果未启用或不是snapka模式则直接返回 */
+	if (!enable || !isSnapka) return;
+	/** 生成鉴权 */
+	const authorization = token ? `Bearer ${crypto.createHash("sha256").update(token).digest("hex")}` : void 0;
+	/**
+	* 关闭客户端
+	*/
+	const close = () => {
+		isReconnect = false;
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = void 0;
+		}
+		client?.close();
+		snapkaMap$1.delete(url);
+	};
+	/**
+	* 创建客户端
+	*/
+	const client = token ? new WebSocket(url, { headers: { authorization: `Bearer ${crypto.createHash("sha256").update(token).digest("hex")}` } }) : new WebSocket(url);
+	/**
+	* 关闭客户端
+	*/
+	const fnc = (isPrint = true) => {
+		client.removeAllListeners();
+		client?.close();
+		index > 0 && unregisterRender(index);
+		if (!isReconnect) {
+			isPrint && logger.error(`${PREFIX}连接关闭: ${url}`);
+			return;
+		}
+		isPrint && logger.error(`${PREFIX}连接关闭: ${url} ${reconnectTime / 1e3}s 后重连...`);
+		reconnectTimer = setTimeout(() => createSnapkaClient(clientOptions), reconnectTime);
+	};
+	client.once("open", () => {
+		const timer = setInterval(() => client.ping(), heartbeatTime);
+		if (snapkaMap$1.has(url)) snapkaMap$1.get(url)?.close();
+		snapkaMap$1.set(url, {
+			client,
+			close
+		});
+		client.once("close", () => {
+			clearInterval(timer);
+			fnc();
+		});
+		setTimeout(() => {
+			if (client.readyState !== WebSocket.OPEN) return;
+			logger.info(`${PREFIX}连接成功: ${url}`);
+			index = registerRender("snapka", render);
+			client.on("message", async (event) => onMessage(client, url, event, authorization));
+		}, 3e3);
+	});
+	client.on("error", (error) => {
+		logger.error(`${PREFIX}连接错误: ${error}`);
+		fnc(false);
+	});
+	/**
+	* 截图函数
+	*/
+	const render = (options) => {
+		options = renderTemplate(options);
+		return sendWsScreenshotRequest(client, options);
+	};
+	return {
+		render,
+		close
+	};
+};
+/**
+* 收到消息事件
+* @param client 客户端
+* @param url 地址
+* @param event 事件
+* @param authorization 授权
+*/
+const onMessage = async (client, url, event, authorization) => {
+	const raw = event.toString();
+	const options = JSON.parse(raw);
+	logger.debug(`${PREFIX}收到消息: ${lodash.truncate(raw, { length: 300 })}`);
+	if (options.type === "response") {
+		const key = createWsResponseKey(options.echo);
+		return listeners.emit(key, options);
+	}
+	if (options.type !== "request") return logger.error(`${PREFIX}收到未知消息: ${raw}`);
+	if (options.action === "uploadFile") {
+		const file = fileURLToPath(options.params.path);
+		logger.debug(`${PREFIX}收到上传文件请求: ${options.params.path}`);
+		if (!isPublic(file)) {
+			logger.error(`${PREFIX}上传文件失败: 非法的路径，${file} 没有处于允许静态资源目录下`);
+			/** 失败了需要发一个响应 不然snapka会一直等待 */
+			client.send(JSON.stringify({
+				type: "response",
+				action: "uploadFile",
+				echo: options.echo,
+				status: "failed",
+				data: "非法的路径，没有处于允许静态资源目录下"
+			}));
+			return;
+		}
+		const target = new URL(url);
+		target.protocol = url.startsWith("wss") ? "https:" : "http:";
+		target.pathname = options.params.uploadPath;
+		try {
+			await axios.post(target.toString(), {
+				echo: options.echo,
+				file: `base64://${fs.readFileSync(file, "base64")}`
+			}, { headers: {
+				"Content-Type": "application/json",
+				Authorization: authorization
+			} });
+		} catch (error) {
+			logger.error(new Error(`${PREFIX}上传文件失败: ${error}`, { cause: error }));
+			/** 失败了需要发一个响应 不然snapka会一直等待 */
+			client.send(JSON.stringify({
+				type: "response",
+				action: "uploadFile",
+				echo: options.echo,
+				status: "failed",
+				data: error.message
+			}));
+		}
+	}
+};
+/**
+* 初始化snapka客户端
+*/
+const initSnapkaClient = async () => {
+	const { getRenderCfg } = await import("./file-ZGuqNDd-.mjs").then((n) => n.Zn);
+	getRenderCfg().ws_client.forEach((item) => {
+		createSnapkaClient(item);
+	});
+};
+/**
+* 断开snapka客户端
+* @param url 地址
+*/
+const disconnectSnapkaClient = (url) => {
+	const cache = snapkaMap$1.get(url);
+	if (!cache) return;
+	cache.close();
+	snapkaMap$1.delete(url);
+};
+
+//#endregion
+//#region src/adapter/snapka/auth.ts
+/**
+* 鉴权
+* 1. sha256 加密
+* 2. 明文对比
+* 3. 以上都需要带`Bearer`前缀
+* @param token 令牌
+*/
+const auth = (token) => {
+	if (!process.env.WS_SERVER_AUTH_KEY) return true;
+	if (!token) return false;
+	/** 先对比明文 */
+	if (token === `Bearer ${process.env.WS_SERVER_AUTH_KEY}`) return true;
+	if (token === `Bearer ${crypto.createHash("sha256").update(process.env.WS_SERVER_AUTH_KEY).digest("hex")}`) return true;
+	return false;
+};
+
+//#endregion
+//#region src/adapter/snapka/server.ts
+/**
+* @description 2.0 puppeteer WebSocket服务端
+* @param socket WebSocket
+* @param request IncomingMessage
+*/
+const WebSocketPuppeteerServer = async (socket, request) => {
+	let index = -1;
+	/** 鉴权 */
+	const authorization = request.headers["authorization"];
+	if (!auth(authorization)) {
+		socket.close();
+		logger.error(`[WebSocket] 鉴权失败: authorization: ${authorization} url: ${request.url}`);
+		return;
+	}
+	/**
+	* 截图函数
+	*/
+	const render = (options) => {
+		options = renderTemplate(options);
+		return sendWsScreenshotRequest(socket, options);
+	};
+	socket.on("close", () => {
+		index > 0 && unregisterRender(index);
+		socket.removeAllListeners();
+		socket.close();
+	});
+	socket.on("message", (event) => {
+		const raw = event.toString();
+		const { type, status, echo, data } = JSON.parse(raw) || {};
+		logger.debug(`[WebSocket] ${echo} ${type} ${status}`);
+		logger.trace(`[WebSocket] ${echo} ${raw}`);
+		if (type !== "response") {
+			logger.error(`[WebSocket] 未知的请求: ${raw}`);
+			return;
+		}
+		const key = createWsResponseKey(echo);
+		listeners.emit(key, {
+			status,
+			data
+		});
+	});
+	index = registerRender(request.headers["x-client-name"] || "snapka", render);
+};
+/**
+* @description 初始化WebSocketPuppeteerServer
+*/
+const initWebSocketPuppeteerServer = () => {
+	listeners.on(WS_SNAPKA, (socket, request, call) => {
+		call();
+		WebSocketPuppeteerServer(socket, request);
+	});
+};
+
+//#endregion
+//#region src/adapter/snapka/http.ts
+const snapkaMap = /* @__PURE__ */ new Map();
+/**
+* 创建snapka http
+* @param options 配置
+*/
+const createSnapkaHttp = async (options) => {
+	if (!options.isSnapka || !options.enable) return;
+	const authorization = `Bearer ${crypto.createHash("sha256").update(options.token).digest("hex")}`;
+	/** 测试是否可以连接 */
+	const url = path.dirname(options.url) + `/ping?token=${authorization}`;
+	const test = async () => {
+		try {
+			return (await axios.get(url)).data;
+		} catch (error) {
+			return false;
+		}
+	};
+	if (!await test()) logger.error(`无法连接到 Snapka-http 服务: ${options.url}，将在后台继续尝试连接`);
+	/**
+	* 截图函数
+	*/
+	const render = async (data) => {
+		data = renderTemplate(data);
+		try {
+			const result = await axios.post(options.url, data, { headers: { Authorization: authorization } });
+			if (result.status === 200 && result.data?.code === 200) return result.data.data;
+			throw new Error("请求失败:", { cause: result.data });
+		} catch (error) {
+			logger.error(`Snapka-http 服务请求异常: ${options.url}`, error);
+			throw error;
+		}
+	};
+	/** ping定时器 */
+	let pingTimer;
+	/** 连续失败次数 */
+	let consecutiveFailures = 0;
+	/** 注册render */
+	const index = registerRender("snapka-http", render);
+	/**
+	* 关闭snapka http
+	*/
+	const close = () => {
+		if (pingTimer) {
+			clearInterval(pingTimer);
+			pingTimer = void 0;
+		}
+		snapkaMap.delete(options.url);
+		unregisterRender(index);
+	};
+	/**
+	* 启动ping检测
+	*/
+	const startPingInterval = () => {
+		pingTimer = setInterval(async () => {
+			if (await test()) {
+				if (consecutiveFailures > 0) {
+					logger.info(`Snapka-http 服务 ${options.url} 恢复连接`);
+					consecutiveFailures = 0;
+				}
+			} else {
+				consecutiveFailures++;
+				logger.error(`Snapka-http 服务连接异常 (${consecutiveFailures}次): ${options.url}，将继续尝试重连`);
+			}
+		}, 1e4);
+	};
+	startPingInterval();
+	snapkaMap.set(options.url, {
+		close,
+		pingTimer
+	});
+	return {
+		render,
+		close
+	};
+};
+/**
+* 初始化snapka http
+*/
+const initSnapkaHttp = async () => {
+	const cfg = getRenderCfg();
+	for (const options of cfg.http_server) await createSnapkaHttp(options);
+};
+/**
+* 断开snapka http
+* @param url 地址
+*/
+const disconnectSnapkaHttp = (url) => {
+	const handler = snapkaMap.get(url);
+	if (handler) handler.close();
+};
+
+//#endregion
+export { createSnapkaClient, createSnapkaHttp, disconnectSnapkaClient, disconnectSnapkaHttp, initSnapkaClient, initSnapkaHttp, initWebSocketPuppeteerServer };