koishi-plugin-echo-cave 1.29.9 → 1.29.10

package/README.md

@@ -24,6 +24,7 @@
 - 🧭 **转发绑定体验优化**：转发消息关联用户的详细输入指南仅在用户首次成功完成选择前显示，选择完成或超时后会尝试撤回提示消息
 - 🤖 **特殊转发用户处理**：可配置在检测到转发记录中包含特殊用户 `1094950020` 时直接拒绝存储，或要求二次确认后再存储
 - 🛠️ **回声洞 ID 重排**：提供管理员维护命令，可在写入备份后安全重排现有回声洞 ID
+- ♻️ **回声洞备份恢复**：提供管理员维护命令，可从 ID 重排生成的 JSON 备份自动恢复数据库
 - ⚖️ **加权随机抽取**：根据消息被抽取次数动态调整抽取概率，被抽取次数越多，概率越低。使用公式：
   ```
   权重 = 1 / (1 + drawCount * α)
@@ -47,6 +48,7 @@
 | `cave.bind <id> <...userIds>` | 将用户绑定到特定 ID 的回声洞 | 所有人             |
 | `cave.rank [period]`          | 查看回声洞排行榜，支持多种时间段 | 所有人             |
 | `cave.admin.reindex`          | 安全重排所有现有回声洞 ID，并先写入备份 | 管理员（私聊） |
+| `cave.admin.restore-reindex <backupPath>` | 从重排生成的 JSON 备份恢复回声洞数据 | 管理员（私聊） |
 
 ## 🚀 使用指南
 
@@ -95,6 +97,7 @@ npm install koishi-plugin-echo-cave
 - 可通过配置项禁用转发消息用户选择、开启单用户自动绑定，或配置检测到特殊用户 `1094950020` 时的处理模式
 - `cave.admin.reindex` 会先在 `logs/` 下写入备份文件，再执行 ID 重排；建议仅在单实例维护时段执行
 - 如果重排前备份写入失败，命令会直接终止，不会开始改写数据库
+- 如果需要恢复，可执行 `cave.admin.restore-reindex <备份路径>` 读取对应的 JSON 备份并回写数据库
 
 ## 🤝 贡献指南
 

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

@@ -6,3 +6,4 @@ export declare function migrateLegacyLocalMedia(ctx: Context, session: Session,
 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 reindexCaveIds(ctx: Context, session: Session, cfg: Config): Promise<string>;
+export declare function restoreReindexBackup(ctx: Context, session: Session, cfg: Config, backupPathInput?: string): Promise<string>;

package/lib/index.cjs

@@ -34852,6 +34852,105 @@ 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 cloneCaveRecord(cave, id) {
+  return {
+    ...cave,
+    createTime: new Date(cave.createTime),
+    id,
+    relatedUsers: [...cave.relatedUsers]
+  };
+}
+function getCaveIdList(caves) {
+  return caves.map((cave) => cave.id);
+}
+async function removeCavesByIds(ctx, ids) {
+  for (const id of ids) {
+    await ctx.database.remove("echo_cave_v2", id);
+  }
+}
+async function upsertCaves(ctx, caves) {
+  if (caves.length === 0) {
+    return;
+  }
+  await ctx.database.upsert("echo_cave_v2", caves);
+}
+function buildTemporarySnapshot(currentCaves, nextCaves) {
+  const currentMaxId = currentCaves.reduce((currentMax, cave) => Math.max(currentMax, cave.id), 0);
+  const nextMaxId = nextCaves.reduce((currentMax, cave) => Math.max(currentMax, cave.id), 0);
+  const offset = Math.max(currentMaxId, nextMaxId) + currentCaves.length + nextCaves.length + REINDEX_SPECIAL_OFFSET;
+  return currentCaves.map((cave) => cloneCaveRecord(cave, cave.id + offset));
+}
+async function rollbackCaveReplacement(ctx, currentCaves, nextCaves, tempCaves) {
+  const idsToRemove = [.../* @__PURE__ */ new Set([...getCaveIdList(nextCaves), ...getCaveIdList(tempCaves)])];
+  await removeCavesByIds(ctx, idsToRemove);
+  await upsertCaves(ctx, currentCaves);
+}
+async function replaceCaveSnapshot(ctx, currentCaves, nextCaves) {
+  const tempCaves = buildTemporarySnapshot(currentCaves, nextCaves);
+  try {
+    await upsertCaves(ctx, tempCaves);
+    await removeCavesByIds(ctx, getCaveIdList(currentCaves));
+    await upsertCaves(ctx, nextCaves);
+    await removeCavesByIds(ctx, getCaveIdList(tempCaves));
+  } catch (error2) {
+    await rollbackCaveReplacement(ctx, currentCaves, nextCaves, tempCaves);
+    throw error2;
+  }
+}
+function buildSequentialCaveSnapshot(caves) {
+  return [...caves].sort((a5, b5) => a5.id - b5.id).map((cave, index) => cloneCaveRecord(cave, index + 1));
+}
+function normalizeCaveRecord(cave) {
+  return {
+    channelId: cave.channelId,
+    content: cave.content,
+    createTime: new Date(cave.createTime).toISOString(),
+    drawCount: cave.drawCount,
+    id: cave.id,
+    originUserId: cave.originUserId,
+    relatedUsers: [...cave.relatedUsers],
+    type: cave.type,
+    userId: cave.userId
+  };
+}
+function isRecordObject(value) {
+  return typeof value === "object" && value !== null;
+}
+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";
+}
+function isReindexPlanItem(value) {
+  if (!isRecordObject(value)) {
+    return false;
+  }
+  return typeof value.oldId === "number" && typeof value.newId === "number" && typeof value.tempId === "number";
+}
+function parseReindexBackupPayload(content) {
+  const parsed = JSON.parse(content);
+  if (!isRecordObject(parsed)) {
+    throw new Error("invalid_backup_payload");
+  }
+  if (typeof parsed.createdAt !== "string") {
+    throw new Error("invalid_backup_created_at");
+  }
+  if (!Array.isArray(parsed.records) || !parsed.records.every((record) => isEchoCaveRecord(record))) {
+    throw new Error("invalid_backup_records");
+  }
+  if (!Array.isArray(parsed.mapping) || !parsed.mapping.every((item) => isReindexPlanItem(item))) {
+    throw new Error("invalid_backup_mapping");
+  }
+  return {
+    createdAt: parsed.createdAt,
+    mapping: parsed.mapping,
+    records: parsed.records.map((record) => cloneCaveRecord(record, record.id))
+  };
+}
+function resolveBackupPath(backupPath) {
+  return import_node_path2.default.isAbsolute(backupPath) ? backupPath : import_node_path2.default.resolve(process.cwd(), backupPath);
+}
 function getCaveMaintenanceMessage(session) {
   return caveMaintenanceLock ? session.text("echo-cave.general.maintenanceLocked") : null;
 }
@@ -35166,56 +35265,37 @@ async function writeReindexBackup(backupDir, caves, mapping) {
   await import_node_fs2.promises.writeFile(backupPath, JSON.stringify(payload2, null, 2), "utf8");
   return backupPath;
 }
-async function applyReindexPlan(ctx, plan) {
-  const descendingPlan = [...plan].sort((a5, b5) => b5.oldId - a5.oldId);
-  for (const item of descendingPlan) {
-    if (item.oldId === item.newId) {
-      continue;
-    }
-    await ctx.database.set("echo_cave_v2", { id: item.oldId }, { id: item.tempId });
+async function applyReindexPlan(ctx, originalCaves) {
+  const reindexedCaves = buildSequentialCaveSnapshot(originalCaves);
+  await replaceCaveSnapshot(ctx, originalCaves, reindexedCaves);
+}
+async function verifyCaveSnapshot(ctx, expectedCaves) {
+  const actualCaves = (await ctx.database.get("echo_cave_v2", {})).sort((a5, b5) => a5.id - b5.id);
+  const normalizedExpected = [...expectedCaves].sort((a5, b5) => a5.id - b5.id).map(normalizeCaveRecord);
+  const normalizedActual = actualCaves.map(normalizeCaveRecord);
+  if (normalizedActual.length !== normalizedExpected.length) {
+    throw new Error("record_count_mismatch");
   }
-  const ascendingPlan = [...plan].sort((a5, b5) => a5.newId - b5.newId);
-  for (const item of ascendingPlan) {
-    if (item.oldId === item.newId) {
-      continue;
+  for (let index = 0; index < normalizedActual.length; index++) {
+    const actual = normalizedActual[index];
+    const expected = normalizedExpected[index];
+    if (actual.id !== index + 1) {
+      throw new Error("id_sequence_mismatch");
+    }
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+      throw new Error("record_content_mismatch");
     }
-    await ctx.database.set("echo_cave_v2", { id: item.tempId }, { id: item.newId });
   }
 }
-async function verifyReindexPlan(ctx, originalCaves) {
-  const reindexedCaves = (await ctx.database.get("echo_cave_v2", {})).sort((a5, b5) => a5.id - b5.id);
-  if (reindexedCaves.length !== originalCaves.length) {
+async function verifyRestoredSnapshot(ctx, expectedCaves) {
+  const actualCaves = (await ctx.database.get("echo_cave_v2", {})).sort((a5, b5) => a5.id - b5.id);
+  const normalizedExpected = [...expectedCaves].sort((a5, b5) => a5.id - b5.id).map(normalizeCaveRecord);
+  const normalizedActual = actualCaves.map(normalizeCaveRecord);
+  if (normalizedActual.length !== normalizedExpected.length) {
     throw new Error("record_count_mismatch");
   }
-  const normalizedOriginal = [...originalCaves].sort((a5, b5) => a5.id - b5.id).map((cave) => ({
-    channelId: cave.channelId,
-    content: cave.content,
-    createTime: new Date(cave.createTime).toISOString(),
-    drawCount: cave.drawCount,
-    originUserId: cave.originUserId,
-    relatedUsers: [...cave.relatedUsers],
-    type: cave.type,
-    userId: cave.userId
-  }));
-  const normalizedReindexed = reindexedCaves.map((cave, index) => ({
-    channelId: cave.channelId,
-    content: cave.content,
-    createTime: new Date(cave.createTime).toISOString(),
-    drawCount: cave.drawCount,
-    id: cave.id,
-    originUserId: cave.originUserId,
-    relatedUsers: [...cave.relatedUsers],
-    type: cave.type,
-    userId: cave.userId,
-    expectedId: index + 1
-  }));
-  for (let index = 0; index < normalizedReindexed.length; index++) {
-    const reindexed = normalizedReindexed[index];
-    const original = normalizedOriginal[index];
-    if (reindexed.id !== reindexed.expectedId) {
-      throw new Error("id_sequence_mismatch");
-    }
-    if (reindexed.channelId !== original.channelId || reindexed.content !== original.content || reindexed.createTime !== original.createTime || reindexed.drawCount !== original.drawCount || reindexed.originUserId !== original.originUserId || reindexed.relatedUsers.join(",") !== original.relatedUsers.join(",") || reindexed.type !== original.type || reindexed.userId !== original.userId) {
+  for (let index = 0; index < normalizedActual.length; index++) {
+    if (JSON.stringify(normalizedActual[index]) !== JSON.stringify(normalizedExpected[index])) {
       throw new Error("record_content_mismatch");
     }
   }
@@ -35265,8 +35345,9 @@ async function reindexCaveIds(ctx, session, cfg) {
   }
   setCaveMaintenanceLock(true);
   try {
-    await applyReindexPlan(ctx, plan);
-    await verifyReindexPlan(ctx, caves);
+    const reindexedCaves = buildSequentialCaveSnapshot(caves);
+    await applyReindexPlan(ctx, caves);
+    await verifyCaveSnapshot(ctx, reindexedCaves);
     return session.text("commands.cave.admin.reindex.messages.reindexDone", {
       caveCount: caves.length,
       backupPath
@@ -35281,6 +35362,61 @@ async function reindexCaveIds(ctx, session, cfg) {
     setCaveMaintenanceLock(false);
   }
 }
+async function restoreReindexBackup(ctx, session, cfg, backupPathInput) {
+  const accessError = ensureAdminPrivateAccess(session, cfg);
+  if (accessError) {
+    return accessError;
+  }
+  if (!backupPathInput?.trim()) {
+    return session.text("commands.cave.admin.restore-reindex.messages.missingBackupPath");
+  }
+  const backupPath = resolveBackupPath(backupPathInput.trim());
+  let backup;
+  try {
+    const content = await import_node_fs2.promises.readFile(backupPath, "utf8");
+    backup = parseReindexBackupPayload(content);
+  } catch (error2) {
+    ctx.logger.error(`Failed to read cave reindex backup: ${error2}`);
+    return session.text("commands.cave.admin.restore-reindex.messages.backupReadFailed", {
+      backupPath,
+      error: error2 instanceof Error ? error2.message : String(error2)
+    });
+  }
+  const currentCaves = (await ctx.database.get("echo_cave_v2", {})).sort((a5, b5) => a5.id - b5.id);
+  const confirmed = await requestSecondConfirmation(
+    ctx,
+    session,
+    session.text("commands.cave.admin.restore-reindex.messages.confirmSummary", {
+      backupPath,
+      currentCount: currentCaves.length,
+      backupCount: backup.records.length,
+      backupCreatedAt: backup.createdAt
+    }),
+    session.text("commands.cave.admin.restore-reindex.messages.confirmRetry"),
+    session.text("commands.cave.admin.restore-reindex.messages.confirmTimeout"),
+    session.text("commands.cave.admin.restore-reindex.messages.confirmCancelled")
+  );
+  if (!confirmed) {
+    return;
+  }
+  setCaveMaintenanceLock(true);
+  try {
+    await replaceCaveSnapshot(ctx, currentCaves, backup.records);
+    await verifyRestoredSnapshot(ctx, backup.records);
+    return session.text("commands.cave.admin.restore-reindex.messages.restoreDone", {
+      backupPath,
+      caveCount: backup.records.length
+    });
+  } catch (error2) {
+    ctx.logger.error(`Failed to restore cave reindex backup: ${error2}`);
+    return session.text("commands.cave.admin.restore-reindex.messages.restoreFailed", {
+      backupPath,
+      error: error2 instanceof Error ? error2.message : String(error2)
+    });
+  } finally {
+    setCaveMaintenanceLock(false);
+  }
+}
 
 // src/core/parser/forward-parser.ts
 async function reconstructForwardMsg(ctx, session, message, cfg, processMedia = true) {
@@ -36704,7 +36840,20 @@ var zh_CN_default = {
         confirmCancelled: "\u{1F6D1} \u5DF2\u53D6\u6D88\u672C\u6B21\u56DE\u58F0\u6D1E ID \u91CD\u6392\u3002",
         confirmTimeout: "\u231B \u4E8C\u6B21\u786E\u8BA4\u8D85\u65F6\uFF0C\u56DE\u58F0\u6D1E ID \u91CD\u6392\u672A\u6267\u884C\u3002",
         reindexDone: "\u2705 \u56DE\u58F0\u6D1E ID \u91CD\u6392\u5B8C\u6210\uFF0C\u5171\u5904\u7406 {caveCount} \u6761\u8BB0\u5F55\u3002\u5907\u4EFD\u6587\u4EF6\uFF1A{backupPath}",
-        reindexFailed: "\u274C \u56DE\u58F0\u6D1E ID \u91CD\u6392\u5931\u8D25\uFF0C\u5DF2\u505C\u6B62\u7EE7\u7EED\u5199\u5165\u3002\u8BF7\u6839\u636E\u5907\u4EFD\u6587\u4EF6\u68C0\u67E5\u5E76\u6062\u590D\uFF1A{backupPath}\n\u9519\u8BEF\uFF1A{error}"
+        reindexFailed: "\u274C \u56DE\u58F0\u6D1E ID \u91CD\u6392\u5931\u8D25\uFF0C\u5DF2\u505C\u6B62\u7EE7\u7EED\u5199\u5165\u3002\u53EF\u4F7F\u7528 cave.admin.restore-reindex \u6062\u590D\u5907\u4EFD\uFF1A{backupPath}\n\u9519\u8BEF\uFF1A{error}"
+      }
+    },
+    "cave.admin.restore-reindex": {
+      description: "\u4ECE\u56DE\u58F0\u6D1E ID \u91CD\u6392\u751F\u6210\u7684 JSON \u5907\u4EFD\u6062\u590D\u6570\u636E\u5E93",
+      messages: {
+        missingBackupPath: "\u274C \u8BF7\u63D0\u4F9B\u8981\u6062\u590D\u7684\u5907\u4EFD\u6587\u4EF6\u8DEF\u5F84\u3002",
+        backupReadFailed: "\u274C \u8BFB\u53D6\u56DE\u58F0\u6D1E\u91CD\u6392\u5907\u4EFD\u5931\u8D25\uFF1A{backupPath}\n\u9519\u8BEF\uFF1A{error}",
+        confirmSummary: "\u26A0\uFE0F \u5373\u5C06\u4ECE\u5907\u4EFD\u6062\u590D\u56DE\u58F0\u6D1E\u6570\u636E\n\u5907\u4EFD\u6587\u4EF6\uFF1A{backupPath}\n\u5907\u4EFD\u521B\u5EFA\u65F6\u95F4\uFF1A{backupCreatedAt}\n\u5907\u4EFD\u8BB0\u5F55\u6570\uFF1A{backupCount}\n\u5F53\u524D\u6570\u636E\u5E93\u8BB0\u5F55\u6570\uFF1A{currentCount}\n\n\u672C\u6B21\u64CD\u4F5C\u4F1A\u5148\u4E34\u65F6\u817E\u632A\u5F53\u524D\u8BB0\u5F55\uFF0C\u518D\u6309\u5907\u4EFD\u5185\u5BB9\u5B8C\u6574\u6062\u590D\u3002\u6267\u884C\u671F\u95F4\u4F1A\u4E34\u65F6\u9501\u5B9A\u56DE\u58F0\u6D1E\u76F8\u5173\u547D\u4EE4\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\u56DE\u58F0\u6D1E\u5907\u4EFD\u6062\u590D\u3002",
+        confirmTimeout: "\u231B \u4E8C\u6B21\u786E\u8BA4\u8D85\u65F6\uFF0C\u56DE\u58F0\u6D1E\u5907\u4EFD\u6062\u590D\u672A\u6267\u884C\u3002",
+        restoreDone: "\u2705 \u56DE\u58F0\u6D1E\u5907\u4EFD\u6062\u590D\u5B8C\u6210\uFF0C\u5171\u6062\u590D {caveCount} \u6761\u8BB0\u5F55\u3002\u5907\u4EFD\u6587\u4EF6\uFF1A{backupPath}",
+        restoreFailed: "\u274C \u56DE\u58F0\u6D1E\u5907\u4EFD\u6062\u590D\u5931\u8D25\uFF0C\u5DF2\u5C1D\u8BD5\u56DE\u6EDA\u5230\u6062\u590D\u524D\u72B6\u6001\uFF1A{backupPath}\n\u9519\u8BEF\uFF1A{error}"
       }
     }
   }
@@ -36920,6 +37069,9 @@ function apply(ctx, cfg) {
   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)
+  );
   registerSendFailureSummaryScheduler(ctx, cfg);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

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