koishi-plugin-forward-hime 1.2.3 → 1.3.1

package/README.md

@@ -7,6 +7,10 @@
 
 </div>
 
+## Screenshot
+
+![screenshot](https://github.com/Nigh/forward-hime/assets/1407471/796b4f1c-c828-438c-85e9-71379c6c7e21)
+
 ## 安装
 
 在 Koishi WebUI 或 Koishi 桌面应用中，打开插件市场，搜索 `forward-hime`，找到本插件后，点击 `添加` 按钮后点击 `安装` 即可。

package/lib/cache.d.ts

@@ -1,4 +1,5 @@
 import { Context } from "koishi";
+import { ConfigSet } from "./config";
 export interface MsgCache {
     platform: string;
     bot: string;
@@ -11,7 +12,7 @@ declare module "@koishijs/cache" {
         msgCache: MsgCache;
     }
 }
-export declare function msgCacheInit(context: Context): void;
+export declare function msgCacheInit(context: Context, cfg: ConfigSet): void;
 export declare function msgCache(mc: MsgCache): Promise<void>;
 export declare function msgCacheDelete(key: string): Promise<void>;
 export declare function msgCacheFindByKey(key: string): Promise<any>;

package/lib/config.d.ts

@@ -8,6 +8,7 @@ export interface ForwardNode {
 export interface ConfigSet {
     WithChannelName: boolean;
     WithPlatformName: boolean;
+    CacheTimeout: number;
     ForwardGroups: {
         Nodes: ForwardNode[];
     }[];

package/lib/decorator.d.ts

@@ -1,3 +1,5 @@
-import { Session } from "koishi";
+import { Session, Element } from "koishi";
 import { ForwardNode } from "./config";
+export declare function MsgMiddlewareCache(session: Session): Promise<void>;
 export declare function MsgDecorator(session: Session, node: ForwardNode): Promise<any>;
+export declare function MsgDecoratorFallback(session: Session, node: ForwardNode): Promise<Element[]>;

package/lib/index.js

@@ -35,7 +35,10 @@ var createConfig = /* @__PURE__ */ __name(() => import_koishi.Schema.intersect([
   import_koishi.Schema.object({
     WithChannelName: import_koishi.Schema.boolean().description("是否包含频道名称").default(false),
     WithPlatformName: import_koishi.Schema.boolean().description("是否包含平台名称").default(true)
-  }).description("转发格式"),
+  }).description("转发格式").hidden(),
+  import_koishi.Schema.object({
+    CacheTimeout: import_koishi.Schema.number().description("消息缓存时间（分钟）- 影响跨平台删除与回复等功能").default(120).min(120).max(1440 * 7)
+  }).description("消息缓存"),
   import_koishi.Schema.object({
     ForwardGroups: import_koishi.Schema.array(
       import_koishi.Schema.object({
@@ -86,14 +89,51 @@ var kook_default = {
 
 // src/decorators/onebot.ts
 var import_koishi4 = require("koishi");
+function cqJsonTranslator(content, elem) {
+  let json = JSON.parse(elem.attrs.data);
+  let hit = 0;
+  if (json) {
+    if (json.prompt) {
+      hit += 1;
+      content.push((0, import_koishi4.h)("p", `${json.prompt}`));
+    }
+    if (json.meta && json.meta.detail_1) {
+      if (json.meta.detail_1.preview) {
+        hit += 1;
+        content.push(import_koishi4.h.image(json.meta.detail_1.preview));
+      }
+      if (json.meta.detail_1.qqdocurl) {
+        hit += 1;
+        content.push((0, import_koishi4.h)("span", `${json.meta.detail_1.qqdocurl}`));
+      }
+    }
+  }
+  if (hit === 0) {
+    content.push((0, import_koishi4.h)("span", `[CQ:JSON消息]`));
+  }
+}
+__name(cqJsonTranslator, "cqJsonTranslator");
 function Middleware(session) {
   const platform = guessPlatform(session);
+  let newContent = [];
   let head = [
     (0, import_koishi4.h)("b", `${session.username}`),
     (0, import_koishi4.h)("span", " 转发自 "),
     (0, import_koishi4.h)("i", `${platform}`),
     (0, import_koishi4.h)("span", `：`)
   ];
+  if (platform === "QQ") {
+    for (const key in session.elements) {
+      if (session.elements[key].type === "forward") {
+        newContent.push((0, import_koishi4.h)("span", `[CQ:转发消息]`));
+      } else if (session.elements[key].type === "json") {
+        cqJsonTranslator(newContent, session.elements[key]);
+      } else {
+        newContent.push(session.elements[key]);
+      }
+    }
+    return { head, content: newContent };
+  }
   return { head, content: session.elements };
 }
 __name(Middleware, "Middleware");
@@ -112,6 +152,7 @@ var onebot_default = {
 
 // src/cache.ts
 var ctx;
+var cacheTimeout = 86400 * 1e3;
 function cacheNotEnabled() {
   if (!ctx.cache) {
     return true;
@@ -119,8 +160,9 @@ function cacheNotEnabled() {
   return false;
 }
 __name(cacheNotEnabled, "cacheNotEnabled");
-function msgCacheInit(context) {
+function msgCacheInit(context, cfg) {
   ctx = context;
+  cacheTimeout = 60 * cfg.CacheTimeout * 1e3;
 }
 __name(msgCacheInit, "msgCacheInit");
 async function msgCache(mc) {
@@ -129,7 +171,7 @@ async function msgCache(mc) {
   }
   const key = mc.guild + ":" + mc.msgid;
   logger.debug(`[message-cache] ${mc.platform} ${key}`);
-  await ctx.cache.set("msgCache", key, mc, 7200 * 1e3);
+  await ctx.cache.set("msgCache", key, mc, cacheTimeout);
 }
 __name(msgCache, "msgCache");
 async function msgCacheDelete(key) {
@@ -191,15 +233,52 @@ function defaultMiddleware(session) {
 }
 __name(defaultMiddleware, "defaultMiddleware");
 var localDecorators = [atTranslator, quoteTranslator];
-async function MsgDecorator(session, node) {
+var msgMiddleCache = [];
+function msgMiddleCacheAppend(msg) {
+  msgMiddleCache.push(msg);
+  if (msgMiddleCache.length > 16) {
+    msgMiddleCache.shift();
+  }
+  logger.debug(`[msgMiddleCache]`, msgMiddleCache.length);
+}
+__name(msgMiddleCacheAppend, "msgMiddleCacheAppend");
+function msgMiddleCacheFind(uuid) {
+  for (const item of msgMiddleCache) {
+    if (item.UUID === uuid) {
+      return item.msg;
+    }
+  }
+  return null;
+}
+__name(msgMiddleCacheFind, "msgMiddleCacheFind");
+function MsgToMiddleware(session) {
   let elems = { head: [], content: [] };
   let _platform_in = decorators_exports[session.platform];
-  let _platform_out = decorators_exports[node.Platform];
   if (_platform_in && typeof _platform_in.Middleware === "function") {
     elems = _platform_in.Middleware(session);
   } else {
     elems = defaultMiddleware(session);
   }
+  return elems;
+}
+__name(MsgToMiddleware, "MsgToMiddleware");
+async function MsgMiddlewareCache(session) {
+  let elems = MsgToMiddleware(session);
+  msgMiddleCacheAppend({ UUID: MsgUUIDFromSession(session), msg: elems });
+  logger.debug(`[msgMiddleCache] CACHED`);
+}
+__name(MsgMiddlewareCache, "MsgMiddlewareCache");
+async function MsgDecorator(session, node) {
+  let elems;
+  let _platform_out = decorators_exports[node.Platform];
+  let elemCache = msgMiddleCacheFind(MsgUUIDFromSession(session));
+  if (elemCache) {
+    logger.debug(`[msgMiddleCache] HIT`);
+    elems = elemCache;
+  } else {
+    logger.debug(`[msgMiddleCache] MISSED`);
+    elems = MsgToMiddleware(session);
+  }
   for (const fn of localDecorators) {
     elems = await fn(session, node, elems);
   }
@@ -210,6 +289,30 @@ async function MsgDecorator(session, node) {
   }
 }
 __name(MsgDecorator, "MsgDecorator");
+function defaultDecoratorFallback({ head, content }) {
+  let msg = [];
+  let newContent = [];
+  newContent.push((0, import_koishi5.h)("span", `[消息降级] `));
+  for (const key in content) {
+    if (["img", "audio", "video", "file"].includes(content[key].type)) {
+      newContent.push((0, import_koishi5.h)("span", ` [${content[key].type}] `));
+    } else {
+      newContent.push(content[key]);
+    }
+  }
+  msg = msg.concat(head, (0, import_koishi5.h)("br"), newContent);
+  return msg;
+}
+__name(defaultDecoratorFallback, "defaultDecoratorFallback");
+async function MsgDecoratorFallback(session, node) {
+  let elems = { head: [], content: [] };
+  elems = defaultMiddleware(session);
+  for (const fn of localDecorators) {
+    elems = await fn(session, node, elems);
+  }
+  return defaultDecoratorFallback(elems);
+}
+__name(MsgDecoratorFallback, "MsgDecoratorFallback");
 async function atTranslator(session, node, { head, content }) {
   const newMsg = await new Promise((resolve, reject) => {
     let newContent = [];
@@ -239,7 +342,8 @@ async function quoteTranslator(session, node, { head, content }) {
   if (cache) {
     let msgid = await msgCacheGetLocalIDByUUID(node, cache.uuid);
     if (msgid) {
-      head.unshift((0, import_koishi5.h)("quote", { id: msgid }));
+      let newHead = [(0, import_koishi5.h)("quote", { id: msgid })].concat(head);
+      return { head: newHead, content };
     } else {
       logger.error(`[msgCacheGetLocalIDByUUID] ${cache.uuid} not found`);
     }
@@ -249,42 +353,64 @@ async function quoteTranslator(session, node, { head, content }) {
 __name(quoteTranslator, "quoteTranslator");
 
 // src/message.ts
-async function MessageForward(ctx2, node, session) {
+async function MessageSendWithDecorator(ctx2, node, session, Deco) {
   const uuid = session.channelId + ":" + session.messageId;
-  const content = await MsgDecorator(session, node);
-  try {
-    botExistsCheck(ctx2, node);
-    await ctx2.bots[`${node.Platform}:${node.BotID}`].sendMessage(node.Guild, content).then((res) => {
-      let mc = {
-        platform: node.Platform,
-        bot: node.BotID,
-        guild: node.Guild,
-        msgid: res[0],
-        uuid
-      };
+  const content = await Deco(session, node);
+  await ctx2.bots[`${node.Platform}:${node.BotID}`].sendMessage(node.Guild, content).then((res) => {
+    let mc = {
+      platform: node.Platform,
+      bot: node.BotID,
+      guild: node.Guild,
+      msgid: res[0],
+      uuid
+    };
+    if (!mc.msgid) {
+      throw new Error(`Empty Message ID`);
+    } else {
       msgCache(mc);
       logger.debug(`[MessageForward] to ${mc.platform} ${mc.uuid}`);
-    });
-  } catch (error) {
-    logger.error(`ERROR:<MessageSend> ${error}`, content);
+    }
+  }).catch((error) => {
+    logger.error(`content: ${content}`);
+    throw error;
+  });
+}
+__name(MessageSendWithDecorator, "MessageSendWithDecorator");
+async function MessageForward(ctx2, node, session) {
+  if (!botExistsCheck(ctx2, node)) {
+    return;
   }
+  MessageSendWithDecorator(ctx2, node, session, MsgDecorator).catch((error) => {
+    logger.error(`ERROR:<MessageSend ${node.Platform}> ${error}`);
+    MessageSendWithDecorator(ctx2, node, session, MsgDecoratorFallback).catch(
+      (error2) => {
+        logger.error(`ERROR:<MessageSendFallback ${node.Platform}> ${error2}`);
+      }
+    );
+  });
 }
 __name(MessageForward, "MessageForward");
 async function MessageDelete(ctx2, msg) {
-  try {
-    botExistsCheck(ctx2, { Platform: msg.platform, BotID: msg.bot, Guild: msg.guild });
-    await ctx2.bots[`${msg.platform}:${msg.bot}`].deleteMessage(msg.guild, msg.msgid);
-  } catch (error) {
-    logger.error(`ERROR:<MessageDelete> ${error}`);
+  if (!botExistsCheck(ctx2, { Platform: msg.platform, BotID: msg.bot, Guild: msg.guild })) {
+    return;
   }
+  await ctx2.bots[`${msg.platform}:${msg.bot}`].deleteMessage(msg.guild, msg.msgid).catch((error) => {
+    logger.error(`ERROR:<MessageDelete> ${error}`);
+  });
 }
 __name(MessageDelete, "MessageDelete");
 function botExistsCheck(ctx2, node) {
   if (ctx2.bots[`${node.Platform}:${node.BotID}`] == void 0) {
-    throw new Error("Bot Not Found");
+    logger.error(`ERROR:<BOT not Exist> ${node.Platform}:${node.BotID}`);
+    return false;
   }
+  return true;
 }
 __name(botExistsCheck, "botExistsCheck");
+function MsgUUIDFromSession(session) {
+  return session.channelId + ":" + session.messageId;
+}
+__name(MsgUUIDFromSession, "MsgUUIDFromSession");
 
 // src/index.ts
 var name = `forward hime - 转发姬`;
@@ -305,18 +431,22 @@ var inject = {
 };
 var Config = createConfig();
 function apply(ctx2, cfg) {
-  msgCacheInit(ctx2);
+  msgCacheInit(ctx2, cfg);
   ctx2.on("message-created", async (session) => {
     const hitGroup = [];
     for (const g in cfg.ForwardGroups) {
       const group = cfg.ForwardGroups[g];
       for (const k in group.Nodes) {
         if (group.Nodes[k].Guild === session.channelId && group.Nodes[k].Platform === session.platform && group.Nodes[k].BotID !== session.userId) {
+          if (!session.channelId || !session.messageId) {
+            continue;
+          }
           logger.debug(
             "[message-created]",
+            session.platform,
             session.channelId + ":" + session.messageId
           );
-          let uuid = session.channelId + ":" + session.messageId;
+          let uuid = MsgUUIDFromSession(session);
           msgCache({
             platform: session.platform,
             bot: group.Nodes[k].BotID,
@@ -329,6 +459,9 @@ function apply(ctx2, cfg) {
         }
       }
     }
+    if (hitGroup.length > 0) {
+      await MsgMiddlewareCache(session);
+    }
     for (const g in hitGroup) {
       const group = cfg.ForwardGroups[hitGroup[g]];
       for (const k in group.Nodes) {

package/lib/message.d.ts

@@ -4,3 +4,4 @@ import { MsgCache } from "./cache";
 export declare function MessageForward(ctx: Context, node: ForwardNode, session: Session): Promise<void>;
 export declare function MessageDelete(ctx: Context, msg: MsgCache): Promise<void>;
 export declare function MessageEdit(ctx: Context, node: ForwardNode, session: Session): Promise<void>;
+export declare function MsgUUIDFromSession(session: Session): string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "koishi-plugin-forward-hime",
 	"description": "多群组消息互通",
-	"version": "1.2.3",
+	"version": "1.3.1",
 	"author": {
 		"name": "xianii",
 		"email": "jiyucheng007@gmail.com"
@@ -15,7 +15,7 @@
 		"browser": true
 	},
 	"license": "MIT",
-	"homepage": "https://github.com/Nigh/forward-hime",
+	"homepage": "https://nigh.github.io/forward-hime/",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/Nigh/forward-hime.git"