@maorongwan/koishi-plugin-message-bridge 1.0.1

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "message-bridge";
+export interface Config {
+    pushBindAddress: string;
+    pullBindAddress: string;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,252 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var zmq = __toESM(require("zeromq"));
+var name = "message-bridge";
+var Config = import_koishi.Schema.object({
+  pushBindAddress: import_koishi.Schema.string().description("PUSH绑定地址（发送到C#）").default("tcp://*:5555"),
+  pullBindAddress: import_koishi.Schema.string().default("tcp://*:5556")
+});
+function apply(ctx, config) {
+  const logger = ctx.logger(name);
+  let pushSocket;
+  let isPushBound = false;
+  const initPushSocket = /* @__PURE__ */ __name(async () => {
+    try {
+      pushSocket = new zmq.Push();
+      await pushSocket.bind(config.pushBindAddress);
+      isPushBound = true;
+      logger.info(`PUSH socket 已绑定: ${config.pushBindAddress}`);
+    } catch (error) {
+      logger.error(`PUSH socket 绑定失败: ${error.message}`);
+      isPushBound = false;
+      setTimeout(initPushSocket, 5e3);
+    }
+  }, "initPushSocket");
+  const sendMessage = /* @__PURE__ */ __name(async (data) => {
+    if (!isPushBound) {
+      logger.warn("无法发送消息：PUSH socket 未绑定");
+      return false;
+    }
+    try {
+      const message = JSON.stringify(data);
+      await pushSocket.send(message);
+      return true;
+    } catch (error) {
+      logger.warn(`发送消息失败: ${error.message}`);
+      return false;
+    }
+  }, "sendMessage");
+  let pullSocket;
+  let isPullBound = false;
+  const initPullSocket = /* @__PURE__ */ __name(async () => {
+    try {
+      pullSocket = new zmq.Pull();
+      await pullSocket.bind(config.pullBindAddress);
+      isPullBound = true;
+      logger.info(`PULL socket 已绑定: ${config.pullBindAddress}`);
+      startReceiveLoop();
+    } catch (error) {
+      logger.error(`PULL socket 绑定失败: ${error.message}`);
+      isPullBound = false;
+      setTimeout(initPullSocket, 5e3);
+    }
+  }, "initPullSocket");
+  let receiveLoopRunning = false;
+  const startReceiveLoop = /* @__PURE__ */ __name(() => {
+    if (receiveLoopRunning) return;
+    receiveLoopRunning = true;
+    const receiveLoop = /* @__PURE__ */ __name(async () => {
+      while (receiveLoopRunning && isPullBound) {
+        try {
+          const [message] = await pullSocket.receive();
+          const messageStr = message.toString();
+          processReceivedMessage(messageStr);
+        } catch (error) {
+          if (receiveLoopRunning && isPullBound) {
+            if (!error.message?.includes("Operation was not possible or timed out")) {
+              logger.error(`接收消息失败: ${error.message}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          } else {
+            break;
+          }
+        }
+      }
+    }, "receiveLoop");
+    receiveLoop().catch((error) => {
+      logger.error(`接收循环错误: ${error.message}`);
+    });
+  }, "startReceiveLoop");
+  const processReceivedMessage = /* @__PURE__ */ __name(async (message) => {
+    try {
+      const data = JSON.parse(message);
+      switch (data.type) {
+        case "SendMessage":
+          await handleSendMessage(data);
+          break;
+        case "UploadFile":
+          await handleUploadFile(data);
+          break;
+        default:
+          logger.warn(`收到未知类型的消息: ${data.type}`);
+          logger.info(`完整消息: ${JSON.stringify(data)}`);
+      }
+    } catch (error) {
+      logger.info(`收到非JSON消息: ${message.substring(0, 100)}...`);
+    }
+  }, "processReceivedMessage");
+  const handleSendMessage = /* @__PURE__ */ __name(async (data) => {
+    const { channelId, content, botId } = data;
+    if (!content || !channelId) {
+      logger.warn("收到无效的发送消息请求，缺少 content 或 channelId");
+      return;
+    }
+    try {
+      let bot;
+      if (botId) {
+        for (const botItem of ctx.bots) {
+          if (botItem.selfId === botId) {
+            bot = botItem;
+            break;
+          }
+        }
+        if (!bot) {
+          logger.warn(`指定的机器人不存在: ${botId}`);
+          return;
+        }
+      } else {
+        if (ctx.bots.length === 0) {
+          logger.warn("没有可用的机器人");
+          return;
+        }
+        bot = ctx.bots[0];
+      }
+      await bot.sendMessage(channelId, content);
+      logger.info(`机器人 ${bot.selfId} 发送消息到 ${channelId}: ${content}`);
+    } catch (error) {
+      logger.error(`发送消息失败: ${error.message}`);
+    }
+  }, "handleSendMessage");
+  const handleUploadFile = /* @__PURE__ */ __name(async (data) => {
+    const { channelId, url, fileName, isGuild, botId } = data;
+    if (!url || !fileName || !channelId) {
+      logger.warn("收到无效的上传文件请求，缺少必要参数");
+      return;
+    }
+    try {
+      let bot;
+      if (botId) {
+        for (const botItem of ctx.bots) {
+          if (botItem.selfId === botId) {
+            bot = botItem;
+            break;
+          }
+        }
+        if (!bot) {
+          logger.warn(`指定的机器人不存在: ${botId}`);
+          return;
+        }
+      } else {
+        if (ctx.bots.length === 0) {
+          logger.warn("没有可用的机器人");
+          return;
+        }
+        bot = ctx.bots[0];
+      }
+      if (bot.platform === "onebot") {
+        if (isGuild) {
+          await bot.internal.uploadGroupFile(channelId, url, fileName);
+        } else {
+          await bot.internal.uploadPrivateFile(channelId, url, fileName);
+        }
+        logger.info(`机器人 ${bot.selfId} 上传文件到 ${channelId}: ${fileName} (${url})`);
+      } else {
+        logger.warn(`机器人 ${bot.selfId} 的平台 ${bot.platform} 不支持文件上传功能`);
+      }
+    } catch (error) {
+      logger.error(`上传文件失败: ${error.message}`);
+    }
+  }, "handleUploadFile");
+  const middleware = /* @__PURE__ */ __name(async (session, next) => {
+    const messageData = {
+      timestamp: session.timestamp,
+      userId: session.userId,
+      username: session.username,
+      channel: session.event.channel,
+      guildId: session.guildId,
+      platform: session.platform,
+      content: session.content,
+      messageId: session.messageId,
+      botId: session.selfId
+    };
+    sendMessage(messageData);
+  }, "middleware");
+  initPushSocket();
+  initPullSocket();
+  ctx.middleware(middleware, true);
+  ctx.on("dispose", () => {
+    receiveLoopRunning = false;
+    if (pushSocket) {
+      try {
+        pushSocket.close();
+        logger.info("PUSH socket 已关闭");
+      } catch (error) {
+        logger.warn("关闭PUSH socket失败:", error.message);
+      }
+    }
+    if (pullSocket) {
+      try {
+        pullSocket.close();
+        logger.info("PULL socket 已关闭");
+      } catch (error) {
+        logger.warn("关闭PULL socket失败:", error.message);
+      }
+    }
+  });
+  logger.info("消息桥接插件已启动");
+  logger.info(`发送地址(PUSH): ${config.pushBindAddress}`);
+  logger.info(`接收地址(PULL): ${config.pullBindAddress}`);
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@maorongwan/koishi-plugin-message-bridge",
+  "description": "将聊天消息通过zeromq转发到指定网络位置",
+  "version": "1.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "devDependencies": {},
+  "peerDependencies": {
+    "koishi": "^4.18.7",
+    "zeromq": "^6.5.0"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-message-bridge
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-message-bridge?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-message-bridge)
+
+