luckytri 1.0.1 → 1.0.2

package/public/tutorial.en.md

@@ -168,6 +168,16 @@ Cleanup verifies a retained automatic backup of this instance from the last 72 h
 
 To restore, stop the service, move the current `data/friend.db` and its `-wal` and `-shm` files away, then copy the chosen backup to `data/friend.db`. When `DB_PATH` is set, work on that path. Never keep an old WAL file next to a restored database. The safer way is `npm run recovery`, which verifies a backup and restores it into a brand new file; see `docs/en/recovery.md`.
 
+### Import and export from the studio
+
+"System → Data and backups" provides "Export data package" and "Choose import file". A `.luckytri` package contains chats, memories, relationships, personal state, diaries, tasks, work versions, knowledge text and settings stored in the database, including saved credentials. Management passwords and login sessions are not migrated. Plugin programs, original knowledge files and the local `.env` are outside the package. Export uses a consistent snapshot while the instance continues running and streams large downloads.
+
+Imports accept `.luckytri` packages and existing `.db` / SQLite backups. The default upload limit is 10 GiB; adjust `DATA_TRANSFER_MAX_GB` (1–100) in `.env`. Uploads are checked for package SHA-256, database integrity, references and supported structures. Older versions are upgraded only in staging. The preview shows the name, version and record counts before current data changes, so it can be cancelled.
+
+Confirming "Import and restart" stops the instance, retains a complete `luckytri-before-import-*.db` snapshot, replaces the data and restarts automatically. The local management password, current logins, QQ connection settings and backup cleanup rules are preserved. Automatic replies are turned off and plugin execution grants reset. Review connections, models and tasks before enabling replies; reinstall plugins or review their permissions. Import replaces the whole database rather than merging records. Pre-import snapshots can be managed manually and are excluded from scheduled full-backup cleanup.
+
+The server removes the export copy after download. Cancelled, expired and interrupted staging files are reclaimed; unused previews expire after one hour. Failed imports retain or restore the original database rather than starting with a partial file.
+
 ## 9. Troubleshooting
 
 | Symptom                           | Check first                                                                                                                              |

package/public/tutorial.md

@@ -168,6 +168,16 @@ TA 的一切都存在这一个数据库里，所以服务运行时会自动备
 
 恢复时先停止服务，把当前 `data/friend.db` 及同名 `-wal`、`-shm` 移开，再把选中的备份复制为 `data/friend.db`。设置了 `DB_PATH` 时操作该路径。不要把旧的 WAL 文件和恢复后的数据库放在一起。更稳妥的做法是用 `npm run recovery` 校验并恢复到一个全新的文件，见 `docs/zh/recovery.md`。
 
+### 从管理台导入与导出
+
+「系统 → 数据与备份」提供「导出数据包」和「选择导入文件」。导出的 `.luckytri` 文件包含数据库内的聊天、记忆、关系、个人状态、日记、待办、作品版本、知识文本和设置，也包含保存在设置中的密钥。管理密码和登录会话不随数据包迁移；插件程序、知识库原始文件及本机 `.env` 不在其中。导出读取一致快照，实例可以继续运行，大文件通过流式传输下载。
+
+导入支持 `.luckytri` 数据包及已有 `.db` / SQLite 备份。默认单个文件最多 10 GiB，可用 `.env` 中的 `DATA_TRANSFER_MAX_GB`（1–100）调整。上传后先校验数据包 SHA-256、数据库完整性、引用和结构，旧版本只在暂存副本上升级，界面会显示姓名、版本和记录数量。此时尚未改变当前数据，可以取消。
+
+确认「导入并重启」后，程序停止实例，保留一份完整的 `luckytri-before-import-*.db` 快照，再替换数据并自动重启。本机管理密码、当前登录、QQ 连接配置和备份整理规则保留。导入后的自动回复关闭，插件执行权限重置；检查连接、模型和待办后可重新开启，插件需重新安装或确认权限。导入是替换整份数据，不与当前记录合并；原有快照可在备份列表手动管理，定时清理完整备份不会删除它。
+
+下载完成后删除服务器导出副本；取消、失效或中断的暂存文件会回收，未使用的预览默认一小时失效。导入失败时保留或恢复原数据，不会把不完整的文件交给实例运行。
+
 ## 9. 常见问题
 
 | 现象                      | 先检查                                                                                             |

package/scripts/import-data.js

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { openSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { prepareRuntime } from "./runtime.js";
+import { claimLaunch, clearStarting } from "../server/startup-lock.js";
+import { applyDataImport } from "../server/storage/data-package.js";
+import {
+  transferRoot,
+  readTransferJob,
+  writeTransferJob,
+  IMPORT_FAILURE,
+  IMPORT_START_FAILURE,
+  IMPORT_RESTART_FAILURE,
+} from "../server/storage/data-transfer.js";
+
+const id = process.argv[2];
+const parent = Number(process.argv[3]);
+let job,
+  paths,
+  claimed = false;
+const alive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+};
+try {
+  paths = prepareRuntime({ initialize: false });
+  if (!Number.isInteger(parent) || parent <= 0) throw Error("导入启动信息无效");
+  job = readTransferJob(transferRoot(), id);
+  if (job.kind !== "import" || job.status !== "queued")
+    throw Error("导入任务已经处理或不可用");
+  for (let attempt = 0; attempt < 160 && alive(parent); attempt++)
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  if (alive(parent)) throw Error("旧实例仍在运行，未替换数据");
+  if (!claimLaunch()) throw Error("另一次启动正在进行，未替换数据");
+  claimed = true;
+  try {
+    const result = applyDataImport(
+      join(transferRoot(), id, "data.db"),
+      paths.database,
+      paths.backups,
+      {
+        id,
+        beforeSwap(backup) {
+          job = { ...job, backup };
+          writeTransferJob(transferRoot(), job);
+        },
+      },
+    );
+    job = {
+      ...job,
+      status: "done",
+      applied: Date.now(),
+      ...result,
+    };
+    try {
+      writeTransferJob(transferRoot(), job);
+    } catch {
+      console.error("导入结果记录未写入，重启后会核对已提交的数据。");
+    }
+    console.log("数据导入完成，当前数据快照已保留。");
+  } catch (error) {
+    writeTransferJob(transferRoot(), {
+      ...job,
+      status: "error",
+      error: IMPORT_FAILURE,
+    });
+    console.error("数据导入未完成：", error.code || "校验或替换失败");
+  }
+  // Hand the launch claim directly to the new server so no other launch can
+  // open the database halfway through the swap.
+  const log = openSync(paths.log, "a", 0o600);
+  const child = spawn(
+    process.execPath,
+    [
+      ...(process.execArgv.includes("--use-env-proxy")
+        ? ["--use-env-proxy"]
+        : []),
+      join(paths.package, "server", "index.js"),
+    ],
+    {
+      cwd: paths.home,
+      env: { ...process.env, LUCKYTRI_LAUNCH_PID: String(process.pid) },
+      detached: true,
+      windowsHide: true,
+      stdio: ["ignore", log, log],
+    },
+  );
+  closeSync(log);
+  await new Promise((resolve, reject) => {
+    child.once("spawn", resolve);
+    child.once("error", reject);
+  });
+  child.unref();
+  for (let attempt = 0; attempt < 120; attempt++) {
+    try {
+      const info = JSON.parse(
+        (await import("node:fs")).readFileSync(
+          join(paths.data, "startup.json"),
+          "utf8",
+        ),
+      );
+      if (info.pid === child.pid && info.role === "server") {
+        claimed = false;
+        break;
+      }
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+} catch (error) {
+  if (job) {
+    try {
+      writeTransferJob(transferRoot(), {
+        ...job,
+        status: "error",
+        error:
+          job.status === "done" ? IMPORT_RESTART_FAILURE : IMPORT_START_FAILURE,
+      });
+    } catch {}
+  }
+  console.error("导入启动失败：", error.code || "请查看数据任务状态");
+  process.exitCode = 1;
+} finally {
+  if (claimed) clearStarting();
+}

package/server/app.js

@@ -12,6 +12,7 @@ import { mountMind } from "./mind/api.js";
 import { mountPlugins } from "./plugins/api.js";
 import { Life } from "./mind/life/index.js";
 import { runtimePaths } from "./paths.js";
+import { mountDataTransfer } from "./storage/data-transfer-api.js";
 
 export function createApp({
   store,
@@ -39,7 +40,7 @@ export function createApp({
     if (
       ["POST", "PATCH", "PUT"].includes(req.method) &&
       (!req.body || typeof req.body !== "object" || Array.isArray(req.body)) &&
-      req.path !== "/plugins/import/upload"
+      !["/plugins/import/upload", "/storage/transfer/upload"].includes(req.path)
     )
       return res.status(400).json({ error: "请提交 JSON 对象" });
     next();
@@ -56,6 +57,7 @@ export function createApp({
     res.status(401).json({ error: "请先登录管理台" });
   });
   app.use("/api", objectBody);
+  mountDataTransfer(app, runtime.transfer);
   if (plugins) {
     app.post(
       "/api/plugins/import/upload",

package/server/i18n/errors.js

@@ -2,6 +2,42 @@
 // key, exactly as the code writes it. `{0}` stands for a value the code puts
 // into the message; patterns are used when a message carries one.
 export const ERRORS = {
+  数据清单过大: "The data manifest is too large",
+  数据文件包含不支持的数据库结构:
+    "The file contains unsupported database structures",
+  "不是有效的 LuckyTri 数据文件": "This is not a valid LuckyTri data file",
+  数据包已损坏: "The data package is damaged",
+  当前实例不支持文件导入: "This instance does not support file imports",
+  "当前数据库仍在使用，请稍后导入":
+    "The database is still in use. Import it later.",
+  请上传数据包或数据库文件: "Upload a data package or database file",
+  数据任务不存在: "The data operation does not exist",
+  数据处理失败: "Data processing failed",
+  "数据已导入，但自动重启未完成。请手动重新启动实例。":
+    "Data was imported, but the automatic restart did not complete. Restart the instance manually.",
+  "临时数据文件正在使用，请稍后再试":
+    "Temporary data files are in use. Try again later.",
+  "数据处理被中断，请重新操作":
+    "Data processing was interrupted. Start the operation again.",
+  "数据处理或备份正在进行，请稍后再试":
+    "Data processing or backup is in progress. Try again later.",
+  当前实例不支持文件导入导出:
+    "This instance does not support file import and export",
+  数据文件超过导入大小限制: "The data file exceeds the import size limit",
+  数据文件为空: "The data file is empty",
+  数据上传失败: "Data upload failed",
+  导出文件尚未就绪或已过期: "The export is not ready or has expired",
+  "当前实例不支持自动导入，请使用恢复命令":
+    "Automatic import is unavailable. Use the recovery command.",
+  导入数据尚未就绪或已过期: "The import is not ready or has expired",
+  "数据处理正在进行，请稍后再试":
+    "Data processing is in progress. Try again later.",
+  磁盘空间不足: "There is not enough disk space",
+  数据文件无法校验: "The data file could not be verified",
+  "导入未完成，原数据已保留。请重新上传或查看运行日志。":
+    "Import could not complete. The original data was retained. Upload again or check the runtime log.",
+  "导入启动未完成，未替换运行数据。请重新启动实例。":
+    "Import could not start. The running data was not replaced. Restart the instance.",
   请使用本机命令重置管理密码:
     "Use the local CLI to reset the management password",
   "LUCKYTRI_HOME / --home 必须是绝对路径 (must be an absolute path)":

package/server/index.js

@@ -8,6 +8,11 @@ import { createBackupScheduler } from "./storage/backup-scheduler.js";
 import { createBackupCleanup } from "./storage/backup-cleanup.js";
 import { PluginHost } from "./plugins/host.js";
 import { createManagementAuth } from "./auth.js";
+import { createDataTransfer } from "./storage/data-transfer.js";
+import { runtimePaths } from "./paths.js";
+import { spawn } from "node:child_process";
+import { openSync, closeSync } from "node:fs";
+import { join } from "node:path";
 
 claimServer();
 process.on("exit", clearStarting);
@@ -37,6 +42,43 @@ plugins
   .catch((error) => console.error(`插件没有启动：${error.message}`));
 const backups = createBackupScheduler();
 const cleanup = createBackupCleanup({ store, backup: backups });
+const transfer = createDataTransfer({
+  backup: backups,
+  cleanup,
+  async onApply(id) {
+    const paths = runtimePaths();
+    const log = openSync(paths.log, "a", 0o600);
+    try {
+      const child = spawn(
+        process.execPath,
+        [
+          ...(process.execArgv.includes("--use-env-proxy")
+            ? ["--use-env-proxy"]
+            : []),
+          join(paths.package, "scripts", "import-data.js"),
+          id,
+          String(process.pid),
+        ],
+        {
+          cwd: paths.home,
+          detached: true,
+          windowsHide: true,
+          env: process.env,
+          stdio: ["ignore", log, log],
+        },
+      );
+      child.unref();
+      await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+      });
+      setTimeout(shutdown, 300);
+      return child.pid;
+    } finally {
+      closeSync(log);
+    }
+  },
+});
 const host = process.env.HOST || "127.0.0.1";
 if (!["127.0.0.1", "localhost", "::1"].includes(host) && !auth.configured())
   throw new Error("绑定外网地址前请先在本机设置管理密码");
@@ -74,6 +116,7 @@ const app = createApp({
     syncChannel: () => channel.sync(),
     backup: () => backups.status(),
     cleanup,
+    transfer,
     shutdown,
   },
 });
@@ -89,12 +132,13 @@ function runMaintenance() {
     console.error(`后台维护失败：${error.message}`);
   }
   try {
-    if (!cleanup.running) backups.tick();
+    if (!cleanup.running && !transfer.busy) backups.tick();
   } catch (error) {
     console.error(`自动备份调度失败：${error.message}`);
   }
   try {
-    cleanup.tick();
+    if (!transfer.busy) cleanup.tick();
+    transfer.info();
   } catch (error) {
     console.error(`定时备份整理调度失败：${error.message}`);
   }

package/server/knowledge/schema.js

@@ -57,6 +57,16 @@ function mergeLegacyMemories(db) {
   }
 }
 
+export const KNOWLEDGE_TRIGGERS = [
+  `CREATE TRIGGER IF NOT EXISTS core_vector_changed AFTER UPDATE OF embedding ON core_chunks BEGIN
+      DELETE FROM core_vector_buckets WHERE chunk_id=NEW.id;
+      UPDATE core_chunks SET vector_indexed=0 WHERE id=NEW.id;
+    END`,
+  `CREATE TRIGGER IF NOT EXISTS core_vector_deleted AFTER DELETE ON core_chunks BEGIN
+      DELETE FROM core_vector_buckets WHERE chunk_id=OLD.id;
+    END`,
+];
+
 export function migrateKnowledge(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS core_collections (
@@ -124,14 +134,8 @@ export function migrateKnowledge(db) {
   db.exec(`CREATE INDEX IF NOT EXISTS core_chunks_collection ON core_chunks(collection_id, document_id);
     CREATE INDEX IF NOT EXISTS core_chunks_unindexed ON core_chunks(vector_indexed) WHERE embedding IS NOT NULL;
     CREATE TABLE IF NOT EXISTS core_vector_buckets(dimension INTEGER NOT NULL,band INTEGER NOT NULL,bucket INTEGER NOT NULL,chunk_id TEXT NOT NULL,PRIMARY KEY(dimension,band,bucket,chunk_id));
-    CREATE INDEX IF NOT EXISTS core_vector_buckets_chunk ON core_vector_buckets(chunk_id);
-    CREATE TRIGGER IF NOT EXISTS core_vector_changed AFTER UPDATE OF embedding ON core_chunks BEGIN
-      DELETE FROM core_vector_buckets WHERE chunk_id=NEW.id;
-      UPDATE core_chunks SET vector_indexed=0 WHERE id=NEW.id;
-    END;
-    CREATE TRIGGER IF NOT EXISTS core_vector_deleted AFTER DELETE ON core_chunks BEGIN
-      DELETE FROM core_vector_buckets WHERE chunk_id=OLD.id;
-    END;`);
+    CREATE INDEX IF NOT EXISTS core_vector_buckets_chunk ON core_vector_buckets(chunk_id);`);
+  db.exec(KNOWLEDGE_TRIGGERS.join(";") + ";");
   if (
     !db
       .prepare("SELECT id FROM core_collections WHERE id='shared-default'")

package/server/storage/archive.js

@@ -194,7 +194,7 @@ export function restoreToNewFile(source, destination) {
   }
 }
 
-export function prepareDatabaseMigration(file) {
+export function prepareDatabaseMigration(file, { quiet = false } = {}) {
   if (file === ":memory:" || !existsSync(file)) return null;
   const db = new DatabaseSync(file, { readOnly: true });
   let version, hasData;
@@ -211,9 +211,10 @@ export function prepareDatabaseMigration(file) {
     db.close();
   }
   if (version === DATABASE_VERSION || !hasData) return null;
-  console.log(
-    `正在把数据库从 v${version} 升级到 v${DATABASE_VERSION}。会先复制整份数据，记录越多越久，请不要关闭窗口。`,
-  );
+  if (!quiet)
+    console.log(
+      `正在把数据库从 v${version} 升级到 v${DATABASE_VERSION}。会先复制整份数据，记录越多越久，请不要关闭窗口。`,
+    );
   const directory = join(dirname(resolve(file)), "backups");
   mkdirSync(directory, { recursive: true });
   const target = join(

package/server/storage/backup-cleanup.js

@@ -25,6 +25,7 @@ const DEFAULTS = Object.freeze({
 function kind(scope, name) {
   if (scope === "root")
     return /^friend\.pre-[\w-]+\.db$/.test(name) ? "snapshot" : null;
+  if (/^luckytri-before-import-\d+-[\da-f]{8}\.db$/.test(name)) return "import";
   if (/^luckytri-auto-\d{4}-\d\d-\d\dT[\d-]+Z\.db$/.test(name)) return "auto";
   if (/^luckytri-migration-v\d+-to-v\d+-\d+-[\da-f]{8}\.db$/.test(name))
     return "migration";

package/server/storage/data-package.js

@@ -0,0 +1,298 @@
+import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "node:crypto";
+import {
+  createReadStream,
+  createWriteStream,
+  writeFileSync,
+  openSync,
+  readSync,
+  closeSync,
+  existsSync,
+  statSync,
+  renameSync,
+  mkdirSync,
+  rmSync,
+} from "node:fs";
+import { join, dirname, basename } from "node:path";
+import { pipeline } from "node:stream/promises";
+import {
+  copyDatabaseFile,
+  inspectDatabase,
+  writeArchiveManifest,
+  verifyArchive,
+  DATABASE_VERSION,
+} from "./archive.js";
+import { withBackupLock } from "./backup-lock.js";
+import { createStore } from "./store.js";
+import { Repository } from "../core/repository.js";
+import { KNOWLEDGE_TRIGGERS } from "../knowledge/schema.js";
+
+export const PACKAGE_MAGIC = Buffer.from("LUCKYTRI-DATA\n");
+const SQLITE_MAGIC = Buffer.from("SQLite format 3\0");
+export function packageHeader(manifest) {
+  const json = Buffer.from(JSON.stringify(manifest));
+  if (json.length > 262144) throw Error("数据清单过大");
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(json.length);
+  return Buffer.concat([PACKAGE_MAGIC, length, json]);
+}
+
+export function validateData(file) {
+  const result = inspectDatabase(file);
+  const db = new DatabaseSync(file, { readOnly: true });
+  try {
+    const canonical = (sql) =>
+      String(sql)
+        .replace(/\bIF\s+NOT\s+EXISTS\b/gi, "")
+        .replace(/\s+/g, "")
+        .replace(/;$/, "")
+        .toLowerCase();
+    const allowed = new Set(KNOWLEDGE_TRIGGERS.map(canonical));
+    if (
+      db
+        .prepare(
+          "SELECT type,sql FROM sqlite_master WHERE type IN ('trigger','view')",
+        )
+        .all()
+        .some(
+          (row) => row.type !== "trigger" || !allowed.has(canonical(row.sql)),
+        )
+    )
+      throw Error("数据文件包含不支持的数据库结构");
+    const settings = JSON.parse(
+      db.prepare("SELECT value FROM settings WHERE id=1").get()?.value ||
+        "null",
+    );
+    if (
+      !settings ||
+      typeof settings !== "object" ||
+      Array.isArray(settings) ||
+      typeof settings.name !== "string"
+    )
+      throw Error("不是有效的 LuckyTri 数据文件");
+    return { ...result, name: settings.name.slice(0, 100) };
+  } finally {
+    db.close();
+  }
+}
+
+export function makeDataExport(source, target, backups) {
+  return withBackupLock(backups, () => {
+    copyDatabaseFile(source, target);
+    const db = new DatabaseSync(target);
+    try {
+      for (const table of ["management_sessions", "management_auth"])
+        if (
+          db
+            .prepare(
+              "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?",
+            )
+            .get(table)
+        )
+          db.exec(`DELETE FROM ${table}`);
+      db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    } finally {
+      db.close();
+    }
+    const manifest = writeArchiveManifest(target, {
+      kind: "export",
+      filename: "data.db",
+    });
+    const summary = validateData(target);
+    return { manifest, summary, bytes: statSync(target).size };
+  });
+}
+
+export async function prepareDataImport(upload, target) {
+  const fd = openSync(upload, "r");
+  let offset = 0,
+    manifest = null;
+  try {
+    const start = Buffer.alloc(16);
+    const read = readSync(fd, start, 0, 16, 0);
+    if (read !== 16) throw Error("不是有效的 LuckyTri 数据文件");
+    if (!start.equals(SQLITE_MAGIC)) {
+      if (!start.subarray(0, PACKAGE_MAGIC.length).equals(PACKAGE_MAGIC))
+        throw Error("不是有效的 LuckyTri 数据文件");
+      const lengthBytes = Buffer.alloc(4);
+      if (readSync(fd, lengthBytes, 0, 4, PACKAGE_MAGIC.length) !== 4)
+        throw Error("数据包已损坏");
+      const length = lengthBytes.readUInt32BE();
+      if (length < 2 || length > 262144) throw Error("数据包已损坏");
+      const json = Buffer.alloc(length);
+      if (readSync(fd, json, 0, length, PACKAGE_MAGIC.length + 4) !== length)
+        throw Error("数据包已损坏");
+      manifest = JSON.parse(json.toString("utf8"));
+      if (
+        manifest.app !== "luckytri" ||
+        manifest.format !== 1 ||
+        !/^[a-f0-9]{64}$/.test(manifest.sha256)
+      )
+        throw Error("数据包已损坏");
+      offset = PACKAGE_MAGIC.length + 4 + length;
+    }
+  } finally {
+    closeSync(fd);
+  }
+  if (statSync(upload).size <= offset) throw Error("数据包已损坏");
+  await pipeline(
+    createReadStream(upload, { start: offset }),
+    createWriteStream(target, { flags: "wx", mode: 0o600 }),
+  );
+  if (manifest) {
+    writeFileSync(`${target}.json`, JSON.stringify(manifest), { mode: 0o600 });
+    verifyArchive(target);
+  }
+  const original = validateData(target);
+  // Upgrade only the staged copy; the running database is never opened here.
+  const store = createStore(target, { quietMigration: true });
+  try {
+    new Repository(store);
+  } finally {
+    store.db.close();
+  }
+  const migrated = validateData(target);
+  const checked = writeArchiveManifest(target, {
+    kind: "import",
+    filename: "data.db",
+  });
+  return {
+    summary: migrated,
+    originalVersion: original.schemaVersion,
+    manifest: checked,
+    bytes: statSync(target).size,
+  };
+}
+
+export function applyDataImport(
+  candidate,
+  source,
+  backups,
+  { id = randomUUID(), move = renameSync, beforeSwap = () => {} } = {},
+) {
+  if (source === ":memory:" || !existsSync(source))
+    throw Error("当前实例不支持文件导入");
+  return withBackupLock(backups, () => {
+    verifyArchive(candidate);
+    validateData(candidate);
+    const old = new DatabaseSync(source);
+    let auth, sessions, settings;
+    try {
+      settings = JSON.parse(
+        old.prepare("SELECT value FROM settings WHERE id=1").get().value,
+      );
+      auth = old
+        .prepare("SELECT salt,hash FROM management_auth WHERE id=1")
+        .get();
+      sessions = old
+        .prepare("SELECT id,expires FROM management_sessions")
+        .all();
+      const checkpoint = old.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      if (checkpoint.busy) throw Error("当前数据库仍在使用，请稍后导入");
+    } finally {
+      old.close();
+    }
+    if (existsSync(`${source}-wal`) || existsSync(`${source}-shm`))
+      throw Error("当前数据库仍在使用，请稍后导入");
+    const imported = new DatabaseSync(candidate);
+    try {
+      imported.exec("BEGIN IMMEDIATE");
+      imported.exec(
+        "DROP TABLE IF EXISTS management_sessions; DROP TABLE IF EXISTS management_auth; CREATE TABLE management_auth(id INTEGER PRIMARY KEY CHECK(id=1),salt TEXT NOT NULL,hash TEXT NOT NULL); CREATE TABLE management_sessions(id TEXT PRIMARY KEY,expires INTEGER NOT NULL);",
+      );
+      if (auth)
+        imported
+          .prepare("INSERT INTO management_auth VALUES (1,?,?)")
+          .run(auth.salt, auth.hash);
+      for (const row of sessions)
+        imported
+          .prepare("INSERT INTO management_sessions VALUES (?,?)")
+          .run(row.id, row.expires);
+      const incoming = JSON.parse(
+        imported.prepare("SELECT value FROM settings WHERE id=1").get().value,
+      );
+      for (const field of [
+        "onebotToken",
+        "qqbotAppId",
+        "qqbotSecret",
+        "channel",
+        "backupCleanup",
+        "backupCleanupLast",
+      ]) {
+        delete incoming[field];
+        if (settings[field] !== undefined) incoming[field] = settings[field];
+      }
+      incoming.enabled = false;
+      incoming.dataImportId = id;
+      imported
+        .prepare("UPDATE settings SET value=? WHERE id=1")
+        .run(JSON.stringify(incoming));
+      imported.exec(
+        "UPDATE plugin_installs SET enabled=0,granted='[]',path=''; COMMIT; PRAGMA wal_checkpoint(TRUNCATE);",
+      );
+    } catch (error) {
+      if (imported.isTransaction) imported.exec("ROLLBACK");
+      throw error;
+    } finally {
+      imported.close();
+    }
+    validateData(candidate);
+    mkdirSync(backups, { recursive: true });
+    const rollback = join(
+      backups,
+      `luckytri-before-import-${Date.now()}-${randomUUID().slice(0, 8)}.db`,
+    );
+    // Move the checkpointed original instead of creating another multi-GiB
+    // duplicate. The snapshot and its manifest remain available to restore.
+    writeArchiveManifest(source, {
+      kind: "before-import",
+      filename: basename(rollback),
+    });
+    beforeSwap(basename(rollback));
+    let original = rollback;
+    try {
+      move(source, rollback);
+    } catch (error) {
+      if (error.code !== "EXDEV") throw error;
+      // Custom backup folders may be on another disk. Retain one verified
+      // snapshot there, and keep the swap on the database's own filesystem.
+      copyDatabaseFile(source, rollback);
+      writeArchiveManifest(rollback, {
+        kind: "before-import",
+        filename: basename(rollback),
+      });
+      original = `${source}.import-swap-${randomUUID()}`;
+      move(source, original);
+    }
+    try {
+      if (original === rollback) move(`${source}.json`, `${rollback}.json`);
+      try {
+        move(candidate, source);
+      } catch (error) {
+        if (error.code !== "EXDEV") throw error;
+        const local = join(
+          dirname(source),
+          `.luckytri-import-${randomUUID()}.partial.db`,
+        );
+        try {
+          copyDatabaseFile(candidate, local);
+          validateData(local);
+          move(local, source);
+          rmSync(candidate, { force: true });
+        } finally {
+          rmSync(local, { force: true });
+        }
+      }
+    } catch (error) {
+      if (!existsSync(source)) renameSync(original, source);
+      if (existsSync(`${rollback}.json`))
+        renameSync(`${rollback}.json`, `${source}.json`);
+      throw error;
+    }
+    if (original !== rollback) {
+      rmSync(original, { force: true });
+      rmSync(`${source}.json`, { force: true });
+    }
+    return { backup: basename(rollback), schemaVersion: DATABASE_VERSION };
+  });
+}