koishi-plugin-echo-cave 1.30.0 → 1.31.1

package/README.md

@@ -85,6 +85,7 @@ npm install koishi-plugin-echo-cave
 | `autoBindSingleForwardUser`  | boolean | `false` | 转发消息仅识别到一个用户时，是否默认自动绑定该用户 |
 | `forwardSpecialUserHandlingMode` | `'ignore' \| 'reject' \| 'confirm'` | `'ignore'` | 检测到转发消息中包含用户 `1094950020` 时的处理方式：忽略、提醒后拒绝存储、或提醒并要求确认后再存储 |
 | `alpha`                      | number  | `0.2`   | 加权随机抽取的调整因子，控制抽取次数对概率的影响程度，值越大影响越明显 |
+| `s3UploadFailureFallbackMode` | `'local' \| 'original-link'` | `'local'` | 仅在 `mediaStorage='s3'` 时生效：S3 上传失败后回退到本地存储，或保留原始链接 |
 | `enableAutoReindex`          | boolean | `false` | 是否启用每日自动重整回声洞 public ID |
 | `autoReindexTime`            | string  | `00:00` | 自动重整的每日执行时间，格式为 `HH:mm` |
 
@@ -108,6 +109,7 @@ npm install koishi-plugin-echo-cave
 - 如果重排前备份写入失败，命令会直接终止，不会开始改写数据库
 - 若开启 `enableAutoReindex`，插件会在 `autoReindexTime` 指定的每日时间自动执行同样的 public ID 重排，并输出日志
 - 如果需要恢复，可执行 `cave.admin.restore-reindex <备份路径>` 读取对应的 JSON 备份并回写数据库
+- 若 `mediaStorage='s3'` 且上传失败，可通过 `s3UploadFailureFallbackMode` 指定回退到本地存储，或直接保留原始媒体链接
 
 ## 🤝 贡献指南
 

package/lib/config/config.d.ts

@@ -2,6 +2,7 @@ import { Schema } from 'koishi';
 export type SendFailureHandlingMode = 'auto-delete' | 'daily-report' | 'ignore';
 export type OversizedMediaCleanupMode = 'delete-cave' | 'keep-cave';
 export type ForwardSpecialUserHandlingMode = 'ignore' | 'reject' | 'confirm';
+export type S3UploadFailureFallbackMode = 'local' | 'original-link';
 export interface Config {
     adminMessageProtection?: boolean;
     adminIds?: string[];
@@ -22,6 +23,7 @@ export interface Config {
     forwardSpecialUserHandlingMode?: ForwardSpecialUserHandlingMode;
     alpha?: number;
     mediaStorage?: 'local' | 's3';
+    s3UploadFailureFallbackMode?: S3UploadFailureFallbackMode;
     s3Bucket?: string;
     s3Region?: string;
     s3Endpoint?: string;

package/lib/core/cave-store.d.ts

@@ -1,7 +1,15 @@
 import { Context } from 'koishi';
 import { EchoCave } from '../index';
 export declare const ACTIVE_CAVE_TABLE: "echo_cave_v3";
-export interface CaveSnapshotRecord {
+export interface CaveMediaUrlFields {
+    fileUrls: string[];
+    imageUrls: string[];
+    recordUrls: string[];
+    videoUrls: string[];
+}
+export declare function createEmptyCaveMediaUrlFields(): CaveMediaUrlFields;
+export declare function normalizeCaveMediaUrlFields(cave?: Partial<CaveMediaUrlFields> | null): CaveMediaUrlFields;
+export interface CaveSnapshotRecord extends CaveMediaUrlFields {
     id: number;
     channelId: string;
     createTime: Date;

package/lib/core/command/admin.d.ts

@@ -5,6 +5,7 @@ export declare function mergeCavesBetweenChannels(ctx: Context, session: Session
 export declare function migrateLegacyLocalMedia(ctx: Context, session: Session, cfg: Config): Promise<string>;
 export declare function migrateMediaToS3(ctx: Context, session: Session, cfg: Config, keepLocalOption?: string): Promise<string>;
 export declare function inspectMediaRefsForMigration(ctx: Context, session: Session, cfg: Config, idRangesOption?: string): Promise<string>;
+export declare function backfillCaveMediaUrls(ctx: Context, session: Session, cfg: Config, idRangesOption?: string): Promise<string>;
 export declare function reindexCaveIds(ctx: Context, session: Session, cfg: Config): Promise<string>;
 export declare function restoreReindexBackup(ctx: Context, session: Session, cfg: Config, backupPathInput?: string): Promise<string>;
 export declare function registerAutoReindexScheduler(ctx: Context, cfg: Config): void;

package/lib/index.cjs

@@ -33460,7 +33460,30 @@ module.exports = __toCommonJS(index_exports);
 
 // src/core/cave-store.ts
 var ACTIVE_CAVE_TABLE = "echo_cave_v3";
+function createEmptyCaveMediaUrlFields() {
+  return {
+    fileUrls: [],
+    imageUrls: [],
+    recordUrls: [],
+    videoUrls: []
+  };
+}
+function normalizeStringList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+}
+function normalizeCaveMediaUrlFields(cave) {
+  return {
+    fileUrls: normalizeStringList(cave?.fileUrls),
+    imageUrls: normalizeStringList(cave?.imageUrls),
+    recordUrls: normalizeStringList(cave?.recordUrls),
+    videoUrls: normalizeStringList(cave?.videoUrls)
+  };
+}
 function toCaveSnapshotRecord(cave) {
+  const mediaUrlFields = normalizeCaveMediaUrlFields(cave);
   return {
     id: cave.id,
     channelId: cave.channelId,
@@ -33471,7 +33494,8 @@ function toCaveSnapshotRecord(cave) {
     content: cave.content,
     relatedUsers: [...cave.relatedUsers],
     drawCount: cave.drawCount,
-    picDrawCount: cave.picDrawCount ?? 0
+    picDrawCount: cave.picDrawCount ?? 0,
+    ...mediaUrlFields
   };
 }
 function toCaveBackupRecord(cave) {
@@ -33501,6 +33525,7 @@ async function removeCaveByEntryId(ctx, entryId) {
   await ctx.database.remove(ACTIVE_CAVE_TABLE, entryId);
 }
 async function createCaveRecord(ctx, cave) {
+  const mediaUrlFields = normalizeCaveMediaUrlFields(cave);
   return await ctx.database.create(ACTIVE_CAVE_TABLE, {
     id: cave.id,
     channelId: cave.channelId,
@@ -33511,7 +33536,8 @@ async function createCaveRecord(ctx, cave) {
     content: cave.content,
     relatedUsers: [...cave.relatedUsers],
     drawCount: cave.drawCount,
-    picDrawCount: cave.picDrawCount ?? 0
+    picDrawCount: cave.picDrawCount ?? 0,
+    ...mediaUrlFields
   });
 }
 async function updateCaveByEntryId(ctx, entryId, data2) {
@@ -33557,6 +33583,7 @@ async function checkUsersInGroup(ctx, session, userIds) {
 var import_axios = __toESM(require("axios"), 1);
 var import_client_s3 = __toESM(require_dist_cjs71(), 1);
 var import_s3_request_presigner = __toESM(require_dist_cjs73(), 1);
+var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
@@ -33611,9 +33638,108 @@ function createEmptyStats() {
     mediaFailed: 0
   };
 }
+function getMediaUrlFieldName(type) {
+  switch (type) {
+    case "image":
+      return "imageUrls";
+    case "video":
+      return "videoUrls";
+    case "record":
+      return "recordUrls";
+    default:
+      return "fileUrls";
+  }
+}
+function hasMediaUrlFieldChanges(current, next) {
+  const normalizedCurrent = normalizeCaveMediaUrlFields(current);
+  return JSON.stringify(normalizedCurrent.fileUrls) !== JSON.stringify(next.fileUrls) || JSON.stringify(normalizedCurrent.imageUrls) !== JSON.stringify(next.imageUrls) || JSON.stringify(normalizedCurrent.recordUrls) !== JSON.stringify(next.recordUrls) || JSON.stringify(normalizedCurrent.videoUrls) !== JSON.stringify(next.videoUrls);
+}
+function createUniqueStringList(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function normalizeSourceIdentity(fileRef) {
+  if (fileRef.startsWith("file:///")) {
+    return normalizePathForComparison(fromFileUri(fileRef));
+  }
+  if (import_node_path.default.isAbsolute(fileRef) || /^[A-Za-z]:[\\/]/.test(fileRef)) {
+    return normalizePathForComparison(fileRef);
+  }
+  if (fileRef.startsWith("s3://")) {
+    return fileRef.toLowerCase();
+  }
+  return fileRef;
+}
+function getFileNameFromRef(fileRef, type) {
+  if (fileRef.startsWith("file:///")) {
+    return import_node_path.default.basename(fromFileUri(fileRef));
+  }
+  if (import_node_path.default.isAbsolute(fileRef) || /^[A-Za-z]:[\\/]/.test(fileRef)) {
+    return import_node_path.default.basename(fileRef);
+  }
+  if (fileRef.startsWith("s3://")) {
+    const location = parseS3Uri(fileRef);
+    if (location) {
+      return import_node_path.default.basename(location.key);
+    }
+  }
+  if (/^https?:\/\//i.test(fileRef)) {
+    try {
+      return import_node_path.default.basename(new URL(fileRef).pathname) || `media.${getDefaultExtension(type)}`;
+    } catch (error2) {
+      return `media.${getDefaultExtension(type)}`;
+    }
+  }
+  return `media.${getDefaultExtension(type)}`;
+}
+function buildStableTransferFileName(fileRef, type) {
+  const sourceName = getFileNameFromRef(fileRef, type);
+  const parsedName = import_node_path.default.parse(sourceName);
+  const baseName = parsedName.name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "media";
+  const extension = parsedName.ext.replace(/^\./, "") || getDefaultExtension(type);
+  const hash = (0, import_node_crypto.createHash)("sha1").update(normalizeSourceIdentity(fileRef)).digest("hex").slice(0, 12);
+  return `${baseName}-${hash}.${extension}`;
+}
+async function removeFileIfExists(filePath) {
+  try {
+    await import_node_fs.promises.unlink(filePath);
+  } catch (error2) {
+    const fileError = error2;
+    if (fileError.code !== "ENOENT") {
+      throw error2;
+    }
+  }
+}
+async function writeTransferredLocalMedia(ctx, fileRef, channelId, type, buffer) {
+  const targetDir = getLocalMediaV2Dir(ctx, channelId, type);
+  await import_node_fs.promises.mkdir(targetDir, { recursive: true });
+  const targetPath = import_node_path.default.join(targetDir, buildStableTransferFileName(fileRef, type));
+  await removeFileIfExists(targetPath);
+  await import_node_fs.promises.writeFile(targetPath, buffer);
+  return targetPath;
+}
+async function uploadTransferredMediaToS3(cfg, fileRef, channelId, type, buffer, contentType) {
+  const client = getS3Client(cfg);
+  const bucket = cfg.s3Bucket;
+  if (!bucket) {
+    throw new Error("S3 bucket is not configured.");
+  }
+  const key = buildS3Key(cfg, channelId, type, buildStableTransferFileName(fileRef, type));
+  await client.send(
+    new import_client_s3.PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: buffer,
+      ContentType: contentType
+    })
+  );
+  return { bucket, key };
+}
 function getStorageMode(cfg) {
   return cfg.mediaStorage === "s3" ? "s3" : "local";
 }
+function getS3UploadFailureFallbackMode(cfg) {
+  return cfg.s3UploadFailureFallbackMode === "original-link" ? "original-link" : "local";
+}
 function hasS3Config(cfg) {
   return Boolean(cfg.s3Bucket && cfg.s3Region);
 }
@@ -33987,12 +34113,13 @@ async function createPresignedGetUrl(cfg, location) {
 }
 async function transferLocalFileToChannel(ctx, sourcePath, type, targetChannelId, mode) {
   const targetDir = getLocalMediaV2Dir(ctx, targetChannelId, type);
-  if (isPathInsideDir(sourcePath, targetDir)) {
+  await import_node_fs.promises.mkdir(targetDir, { recursive: true });
+  const sourceRef = toFileUri(sourcePath);
+  const targetPath = import_node_path.default.join(targetDir, buildStableTransferFileName(sourceRef, type));
+  if (normalizePathForComparison(sourcePath) === normalizePathForComparison(targetPath)) {
     return toFileUri(sourcePath);
   }
-  await import_node_fs.promises.mkdir(targetDir, { recursive: true });
-  const extension = import_node_path.default.extname(sourcePath).slice(1) || getDefaultExtension(type);
-  const targetPath = import_node_path.default.join(targetDir, `${(0, import_uuid2.v4)().replace(/-/g, "")}.${extension}`);
+  await removeFileIfExists(targetPath);
   await import_node_fs.promises.copyFile(sourcePath, targetPath);
   return toFileUri(targetPath);
 }
@@ -34001,8 +34128,12 @@ async function transferS3ObjectToChannel(cfg, source, type, targetChannelId, mod
   if (!bucket) {
     throw new Error("S3 bucket is not configured.");
   }
-  const extension = import_node_path.default.extname(source.key).slice(1) || getDefaultExtension(type);
-  const key = buildS3Key(cfg, targetChannelId, type, `${(0, import_uuid2.v4)().replace(/-/g, "")}.${extension}`);
+  const key = buildS3Key(
+    cfg,
+    targetChannelId,
+    type,
+    buildStableTransferFileName(toS3Uri(source), type)
+  );
   const target = { bucket, key };
   if (source.bucket === target.bucket && source.key === target.key) {
     return toS3Uri(source);
@@ -34051,19 +34182,19 @@ async function transferMediaRefToChannel(ctx, fileRef, type, targetChannelId, ta
   if (targetMode === "local") {
     if (isFileUri(fileRef)) {
       const localSourcePath = fromFileUri(fileRef);
-      const nextRef2 = await transferLocalFileToChannel(
+      const nextRef = await transferLocalFileToChannel(
         ctx,
         localSourcePath,
         type,
         targetChannelId,
         transferMode
       );
-      const plan3 = {
-        nextRef: nextRef2,
-        rollback: createDeleteLocalFilePlan(fromFileUri(nextRef2)).rollback
+      const plan2 = {
+        nextRef,
+        rollback: createDeleteLocalFilePlan(fromFileUri(nextRef)).rollback
       };
       if (transferMode === "move") {
-        plan3.commit = async () => {
+        plan2.commit = async () => {
           try {
             await import_node_fs.promises.unlink(localSourcePath);
             base64Cache.delete(localSourcePath);
@@ -34076,20 +34207,25 @@ async function transferMediaRefToChannel(ctx, fileRef, type, targetChannelId, ta
       } else {
         stats.mediaCopied += 1;
       }
-      state2.transferPlans.set(cacheKey, plan3);
-      return plan3;
+      state2.transferPlans.set(cacheKey, plan2);
+      return plan2;
     }
-    const loaded2 = await loadMediaBuffer(ctx, fileRef, cfg);
-    const extension2 = import_node_path.default.extname(loaded2.sourceKey).slice(1) || getDefaultExtension(type);
-    const targetPath = await writeLocalMedia(ctx, targetChannelId, type, loaded2.buffer, extension2);
-    const plan2 = {
+    const loaded = await loadMediaBuffer(ctx, fileRef, cfg);
+    const targetPath = await writeTransferredLocalMedia(
+      ctx,
+      fileRef,
+      targetChannelId,
+      type,
+      loaded.buffer
+    );
+    const plan = {
       nextRef: toFileUri(targetPath),
       rollback: createDeleteLocalFilePlan(targetPath).rollback
     };
     if (transferMode === "move" && isS3Uri(fileRef)) {
       const source = parseS3Uri(fileRef);
       if (source) {
-        plan2.commit = async () => {
+        plan.commit = async () => {
           try {
             await deleteS3Object(cfg, source);
           } catch (error2) {
@@ -34102,88 +34238,113 @@ async function transferMediaRefToChannel(ctx, fileRef, type, targetChannelId, ta
     } else {
       stats.mediaCopied += 1;
     }
-    state2.transferPlans.set(cacheKey, plan2);
-    return plan2;
+    state2.transferPlans.set(cacheKey, plan);
+    return plan;
   }
-  if (isS3Uri(fileRef)) {
-    const source = parseS3Uri(fileRef);
-    if (!source) {
-      throw new Error(`Invalid S3 uri: ${fileRef}`);
+  try {
+    if (isS3Uri(fileRef)) {
+      const source = parseS3Uri(fileRef);
+      if (!source) {
+        throw new Error(`Invalid S3 uri: ${fileRef}`);
+      }
+      const nextRef2 = await transferS3ObjectToChannel(
+        cfg,
+        source,
+        type,
+        targetChannelId,
+        transferMode
+      );
+      const targetLocation2 = parseS3Uri(nextRef2);
+      const plan2 = {
+        nextRef: nextRef2,
+        rollback: targetLocation2 ? async () => {
+          try {
+            await deleteS3Object(cfg, targetLocation2);
+          } catch (error2) {
+            return;
+          }
+        } : void 0
+      };
+      if (transferMode === "move") {
+        plan2.commit = async () => {
+          try {
+            await deleteS3Object(cfg, source);
+          } catch (error2) {
+            return;
+          }
+        };
+        stats.mediaMoved += 1;
+        stats.mediaDeleted += 1;
+      } else {
+        stats.mediaCopied += 1;
+      }
+      state2.transferPlans.set(cacheKey, plan2);
+      return plan2;
     }
-    const nextRef2 = await transferS3ObjectToChannel(
+    const loaded = await loadMediaBuffer(ctx, fileRef, cfg);
+    const location = await uploadTransferredMediaToS3(
       cfg,
-      source,
-      type,
+      fileRef,
       targetChannelId,
-      transferMode
+      type,
+      loaded.buffer,
+      loaded.contentType
     );
-    const targetLocation2 = parseS3Uri(nextRef2);
-    const plan2 = {
-      nextRef: nextRef2,
-      rollback: targetLocation2 ? async () => {
+    const nextRef = toS3Uri(location);
+    const targetLocation = parseS3Uri(nextRef);
+    const plan = {
+      nextRef,
+      rollback: targetLocation ? async () => {
         try {
-          await deleteS3Object(cfg, targetLocation2);
+          await deleteS3Object(cfg, targetLocation);
         } catch (error2) {
           return;
         }
       } : void 0
     };
-    if (transferMode === "move") {
-      plan2.commit = async () => {
+    if (transferMode === "move" && isFileUri(fileRef)) {
+      const currentPath = fromFileUri(fileRef);
+      plan.commit = async () => {
         try {
-          await deleteS3Object(cfg, source);
+          await import_node_fs.promises.unlink(currentPath);
+          base64Cache.delete(currentPath);
+          base64Cache.delete(fileRef);
         } catch (error2) {
           return;
         }
       };
-      stats.mediaMoved += 1;
       stats.mediaDeleted += 1;
-    } else {
-      stats.mediaCopied += 1;
+      stats.mediaMoved += 1;
     }
-    state2.transferPlans.set(cacheKey, plan2);
-    return plan2;
-  }
-  const loaded = await loadMediaBuffer(ctx, fileRef, cfg);
-  const extension = import_node_path.default.extname(loaded.sourceKey).slice(1) || getDefaultExtension(type);
-  const location = await uploadBufferToS3(
-    cfg,
-    targetChannelId,
-    type,
-    loaded.buffer,
-    extension,
-    loaded.contentType
-  );
-  const nextRef = toS3Uri(location);
-  const targetLocation = parseS3Uri(nextRef);
-  const plan = {
-    nextRef,
-    rollback: targetLocation ? async () => {
-      try {
-        await deleteS3Object(cfg, targetLocation);
-      } catch (error2) {
-        return;
-      }
-    } : void 0
-  };
-  if (transferMode === "move" && isFileUri(fileRef)) {
-    const currentPath = fromFileUri(fileRef);
-    plan.commit = async () => {
-      try {
-        await import_node_fs.promises.unlink(currentPath);
-        base64Cache.delete(currentPath);
-        base64Cache.delete(fileRef);
-      } catch (error2) {
-        return;
-      }
-    };
-    stats.mediaDeleted += 1;
-    stats.mediaMoved += 1;
+    state2.transferPlans.set(cacheKey, plan);
+    stats.mediaUploaded += 1;
+    await hooks?.onS3Upload?.(type, nextRef);
+    return plan;
+  } catch (error2) {
+    const fallbackMode = getS3UploadFailureFallbackMode(cfg);
+    ctx.logger.warn(
+      `Failed to store media in S3 for ${fileRef}, fallback mode=${fallbackMode}: ${error2}`
+    );
+    if (fallbackMode === "original-link") {
+      const plan = { nextRef: fileRef };
+      state2.transferPlans.set(cacheKey, plan);
+      return plan;
+    }
+    const fallbackPlan = await transferMediaRefToChannel(
+      ctx,
+      fileRef,
+      type,
+      targetChannelId,
+      "local",
+      transferMode,
+      cfg,
+      state2,
+      stats,
+      hooks
+    );
+    state2.transferPlans.set(cacheKey, fallbackPlan);
+    return fallbackPlan;
   }
-  state2.transferPlans.set(cacheKey, plan);
-  stats.mediaUploaded += 1;
-  await hooks?.onS3Upload?.(type, nextRef);
-  return plan;
 }
 async function mutateMessageContent(ctx, content, handler) {
   const parsed = JSON.parse(content);
@@ -34234,15 +34395,15 @@ async function processStoredMessageMedia(ctx, content, cfg, channelId, progressO
   });
   return rewritten.content;
 }
-async function collectMessageMediaRefs(ctx, content) {
+async function collectStoredMessageMediaUrls(ctx, content) {
   const parsed = JSON.parse(content);
   const elements = Array.isArray(parsed) ? parsed : [parsed];
-  const refs = [];
+  const refs = createEmptyCaveMediaUrlFields();
   const visitElement = async (element) => {
     if (isMediaType(element.type)) {
       const fileRef = getElementFileRef(ctx, element, element.type);
       if (fileRef) {
-        refs.push(fileRef);
+        refs[getMediaUrlFieldName(element.type)].push(fileRef);
       }
     }
     const contentValue = element.data?.content;
@@ -34255,7 +34416,16 @@ async function collectMessageMediaRefs(ctx, content) {
   for (const element of elements) {
     await visitElement(element);
   }
-  return refs;
+  return {
+    fileUrls: createUniqueStringList(refs.fileUrls),
+    imageUrls: createUniqueStringList(refs.imageUrls),
+    recordUrls: createUniqueStringList(refs.recordUrls),
+    videoUrls: createUniqueStringList(refs.videoUrls)
+  };
+}
+async function collectMessageMediaRefs(ctx, content) {
+  const refs = await collectStoredMessageMediaUrls(ctx, content);
+  return [...refs.fileUrls, ...refs.imageUrls, ...refs.recordUrls, ...refs.videoUrls];
 }
 async function collectCavesReferencingFiles(ctx, targetPaths) {
   const targetSet = new Set(targetPaths.map((filePath) => normalizePathForComparison(filePath)));
@@ -34449,15 +34619,28 @@ async function saveMedia(ctx, mediaElement, type, cfg, channelId, progressOption
       return mediaUrl;
     }
     if (getStorageMode(cfg) === "s3") {
-      const location = await uploadBufferToS3(
-        cfg,
-        channelId,
-        type,
-        buffer,
-        extension,
-        contentType || getMimeTypeByExtension(`.${extension}`, type)
-      );
-      return toS3Uri(location);
+      try {
+        const location = await uploadBufferToS3(
+          cfg,
+          channelId,
+          type,
+          buffer,
+          extension,
+          contentType || getMimeTypeByExtension(`.${extension}`, type)
+        );
+        return toS3Uri(location);
+      } catch (error2) {
+        const fallbackMode = getS3UploadFailureFallbackMode(cfg);
+        ctx.logger.warn(
+          `Failed to upload ${type} to S3 for ${mediaUrl}, fallback mode=${fallbackMode}: ${error2}`
+        );
+        if (fallbackMode === "original-link") {
+          return mediaUrl;
+        }
+        const savedPath2 = await writeLocalMedia(ctx, channelId, type, buffer, extension);
+        await debouncedCleanup(ctx, cfg, type, channelId);
+        return savedPath2;
+      }
     }
     const savedPath = await writeLocalMedia(ctx, channelId, type, buffer, extension);
     await debouncedCleanup(ctx, cfg, type, channelId);
@@ -34707,11 +34890,16 @@ async function migrateLocalMediaToV2(ctx, cfg) {
         stats,
         (fileRef, type) => isLegacyLocalMediaRef(ctx, fileRef, type)
       );
-      if (rewritten.content !== cave.content) {
+      const mediaUrlFields = await collectStoredMessageMediaUrls(ctx, rewritten.content);
+      const shouldUpdateMediaFields = hasMediaUrlFieldChanges(cave, mediaUrlFields);
+      if (rewritten.content !== cave.content || shouldUpdateMediaFields) {
         if (typeof cave.entryId !== "number") {
           throw new Error(`missing_entry_id_for_cave_${cave.id}`);
         }
-        await updateCaveByEntryId(ctx, cave.entryId, { content: rewritten.content });
+        await updateCaveByEntryId(ctx, cave.entryId, {
+          content: rewritten.content,
+          ...mediaUrlFields
+        });
         await runTransferPlans(rewritten.plans, "commit");
       }
     } catch (error2) {
@@ -34751,11 +34939,16 @@ async function migrateLocalMediaToS3(ctx, cfg, keepLocal, createHooks) {
         (fileRef, type) => isFileUri(fileRef) || isLegacyLocalMediaRef(ctx, fileRef, type),
         hooks
       );
-      if (rewritten.content !== cave.content) {
+      const mediaUrlFields = await collectStoredMessageMediaUrls(ctx, rewritten.content);
+      const shouldUpdateMediaFields = hasMediaUrlFieldChanges(cave, mediaUrlFields);
+      if (rewritten.content !== cave.content || shouldUpdateMediaFields) {
         if (typeof cave.entryId !== "number") {
           throw new Error(`missing_entry_id_for_cave_${cave.id}`);
         }
-        await updateCaveByEntryId(ctx, cave.entryId, { content: rewritten.content });
+        await updateCaveByEntryId(ctx, cave.entryId, {
+          content: rewritten.content,
+          ...mediaUrlFields
+        });
         await runTransferPlans(rewritten.plans, "commit");
         await hooks?.onMigrationCommitted?.();
       }
@@ -34798,6 +34991,7 @@ async function mergeChannelCaves(ctx, cfg, sourceChannelId, targetChannelId, kee
       );
       if (keepSource) {
         const nextId = await getNextCavePublicId(ctx);
+        const mediaUrlFields = await collectStoredMessageMediaUrls(ctx, rewritten.content);
         await createCaveRecord(ctx, {
           id: nextId,
           channelId: targetChannelId,
@@ -34808,15 +35002,18 @@ async function mergeChannelCaves(ctx, cfg, sourceChannelId, targetChannelId, kee
           content: rewritten.content,
           relatedUsers: cave.relatedUsers,
           drawCount: cave.drawCount,
-          picDrawCount: cave.picDrawCount ?? 0
+          picDrawCount: cave.picDrawCount ?? 0,
+          ...mediaUrlFields
         });
       } else {
         if (typeof cave.entryId !== "number") {
           throw new Error(`missing_entry_id_for_cave_${cave.id}`);
         }
+        const mediaUrlFields = await collectStoredMessageMediaUrls(ctx, rewritten.content);
         await updateCaveByEntryId(ctx, cave.entryId, {
           channelId: targetChannelId,
-          content: rewritten.content
+          content: rewritten.content,
+          ...mediaUrlFields
         });
       }
       await runTransferPlans(rewritten.plans, "commit");
@@ -34920,12 +35117,21 @@ var import_node_fs2 = require("node:fs");
 var import_node_path2 = __toESM(require("node:path"), 1);
 var REINDEX_SPECIAL_OFFSET = 1e6;
 var caveMaintenanceLock = false;
+function hasStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function areMediaUrlFieldsEmpty(fields) {
+  const normalized = normalizeCaveMediaUrlFields(fields);
+  return normalized.fileUrls.length === 0 && normalized.imageUrls.length === 0 && normalized.recordUrls.length === 0 && normalized.videoUrls.length === 0;
+}
 function cloneCaveRecord(cave, id) {
+  const mediaUrlFields = normalizeCaveMediaUrlFields(cave);
   return {
     ...cave,
     createTime: new Date(cave.createTime),
     id,
-    relatedUsers: [...cave.relatedUsers]
+    relatedUsers: [...cave.relatedUsers],
+    ...mediaUrlFields
   };
 }
 async function removeCavesByEntryIds(ctx, entryIds) {
@@ -34964,6 +35170,7 @@ function buildSequentialCaveSnapshot(caves) {
   return [...caves].sort((a5, b5) => a5.id - b5.id).map((cave, index) => cloneCaveRecord(cave, index + 1));
 }
 function normalizeCaveRecord(cave) {
+  const mediaUrlFields = normalizeCaveMediaUrlFields(cave);
   return {
     channelId: cave.channelId,
     content: cave.content,
@@ -34974,7 +35181,8 @@ function normalizeCaveRecord(cave) {
     originUserId: cave.originUserId,
     relatedUsers: [...cave.relatedUsers],
     type: cave.type,
-    userId: cave.userId
+    userId: cave.userId,
+    ...mediaUrlFields
   };
 }
 function normalizeBackupRecord(cave) {
@@ -34990,7 +35198,7 @@ function isEchoCaveRecord(value) {
   if (!isRecordObject(value)) {
     return false;
   }
-  return typeof value.id === "number" && typeof value.channelId === "string" && (value.createTime instanceof Date || typeof value.createTime === "string" || typeof value.createTime === "number") && typeof value.userId === "string" && typeof value.originUserId === "string" && (value.type === "forward" || value.type === "msg") && typeof value.content === "string" && Array.isArray(value.relatedUsers) && value.relatedUsers.every((user) => typeof user === "string") && typeof value.drawCount === "number" && (typeof value.picDrawCount === "number" || typeof value.picDrawCount === "undefined");
+  return typeof value.id === "number" && typeof value.channelId === "string" && (value.createTime instanceof Date || typeof value.createTime === "string" || typeof value.createTime === "number") && typeof value.userId === "string" && typeof value.originUserId === "string" && (value.type === "forward" || value.type === "msg") && typeof value.content === "string" && Array.isArray(value.relatedUsers) && value.relatedUsers.every((user) => typeof user === "string") && typeof value.drawCount === "number" && (typeof value.picDrawCount === "number" || typeof value.picDrawCount === "undefined") && (typeof value.fileUrls === "undefined" || hasStringArray(value.fileUrls)) && (typeof value.imageUrls === "undefined" || hasStringArray(value.imageUrls)) && (typeof value.recordUrls === "undefined" || hasStringArray(value.recordUrls)) && (typeof value.videoUrls === "undefined" || hasStringArray(value.videoUrls));
 }
 function isCaveBackupRecord(value) {
   if (!isEchoCaveRecord(value)) {
@@ -35342,6 +35550,69 @@ async function inspectMediaRefsForMigration(ctx, session, cfg, idRangesOption) {
     );
   }
 }
+async function backfillCaveMediaUrls(ctx, session, cfg, idRangesOption) {
+  const accessError = ensureAdminPrivateAccess(session, cfg);
+  if (accessError) {
+    return accessError;
+  }
+  const idRanges = parseIdRanges(idRangesOption);
+  if (idRanges === null) {
+    return session.text("commands.cave.admin.backfill-media-urls.messages.invalidRange");
+  }
+  const displayRanges = idRangesOption?.trim() || getAllRangesLabel(session);
+  const caves = await getAllCaves(ctx);
+  const candidates = caves.filter(
+    (cave) => isIdInRanges(cave.id, idRanges) && areMediaUrlFieldsEmpty(cave)
+  );
+  if (candidates.length === 0) {
+    return session.text("commands.cave.admin.backfill-media-urls.messages.noCandidates", {
+      idRanges: displayRanges
+    });
+  }
+  const confirmed = await requestSecondConfirmation(
+    ctx,
+    session,
+    session.text("commands.cave.admin.backfill-media-urls.messages.confirmSummary", {
+      idRanges: displayRanges,
+      candidateCount: candidates.length
+    }),
+    session.text("commands.cave.admin.backfill-media-urls.messages.confirmRetry"),
+    session.text("commands.cave.admin.backfill-media-urls.messages.confirmTimeout"),
+    session.text("commands.cave.admin.backfill-media-urls.messages.confirmCancelled")
+  );
+  if (!confirmed) {
+    return;
+  }
+  let updatedCount = 0;
+  let skippedWithoutMedia = 0;
+  const failedRecordIds = [];
+  for (const cave of candidates) {
+    try {
+      if (typeof cave.entryId !== "number") {
+        throw new Error(`missing_entry_id_for_cave_${cave.id}`);
+      }
+      const mediaUrlFields = await collectStoredMessageMediaUrls(ctx, cave.content);
+      if (areMediaUrlFieldsEmpty(mediaUrlFields)) {
+        skippedWithoutMedia += 1;
+        continue;
+      }
+      await updateCaveByEntryId(ctx, cave.entryId, mediaUrlFields);
+      updatedCount += 1;
+    } catch (error2) {
+      failedRecordIds.push(cave.id);
+      ctx.logger.warn(`Failed to backfill media URLs for cave #${cave.id}: ${error2}`);
+    }
+  }
+  return appendFailedRecordSummary(
+    session,
+    session.text("commands.cave.admin.backfill-media-urls.messages.backfillDone", {
+      scannedRecords: candidates.length,
+      updatedCount,
+      skippedWithoutMedia
+    }),
+    failedRecordIds
+  );
+}
 function buildReindexPlan(caves) {
   const maxId = caves.reduce((currentMax, cave) => Math.max(currentMax, cave.id), 0);
   const offset = maxId + caves.length + REINDEX_SPECIAL_OFFSET;
@@ -35741,6 +36012,7 @@ async function addCave(ctx, session, cfg, userIds) {
     finalParsedUserIds,
     originName
   );
+  const mediaUrlFields = await collectStoredMessageMediaUrls(ctx, content);
   try {
     const nextId = await getNextCavePublicId(ctx);
     const result = await ctx.database.create(ACTIVE_CAVE_TABLE, {
@@ -35752,7 +36024,9 @@ async function addCave(ctx, session, cfg, userIds) {
       type,
       content,
       relatedUsers: finalParsedUserIds,
-      picDrawCount: 0
+      drawCount: 0,
+      picDrawCount: 0,
+      ...mediaUrlFields
     });
     return session.text(".msgSaved", { id: result.id, relatedUsers: relatedUsersFormatted });
   } catch (error2) {
@@ -37036,6 +37310,18 @@ var zh_CN_default = {
         confirmTimeout: "\u231B \u4E8C\u6B21\u786E\u8BA4\u8D85\u65F6\uFF0C\u68C0\u6D4B\u672A\u6267\u884C\u3002"
       }
     },
+    "cave.admin.backfill-media-urls": {
+      description: "\u4E3A\u5386\u53F2\u56DE\u58F0\u6D1E\u56DE\u586B\u5A92\u4F53 URL \u5217",
+      messages: {
+        invalidRange: "\u274C \u8303\u56F4\u53C2\u6570\u683C\u5F0F\u65E0\u6548\u3002\u8BF7\u4F7F\u7528 0-100,105-240 \u6216 12,18-20 \u8FD9\u6837\u7684\u683C\u5F0F\u3002",
+        noCandidates: "\u{1F50D} \u5728\u8303\u56F4 {idRanges} \u5185\u672A\u627E\u5230\u56DB\u5217\u5A92\u4F53 URL \u90FD\u4E3A\u7A7A\u7684\u8BB0\u5F55\u3002",
+        confirmSummary: "\u26A0\uFE0F \u5373\u5C06\u4E3A\u5386\u53F2\u56DE\u58F0\u6D1E\u56DE\u586B\u5A92\u4F53 URL \u5217\n\u68C0\u6D4B\u8303\u56F4\uFF1A{idRanges}\n\u5019\u9009\u8BB0\u5F55\u6570\uFF1A{candidateCount}\n\n\u672C\u6B21\u64CD\u4F5C\u53EA\u4F1A\u5904\u7406 fileUrls\u3001imageUrls\u3001recordUrls\u3001videoUrls \u56DB\u5217\u90FD\u4E3A\u7A7A\u7684\u8BB0\u5F55\uFF0C\u5E76\u4ECE\u5B58\u50A8\u6D88\u606F\u5185\u5BB9\u4E2D\u63D0\u53D6\u5A92\u4F53\u5F15\u7528\u540E\u5199\u56DE\u6570\u636E\u5E93\u3002\u8BF7\u5728 30 \u79D2\u5185\u8F93\u5165\u201C\u786E\u8BA4\u201D\u7EE7\u7EED\uFF0C\u8F93\u5165\u201C\u53D6\u6D88\u201D\u53EF\u7EC8\u6B62\u3002",
+        confirmRetry: "\u26A0\uFE0F \u672A\u6536\u5230\u201C\u786E\u8BA4\u201D\u3002\u8BF7\u5728\u5269\u4F59\u65F6\u95F4\u5185\u8F93\u5165\u201C\u786E\u8BA4\u201D\u7EE7\u7EED\uFF0C\u6216\u8F93\u5165\u201C\u53D6\u6D88\u201D\u7EC8\u6B62\u3002",
+        confirmCancelled: "\u{1F6D1} \u5DF2\u53D6\u6D88\u672C\u6B21\u5A92\u4F53 URL \u56DE\u586B\u3002",
+        confirmTimeout: "\u231B \u4E8C\u6B21\u786E\u8BA4\u8D85\u65F6\uFF0C\u5A92\u4F53 URL \u56DE\u586B\u672A\u6267\u884C\u3002",
+        backfillDone: "\u2705 \u5A92\u4F53 URL \u56DE\u586B\u5B8C\u6210\uFF1A\u626B\u63CF {scannedRecords} \u6761\u5019\u9009\u8BB0\u5F55\uFF0C\u6210\u529F\u66F4\u65B0 {updatedCount} \u6761\uFF0C\u65E0\u5A92\u4F53\u53EF\u56DE\u586B {skippedWithoutMedia} \u6761\u3002"
+      }
+    },
     "cave.admin.reindex": {
       description: "\u91CD\u6392\u6240\u6709\u56DE\u58F0\u6D1E public ID\uFF0C\u4F7F\u73B0\u6709\u8BB0\u5F55\u91CD\u65B0\u8FDE\u7EED\u7F16\u53F7\u800C\u4E0D\u6539\u52A8\u5185\u90E8\u4E3B\u952E",
       messages: {
@@ -37088,6 +37374,7 @@ var zh_CN_default2 = {
   forwardSpecialUserHandlingMode: "\u68C0\u6D4B\u5230\u7279\u6B8A\u7528\u6237 1094950020 \u65F6\u7684\u5904\u7406\u65B9\u5F0F\uFF1Aignore \u4E3A\u5FFD\u7565\uFF0Creject \u4E3A\u63D0\u9192\u5E76\u62D2\u7EDD\u5B58\u50A8\uFF0Cconfirm \u4E3A\u63D0\u9192\u3001\u5C55\u793A\u8F6C\u53D1\u5185\u5BB9\u5E76\u8981\u6C42\u786E\u8BA4\u540E\u518D\u5B58\u50A8",
   alpha: "\u52A0\u6743\u968F\u673A\u62BD\u53D6\u7684\u8C03\u6574\u56E0\u5B50\uFF0C\u63A7\u5236\u62BD\u53D6\u6B21\u6570\u5BF9\u6982\u7387\u7684\u5F71\u54CD\u7A0B\u5EA6\uFF0C\u503C\u8D8A\u5927\u5F71\u54CD\u8D8A\u660E\u663E",
   mediaStorage: "\u5A92\u4F53\u5B58\u50A8\u65B9\u5F0F\uFF1Alocal \u4E3A\u672C\u5730\uFF0Cs3 \u4E3A\u5BF9\u8C61\u5B58\u50A8",
+  s3UploadFailureFallbackMode: "\u4EC5\u5728\u5A92\u4F53\u5B58\u50A8\u65B9\u5F0F\u4E3A s3 \u65F6\u751F\u6548\uFF1AS3 \u4E0A\u4F20\u5931\u8D25\u540E\u56DE\u9000\u5230\u672C\u5730\u5B58\u50A8\uFF0C\u6216\u4FDD\u7559\u539F\u59CB\u94FE\u63A5",
   s3Bucket: "S3 \u5B58\u50A8\u6876\u540D\u79F0",
   s3Region: "S3 \u533A\u57DF",
   s3Endpoint: "S3 Endpoint\uFF0C\u53EF\u7528\u4E8E\u517C\u5BB9 S3 \u7684\u79C1\u6709\u670D\u52A1",
@@ -37133,6 +37420,7 @@ var Config = import_koishi2.Schema.intersect([
   }).description("\u5A92\u4F53\u5904\u7406"),
   import_koishi2.Schema.object({
     mediaStorage: import_koishi2.Schema.union(["local", "s3"]).default("local"),
+    s3UploadFailureFallbackMode: import_koishi2.Schema.union(["local", "original-link"]).default("local"),
     s3Bucket: import_koishi2.Schema.string().default(""),
     s3Region: import_koishi2.Schema.string().default(""),
     s3Endpoint: import_koishi2.Schema.string().default(""),
@@ -37161,6 +37449,7 @@ var Config = import_koishi2.Schema.intersect([
 var name = "echo-cave";
 var inject = ["database"];
 function toV3Record(record) {
+  const mediaUrlFields = createEmptyCaveMediaUrlFields();
   return {
     id: record.id,
     channelId: record.channelId,
@@ -37171,30 +37460,12 @@ function toV3Record(record) {
     content: record.content,
     relatedUsers: [...record.relatedUsers],
     drawCount: record.drawCount,
-    picDrawCount: record.picDrawCount ?? 0
+    picDrawCount: record.picDrawCount ?? 0,
+    ...mediaUrlFields
   };
 }
 function apply(ctx, cfg) {
   ctx.i18n.define("zh-CN", zh_CN_default);
-  ctx.model.extend(
-    "echo_cave",
-    {
-      id: "unsigned",
-      channelId: "string",
-      createTime: "timestamp",
-      userId: "string",
-      originUserId: "string",
-      type: "string",
-      content: "text",
-      relatedUsers: "list",
-      drawCount: { type: "unsigned", initial: 0 },
-      picDrawCount: { type: "unsigned", initial: 0 }
-    },
-    {
-      primary: "id",
-      autoInc: true
-    }
-  );
   ctx.model.extend(
     ACTIVE_CAVE_TABLE,
     {
@@ -37208,7 +37479,11 @@ function apply(ctx, cfg) {
       content: "text",
       relatedUsers: "list",
       drawCount: { type: "unsigned", initial: 0 },
-      picDrawCount: { type: "unsigned", initial: 0 }
+      picDrawCount: { type: "unsigned", initial: 0 },
+      fileUrls: { type: "list", initial: [] },
+      imageUrls: { type: "list", initial: [] },
+      recordUrls: { type: "list", initial: [] },
+      videoUrls: { type: "list", initial: [] }
     },
     {
       primary: "entryId",
@@ -37262,16 +37537,6 @@ function apply(ctx, cfg) {
       primary: "userId"
     }
   );
-  ctx.model.migrate(
-    "echo_cave",
-    {
-      id: "unsigned"
-    },
-    async (database) => {
-      const data2 = await database.get("echo_cave", {});
-      await database.upsert("echo_cave_v2", data2);
-    }
-  );
   ctx.model.migrate("echo_cave_v2", {}, async (database) => {
     const existing = await database.get(ACTIVE_CAVE_TABLE, {});
     if (existing.length > 0) {
@@ -37311,6 +37576,9 @@ function apply(ctx, cfg) {
   ctx.command("cave.admin.inspect-media [idRanges:text]").action(
     async ({ session }, idRanges) => await inspectMediaRefsForMigration(ctx, session, cfg, idRanges)
   );
+  ctx.command("cave.admin.backfill-media-urls [idRanges:text]").action(
+    async ({ session }, idRanges) => await backfillCaveMediaUrls(ctx, session, cfg, idRanges)
+  );
   ctx.command("cave.admin.reindex").action(async ({ session }) => await reindexCaveIds(ctx, session, cfg));
   ctx.command("cave.admin.restore-reindex <backupPath:text>").action(
     async ({ session }, backupPath) => await restoreReindexBackup(ctx, session, cfg, backupPath)

package/lib/index.d.ts

@@ -15,6 +15,10 @@ export interface EchoCave {
     relatedUsers: string[];
     drawCount: number;
     picDrawCount: number;
+    fileUrls: string[];
+    imageUrls: string[];
+    recordUrls: string[];
+    videoUrls: string[];
 }
 export interface EchoCaveSendFailure {
     id: number;

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

@@ -1,4 +1,5 @@
 import { Config } from '../../config/config';
+import { CaveMediaUrlFields } from '../../core/cave-store';
 import { Context, Session } from 'koishi';
 export type MediaType = 'image' | 'video' | 'file' | 'record';
 type MaybeMediaElement = {
@@ -22,6 +23,7 @@ interface CaveMediaRefs {
     refs: string[];
 }
 export declare function processStoredMessageMedia(ctx: Context, content: string, cfg: Config, channelId: string, progressOptions?: MediaSaveProgressOptions): Promise<string>;
+export declare function collectStoredMessageMediaUrls(ctx: Context, content: string): Promise<CaveMediaUrlFields>;
 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, progressOptions?: MediaSaveProgressOptions): Promise<string>;
 export declare function processMediaElement(ctx: Context, element: MaybeMediaElement, cfg: Config, channelId: string, progressOptions?: MediaSaveProgressOptions): Promise<MaybeMediaElement>;

package/package.json

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