koishi-plugin-echo-cave 1.28.2 → 1.29.0

package/lib/config/config.d.ts

@@ -1,4 +1,5 @@
 import { Schema } from 'koishi';
+export type SendFailureHandlingMode = 'auto-delete' | 'daily-report' | 'ignore';
 export interface Config {
     adminMessageProtection?: boolean;
     adminIds?: string[];
@@ -25,5 +26,8 @@ export interface Config {
     s3ForcePathStyle?: boolean;
     s3PathPrefix?: string;
     s3PresignExpiresIn?: number;
+    sendFailureHandlingMode?: SendFailureHandlingMode;
+    sendFailureSummaryAdminId?: string;
+    sendFailureSummaryTime?: string;
 }
 export declare const Config: Schema<Config>;

package/lib/core/command/delete-cave.d.ts

@@ -1,4 +1,6 @@
 import { Config } from '../../config/config';
+import { EchoCave } from '../../index';
 import { Context, Session } from 'koishi';
+export declare function deleteStoredCave(ctx: Context, cfg: Config, caveMsg: EchoCave): Promise<void>;
 export declare function deleteCave(ctx: Context, session: Session, cfg: Config, id: number): Promise<string>;
 export declare function deleteCaves(ctx: Context, session: Session, cfg: Config, ids: number[]): Promise<string>;

package/lib/core/formatter/msg-formatter.d.ts

@@ -1,5 +1,8 @@
 import { Config } from '../../config/config';
 import { EchoCave } from '../../index';
 import { Context, Session } from 'koishi';
+export declare class PartialCaveSendError extends Error {
+    constructor(message: string);
+}
 export declare function sendCaveMsg(ctx: Context, session: Session, caveMsg: EchoCave, cfg: Config): Promise<void>;
 export declare function formatDate(date: Date): string;

package/lib/core/parser/forward-parser.d.ts

@@ -2,4 +2,4 @@ import { Config } from '../../config/config';
 import { CQCode } from '@pynickle/koishi-plugin-adapter-onebot';
 import { Message } from '@pynickle/koishi-plugin-adapter-onebot/lib/types';
 import { Context, Session } from 'koishi';
-export declare function reconstructForwardMsg(ctx: Context, session: Session, message: Message[], cfg: Config): Promise<CQCode[]>;
+export declare function reconstructForwardMsg(ctx: Context, session: Session, message: Message[], cfg: Config, processMedia?: boolean): Promise<CQCode[]>;

package/lib/core/parser/msg-parser.d.ts

@@ -1,4 +1,5 @@
 import { Config } from '../../config/config';
+import { processMediaElement } from '../../utils/media/media-helper';
 import { CQCode } from '@pynickle/koishi-plugin-adapter-onebot';
 import { Context } from 'koishi';
-export declare function processMessageContent(ctx: Context, msg: CQCode[], cfg: Config, channelId: string): Promise<CQCode[]>;
+export declare function processMessageContent(ctx: Context, msg: CQCode[], cfg: Config, channelId: string, progressOptions?: Parameters<typeof processMediaElement>[4]): Promise<CQCode[]>;

package/lib/core/send-failure.d.ts

@@ -0,0 +1,5 @@
+import { Config } from '../config/config';
+import { EchoCave } from '../index';
+import { Context, Session } from 'koishi';
+export declare function handleCaveSendFailure(ctx: Context, session: Session, caveMsg: EchoCave, cfg: Config, error: unknown): Promise<string>;
+export declare function registerSendFailureSummaryScheduler(ctx: Context, cfg: Config): void;

package/lib/index.cjs

@@ -24975,7 +24975,7 @@ var require_dist_cjs54 = __commonJS({
 });
 
 // node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/ruleset.js
-var u, v, w, x, a, b, c, d, e, f, g, h2, i, j, k, l, m, n, o, p, q, r, s, t, _data, ruleSet;
+var u, v, w, x, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, _data, ruleSet;
 var init_ruleset = __esm({
   "node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/ruleset.js"() {
     u = "required";
@@ -24989,16 +24989,16 @@ var init_ruleset = __esm({
     e = "endpoint";
     f = "tree";
     g = "PartitionResult";
-    h2 = "getAttr";
+    h = "getAttr";
     i = { [u]: false, type: "string" };
     j = { [u]: true, default: false, type: "boolean" };
     k = { [x]: "Endpoint" };
     l = { [v]: c, [w]: [{ [x]: "UseFIPS" }, true] };
     m = { [v]: c, [w]: [{ [x]: "UseDualStack" }, true] };
     n = {};
-    o = { [v]: h2, [w]: [{ [x]: g }, "supportsFIPS"] };
+    o = { [v]: h, [w]: [{ [x]: g }, "supportsFIPS"] };
     p = { [x]: g };
-    q = { [v]: c, [w]: [true, { [v]: h2, [w]: [p, "supportsDualStack"] }] };
+    q = { [v]: c, [w]: [true, { [v]: h, [w]: [p, "supportsDualStack"] }] };
     r = [l];
     s = [m];
     t = [{ [x]: "Region" }];
@@ -25049,7 +25049,7 @@ var init_ruleset = __esm({
                       conditions: [{ [v]: c, [w]: [o, a] }],
                       rules: [
                         {
-                          conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h2, [w]: [p, "name"] }, "aws-us-gov"] }],
+                          conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h, [w]: [p, "name"] }, "aws-us-gov"] }],
                           endpoint: { url: "https://oidc.{Region}.amazonaws.com", properties: n, headers: n },
                           type: e
                         },
@@ -26094,7 +26094,7 @@ var init_EndpointParameters2 = __esm({
 });
 
 // node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso/endpoint/ruleset.js
-var u2, v2, w2, x2, a2, b2, c2, d2, e2, f2, g2, h3, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, _data2, ruleSet2;
+var u2, v2, w2, x2, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, _data2, ruleSet2;
 var init_ruleset2 = __esm({
   "node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso/endpoint/ruleset.js"() {
     u2 = "required";
@@ -26108,16 +26108,16 @@ var init_ruleset2 = __esm({
     e2 = "endpoint";
     f2 = "tree";
     g2 = "PartitionResult";
-    h3 = "getAttr";
+    h2 = "getAttr";
     i2 = { [u2]: false, type: "string" };
     j2 = { [u2]: true, default: false, type: "boolean" };
     k2 = { [x2]: "Endpoint" };
     l2 = { [v2]: c2, [w2]: [{ [x2]: "UseFIPS" }, true] };
     m2 = { [v2]: c2, [w2]: [{ [x2]: "UseDualStack" }, true] };
     n2 = {};
-    o2 = { [v2]: h3, [w2]: [{ [x2]: g2 }, "supportsFIPS"] };
+    o2 = { [v2]: h2, [w2]: [{ [x2]: g2 }, "supportsFIPS"] };
     p2 = { [x2]: g2 };
-    q2 = { [v2]: c2, [w2]: [true, { [v2]: h3, [w2]: [p2, "supportsDualStack"] }] };
+    q2 = { [v2]: c2, [w2]: [true, { [v2]: h2, [w2]: [p2, "supportsDualStack"] }] };
     r2 = [l2];
     s2 = [m2];
     t2 = [{ [x2]: "Region" }];
@@ -26168,7 +26168,7 @@ var init_ruleset2 = __esm({
                       conditions: [{ [v2]: c2, [w2]: [o2, a2] }],
                       rules: [
                         {
-                          conditions: [{ [v2]: "stringEquals", [w2]: [{ [v2]: h3, [w2]: [p2, "name"] }, "aws-us-gov"] }],
+                          conditions: [{ [v2]: "stringEquals", [w2]: [{ [v2]: h2, [w2]: [p2, "name"] }, "aws-us-gov"] }],
                           endpoint: { url: "https://portal.sso.{Region}.amazonaws.com", properties: n2, headers: n2 },
                           type: e2
                         },
@@ -26978,7 +26978,7 @@ var init_EndpointParameters3 = __esm({
 });
 
 // node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/signin/endpoint/ruleset.js
-var u3, v3, w3, x3, a3, b3, c3, d3, e3, f3, g3, h4, i3, j3, k3, l3, m3, n3, o3, p3, q3, r3, s3, t3, _data3, ruleSet3;
+var u3, v3, w3, x3, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3, k3, l3, m3, n3, o3, p3, q3, r3, s3, t3, _data3, ruleSet3;
 var init_ruleset3 = __esm({
   "node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/signin/endpoint/ruleset.js"() {
     u3 = "required";
@@ -26992,7 +26992,7 @@ var init_ruleset3 = __esm({
     e3 = "endpoint";
     f3 = "tree";
     g3 = "PartitionResult";
-    h4 = "stringEquals";
+    h3 = "stringEquals";
     i3 = { [u3]: true, default: false, type: "boolean" };
     j3 = { [u3]: false, type: "string" };
     k3 = { [x3]: "Endpoint" };
@@ -27036,17 +27036,17 @@ var init_ruleset3 = __esm({
                   conditions: [{ [v3]: "aws.partition", [w3]: t3, assign: g3 }],
                   rules: [
                     {
-                      conditions: [{ [v3]: h4, [w3]: [o3, "aws"] }, p3, q3],
+                      conditions: [{ [v3]: h3, [w3]: [o3, "aws"] }, p3, q3],
                       endpoint: { url: "https://{Region}.signin.aws.amazon.com", properties: n3, headers: n3 },
                       type: e3
                     },
                     {
-                      conditions: [{ [v3]: h4, [w3]: [o3, "aws-cn"] }, p3, q3],
+                      conditions: [{ [v3]: h3, [w3]: [o3, "aws-cn"] }, p3, q3],
                       endpoint: { url: "https://{Region}.signin.amazonaws.cn", properties: n3, headers: n3 },
                       type: e3
                     },
                     {
-                      conditions: [{ [v3]: h4, [w3]: [o3, "aws-us-gov"] }, p3, q3],
+                      conditions: [{ [v3]: h3, [w3]: [o3, "aws-us-gov"] }, p3, q3],
                       endpoint: { url: "https://{Region}.signin.amazonaws-us-gov.com", properties: n3, headers: n3 },
                       type: e3
                     },
@@ -28047,7 +28047,7 @@ var init_EndpointParameters4 = __esm({
 });
 
 // node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/ruleset.js
-var F, G, H, I, J, a4, b4, c4, d4, e4, f4, g4, h5, i4, j4, k4, l4, m4, n4, o4, p4, q4, r4, s4, t4, u4, v4, w4, x4, y, z, A, B, C, D, E, _data4, ruleSet4;
+var F, G, H, I, J, a4, b4, c4, d4, e4, f4, g4, h4, i4, j4, k4, l4, m4, n4, o4, p4, q4, r4, s4, t4, u4, v4, w4, x4, y, z, A, B, C, D, E, _data4, ruleSet4;
 var init_ruleset4 = __esm({
   "node_modules/.pnpm/@aws-sdk+nested-clients@3.996.17/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/ruleset.js"() {
     F = "required";
@@ -28062,7 +28062,7 @@ var init_ruleset4 = __esm({
     e4 = "sigv4";
     f4 = "sts";
     g4 = "us-east-1";
-    h5 = "endpoint";
+    h4 = "endpoint";
     i4 = "https://sts.{Region}.{PartitionResult#dnsSuffix}";
     j4 = "tree";
     k4 = "error";
@@ -28081,7 +28081,7 @@ var init_ruleset4 = __esm({
       headers: {}
     };
     v4 = {};
-    w4 = { conditions: [{ [H]: d4, [I]: [q4, "aws-global"] }], [h5]: u4, [G]: h5 };
+    w4 = { conditions: [{ [H]: d4, [I]: [q4, "aws-global"] }], [h4]: u4, [G]: h4 };
     x4 = { [H]: c4, [I]: [s4, true] };
     y = { [H]: c4, [I]: [t4, true] };
     z = { [H]: l4, [I]: [{ [J]: "PartitionResult" }, "supportsFIPS"] };
@@ -28104,29 +28104,29 @@ var init_ruleset4 = __esm({
             { [H]: c4, [I]: [t4, a4] }
           ],
           rules: [
-            { conditions: [{ [H]: d4, [I]: [q4, "ap-northeast-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "ap-south-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "ap-southeast-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "ap-southeast-2"] }], endpoint: u4, [G]: h5 },
+            { conditions: [{ [H]: d4, [I]: [q4, "ap-northeast-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "ap-south-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "ap-southeast-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "ap-southeast-2"] }], endpoint: u4, [G]: h4 },
             w4,
-            { conditions: [{ [H]: d4, [I]: [q4, "ca-central-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "eu-central-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "eu-north-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "eu-west-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "eu-west-2"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "eu-west-3"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "sa-east-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, g4] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "us-east-2"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "us-west-1"] }], endpoint: u4, [G]: h5 },
-            { conditions: [{ [H]: d4, [I]: [q4, "us-west-2"] }], endpoint: u4, [G]: h5 },
+            { conditions: [{ [H]: d4, [I]: [q4, "ca-central-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "eu-central-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "eu-north-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "eu-west-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "eu-west-2"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "eu-west-3"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "sa-east-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, g4] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "us-east-2"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "us-west-1"] }], endpoint: u4, [G]: h4 },
+            { conditions: [{ [H]: d4, [I]: [q4, "us-west-2"] }], endpoint: u4, [G]: h4 },
             {
               endpoint: {
                 url: i4,
                 properties: { authSchemes: [{ name: e4, signingName: f4, signingRegion: "{Region}" }] },
                 headers: v4
               },
-              [G]: h5
+              [G]: h4
             }
           ],
           [G]: j4
@@ -28136,7 +28136,7 @@ var init_ruleset4 = __esm({
           rules: [
             { conditions: D, error: "Invalid Configuration: FIPS and custom endpoint are not supported", [G]: k4 },
             { conditions: E, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", [G]: k4 },
-            { endpoint: { url: o4, properties: v4, headers: v4 }, [G]: h5 }
+            { endpoint: { url: o4, properties: v4, headers: v4 }, [G]: h4 }
           ],
           [G]: j4
         },
@@ -28158,7 +28158,7 @@ var init_ruleset4 = __esm({
                             properties: v4,
                             headers: v4
                           },
-                          [G]: h5
+                          [G]: h4
                         }
                       ],
                       [G]: j4
@@ -28176,7 +28176,7 @@ var init_ruleset4 = __esm({
                         {
                           conditions: [{ [H]: d4, [I]: [{ [H]: l4, [I]: [A, "name"] }, "aws-us-gov"] }],
                           endpoint: { url: "https://sts.{Region}.amazonaws.com", properties: v4, headers: v4 },
-                          [G]: h5
+                          [G]: h4
                         },
                         {
                           endpoint: {
@@ -28184,7 +28184,7 @@ var init_ruleset4 = __esm({
                             properties: v4,
                             headers: v4
                           },
-                          [G]: h5
+                          [G]: h4
                         }
                       ],
                       [G]: j4
@@ -28205,7 +28205,7 @@ var init_ruleset4 = __esm({
                             properties: v4,
                             headers: v4
                           },
-                          [G]: h5
+                          [G]: h4
                         }
                       ],
                       [G]: j4
@@ -28215,7 +28215,7 @@ var init_ruleset4 = __esm({
                   [G]: j4
                 },
                 w4,
-                { endpoint: { url: i4, properties: v4, headers: v4 }, [G]: h5 }
+                { endpoint: { url: i4, properties: v4, headers: v4 }, [G]: h4 }
               ],
               [G]: j4
             }
@@ -33351,55 +33351,6 @@ async function checkUsersInGroup(ctx, session, userIds) {
   }
 }
 
-// src/utils/msg/element-helper.ts
-var import_koishi = require("koishi");
-function parseUserIds(userIds) {
-  const parsedUserIds = [];
-  for (const userId of typeof userIds === "string" ? [userIds] : userIds) {
-    const num = Number(userId);
-    if (!Number.isNaN(num)) {
-      parsedUserIds.push(userId);
-      continue;
-    }
-    const element = import_koishi.h.parse(userId);
-    if (element.length === 1 && element[0].type === "at") {
-      const userId2 = element[0].attrs.id;
-      if (userId2 === "all") {
-        return {
-          parsedUserIds: [],
-          error: "invalid_all_mention"
-        };
-      }
-      parsedUserIds.push(userId2);
-    }
-  }
-  return {
-    parsedUserIds
-  };
-}
-
-// src/utils/msg/message-listener.ts
-async function listenForUserMessage(ctx, session, prompt, timeout, onMessage, onTimeout) {
-  const { userId, channelId, guildId, platform } = session;
-  await session.send(prompt);
-  const listener = async (msgSession) => {
-    if (msgSession.userId === userId && msgSession.channelId === channelId && msgSession.guildId === guildId && msgSession.platform === platform) {
-      const shouldContinue = await onMessage(msgSession.content);
-      if (!shouldContinue) {
-        cancelListener();
-        cancelTimeout();
-      }
-    }
-  };
-  const cancelListener = ctx.on("message", listener);
-  const cancelTimeout = ctx.setTimeout(async () => {
-    cancelListener();
-    if (onTimeout) {
-      await onTimeout();
-    }
-  }, timeout);
-}
-
 // src/utils/media/media-helper.ts
 var import_axios = __toESM(require("axios"), 1);
 var import_client_s3 = __toESM(require_dist_cjs71(), 1);
@@ -34077,6 +34028,12 @@ async function mutateMessageContent(ctx, content, handler) {
     changed
   };
 }
+async function processStoredMessageMedia(ctx, content, cfg, channelId, progressOptions) {
+  const rewritten = await mutateMessageContent(ctx, content, async (element) => {
+    return await processMediaElement(ctx, element, cfg, channelId, progressOptions);
+  });
+  return rewritten.content;
+}
 async function collectMessageMediaRefs(ctx, content) {
   const parsed = JSON.parse(content);
   const elements = Array.isArray(parsed) ? parsed : [parsed];
@@ -34225,7 +34182,7 @@ async function collectManagedMediaFiles(ctx, type) {
   }
   return fileInfos;
 }
-async function saveMedia(ctx, mediaElement, type, cfg, channelId) {
+async function saveMedia(ctx, mediaElement, type, cfg, channelId, progressOptions) {
   const mediaUrl = typeof mediaElement.url === "string" ? mediaElement.url : "";
   const originalMediaName = typeof mediaElement.file === "string" ? mediaElement.file : `media.${getDefaultExtension(type)}`;
   const extension = getFileExtension(originalMediaName, type);
@@ -34233,6 +34190,7 @@ async function saveMedia(ctx, mediaElement, type, cfg, channelId) {
     return mediaUrl;
   }
   try {
+    await ensureMediaSaveProgress(progressOptions);
     const response = await import_axios.default.get(mediaUrl, {
       responseType: "arraybuffer",
       validateStatus: () => true,
@@ -34284,9 +34242,16 @@ async function debouncedCleanup(ctx, cfg, type, channelId) {
   }, 5e3);
   cleanupTimers.set(key, timer);
 }
-async function processMediaElement(ctx, element, cfg, channelId) {
+async function processMediaElement(ctx, element, cfg, channelId, progressOptions) {
   if (isMediaType(element.type)) {
-    const savedPath = await saveMedia(ctx, element.data || {}, element.type, cfg, channelId);
+    const savedPath = await saveMedia(
+      ctx,
+      element.data || {},
+      element.type,
+      cfg,
+      channelId,
+      progressOptions
+    );
     const fileRef = typeof savedPath === "string" && isS3Uri(savedPath) ? savedPath : typeof savedPath === "string" && isHttpUrl(savedPath) ? savedPath : typeof savedPath === "string" ? toFileUri(savedPath) : "";
     return {
       ...element,
@@ -34299,6 +34264,38 @@ async function processMediaElement(ctx, element, cfg, channelId) {
   }
   return element;
 }
+async function messageContainsMedia(content) {
+  const elements = Array.isArray(content) ? content : [content];
+  const hasMedia = async (element) => {
+    if (isMediaType(element.type)) {
+      return true;
+    }
+    const nestedContent = element.data?.content;
+    if (element.type === "node" && Array.isArray(nestedContent)) {
+      for (const child of nestedContent) {
+        if (await hasMedia(child)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  for (const element of elements) {
+    if (await hasMedia(element)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function ensureMediaSaveProgress(progressOptions) {
+  if (!progressOptions || progressOptions.state.progressMessageIds?.length) {
+    return;
+  }
+  const { session, state: state2 } = progressOptions;
+  state2.progressMessageIds = await session.send(
+    session.text("commands.cave.echo.messages.mediaSaving")
+  );
+}
 async function resolveMediaElementForSend(ctx, element, cfg) {
   if (isMediaType(element.type)) {
     const fileRef = getElementFileRef(ctx, element, element.type);
@@ -34582,11 +34579,60 @@ async function mergeChannelCaves(ctx, cfg, sourceChannelId, targetChannelId, kee
   };
 }
 
+// src/utils/msg/element-helper.ts
+var import_koishi = require("koishi");
+function parseUserIds(userIds) {
+  const parsedUserIds = [];
+  for (const userId of typeof userIds === "string" ? [userIds] : userIds) {
+    const num = Number(userId);
+    if (!Number.isNaN(num)) {
+      parsedUserIds.push(userId);
+      continue;
+    }
+    const element = import_koishi.h.parse(userId);
+    if (element.length === 1 && element[0].type === "at") {
+      const userId2 = element[0].attrs.id;
+      if (userId2 === "all") {
+        return {
+          parsedUserIds: [],
+          error: "invalid_all_mention"
+        };
+      }
+      parsedUserIds.push(userId2);
+    }
+  }
+  return {
+    parsedUserIds
+  };
+}
+
+// src/utils/msg/message-listener.ts
+async function listenForUserMessage(ctx, session, prompt, timeout, onMessage, onTimeout) {
+  const { userId, channelId, guildId, platform } = session;
+  await session.send(prompt);
+  const listener = async (msgSession) => {
+    if (msgSession.userId === userId && msgSession.channelId === channelId && msgSession.guildId === guildId && msgSession.platform === platform) {
+      const shouldContinue = await onMessage(msgSession.content);
+      if (!shouldContinue) {
+        cancelListener();
+        cancelTimeout();
+      }
+    }
+  };
+  const cancelListener = ctx.on("message", listener);
+  const cancelTimeout = ctx.setTimeout(async () => {
+    cancelListener();
+    if (onTimeout) {
+      await onTimeout();
+    }
+  }, timeout);
+}
+
 // src/core/parser/forward-parser.ts
-async function reconstructForwardMsg(ctx, session, message, cfg) {
+async function reconstructForwardMsg(ctx, session, message, cfg, processMedia = true) {
   return Promise.all(
     message.map(async (msg) => {
-      const content = await processForwardMessageContent(ctx, session, msg, cfg);
+      const content = await processForwardMessageContent(ctx, session, msg, cfg, processMedia);
       const senderNickname = msg.sender.nickname;
       let senderUserId = msg.sender.user_id;
       senderUserId = senderUserId === 1094950020 ? await getUserIdFromNickname(session, senderNickname, senderUserId) : senderUserId;
@@ -34601,26 +34647,29 @@ async function reconstructForwardMsg(ctx, session, message, cfg) {
     })
   );
 }
-async function processForwardMessageContent(ctx, session, msg, cfg) {
+async function processForwardMessageContent(ctx, session, msg, cfg, processMedia) {
   if (typeof msg.message === "string") {
     return msg.message;
   }
   const firstElement = msg.message[0];
   if (firstElement?.type === "forward") {
-    return reconstructForwardMsg(ctx, session, firstElement.data.content, cfg);
+    return reconstructForwardMsg(ctx, session, firstElement.data.content, cfg, processMedia);
   }
   return Promise.all(
     msg.message.map(async (element) => {
+      if (!processMedia) {
+        return element;
+      }
       return await processMediaElement(ctx, element, cfg, session.channelId);
     })
   );
 }
 
 // src/core/parser/msg-parser.ts
-async function processMessageContent(ctx, msg, cfg, channelId) {
+async function processMessageContent(ctx, msg, cfg, channelId, progressOptions) {
   return Promise.all(
     msg.map(
-      async (element) => await processMediaElement(ctx, element, cfg, channelId)
+      async (element) => await processMediaElement(ctx, element, cfg, channelId, progressOptions)
     )
   );
 }
@@ -34654,14 +34703,19 @@ async function addCave(ctx, session, cfg, userIds) {
   let content;
   let type;
   let forwardUsers = [];
+  let hasMedia = false;
+  let needsDeferredMediaProcessing = false;
   if (quote.elements[0].type === "forward") {
     type = "forward";
     const message = await reconstructForwardMsg(
       ctx,
       session,
       await session.onebot.getForwardMsg(messageId),
-      cfg
+      cfg,
+      false
     );
+    hasMedia = await messageContainsMedia(message);
+    needsDeferredMediaProcessing = true;
     content = JSON.stringify(message);
     const userMap = /* @__PURE__ */ new Map();
     for (const node of message) {
@@ -34690,7 +34744,15 @@ async function addCave(ctx, session, cfg, userIds) {
       }
       msgJson = message;
     }
-    content = JSON.stringify(await processMessageContent(ctx, msgJson, cfg, channelId));
+    hasMedia = await messageContainsMedia(msgJson);
+    content = JSON.stringify(
+      await processMediaWithOptionalProgress(
+        session,
+        cfg,
+        hasMedia,
+        async (progressOptions) => await processMessageContent(ctx, msgJson, cfg, channelId, progressOptions)
+      )
+    );
   }
   if (type === "forward" && forwardUsers.length > 0 && parsedUserIds.length === 0 && cfg.enableForwardUserSelection) {
     const userSelectionPromise = new Promise(
@@ -34738,9 +34800,23 @@ ${session.text(".selectInstruction")}`;
     );
     selectedUsersWithNames = await userSelectionPromise;
   }
-  const finalParsedUserIds = selectedUsersWithNames.map((user) => user.userId);
+  if (needsDeferredMediaProcessing) {
+    content = await processMediaWithOptionalProgress(
+      session,
+      cfg,
+      hasMedia,
+      async (progressOptions) => await processStoredMessageMedia(ctx, content, cfg, channelId, progressOptions)
+    );
+  }
+  const finalParsedUserIds = selectedUsersWithNames.length !== 0 ? selectedUsersWithNames.map((user) => user.userId) : parsedUserIds;
   const originName = await getUserName(ctx, session, quote.user.id);
-  const relatedUsersFormatted = selectedUsersWithNames.length !== 0 ? selectedUsersWithNames.map((user) => user.nickname).join(", ") : originName;
+  const relatedUsersFormatted = await formatRelatedUsers(
+    ctx,
+    session,
+    selectedUsersWithNames,
+    finalParsedUserIds,
+    originName
+  );
   try {
     const result = await ctx.database.create("echo_cave_v2", {
       channelId,
@@ -34756,6 +34832,39 @@ ${session.text(".selectInstruction")}`;
     return session.text(".msgFailedToSave");
   }
 }
+async function processMediaWithOptionalProgress(session, cfg, hasMedia, action) {
+  const shouldShowProgress = cfg.mediaStorage === "s3" && hasMedia;
+  const state2 = {};
+  try {
+    return await action(shouldShowProgress ? { session, state: state2 } : void 0);
+  } finally {
+    await tryDeleteProgressMessages(session, state2.progressMessageIds);
+  }
+}
+async function tryDeleteProgressMessages(session, messageIds) {
+  if (!messageIds || messageIds.length === 0) {
+    return;
+  }
+  for (const messageId of messageIds) {
+    try {
+      await session.bot.deleteMessage(session.channelId, messageId);
+    } catch (error2) {
+      session.app.logger("echo-cave").warn(`Failed to delete progress message ${messageId}: ${error2}`);
+    }
+  }
+}
+async function formatRelatedUsers(ctx, session, selectedUsersWithNames, relatedUserIds, originName) {
+  if (selectedUsersWithNames.length !== 0) {
+    return selectedUsersWithNames.map((user) => user.nickname).join(", ");
+  }
+  if (relatedUserIds.length !== 0) {
+    const relatedUserNames = await Promise.all(
+      relatedUserIds.map(async (relatedUserId) => await getUserName(ctx, session, relatedUserId))
+    );
+    return relatedUserNames.join(", ");
+  }
+  return originName;
+}
 
 // src/core/command/admin.ts
 function ensureAdminPrivateAccess(session, cfg) {
@@ -35016,6 +35125,12 @@ ${refs.join("\n")}`);
 }
 
 // src/core/command/delete-cave.ts
+async function deleteStoredCave(ctx, cfg, caveMsg) {
+  if (cfg.deleteMediaWhenDeletingMsg) {
+    await deleteMediaFilesFromMessage(ctx, caveMsg.content, cfg);
+  }
+  await ctx.database.remove("echo_cave_v2", caveMsg.id);
+}
 async function deleteCave(ctx, session, cfg, id) {
   if (!session.guildId) {
     return session.text("echo-cave.general.privateChatReminder");
@@ -35052,10 +35167,7 @@ async function deleteCave(ctx, session, cfg, id) {
       return session.text(".permissionDenied");
     }
   }
-  if (cfg.deleteMediaWhenDeletingMsg) {
-    await deleteMediaFilesFromMessage(ctx, caveMsg.content, cfg);
-  }
-  await ctx.database.remove("echo_cave_v2", id);
+  await deleteStoredCave(ctx, cfg, caveMsg);
   return session.text(".msgDeleted", [id]);
 }
 async function deleteCaves(ctx, session, cfg, ids) {
@@ -35093,10 +35205,7 @@ async function deleteCaves(ctx, session, cfg, ids) {
       failedIds.push(cave.id);
       continue;
     }
-    if (cfg.deleteMediaWhenDeletingMsg) {
-      await deleteMediaFilesFromMessage(ctx, caveMsg.content, cfg);
-    }
-    await ctx.database.remove("echo_cave_v2", cave.id);
+    await deleteStoredCave(ctx, cfg, caveMsg);
   }
   const foundIds = new Set(caves.map((r5) => r5.id));
   const missingIds = ids.filter((id) => !foundIds.has(id));
@@ -35110,6 +35219,257 @@ async function deleteCaves(ctx, session, cfg, ids) {
   }
 }
 
+// src/core/send-failure.ts
+var DEFAULT_SUMMARY_TIME = "09:00";
+var MAX_ERROR_MESSAGE_LENGTH = 120;
+var MAX_MESSAGE_LENGTH = 1500;
+async function handleCaveSendFailure(ctx, session, caveMsg, cfg, error2) {
+  const handlingMode = cfg.sendFailureHandlingMode || "ignore";
+  const errorMessage = normalizeErrorMessage(error2);
+  ctx.logger.warn(`Failed to send cave #${caveMsg.id} in ${session.channelId}: ${errorMessage}`);
+  if (handlingMode === "auto-delete") {
+    return handleAutoDeleteOnFailure(ctx, session, caveMsg, cfg, errorMessage);
+  }
+  if (handlingMode === "daily-report") {
+    return handleDailyReportOnFailure(ctx, session, caveMsg, cfg, errorMessage);
+  }
+  return session.text("commands.cave.messages.sendFailedIgnored", {
+    id: caveMsg.id,
+    errorMessage
+  });
+}
+function registerSendFailureSummaryScheduler(ctx, cfg) {
+  if ((cfg.sendFailureHandlingMode || "ignore") !== "daily-report") {
+    return;
+  }
+  ctx.on("ready", () => {
+    scheduleNextSendFailureSummary(ctx, cfg);
+  });
+}
+async function handleAutoDeleteOnFailure(ctx, session, caveMsg, cfg, errorMessage) {
+  try {
+    await deleteStoredCave(ctx, cfg, caveMsg);
+    return session.text("commands.cave.messages.sendFailedAutoDeleted", {
+      id: caveMsg.id,
+      errorMessage
+    });
+  } catch (deleteError) {
+    const deleteErrorMessage = normalizeErrorMessage(deleteError);
+    ctx.logger.error(
+      `Failed to auto-delete cave #${caveMsg.id} after send failure: ${deleteErrorMessage}`
+    );
+    return session.text("commands.cave.messages.sendFailedAutoDeleteAlsoFailed", {
+      id: caveMsg.id,
+      errorMessage,
+      deleteErrorMessage
+    });
+  }
+}
+async function handleDailyReportOnFailure(ctx, session, caveMsg, cfg, errorMessage) {
+  const summaryAdminId = cfg.sendFailureSummaryAdminId?.trim() || "";
+  try {
+    await ctx.database.create("echo_cave_send_failure", {
+      caveId: caveMsg.id,
+      channelId: session.channelId,
+      guildId: session.guildId || "",
+      platform: session.platform,
+      selfId: session.selfId,
+      failTime: /* @__PURE__ */ new Date(),
+      errorMessage
+    });
+  } catch (recordError) {
+    const recordErrorMessage = normalizeErrorMessage(recordError);
+    ctx.logger.error(`Failed to record cave send failure for #${caveMsg.id}: ${recordErrorMessage}`);
+    return session.text("commands.cave.messages.sendFailedReportRecordFailed", {
+      id: caveMsg.id,
+      errorMessage
+    });
+  }
+  if (!summaryAdminId) {
+    return session.text("commands.cave.messages.sendFailedRecordedWithoutAdmin", {
+      id: caveMsg.id,
+      errorMessage,
+      summaryTime: cfg.sendFailureSummaryTime || DEFAULT_SUMMARY_TIME
+    });
+  }
+  return session.text("commands.cave.messages.sendFailedRecordedForDailyReport", {
+    id: caveMsg.id,
+    errorMessage,
+    summaryTime: cfg.sendFailureSummaryTime || DEFAULT_SUMMARY_TIME,
+    adminId: summaryAdminId
+  });
+}
+function scheduleNextSendFailureSummary(ctx, cfg) {
+  const summaryTime = parseSummaryTime(cfg.sendFailureSummaryTime || DEFAULT_SUMMARY_TIME);
+  if (!summaryTime) {
+    ctx.logger.warn(
+      `Invalid sendFailureSummaryTime: ${cfg.sendFailureSummaryTime}. Expected HH:mm.`
+    );
+    return;
+  }
+  const delay = getDelayUntilNextRun(summaryTime);
+  ctx.setTimeout(async () => {
+    try {
+      await flushSendFailureSummary(ctx, cfg);
+    } catch (error2) {
+      ctx.logger.error(`Failed to flush cave send failure summary: ${normalizeErrorMessage(error2)}`);
+    }
+    scheduleNextSendFailureSummary(ctx, cfg);
+  }, delay);
+}
+async function flushSendFailureSummary(ctx, cfg) {
+  const adminId = cfg.sendFailureSummaryAdminId?.trim();
+  if (!adminId) {
+    ctx.logger.warn("Skipped cave send failure summary because sendFailureSummaryAdminId is empty.");
+    return;
+  }
+  const failures = await ctx.database.get("echo_cave_send_failure", {});
+  if (failures.length === 0) {
+    return;
+  }
+  const groupedFailures = groupFailuresByBot(failures);
+  for (const [botKey, entries] of groupedFailures.entries()) {
+    const [platform, selfId] = botKey.split(":");
+    const bot = ctx.bots.find((item) => item.platform === platform && item.selfId === selfId);
+    if (!bot) {
+      ctx.logger.warn(`Skipped cave send failure summary because bot ${botKey} is unavailable.`);
+      continue;
+    }
+    const messages = buildSummaryMessages(entries);
+    try {
+      for (const message of messages) {
+        await bot.sendPrivateMessage(adminId, message);
+      }
+    } catch (error2) {
+      ctx.logger.error(
+        `Failed to deliver cave send failure summary through bot ${botKey}: ${normalizeErrorMessage(error2)}`
+      );
+      continue;
+    }
+    try {
+      for (const entry of entries) {
+        await ctx.database.remove("echo_cave_send_failure", entry.id);
+      }
+    } catch (error2) {
+      ctx.logger.error(
+        `Delivered cave send failure summary through bot ${botKey}, but cleanup failed: ${normalizeErrorMessage(error2)}`
+      );
+    }
+  }
+}
+function groupFailuresByBot(failures) {
+  const groupedFailures = /* @__PURE__ */ new Map();
+  for (const entry of failures) {
+    const key = `${entry.platform}:${entry.selfId}`;
+    const items = groupedFailures.get(key) || [];
+    items.push(entry);
+    groupedFailures.set(key, items);
+  }
+  return groupedFailures;
+}
+function buildSummaryMessages(entries) {
+  const sortedEntries = [...entries].sort((left, right) => {
+    return new Date(left.failTime).getTime() - new Date(right.failTime).getTime();
+  });
+  const summaryItems = summarizeFailures(sortedEntries);
+  const headerLines = [
+    "\u{1F4EE} \u56DE\u58F0\u6D1E\u53D1\u9001\u5931\u8D25\u65E5\u62A5",
+    `\u7EDF\u8BA1\u533A\u95F4\uFF1A${formatDateTime(sortedEntries[0].failTime)} ~ ${formatDateTime(
+      sortedEntries.at(-1).failTime
+    )}`,
+    `\u5931\u8D25\u6B21\u6570\uFF1A${sortedEntries.length}`,
+    `\u6D89\u53CA\u56DE\u58F0\u6D1E\uFF1A${summaryItems.length}`,
+    ""
+  ];
+  const detailLines = summaryItems.map((item) => {
+    return `#${item.caveId}\uFF08\u7FA4 ${item.channelId}\uFF09\u5931\u8D25 ${item.count} \u6B21\uFF0C\u6700\u8FD1 ${formatDateTime(
+      item.lastFailTime
+    )}\uFF0C\u9519\u8BEF\uFF1A${item.lastErrorMessage}`;
+  });
+  return splitLinesIntoMessages(headerLines, detailLines, MAX_MESSAGE_LENGTH);
+}
+function summarizeFailures(entries) {
+  const summaryMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = `${entry.channelId}:${entry.caveId}`;
+    const existing = summaryMap.get(key);
+    if (!existing) {
+      summaryMap.set(key, {
+        caveId: entry.caveId,
+        channelId: entry.channelId,
+        count: 1,
+        lastFailTime: new Date(entry.failTime),
+        lastErrorMessage: entry.errorMessage
+      });
+      continue;
+    }
+    existing.count += 1;
+    existing.lastFailTime = new Date(entry.failTime);
+    existing.lastErrorMessage = entry.errorMessage;
+  }
+  return [...summaryMap.values()].sort((left, right) => {
+    if (right.count !== left.count) {
+      return right.count - left.count;
+    }
+    return right.lastFailTime.getTime() - left.lastFailTime.getTime();
+  });
+}
+function splitLinesIntoMessages(headerLines, detailLines, maxLength) {
+  const messages = [];
+  let current = headerLines.join("\n");
+  for (const line of detailLines) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= maxLength) {
+      current = next;
+      continue;
+    }
+    messages.push(current);
+    current = `\u{1F4EE} \u56DE\u58F0\u6D1E\u53D1\u9001\u5931\u8D25\u65E5\u62A5\uFF08\u7EED\uFF09
+${line}`;
+  }
+  if (current) {
+    messages.push(current);
+  }
+  return messages;
+}
+function parseSummaryTime(value) {
+  const match = value.trim().match(/^(\d{1,2}):(\d{2})$/);
+  if (!match) {
+    return null;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+    return null;
+  }
+  return { hour, minute };
+}
+function getDelayUntilNextRun(summaryTime) {
+  const now = /* @__PURE__ */ new Date();
+  const nextRun = new Date(now);
+  nextRun.setSeconds(0, 0);
+  nextRun.setHours(summaryTime.hour, summaryTime.minute, 0, 0);
+  if (nextRun.getTime() <= now.getTime()) {
+    nextRun.setDate(nextRun.getDate() + 1);
+  }
+  return nextRun.getTime() - now.getTime();
+}
+function normalizeErrorMessage(error2) {
+  if (error2 instanceof Error) {
+    return error2.message.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+  }
+  if (typeof error2 === "string") {
+    return error2.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+  }
+  return "\u672A\u77E5\u9519\u8BEF";
+}
+function formatDateTime(date2) {
+  return new Date(date2).toLocaleString("zh-CN", {
+    hour12: false
+  });
+}
+
 // src/utils/msg/cqcode-helper.ts
 function createTextMsg(content) {
   return {
@@ -35131,6 +35491,12 @@ function createTextMsgNode(userId, nickname, content) {
 }
 
 // src/core/formatter/msg-formatter.ts
+var PartialCaveSendError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PartialCaveSendError";
+  }
+};
 async function sendCaveMsg(ctx, session, caveMsg, cfg) {
   const { channelId } = session;
   let content = JSON.parse(caveMsg.content);
@@ -35174,24 +35540,33 @@ async function sendCaveMsg(ctx, session, caveMsg, cfg) {
     }
     const chosenTemplate2 = availableTemplates2[Math.floor(Math.random() * availableTemplates2.length)];
     await session.onebot.sendGroupMsg(channelId, [createTextMsg(chosenTemplate2)]);
-    if (!isActualForward) {
-      if (content[0].type === "record") {
-        await session.onebot.sendGroupMsg(channelId, content);
-        return;
-      }
-      const forwardContent = [
-        {
-          type: "node",
-          data: {
-            user_id: caveMsg.originUserId,
-            nickname: originName,
-            content
-          }
+    try {
+      if (!isActualForward) {
+        if (content[0].type === "record") {
+          await session.onebot.sendGroupMsg(channelId, content);
+          return;
         }
-      ];
-      await session.onebot.sendGroupForwardMsg(channelId, forwardContent);
-    } else {
-      await session.onebot.sendGroupForwardMsg(channelId, content);
+        const forwardContent = [
+          {
+            type: "node",
+            data: {
+              user_id: caveMsg.originUserId,
+              nickname: originName,
+              content
+            }
+          }
+        ];
+        await session.onebot.sendGroupForwardMsg(channelId, forwardContent);
+      } else {
+        await session.onebot.sendGroupForwardMsg(channelId, content);
+      }
+    } catch (error2) {
+      try {
+        await session.send(session.text("commands.cave.messages.sendPartialFailure"));
+      } catch {
+      }
+      const message = error2 instanceof Error ? error2.message : "\u56DE\u58F0\u6D1E\u6B63\u6587\u53D1\u9001\u5931\u8D25";
+      throw new PartialCaveSendError(message);
     }
     return;
   }
@@ -35284,16 +35659,6 @@ async function getCave(ctx, session, cfg, id) {
       selectedIndex++;
     }
     caveMsg = caves[selectedIndex];
-    await ctx.database.set(
-      "echo_cave_v2",
-      {
-        id: caveMsg.id,
-        channelId
-      },
-      {
-        drawCount: caveMsg.drawCount + 1
-      }
-    );
   } else {
     const caves = await ctx.database.get("echo_cave_v2", {
       id,
@@ -35303,18 +35668,35 @@ async function getCave(ctx, session, cfg, id) {
       return session.text("echo-cave.general.noMsgWithId");
     }
     caveMsg = caves[0];
-    await ctx.database.set(
-      "echo_cave_v2",
-      {
-        id,
-        channelId
-      },
-      {
-        drawCount: caveMsg.drawCount + 1
-      }
-    );
   }
-  await sendCaveMsg(ctx, session, caveMsg, cfg);
+  try {
+    await sendCaveMsg(ctx, session, caveMsg, cfg);
+  } catch (error2) {
+    if (error2 instanceof PartialCaveSendError) {
+      await ctx.database.set(
+        "echo_cave_v2",
+        {
+          id: caveMsg.id,
+          channelId
+        },
+        {
+          drawCount: caveMsg.drawCount + 1
+        }
+      );
+      return;
+    }
+    return await handleCaveSendFailure(ctx, session, caveMsg, cfg, error2);
+  }
+  await ctx.database.set(
+    "echo_cave_v2",
+    {
+      id: caveMsg.id,
+      channelId
+    },
+    {
+      drawCount: caveMsg.drawCount + 1
+    }
+  );
 }
 
 // src/core/command/misc/bind-user.ts
@@ -35588,13 +35970,21 @@ var zh_CN_default = {
     cave: {
       description: "\u968F\u673A\u83B7\u53D6 / \u83B7\u53D6\u7279\u5B9A id \u7684\u56DE\u58F0\u6D1E\u4FE1\u606F",
       messages: {
-        noMsgInCave: '\u{1F680} \u56DE\u58F0\u6D1E\u4E2D\u6682\u65E0\u6D88\u606F\uFF0C\u5FEB\u4F7F\u7528 "cave.echo" \u547D\u4EE4\u6DFB\u52A0\u7B2C\u4E00\u6761\u6D88\u606F\u5427\uFF01'
+        noMsgInCave: '\u{1F680} \u56DE\u58F0\u6D1E\u4E2D\u6682\u65E0\u6D88\u606F\uFF0C\u5FEB\u4F7F\u7528 "cave.echo" \u547D\u4EE4\u6DFB\u52A0\u7B2C\u4E00\u6761\u6D88\u606F\u5427\uFF01',
+        sendPartialFailure: "\u26A0\uFE0F \u56DE\u58F0\u6D1E\u6807\u9898\u5DF2\u53D1\u9001\uFF0C\u4F46\u6B63\u6587\u53D1\u9001\u5931\u8D25\u4E86\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+        sendFailedAutoDeleted: "\u26A0\uFE0F \u56DE\u58F0\u6D1E #{id} \u53D1\u9001\u5931\u8D25\uFF0C\u5DF2\u81EA\u52A8\u4ECE\u56DE\u58F0\u6D1E\u5220\u9664\u3002\u9519\u8BEF\uFF1A{errorMessage}",
+        sendFailedAutoDeleteAlsoFailed: "\u26A0\uFE0F \u56DE\u58F0\u6D1E #{id} \u53D1\u9001\u5931\u8D25\uFF0C\u4E14\u81EA\u52A8\u5220\u9664\u4E5F\u5931\u8D25\u4E86\uFF0C\u8BF7\u7BA1\u7406\u5458\u5C3D\u5FEB\u5904\u7406\u3002\u53D1\u9001\u9519\u8BEF\uFF1A{errorMessage}\uFF1B\u5220\u9664\u9519\u8BEF\uFF1A{deleteErrorMessage}",
+        sendFailedRecordedForDailyReport: "\u26A0\uFE0F \u56DE\u58F0\u6D1E #{id} \u53D1\u9001\u5931\u8D25\uFF0C\u5DF2\u8BB0\u5F55\u672C\u6B21\u5F02\u5E38\uFF0C\u5E76\u5C06\u5728\u6BCF\u65E5 {summaryTime} \u6C47\u603B\u4E0A\u62A5\u7ED9\u7BA1\u7406\u5458 {adminId}\u3002\u9519\u8BEF\uFF1A{errorMessage}",
+        sendFailedRecordedWithoutAdmin: "\u26A0\uFE0F \u56DE\u58F0\u6D1E #{id} \u53D1\u9001\u5931\u8D25\uFF0C\u5DF2\u8BB0\u5F55\u672C\u6B21\u5F02\u5E38\uFF0C\u4F46\u5C1A\u672A\u914D\u7F6E\u65E5\u62A5\u7BA1\u7406\u5458\uFF0C\u6682\u65F6\u65E0\u6CD5\u4E0A\u62A5\u3002\u5F53\u524D\u6C47\u603B\u65F6\u95F4\uFF1A{summaryTime}\u3002\u9519\u8BEF\uFF1A{errorMessage}",
+        sendFailedReportRecordFailed: "\u26A0\uFE0F \u56DE\u58F0\u6D1E #{id} \u53D1\u9001\u5931\u8D25\uFF0C\u800C\u4E14\u5F02\u5E38\u8BB0\u5F55\u5199\u5165\u5931\u8D25\uFF0C\u65E0\u6CD5\u7EB3\u5165\u65E5\u62A5\uFF0C\u8BF7\u68C0\u67E5\u6570\u636E\u5E93\u6216\u65E5\u5FD7\u3002\u9519\u8BEF\uFF1A{errorMessage}",
+        sendFailedIgnored: "\u26A0\uFE0F \u56DE\u58F0\u6D1E #{id} \u53D1\u9001\u5931\u8D25\uFF0C\u5F53\u524D\u914D\u7F6E\u4E3A\u201C\u4E0D\u989D\u5916\u5904\u7406\u201D\uFF0C\u672C\u6B21\u4E0D\u4F1A\u81EA\u52A8\u5220\u9664\u6216\u4E0A\u62A5\u7BA1\u7406\u5458\u3002\u9519\u8BEF\uFF1A{errorMessage}"
       }
     },
     "cave.echo": {
       description: "\u5C06\u6D88\u606F\u5B58\u5165\u56DE\u58F0\u6D1E",
       messages: {
         noMsgQuoted: "\u{1F4A1} \u8BF7\u5F15\u7528\u4E00\u6761\u6D88\u606F\u540E\u518D\u4F7F\u7528\u6B64\u547D\u4EE4\uFF01",
+        mediaSaving: "\u23F3 \u68C0\u6D4B\u5230\u5A92\u4F53\u8D44\u6E90\uFF0C\u6B63\u5728\u5B58\u50A8\u5A92\u4F53\u6587\u4EF6\uFF0C\u8BF7\u7A0D\u5019\u2026\u2026",
         msgSaved: "\u2705 \u56DE\u58F0\u6D1E\u6D88\u606F\u5DF2\u6210\u529F\u5B58\u5165\uFF0C\u6D88\u606F ID\uFF1A{id}",
         msgFailedToSave: "\u274C \u56DE\u58F0\u6D1E\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF01",
         selectRelatedUsers: "\u8BF7\u9009\u62E9\u8981\u5173\u8054\u7684\u7528\u6237\uFF08\u4EE5\u7A7A\u683C\u5206\u9694\u5E8F\u53F7\uFF0C\u8F93\u5165'all'\u9009\u62E9\u5168\u90E8\uFF09\uFF1A",
@@ -35745,7 +36135,10 @@ var zh_CN_default2 = {
   s3SecretAccessKey: "S3 Secret Access Key",
   s3ForcePathStyle: "\u662F\u5426\u5F3A\u5236\u4F7F\u7528 path-style \u8BBF\u95EE S3",
   s3PathPrefix: "S3 \u5B58\u50A8\u8DEF\u5F84\u524D\u7F00\uFF0C\u4F1A\u62FC\u63A5\u5728 v2/channel/type \u76EE\u5F55\u524D",
-  s3PresignExpiresIn: "S3 \u79C1\u6709\u5BF9\u8C61\u9884\u7B7E\u540D URL \u7684\u6709\u6548\u671F (\u79D2)"
+  s3PresignExpiresIn: "S3 \u79C1\u6709\u5BF9\u8C61\u9884\u7B7E\u540D URL \u7684\u6709\u6548\u671F (\u79D2)",
+  sendFailureHandlingMode: "\u56DE\u58F0\u6D1E\u53D1\u9001\u5931\u8D25\u540E\u7684\u5904\u7406\u65B9\u5F0F\uFF1A\u81EA\u52A8\u5220\u9664\u3001\u6309\u65E5\u6C47\u603B\u4E0A\u62A5\u6216\u4E0D\u989D\u5916\u5904\u7406",
+  sendFailureSummaryAdminId: "\u53D1\u9001\u5931\u8D25\u65E5\u62A5\u7684\u5355\u72EC\u7BA1\u7406\u5458 ID\uFF08\u4E0D\u590D\u7528\u7BA1\u7406\u5458 ID \u5217\u8868\uFF09",
+  sendFailureSummaryTime: "\u53D1\u9001\u5931\u8D25\u65E5\u62A5\u7684\u6BCF\u65E5\u53D1\u9001\u65F6\u95F4\uFF0C\u683C\u5F0F\u4E3A HH:mm"
 };
 
 // src/config/config.ts
@@ -35775,7 +36168,10 @@ var Config = import_koishi2.Schema.object({
   s3SecretAccessKey: import_koishi2.Schema.string().role("secret").default(""),
   s3ForcePathStyle: import_koishi2.Schema.boolean().default(false),
   s3PathPrefix: import_koishi2.Schema.string().default(""),
-  s3PresignExpiresIn: import_koishi2.Schema.number().default(3600).min(60).max(604800)
+  s3PresignExpiresIn: import_koishi2.Schema.number().default(3600).min(60).max(604800),
+  sendFailureHandlingMode: import_koishi2.Schema.union(["auto-delete", "daily-report", "ignore"]).default("ignore"),
+  sendFailureSummaryAdminId: import_koishi2.Schema.string().default(""),
+  sendFailureSummaryTime: import_koishi2.Schema.string().default("09:00")
 }).i18n({
   "zh-CN": zh_CN_default2
 });
@@ -35821,6 +36217,23 @@ function apply(ctx, cfg) {
       autoInc: true
     }
   );
+  ctx.model.extend(
+    "echo_cave_send_failure",
+    {
+      id: "unsigned",
+      caveId: "unsigned",
+      channelId: "string",
+      guildId: "string",
+      platform: "string",
+      selfId: "string",
+      failTime: "timestamp",
+      errorMessage: "string"
+    },
+    {
+      primary: "id",
+      autoInc: true
+    }
+  );
   ctx.model.migrate(
     "echo_cave",
     {
@@ -35877,6 +36290,7 @@ function apply(ctx, cfg) {
   ctx.command("cave.admin.inspect-media [idRanges:text]").action(
     async ({ session }, idRanges) => await inspectMediaRefsForMigration(ctx, session, cfg, idRanges)
   );
+  registerSendFailureSummaryScheduler(ctx, cfg);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/index.d.ts

@@ -14,10 +14,21 @@ export interface EchoCave {
     relatedUsers: string[];
     drawCount: number;
 }
+export interface EchoCaveSendFailure {
+    id: number;
+    caveId: number;
+    channelId: string;
+    guildId: string;
+    platform: string;
+    selfId: string;
+    failTime: Date;
+    errorMessage: string;
+}
 declare module 'koishi' {
     interface Tables {
         echo_cave: EchoCave;
         echo_cave_v2: EchoCave;
+        echo_cave_send_failure: EchoCaveSendFailure;
     }
 }
 export declare function apply(ctx: Context, cfg: Config): void;

package/lib/utils/media/media-helper.d.ts

@@ -1,5 +1,5 @@
 import { Config } from '../../config/config';
-import { Context } from 'koishi';
+import { Context, Session } from 'koishi';
 export type MediaType = 'image' | 'video' | 'file' | 'record';
 type MaybeMediaElement = {
     type: string;
@@ -10,13 +10,22 @@ interface RewriteHooks {
     onS3Upload?: (type: MediaType, nextRef: string) => Promise<void>;
     onMigrationCommitted?: () => Promise<void>;
 }
+interface MediaSaveProgressState {
+    progressMessageIds?: string[];
+}
+interface MediaSaveProgressOptions {
+    session: Session;
+    state: MediaSaveProgressState;
+}
 interface CaveMediaRefs {
     id: number;
     refs: string[];
 }
+export declare function processStoredMessageMedia(ctx: Context, content: string, cfg: Config, channelId: string, progressOptions?: MediaSaveProgressOptions): Promise<string>;
 export declare function inspectCaveMediaRefs(ctx: Context, shouldInclude?: (caveId: number) => boolean): Promise<CaveMediaRefs[]>;
-export declare function saveMedia(ctx: Context, mediaElement: Record<string, unknown>, type: MediaType, cfg: Config, channelId: string): Promise<string>;
-export declare function processMediaElement(ctx: Context, element: MaybeMediaElement, cfg: Config, channelId: string): Promise<MaybeMediaElement>;
+export declare function saveMedia(ctx: Context, mediaElement: Record<string, unknown>, type: MediaType, cfg: Config, channelId: string, progressOptions?: MediaSaveProgressOptions): Promise<string>;
+export declare function processMediaElement(ctx: Context, element: MaybeMediaElement, cfg: Config, channelId: string, progressOptions?: MediaSaveProgressOptions): Promise<MaybeMediaElement>;
+export declare function messageContainsMedia(content: unknown): Promise<boolean>;
 export declare function resolveMediaElementForSend(ctx: Context, element: MaybeMediaElement, cfg: Config): Promise<MaybeMediaElement>;
 export declare function checkAndCleanMediaFiles(ctx: Context, cfg: Config, type: MediaType): Promise<void>;
 export declare function deleteMediaFilesFromMessage(ctx: Context, content: string, cfg: Config): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-echo-cave",
   "description": "Group echo cave",
-  "version": "1.28.2",
+  "version": "1.29.0",
   "main": "lib/index.cjs",
   "typings": "lib/index.d.ts",
   "type": "module",