koishi-plugin-forward-hime 1.4.1-alpha.2 → 1.4.2-alpha.1

package/lib/client/index.js

@@ -0,0 +1,45 @@
+// client/index.ts
+import { send } from "@koishijs/client";
+import { defineComponent, h, inject } from "vue";
+var index_default = (ctx) => {
+  ctx.slot({
+    type: "plugin-details",
+    order: -800,
+    component: defineComponent({
+      setup() {
+        const current = inject(
+          "manager.settings.current"
+        );
+        return () => {
+          const plugin = current?.value;
+          if (!plugin || plugin.name !== "forward-hime" && !plugin.path?.includes("forward-hime")) {
+            return null;
+          }
+          return h(
+            "button",
+            {
+              class: "k-button",
+              onClick: async () => {
+                const contents = await send(
+                  "forward-hime:get-diagnostics"
+                );
+                const url = URL.createObjectURL(
+                  new Blob([contents], { type: "application/x-ndjson" })
+                );
+                const anchor = document.createElement("a");
+                anchor.href = url;
+                anchor.download = "forward-hime-diagnostics.jsonl";
+                anchor.click();
+                setTimeout(() => URL.revokeObjectURL(url), 1e3);
+              }
+            },
+            "\u4E0B\u8F7D\u8BCA\u65AD\u65E5\u5FD7"
+          );
+        };
+      }
+    })
+  });
+};
+export {
+  index_default as default
+};

package/lib/console.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "koishi";
+export declare function consoleInit(ctx: Context): void;

package/lib/decorator.d.ts

@@ -8,7 +8,7 @@ export declare function decoratorInit(cfg: ConfigSet): void;
 export declare function defaultDecorator({ head, content }: ForwardMsg): Element[];
 export declare function defaultMiddleware(session: Session): ForwardMsg;
 export declare function MsgMiddlewareCache(session: Session): Promise<void>;
-export declare function MsgDecorator(session: Session, node: ForwardNode): Promise<any>;
+export declare function MsgDecorator(session: Session, node: ForwardNode, traceId?: string): Promise<any>;
 export declare function MsgDecoratorNoRelay(session: Session, node: ForwardNode): Promise<any>;
 export declare function MsgDecoratorFallback(session: Session, node: ForwardNode): Promise<Element[]>;
 export declare function MsgDecoratorFallbackReason(session: Session, node: ForwardNode, reason: string): Promise<Element[]>;

package/lib/diagnostics.d.ts

@@ -0,0 +1,18 @@
+import { Context } from "koishi";
+export interface DiagnosticEvent {
+    traceId: string;
+    phase: string;
+    [key: string]: unknown;
+}
+export declare function createTraceId(): `${string}-${string}-${string}-${string}-${string}`;
+export declare function diagnosticFilename(value: unknown): string;
+export declare function diagnosticMime(value: unknown): string;
+export declare function diagnosticsInit(ctx: Context): void;
+export declare function writeDiagnostic(event: DiagnosticEvent): void;
+export declare function readDiagnosticLogs(): Promise<string>;
+export declare function sanitizeError(error: unknown): {
+    name: string;
+    code: string | number;
+    httpStatus: number;
+    summary: string;
+};

package/lib/index.js

@@ -250,6 +250,99 @@ var onebot_default = {
 
 // src/relay.ts
 var import_koishi5 = require("koishi");
+
+// src/diagnostics.ts
+var import_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var RETENTION_DAYS = 7;
+var FILE_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+var root = "";
+var writeQueue = Promise.resolve();
+var lastCleanupDate = "";
+function createTraceId() {
+  return (0, import_crypto.randomUUID)();
+}
+function diagnosticFilename(value) {
+  if (typeof value !== "string" || /^https?:\/\//i.test(value)) return void 0;
+  return value.replace(/[?#].*$/, "").split(/[\\/]/).pop()?.slice(0, 120);
+}
+function diagnosticMime(value) {
+  return typeof value === "string" && /^[\w.+-]+\/[\w.+-]+$/.test(value) ? value : void 0;
+}
+function utcDate(timestamp = Date.now()) {
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+async function cleanup(date) {
+  if (date === lastCleanupDate) return;
+  const cutoff = Date.parse(`${date}T00:00:00.000Z`) - (RETENTION_DAYS - 1) * 864e5;
+  for (const filename of await (0, import_promises.readdir)(root)) {
+    if (!FILE_PATTERN.test(filename)) continue;
+    if (Date.parse(`${filename.slice(0, 10)}T00:00:00.000Z`) < cutoff) {
+      await (0, import_promises.rm)((0, import_path.join)(root, filename), { force: true });
+    }
+  }
+  lastCleanupDate = date;
+}
+function diagnosticsInit(ctx2) {
+  root = (0, import_path.join)(ctx2.baseDir, "data", "forward-hime");
+  writeQueue = Promise.resolve();
+  lastCleanupDate = "";
+  writeQueue = writeQueue.then(async () => {
+    await (0, import_promises.mkdir)(root, { recursive: true });
+    await cleanup(utcDate());
+  }).catch((error) => logger.warn("failed to initialize diagnostic log", error));
+}
+function writeDiagnostic(event) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const date = timestamp.slice(0, 10);
+  const line = JSON.stringify({ timestamp, ...event }) + "\n";
+  writeQueue = writeQueue.then(async () => {
+    await (0, import_promises.mkdir)(root, { recursive: true });
+    await cleanup(date);
+    await (0, import_promises.appendFile)((0, import_path.join)(root, `${date}.jsonl`), line, "utf8");
+  }).catch((error) => logger.warn("failed to write diagnostic log", error));
+}
+async function readDiagnosticLogs() {
+  await writeQueue;
+  const cutoff = new Date(
+    Date.parse(`${utcDate()}T00:00:00.000Z`) - (RETENTION_DAYS - 1) * 864e5
+  ).toISOString().slice(0, 10);
+  const files = (await (0, import_promises.readdir)(root).catch(() => [])).filter(
+    (filename) => FILE_PATTERN.test(filename) && filename.slice(0, 10) >= cutoff
+  ).sort();
+  const contents = await Promise.all(
+    files.map((filename) => (0, import_promises.readFile)((0, import_path.join)(root, filename), "utf8"))
+  );
+  return contents.join("");
+}
+function sanitizeError(error) {
+  const value = error;
+  const message = typeof value?.message === "string" ? value.message : String(error);
+  const lowerMessage = message.toLowerCase();
+  let summary = "request failed";
+  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    summary = "request timed out";
+  } else if (lowerMessage.includes("denied") || lowerMessage.includes("401") || lowerMessage.includes("403")) {
+    summary = "request denied";
+  } else if (lowerMessage.includes("not found") || lowerMessage.includes("404")) {
+    summary = "resource not found";
+  } else if (lowerMessage.includes("too large")) {
+    summary = "media exceeds size limit";
+  } else if (lowerMessage.includes("network") || lowerMessage.includes("econn") || lowerMessage.includes("enotfound")) {
+    summary = "network error";
+  } else if (lowerMessage.includes("empty media")) {
+    summary = "empty media payload";
+  }
+  return {
+    name: typeof value?.name === "string" && /^[a-z][\w.-]{0,63}$/i.test(value.name) ? value.name : "Error",
+    code: typeof value?.code === "string" && /^[\w.-]{1,64}$/.test(value.code) || typeof value?.code === "number" ? value.code : void 0,
+    httpStatus: typeof value?.status === "number" ? value.status : Number(/\bstatus\s+(\d{3})\b/i.exec(message)?.[1]) || void 0,
+    summary
+  };
+}
+
+// src/relay.ts
 var DEFAULT_IMAGE_MIME = "image/jpeg";
 var DEFAULT_AUDIO_MIME = "audio/mpeg";
 var DEFAULT_VIDEO_MIME = "video/mp4";
@@ -340,8 +433,11 @@ function createRelayElement(kind, mime, buffer, filename) {
   if (kind === "img") {
     return import_koishi5.h.image(buffer, mime);
   }
+  if (kind === "file") {
+    return helperMap.file(buffer, mime, { filename });
+  }
   if (helperMap[kind]) {
-    return helperMap[kind](buffer, mime, filename);
+    return helperMap[kind](buffer, mime);
   }
   const base64 = buffer.toString("base64");
   return (0, import_koishi5.h)(kind, { src: `data:${mime};base64,${base64}`, filename });
@@ -361,9 +457,23 @@ function networkMessageFromError(error) {
   }
   return "\u7F51\u7EDC\u95EE\u9898\uFF1A\u5A92\u4F53\u6587\u4EF6\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\u3002";
 }
-async function downloadAndRelay(element) {
+async function downloadAndRelay(element, traceId, session, node) {
+  const startedAt = Date.now();
   const kind = normalizeMediaType(element.type);
   const src = mediaUrlFromElement(element);
+  const media = {
+    type: kind,
+    filename: diagnosticFilename(element.attrs?.filename),
+    mime: diagnosticMime(element.attrs?.mime),
+    size: typeof element.attrs?.size === "number" ? element.attrs.size : void 0
+  };
+  const context = {
+    source: session && { platform: session.platform, node: session.channelId },
+    target: node && { platform: node.Platform, node: node.Guild }
+  };
+  if (traceId) {
+    writeDiagnostic({ traceId, phase: "media-relay-start", media, ...context });
+  }
   if (!src) {
     throw new MediaRelayError(
       `missing media src for ${element.type}`,
@@ -374,6 +484,17 @@ async function downloadAndRelay(element) {
   const cacheKey = getCacheKey(element);
   const cacheItem = relayCache.get(cacheKey);
   if (cacheItem) {
+    if (traceId) {
+      writeDiagnostic({
+        traceId,
+        phase: "media-relay-result",
+        status: "cache-hit",
+        bytes: cacheItem.buffer.length,
+        mime: diagnosticMime(cacheItem.mime),
+        durationMs: Date.now() - startedAt,
+        ...context
+      });
+    }
     return relayElementFromCache(cacheItem);
   }
   const timeoutSignal = typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(relayConfig.RequestTimeoutSec * 1e3) : void 0;
@@ -435,9 +556,21 @@ async function downloadAndRelay(element) {
     buffer,
     filename
   });
+  if (traceId) {
+    writeDiagnostic({
+      traceId,
+      phase: "media-relay-result",
+      status: "success",
+      media,
+      bytes: buffer.length,
+      mime: diagnosticMime(mime),
+      ...context,
+      durationMs: Date.now() - startedAt
+    });
+  }
   return relayed;
 }
-async function relayForwardContent(content) {
+async function relayForwardContent(content, traceId, session, node) {
   if (!relayConfig.Enabled) {
     return content;
   }
@@ -447,9 +580,24 @@ async function relayForwardContent(content) {
       newContent.push(element);
       continue;
     }
+    const startedAt = Date.now();
     try {
-      newContent.push(await downloadAndRelay(element));
+      newContent.push(await downloadAndRelay(element, traceId, session, node));
     } catch (error) {
+      if (traceId) {
+        writeDiagnostic({
+          traceId,
+          phase: "media-relay-result",
+          status: "error",
+          error: sanitizeError(error),
+          durationMs: Date.now() - startedAt,
+          source: session && {
+            platform: session.platform,
+            node: session.channelId
+          },
+          target: node && { platform: node.Platform, node: node.Guild }
+        });
+      }
       throw new MediaRelayError(
         error instanceof Error ? error.message : "relay failed",
         networkMessageFromError(error)
@@ -460,29 +608,63 @@ async function relayForwardContent(content) {
 }
 
 // src/message.ts
-async function MessageSendWithDecorator(ctx2, node, session, Deco) {
+async function MessageSendWithDecorator(ctx2, node, session, Deco, traceId, attempt) {
+  const startedAt = Date.now();
   const uuid = session.channelId + ":" + session.messageId;
-  const content = await Deco(session, node);
-  await ctx2.bots[`${node.Platform}:${node.BotID}`].sendMessage(node.Guild, content).then((res) => {
-    const 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}`);
+  writeDiagnostic({
+    traceId,
+    phase: "send-attempt",
+    attempt,
+    source: { platform: session.platform, node: session.channelId },
+    target: { platform: node.Platform, node: node.Guild },
+    elementTypes: session.elements.map((element) => element.type)
+  });
+  try {
+    const content = await Deco(session, node, traceId);
+    const res = await ctx2.bots[`${node.Platform}:${node.BotID}`].sendMessage(
+      node.Guild,
+      content
+    );
+    {
+      const 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) => {
+    writeDiagnostic({
+      traceId,
+      phase: "send-result",
+      attempt,
+      status: "success",
+      durationMs: Date.now() - startedAt,
+      source: { platform: session.platform, node: session.channelId },
+      target: { platform: node.Platform, node: node.Guild }
+    });
+  } catch (error) {
+    writeDiagnostic({
+      traceId,
+      phase: "send-result",
+      attempt,
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      source: { platform: session.platform, node: session.channelId },
+      target: { platform: node.Platform, node: node.Guild },
+      error: sanitizeError(error)
+    });
     logger.error(
       `ERROR:<MessageSendWithDecorator ${node.Platform}> ctx=${ctx2} ${error}`
     );
     throw error;
-  });
+  }
 }
 function sessionTypeArray(session) {
   let contentTypes = "|";
@@ -492,9 +674,34 @@ function sessionTypeArray(session) {
   return contentTypes;
 }
 async function MessageForward(ctx2, node, session, timeoutSec, relayEnabled) {
+  const traceId = createTraceId();
+  const source = { platform: session.platform, node: session.channelId };
+  const target = { platform: node.Platform, node: node.Guild };
   if (!botExistsCheck(ctx2, node)) {
+    writeDiagnostic({
+      traceId,
+      phase: "forward-result",
+      status: "bot-missing",
+      source,
+      target
+    });
     return;
   }
+  writeDiagnostic({
+    traceId,
+    phase: "forward-start",
+    source,
+    target,
+    elementTypes: session.elements.map((element) => element.type),
+    media: session.elements.filter(
+      (element) => ["img", "image", "audio", "video", "file"].includes(element.type)
+    ).map((element) => ({
+      type: element.type,
+      filename: diagnosticFilename(element.attrs?.filename),
+      mime: diagnosticMime(element.attrs?.mime),
+      size: typeof element.attrs?.size === "number" ? element.attrs.size : void 0
+    }))
+  });
   const timeoutMs = (timeoutSec ?? 30) * 1e3;
   const deco = relayEnabled !== false ? MsgDecorator : MsgDecoratorNoRelay;
   function warnIfSlow(promise) {
@@ -506,8 +713,16 @@ async function MessageForward(ctx2, node, session, timeoutSec, relayEnabled) {
     return promise.finally(() => clearTimeout(timer));
   }
   function sendDegraded(reason) {
+    writeDiagnostic({ traceId, phase: "forward-degraded", source, target });
     const fallbackDeco = reason ? (fallbackSession, fallbackNode) => MsgDecoratorFallbackReason(fallbackSession, fallbackNode, reason) : MsgDecoratorFallback;
-    MessageSendWithDecorator(ctx2, node, session, fallbackDeco).catch((error) => {
+    MessageSendWithDecorator(
+      ctx2,
+      node,
+      session,
+      fallbackDeco,
+      traceId,
+      "fallback"
+    ).catch((error) => {
       logger.error(
         `ERROR:<MessageSendFallback ${node.Platform}> ctx=${ctx2} ${sessionTypeArray(session)} ${error}`
       );
@@ -519,28 +734,43 @@ async function MessageForward(ctx2, node, session, timeoutSec, relayEnabled) {
     }
     return void 0;
   }
-  warnIfSlow(MessageSendWithDecorator(ctx2, node, session, deco)).catch(
-    (firstError) => {
-      logger.error(
-        `ERROR:<MessageSend ${node.Platform}> ctx=${ctx2} ${sessionTypeArray(session)} ${firstError}`
+  const traceableDeco = (sourceSession, targetNode, id) => deco(sourceSession, targetNode, id);
+  warnIfSlow(
+    MessageSendWithDecorator(
+      ctx2,
+      node,
+      session,
+      traceableDeco,
+      traceId,
+      relayEnabled === false ? "direct" : "relay"
+    )
+  ).catch((firstError) => {
+    logger.error(
+      `ERROR:<MessageSend ${node.Platform}> ctx=${ctx2} ${sessionTypeArray(session)} ${firstError}`
+    );
+    if (relayEnabled !== false && firstError instanceof MediaRelayError) {
+      logger.info(
+        `[MessageForward] relay failed, retrying without relay: ${node.Platform}`
       );
-      if (relayEnabled !== false && firstError instanceof MediaRelayError) {
-        logger.info(
-          `[MessageForward] relay failed, retrying without relay: ${node.Platform}`
+      warnIfSlow(
+        MessageSendWithDecorator(
+          ctx2,
+          node,
+          session,
+          MsgDecoratorNoRelay,
+          traceId,
+          "direct-retry"
+        )
+      ).catch((secondError) => {
+        logger.error(
+          `ERROR:<MessageSendDirect ${node.Platform}> ctx=${ctx2} ${sessionTypeArray(session)} ${secondError}`
         );
-        warnIfSlow(
-          MessageSendWithDecorator(ctx2, node, session, MsgDecoratorNoRelay)
-        ).catch((secondError) => {
-          logger.error(
-            `ERROR:<MessageSendDirect ${node.Platform}> ctx=${ctx2} ${sessionTypeArray(session)} ${secondError}`
-          );
-          sendDegraded(reasonFromError(secondError));
-        });
-      } else {
-        sendDegraded(reasonFromError(firstError));
-      }
+        sendDegraded(reasonFromError(secondError));
+      });
+    } else {
+      sendDegraded(reasonFromError(firstError));
     }
-  );
+  });
 }
 async function MessageDelete(ctx2, msg) {
   if (!botExistsCheck(ctx2, { Platform: msg.platform, BotID: msg.bot, Guild: msg.guild })) {
@@ -617,7 +847,7 @@ async function MsgMiddlewareCache(session) {
   msgMiddleCacheAppend({ UUID: MsgUUIDFromSession(session), msg: elems });
   logger.debug(`[msgMiddleCache] CACHED`);
 }
-async function MsgDecorator(session, node) {
+async function MsgDecorator(session, node, traceId) {
   let elems;
   const _platform_out = decorators_exports[node.Platform];
   const elemCache = msgMiddleCacheFind(MsgUUIDFromSession(session));
@@ -633,7 +863,7 @@ async function MsgDecorator(session, node) {
   }
   elems = {
     head: elems.head,
-    content: await relayForwardContent(elems.content)
+    content: await relayForwardContent(elems.content, traceId, session, node)
   };
   if (_platform_out && typeof _platform_out.Decorator === "function") {
     return _platform_out.Decorator(elems);
@@ -689,7 +919,7 @@ async function MsgDecoratorFallbackReason(session, node, reason) {
   return defaultDecoratorFallback(elems, reason);
 }
 async function atTranslator(session, _, { head, content }) {
-  const newMsg = await new Promise((resolve) => {
+  const newMsg = await new Promise((resolve2) => {
     const newContent = [];
     for (const key in content) {
       const element = content[key];
@@ -703,7 +933,7 @@ async function atTranslator(session, _, { head, content }) {
         newContent.push(element);
       }
     }
-    resolve({ head, content: newContent });
+    resolve2({ head, content: newContent });
   });
   return newMsg;
 }
@@ -725,6 +955,21 @@ async function quoteTranslator(session, node, { head, content }) {
   return { head, content };
 }
 
+// src/console.ts
+var import_path2 = require("path");
+function consoleInit(ctx2) {
+  ctx2.inject(["console"], (ctx3) => {
+    const console = ctx3.console;
+    console.addListener("forward-hime:get-diagnostics", readDiagnosticLogs, {
+      authority: 4
+    });
+    console.addEntry({
+      dev: (0, import_path2.resolve)(__dirname, "../client/index.ts"),
+      prod: (0, import_path2.resolve)(__dirname, "client")
+    });
+  });
+}
+
 // src/index.ts
 var name = `forward hime - \u8F6C\u53D1\u59EC`;
 var usage = `
@@ -740,11 +985,13 @@ var usage = `
 ---`;
 var reusable = true;
 var inject = {
-  optional: ["cache"]
+  optional: ["cache", "console"]
 };
 var Config = createConfig();
 function apply(ctx2, cfg) {
   loggerInit(ctx2);
+  diagnosticsInit(ctx2);
+  consoleInit(ctx2);
   msgCacheInit(ctx2, cfg);
   decoratorInit(cfg);
   ctx2.on("message-created", async (session) => {
@@ -814,7 +1061,7 @@ function apply(ctx2, cfg) {
     });
   });
   ctx2.on("message-updated", async (session) => {
-    logger.debug("[message-updated]", session.messageId, session);
+    logger.debug("[message-updated]", session.messageId);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/relay.d.ts

@@ -1,8 +1,10 @@
 import { Element } from "koishi";
 import { ConfigSet } from "./config";
+import { Session } from "koishi";
+import { ForwardNode } from "./config";
 export declare class MediaRelayError extends Error {
     userMessage: string;
     constructor(message: string, userMessage: string);
 }
 export declare function relayInit(cfg: ConfigSet): void;
-export declare function relayForwardContent(content: Element[]): Promise<Element[]>;
+export declare function relayForwardContent(content: Element[], traceId?: string, session?: Session, node?: ForwardNode): Promise<Element[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "koishi-plugin-forward-hime",
 	"description": "多群组消息互通",
-	"version": "1.4.1-alpha.2",
+	"version": "1.4.2-alpha.1",
 	"author": {
 		"name": "xianii",
 		"email": "jiyucheng007@gmail.com"
@@ -57,7 +57,8 @@
 	},
 	"scripts": {
 		"prepare": "husky",
-		"build": "rm -f tsconfig.tsbuildinfo && rm -rf lib && tsc -b && esbuild src/index.ts --bundle --platform=node --packages=external --outfile=lib/index.js",
+		"build": "rm -f tsconfig.tsbuildinfo && rm -rf lib && tsc -b && esbuild src/index.ts --bundle --platform=node --packages=external --outfile=lib/index.js && esbuild client/index.ts --bundle --platform=browser --format=esm --packages=external --outfile=lib/client/index.js",
+		"test": "node --test",
 		"eslint": "eslint \"src/**/*.{ts,tsx}\"",
 		"format": "prettier --write .",
 		"pub": "npm publish --access public"