napcat-sdk 0.0.0-snapshot.0 → 0.1.0

package/.node-version

@@ -0,0 +1 @@
+24.11.1

package/dist/index.cjs

@@ -0,0 +1,653 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+let mitt = require("mitt");
+mitt = __toESM(mitt);
+
+//#region package.json
+var name$1 = "napcat-sdk";
+var version$1 = "0.1.0";
+var package_default = {
+	name: name$1,
+	type: "module",
+	version: version$1,
+	packageManager: "pnpm@10.26.0",
+	description: "A simple SDK for NapCat OneBot v11.",
+	keywords: [
+		"napcat",
+		"onebot",
+		"onebot v11",
+		"sdk"
+	],
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/vikiboss/mioki.git",
+		"directory": "packages/napcat-sdk"
+	},
+	scripts: {
+		"dev": "tsdown -w",
+		"build": "tsdown"
+	},
+	exports: {
+		".": {
+			"require": "./dist/index.cjs",
+			"import": "./dist/index.mjs",
+			"types": "./dist/index.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	author: "Viki <hi@viki.moe> (https://github.com/vikiboss)",
+	license: "MIT",
+	devDependencies: {
+		"@types/node": "catalog:dev",
+		"tsdown": "catalog:dev",
+		"typescript": "catalog:dev"
+	},
+	dependencies: { "mitt": "^3.0.1" }
+};
+
+//#endregion
+//#region src/segment.ts
+function createSegment(type$1, data) {
+	return {
+		type: type$1,
+		...data
+	};
+}
+/**
+* 消息片段构造器
+*/
+const segment = {
+	text: (text) => createSegment("text", { text }),
+	at: (qq) => createSegment("at", { qq }),
+	face: (id) => createSegment("face", { id }),
+	reply: (id) => createSegment("reply", { id }),
+	image: (file, options) => createSegment("image", {
+		file,
+		...options
+	}),
+	record: (file, options) => createSegment("record", {
+		file,
+		...options
+	}),
+	video: (file, options) => createSegment("video", {
+		file,
+		...options
+	}),
+	mface: (options) => createSegment("mface", { ...options }),
+	bface: (id) => createSegment("bface", { id }),
+	contact: (type$1, id) => createSegment("contact", {
+		id,
+		sub_type: type$1
+	}),
+	poke: () => createSegment("poke", {}),
+	music: (platform, id) => createSegment("music", {
+		platform,
+		id
+	}),
+	musicCustom: (title, audio, url, options) => createSegment("music", {
+		platform: "custom",
+		url,
+		audio,
+		title,
+		...options
+	}),
+	forward: (id) => createSegment("forward", { id }),
+	json: (data) => createSegment("json", { data }),
+	file: (file, options) => createSegment("file", {
+		file,
+		...options
+	}),
+	markdown: () => createSegment("markdown", {}),
+	lightapp: () => createSegment("lightapp", {})
+};
+
+//#endregion
+//#region src/logger.ts
+const LOG_LEVEL_KEYS = Object.keys({
+	fatal: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4,
+	trace: 5
+});
+const noop = () => {};
+const ABSTRACT_LOGGER = Object.fromEntries(LOG_LEVEL_KEYS.map((level) => [level, noop]));
+const CONSOLE_LOGGER = Object.fromEntries(LOG_LEVEL_KEYS.map((level) => [level, (...args) => {
+	console[level === "fatal" ? "error" : level === "trace" ? "debug" : level](...args);
+}]));
+
+//#endregion
+//#region src/onebot.ts
+/**
+* NapCat 通知类型映射表（notify 类型）
+* @description 将 NapCat 特有的通知类型映射到标准的 notice_type 和 sub_type
+*/
+const NAPCAT_NOTICE_NOTIFY_MAP = {
+	input_status: {
+		notice_type: "friend",
+		sub_type: "input"
+	},
+	profile_like: {
+		notice_type: "friend",
+		sub_type: "like"
+	},
+	title: {
+		notice_type: "group",
+		sub_type: "title"
+	}
+};
+/**
+* NapCat 通知事件映射表（notice 类型）
+* @description 将 NapCat 的原始通知事件类型映射到标准的 notice_type 和 sub_type
+*/
+const NAPCAT_NOTICE_EVENT_MAP = {
+	friend_add: {
+		notice_type: "friend",
+		sub_type: "increase"
+	},
+	friend_recall: {
+		notice_type: "friend",
+		sub_type: "recall"
+	},
+	offline_file: {
+		notice_type: "friend",
+		sub_type: "offline_file"
+	},
+	client_status: {
+		notice_type: "client",
+		sub_type: "status"
+	},
+	group_admin: {
+		notice_type: "group",
+		sub_type: "admin"
+	},
+	group_ban: {
+		notice_type: "group",
+		sub_type: "ban"
+	},
+	group_card: {
+		notice_type: "group",
+		sub_type: "card"
+	},
+	group_upload: {
+		notice_type: "group",
+		sub_type: "upload"
+	},
+	group_decrease: {
+		notice_type: "group",
+		sub_type: "decrease"
+	},
+	group_increase: {
+		notice_type: "group",
+		sub_type: "increase"
+	},
+	group_msg_emoji_like: {
+		notice_type: "group",
+		sub_type: "reaction"
+	},
+	essence: {
+		notice_type: "group",
+		sub_type: "essence"
+	},
+	group_recall: {
+		notice_type: "group",
+		sub_type: "recall"
+	}
+};
+
+//#endregion
+//#region src/napcat.ts
+const name = name$1;
+const version = version$1;
+const DEFAULT_NAPCAT_OPTIONS = {
+	protocol: "ws",
+	host: "localhost",
+	port: 3333,
+	logger: ABSTRACT_LOGGER
+};
+var NapCat = class {
+	/** WebSocket 实例 */
+	#ws = null;
+	/** 事件发射器 */
+	#event = (0, mitt.default)();
+	/** Echo 事件发射器 */
+	#echoEvent = (0, mitt.default)();
+	constructor(options) {
+		this.options = options;
+	}
+	/** 配置项 */
+	get #config() {
+		return {
+			protocol: this.options.protocol || DEFAULT_NAPCAT_OPTIONS.protocol,
+			host: this.options.host || DEFAULT_NAPCAT_OPTIONS.host,
+			port: this.options.port || DEFAULT_NAPCAT_OPTIONS.port,
+			logger: this.options.logger || DEFAULT_NAPCAT_OPTIONS.logger,
+			token: this.options.token
+		};
+	}
+	/** WebSocket 实例 */
+	get ws() {
+		if (!this.#ws) {
+			this.logger.error("WebSocket is not connected.");
+			throw new Error("WebSocket is not connected.");
+		}
+		return this.#ws;
+	}
+	/** 日志记录器 */
+	get logger() {
+		return this.#config.logger;
+	}
+	/** 消息段构建器 */
+	get segment() {
+		return segment;
+	}
+	/** 生成唯一的 echo ID */
+	#echoId() {
+		return node_crypto.default.randomBytes(16).toString("hex");
+	}
+	/** 构建 WebSocket 连接地址 */
+	#buildWsUrl() {
+		return `${this.#config.protocol}://${this.#config.host}:${this.#config.port}?access_token=${this.#config.token}`;
+	}
+	/** 包装回复消息 */
+	#wrapReply(sendable, message_id, reply) {
+		const sendableList = typeof sendable === "string" ? [sendable] : [sendable].flat();
+		if (reply && message_id) return [segment.reply(String(message_id)), ...sendableList];
+		return sendableList;
+	}
+	/** 确保 WebSocket 已连接 */
+	#ensureWsConnection(ws) {
+		if (!ws) {
+			this.logger.error("WebSocket is not connected.");
+			throw new Error("WebSocket is not connected.");
+		}
+		if (ws.readyState !== WebSocket.OPEN) {
+			this.logger.error("WebSocket is not open.");
+			throw new Error("WebSocket is not open.");
+		}
+	}
+	/** 标准化可发送消息元素 */
+	#normalizeSendable(msg) {
+		return [msg].flat(2).map((item) => {
+			if (typeof item === "string") return {
+				type: "text",
+				data: { text: item }
+			};
+			if (item.type === "at") return {
+				type: "at",
+				data: { qq: String(item.qq) }
+			};
+			const { type: type$1, ...data } = item;
+			return {
+				type: type$1,
+				data
+			};
+		});
+	}
+	/** 等待服务器响应操作 */
+	#waitForAction(echoId) {
+		const eventName = `echo#${echoId}`;
+		return new Promise((resolve, reject) => {
+			const handle = (data) => {
+				if (!data || data.echo !== echoId) return;
+				this.#echoEvent.off(eventName, handle);
+				if (data.retcode === 0) resolve(data.data);
+				else reject(`Server Error: ${data.message}`);
+			};
+			this.#echoEvent.on(eventName, handle);
+		});
+	}
+	/** 构建群对象 */
+	#buildGroup(group_id, group_name = "", extraInfo = {}) {
+		return {
+			...extraInfo,
+			group_id,
+			group_name,
+			doSign: () => this.api("set_group_sign", { group_id }),
+			getInfo: () => this.api("get_group_info", { group_id }),
+			getMemberList: async () => this.api("get_group_member_list", { group_id }),
+			getMemberInfo: (user_id) => this.api("get_group_member_info", {
+				group_id,
+				user_id
+			}),
+			setTitle: (title) => this.api("set_group_special_title", {
+				group_id,
+				title
+			}),
+			setCard: (user_id, card) => this.api("set_group_card", {
+				group_id,
+				user_id,
+				card
+			}),
+			addEssence: (message_id) => this.api("set_essence_msg", { message_id }),
+			delEssence: (message_id) => this.api("delete_essence_msg", { message_id }),
+			recall: (message_id) => this.api("delete_msg", { message_id }),
+			banMember: (user_id, duration) => this.api("set_group_ban", {
+				group_id,
+				user_id,
+				duration
+			}),
+			sendMsg: (sendable) => this.sendGroupMsg(group_id, sendable)
+		};
+	}
+	/** 构建好友对象 */
+	#buildFriend(user_id, nickname = "", extraInfo = {}) {
+		return {
+			...extraInfo,
+			user_id,
+			nickname,
+			delete: (block, both) => this.api("delete_friend", {
+				user_id,
+				temp_block: block,
+				temp_both_del: both
+			}),
+			sendMsg: (sendable) => this.sendPrivateMsg(user_id, sendable),
+			getInfo: () => this.api("get_stranger_info", { user_id })
+		};
+	}
+	/** 构建群消息事件 */
+	#buildPrivateMessageEvent(event) {
+		return {
+			...event,
+			message: (event.message || []).map((el) => ({
+				type: el.type,
+				...el.data
+			})),
+			friend: this.#buildFriend(event.user_id, event.sender?.nickname || ""),
+			recall: () => this.api("delete_msg", { message_id: event.message_id }),
+			reply: (sendable, reply = false) => this.sendPrivateMsg(event.user_id, this.#wrapReply(sendable, event.message_id, reply))
+		};
+	}
+	/** 构建群消息事件对象 */
+	#buildGroupMessageEvent(event) {
+		return {
+			...event,
+			message: (event.message || []).map((el) => ({
+				type: el.type,
+				...el.data
+			})),
+			group: this.#buildGroup(event.group_id, event.group?.group_name || ""),
+			recall: () => this.api("delete_msg", { message_id: event.message_id }),
+			addReaction: (id) => this.api("set_msg_emoji_like", {
+				message_id: event.message_id,
+				emoji_id: id,
+				set: true
+			}),
+			delReaction: (id) => this.api("set_msg_emoji_like", {
+				message_id: event.message_id,
+				emoji_id: id,
+				set: false
+			}),
+			addEssence: () => this.api("set_essence_msg", { message_id: event.message_id }),
+			delEssence: () => this.api("delete_essence_msg", { message_id: event.message_id }),
+			reply: (sendable, reply = false) => this.sendGroupMsg(event.group_id, this.#wrapReply(sendable, event.message_id, reply))
+		};
+	}
+	/** 绑定内部事件处理器 */
+	#bindInternalEvents(data) {
+		if (data.echo) {
+			this.#echoEvent.emit(`echo#${data.echo}`, data);
+			return;
+		}
+		if (data.post_type) {
+			switch (data.post_type) {
+				case "meta_event":
+					this.logger.trace(`received meta_event: ${JSON.stringify(data)}`);
+					this.#event.emit("meta_event", data);
+					if (data.meta_event_type) {
+						this.#event.emit(`meta_event.${data.meta_event_type}`, data);
+						if (data.sub_type) this.#event.emit(`meta_event.${data.meta_event_type}.${data.sub_type}`, data);
+					}
+					break;
+				case "message":
+					if (data.message_type === "private") data = this.#buildPrivateMessageEvent(data);
+					else data = this.#buildGroupMessageEvent(data);
+					this.#event.emit("message", data);
+					switch (data.message_type) {
+						case "private":
+							this.logger.trace(`received private message: ${JSON.stringify(data)}`);
+							this.#event.emit("message.private", data);
+							this.#event.emit(`message.private.${data.sub_type}`, data);
+							break;
+						case "group":
+							this.logger.trace(`received group message: ${JSON.stringify(data)}`);
+							this.#event.emit("message.group", data);
+							this.#event.emit(`message.group.${data.sub_type}`, data);
+							break;
+						default:
+							this.logger.debug(`received unknown message type: ${JSON.stringify(data)}`);
+							break;
+					}
+					break;
+				case "message_sent":
+					this.logger.trace(`received message_sent: ${JSON.stringify(data)}`);
+					this.#event.emit("message_sent", data);
+					if (data.message_type) {
+						this.#event.emit(`message_sent.${data.message_type}`, data);
+						if (data.sub_type) this.#event.emit(`message_sent.${data.message_type}.${data.sub_type}`, data);
+					}
+					break;
+				case "notice": {
+					this.logger.trace(`received notice: ${JSON.stringify(data)}`);
+					if (!data.notice_type) {
+						this.logger.debug(`received unknown notice type: ${JSON.stringify(data)}`);
+						break;
+					}
+					const isNotify = data.notice_type === "notify";
+					const isPoke = data.sub_type === "poke";
+					const isGroup = !!data.group_id;
+					const { notice_type, sub_type } = isNotify ? isPoke ? {
+						notice_type: isGroup ? "group" : "friend",
+						sub_type: "poke"
+					} : NAPCAT_NOTICE_NOTIFY_MAP[data.sub_type] || {} : NAPCAT_NOTICE_EVENT_MAP[data.notice_type] || {};
+					data.original_notice_type = data.notice_type;
+					data.notice_type = notice_type || data.notice_type;
+					if (data.sub_type && data.sub_type !== sub_type) data.action_type = data.sub_type;
+					data.sub_type = sub_type || data.sub_type;
+					if (isGroup) data.group = this.#buildGroup(data.group_id, data.group_name || "");
+					else data.friend = this.#buildFriend(data.user_id, data.nickname || "");
+					this.#event.emit("notice", data);
+					if (notice_type) {
+						this.#event.emit(`notice.${notice_type}`, data);
+						if (sub_type) this.#event.emit(`notice.${notice_type}.${sub_type}`, data);
+					}
+					break;
+				}
+				case "request":
+					this.logger.trace(`received request: ${JSON.stringify(data)}`);
+					if (data.request_type === "friend") {
+						data.reject = () => this.api("set_friend_request", {
+							flag: data.flag,
+							approve: false
+						});
+						data.approve = () => this.api("set_friend_request", {
+							flag: data.flag,
+							approve: true
+						});
+					}
+					if (data.request_type === "group") {
+						data.reject = (reason) => this.api("set_group_add_request", {
+							flag: data.flag,
+							approve: false,
+							reason
+						});
+						data.approve = () => this.api("set_group_add_request", {
+							flag: data.flag,
+							approve: true
+						});
+					}
+					this.#event.emit("request", data);
+					if (data.request_type) {
+						this.#event.emit(`request.${data.request_type}`, data);
+						if (data.sub_type) this.#event.emit(`request.${data.request_type}.${data.sub_type}`, data);
+					}
+					break;
+				default:
+					this.logger.debug(`received: ${JSON.stringify(data)}`);
+					this.#event.emit(data.post_type, data);
+					return;
+			}
+			return;
+		}
+	}
+	/** 获取一个群的信息，可以用于发送群消息等操作 */
+	async pickGroup(group_id) {
+		const groupInfo = await this.api("get_group_info", { group_id });
+		return this.#buildGroup(group_id, groupInfo.group_name, groupInfo);
+	}
+	/** 获取一个好友的信息，可以用于发送私聊消息等操作 */
+	async pickFriend(user_id) {
+		const friendInfo = await this.api("get_stranger_info", { user_id });
+		return this.#buildFriend(user_id, friendInfo.nickname, friendInfo);
+	}
+	/**
+	* 注册一次性事件监听器
+	*/
+	once(type$1, handler) {
+		const onceHandler = (event) => {
+			handler(event);
+			this.#event.off(type$1, onceHandler);
+		};
+		this.logger.debug(`registering once: ${String(type$1)}`);
+		this.#event.on(type$1, onceHandler);
+	}
+	/**
+	* 注册事件监听器，支持主类型或者点分子类型
+	*
+	* 如： `notice`、`message.private`、`request.group.invite` 等
+	*
+	* 如果需要移除监听器，请调用 `off` 方法
+	*/
+	on(type$1, handler) {
+		this.logger.debug(`registering: ${String(type$1)}`);
+		this.#event.on(type$1, handler);
+	}
+	/**
+	* 移除事件监听器
+	*/
+	off(type$1, handler) {
+		this.logger.debug(`unregistering: ${String(type$1)}`);
+		this.#event.off(type$1, handler);
+	}
+	api(action, params = {}) {
+		this.#ensureWsConnection(this.#ws);
+		this.logger.debug(`calling api action: ${action} with params: ${JSON.stringify(params)}`);
+		const echo = this.#echoId();
+		this.#ws.send(JSON.stringify({
+			echo,
+			action,
+			params
+		}));
+		return this.#waitForAction(echo);
+	}
+	/**
+	* 发送私聊消息
+	*/
+	sendPrivateMsg(user_id, sendable) {
+		return this.api("send_private_msg", {
+			user_id,
+			message: this.#normalizeSendable(sendable)
+		});
+	}
+	/**
+	* 发送群消息
+	*/
+	sendGroupMsg(group_id, sendable) {
+		return this.api("send_group_msg", {
+			group_id,
+			message: this.#normalizeSendable(sendable)
+		});
+	}
+	/** 启动 NapCat SDK 实例，建立 WebSocket 连接 */
+	async bootstrap() {
+		const { logger: _, ...config } = this.#config;
+		this.logger.info(`bootstrap with config: ${JSON.stringify(config)}`);
+		return new Promise((resolve, reject) => {
+			const ws = new WebSocket(this.#buildWsUrl());
+			ws.onmessage = (event) => {
+				const data = (() => {
+					try {
+						return JSON.parse(event.data);
+					} catch {
+						return null;
+					}
+				})();
+				if (!data) {
+					this.logger.warn(`received non-json message: ${event.data}`);
+					return;
+				}
+				this.#event.emit("ws.message", data);
+				this.#bindInternalEvents(data);
+			};
+			ws.onclose = () => {
+				this.logger.info("closed");
+				this.#event.emit("ws.close");
+			};
+			ws.onerror = (error) => {
+				this.logger.error(`error: ${error}`);
+				this.#event.emit("ws.error", error);
+				reject(error);
+			};
+			ws.onopen = () => {
+				this.logger.info("connected");
+				this.#event.emit("ws.open");
+				resolve();
+			};
+			this.#ws = ws;
+			this.logger.trace(`WebSocket instance created: ${this.#ws}`);
+		});
+	}
+	/** 销毁 NapCat SDK 实例，关闭 WebSocket 连接 */
+	async destroy() {
+		if (this.#ws) {
+			this.logger.info("destroying NapCat SDK instance...");
+			this.#ws.close();
+			this.#ws = null;
+			this.logger.info("NapCat SDK instance destroyed.");
+		} else this.logger.warn("NapCat SDK instance is not initialized.");
+	}
+};
+
+//#endregion
+exports.ABSTRACT_LOGGER = ABSTRACT_LOGGER;
+exports.CONSOLE_LOGGER = CONSOLE_LOGGER;
+exports.DEFAULT_NAPCAT_OPTIONS = DEFAULT_NAPCAT_OPTIONS;
+exports.NapCat = NapCat;
+Object.defineProperty(exports, 'PKG', {
+  enumerable: true,
+  get: function () {
+    return package_default;
+  }
+});
+exports.name = name;
+exports.segment = segment;
+exports.version = version;
+//# sourceMappingURL=index.cjs.map