tt-help-cli-ycl 1.4.26 → 1.4.28

package/scripts/sync-raw-jobs.mjs

@@ -1,105 +1,57 @@
 /**
- * raw_jobs 同步程序
+ * raw_jobs 同步与任务补充程序
  *
- * 定时检测主库中各目标国家的 raw_jobs 数量，不足时从归档库搬移补充。
- * 搬移逻辑复用 refillJobsFromRaw 非 LLM 模式的排序规则。
+ * 职责：
+ *   1. 入库   — main.raw_jobs → archive.raw_jobs
+ *   2. 补任务 — archive.raw_jobs → main.jobs（每国 pending<50 时触发）
+ *
+ * 模式：LLM 多轮打分凑够 50 条，不可用时回退常规（tag > comment > video_count）
  *
  * 用法:
- *   node scripts/sync-raw-jobs.mjs --db <主库> --archive <归档库>
- *   node scripts/sync-raw-jobs.mjs --db data/result.db --archive data/result-archive.db
- *   node scripts/sync-raw-jobs.mjs --db data/result.db --archive data/result-archive.db --once
- *   node scripts/sync-raw-jobs.mjs --db data/result.db --archive data/result-archive.db --interval 60 --threshold 2000 --batch 300
+ *   node scripts/sync-raw-jobs.mjs --db <主库> --archive <归档库> [--llm] [--once] [--interval 120]
  */
 
 import Database from "better-sqlite3";
+import { initDb, getDb } from "../src/watch/db-schema.js";
+import { loadLlmConfig, reloadLlmConfig } from "../src/watch/llm-config.js";
+import { scoreJobsBatch } from "../src/watch/llm-scoring.js";
+import { DEFAULT_TARGET_LOCATIONS } from "../src/lib/target-locations.js";
 
-// ===== 目标国家 =====
-const TARGET_LOCATIONS = [
-  "CZ",
-  "GR",
-  "HU",
-  "PT",
-  "ES",
-  "PL",
-  "NL",
-  "BE",
-  "DE",
-  "FR",
-  "IT",
-  "IE",
-  "AT",
-];
-
-// ===== 命令行参数 =====
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const opts = {
-    db: null,
-    archive: null,
-    interval: 30,
-    threshold: 1000,
-    batch: 500,
-    once: false,
-  };
-  for (let i = 0; i < args.length; i++) {
-    switch (args[i]) {
-      case "--db":
-        opts.db = args[++i];
-        break;
-      case "--archive":
-        opts.archive = args[++i];
-        break;
-      case "--interval":
-        opts.interval = parseInt(args[++i]) || 30;
-        break;
-      case "--threshold":
-        opts.threshold = parseInt(args[++i]) || 1000;
-        break;
-      case "--batch":
-        opts.batch = parseInt(args[++i]) || 500;
-        break;
-      case "--once":
-        opts.once = true;
-        break;
-    }
-  }
-  return opts;
-}
+// ═══════════════════════════════════════════════════════════════════
+// 常量
+// ═══════════════════════════════════════════════════════════════════
 
-const opts = parseArgs();
+const LOCATIONS = DEFAULT_TARGET_LOCATIONS;
 
-if (!opts.db || !opts.archive) {
-  console.error(
-    "用法: node scripts/sync-raw-jobs.mjs --db <主库路径> --archive <归档库路径> [选项]",
-  );
-  console.error("");
-  console.error("选项:");
-  console.error("  --db <path>       主库路径（必填）");
-  console.error("  --archive <path>  归档库路径（必填）");
-  console.error("  --interval <秒>   检测间隔，默认 30");
-  console.error("  --threshold <条>  每个国家最低保有量，默认 1000");
-  console.error("  --batch <条>      每次搬移上限，默认 500");
-  console.error("  --once            只执行一次后退出");
-  process.exit(1);
-}
+const FILTER = "video_count>6 AND follower_count>0 AND following_count>0";
 
-// ===== 过滤与排序 =====
-const FILTER_CONDITIONS = [
-  "COALESCE(video_count, 0) > 6",
-  "COALESCE(follower_count, 0) > 0",
-  "COALESCE(following_count, 0) > 0",
+const REFILL_COLS = [
+  "unique_id",
+  "nickname",
+  "sources",
+  "pinned",
+  "tt_seller",
+  "verified",
+  "video_count",
+  "comment_count",
+  "guessed_location",
+  "location_created",
+  "confirmed_location",
+  "follower_count",
+  "following_count",
+  "heart_count",
+  "created_at",
+  "updated_at",
+  "region",
+  "signature",
+  "bio_link",
+  "sec_uid",
+  "status_code",
+  "latest_video_time",
+  "user_create_time",
 ];
 
-const ORDER_CLAUSE = `
-  ORDER BY
-    CASE WHEN sources LIKE '%tag%' THEN 0 ELSE 1 END,
-    CASE WHEN sources LIKE '%comment%' THEN 0 ELSE 1 END,
-    COALESCE(video_count, 0) DESC,
-    created_at DESC
-`;
-
-// raw_jobs 表完整列（与 db-schema.js 对齐）
-const RAW_JOB_COLUMNS = [
+const ARCHIVE_COLS = [
   "unique_id",
   "nickname",
   "status",
@@ -136,146 +88,436 @@ const RAW_JOB_COLUMNS = [
   "user_create_time",
 ];
 
-// ===== 核心：从归档库搬移一批到主库 =====
-function moveBatch(mainDb, archiveDb, country, limit) {
-  const whereSql = [
-    ...FILTER_CONDITIONS,
-    `(UPPER(COALESCE(guessed_location, '')) = ? OR COALESCE(guessed_location, '') = '')`,
-  ].join(" AND ");
-
-  const cols = RAW_JOB_COLUMNS.join(", ");
-
-  // 1. INSERT OR IGNORE 到主库
-  const insertSql = `
-    INSERT OR IGNORE INTO raw_jobs (${cols})
-    SELECT ${cols}
-    FROM (SELECT * FROM raw_jobs WHERE ${whereSql} ${ORDER_CLAUSE} LIMIT ?)
-  `;
-
-  // 2. DELETE 归档库中已搬走的数据（匹配同一批次的 unique_id）
-  const deleteSql = `
-    DELETE FROM raw_jobs
-    WHERE unique_id IN (
-      SELECT unique_id FROM raw_jobs
-      WHERE ${whereSql} ${ORDER_CLAUSE} LIMIT ?
+const LLM_MIN = 60;
+const LLM_FALLBACK_KW = [
+  "全部模型失败",
+  "全部模型不可用",
+  "解析失败",
+  "调用异常",
+  "使用默认分",
+];
+
+const PER_COUNTRY = 50;
+
+function parseArgs() {
+  const a = process.argv.slice(2);
+  const o = { db: null, archive: null, interval: 120, once: false, llm: false };
+  for (let i = 0; i < a.length; i++) {
+    const v = a[i + 1];
+    switch (a[i]) {
+      case "--db":
+        o.db = v;
+        i++;
+        break;
+      case "--archive":
+        o.archive = v;
+        i++;
+        break;
+      case "--interval":
+        o.interval = parseInt(v) || 120;
+        i++;
+        break;
+      case "--llm":
+        o.llm = true;
+        break;
+      case "--once":
+        o.once = true;
+        break;
+    }
+  }
+  return o;
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// 工具
+// ═══════════════════════════════════════════════════════════════════
+
+const log = (tag, msg) =>
+  console.error(
+    `[sync ${new Date().toLocaleTimeString("zh-CN", { hour12: false })}] [${tag}] ${msg}`,
+  );
+/** 按 tag > comment > other 分拣 unique_id，返回去重数组 */
+function pickBySource(rows, limit) {
+  const ids = [
+    ...rows.filter((r) => r.sources?.includes('"tag"')).map((r) => r.unique_id),
+    ...rows
+      .filter(
+        (r) =>
+          r.sources?.includes('"comment"') && !r.sources?.includes('"tag"'),
+      )
+      .map((r) => r.unique_id),
+    ...rows
+      .filter(
+        (r) =>
+          !r.sources?.includes('"tag"') && !r.sources?.includes('"comment"'),
+      )
+      .map((r) => r.unique_id),
+  ];
+  ids.length = Math.min(ids.length, limit);
+  return ids;
+}
+
+const vals = (row, cols) => cols.map((c) => row[c] ?? null);
+const ph = (n) => Array(n).fill("?").join(", ");
+
+/** 构建 WHERE 子句（含国家过滤）。strict=true 时仅匹配明确国家，不含 NULL/空 */
+function buildWhere(locations = LOCATIONS, strict = false) {
+  const locs = [
+    ...new Set(
+      locations.map((l) => String(l).trim().toUpperCase()).filter(Boolean),
+    ),
+  ];
+  const nullClause = strict
+    ? ""
+    : " OR guessed_location IS NULL OR guessed_location=''";
+  const sql =
+    locs.length === 1
+      ? ` AND (guessed_location = ?${nullClause})`
+      : locs.length > 1
+        ? ` AND (guessed_location IN (${ph(locs.length)})${nullClause})`
+        : "";
+  return { sql: FILTER + sql, args: locs.length ? locs : [] };
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// 共享：写入 jobs 并清理归档库
+// ═══════════════════════════════════════════════════════════════════
+
+function moveToJobs(archiveDb, uniqueIds, targetLocation = null) {
+  if (!uniqueIds.length) return 0;
+  const cols = REFILL_COLS.join(", ");
+
+  const rows = archiveDb
+    .prepare(
+      `SELECT ${cols} FROM raw_jobs WHERE unique_id IN (${ph(uniqueIds.length)})`,
     )
-  `;
-
-  const moved = archiveDb.transaction(() => {
-    // 先删后插？不——先插后删，防止 INSERT OR IGNORE 冲突导致删了没插
-    // INSERT OR IGNORE: 如果主库已有该 unique_id，跳过但不报错
-    mainDb.prepare(insertSql).run(country, limit);
-    const del = archiveDb.prepare(deleteSql).run(country, limit);
-    return del.changes;
+    .all(...uniqueIds);
+  if (!rows.length) return 0;
+
+  const inserted = [];
+  archiveDb.transaction(() => {
+    const insert = getDb().prepare(
+      `INSERT OR IGNORE INTO task_queue (${cols}, status) VALUES (${ph(REFILL_COLS.length)}, 'pending')`,
+    );
+    for (const row of rows) {
+      const v = vals(row, REFILL_COLS);
+      if (targetLocation && !v[REFILL_COLS.indexOf("guessed_location")]) {
+        v[REFILL_COLS.indexOf("guessed_location")] = targetLocation;
+      }
+      if (insert.run(...v).changes) inserted.push(row.unique_id);
+    }
+    if (inserted.length) {
+      archiveDb
+        .prepare(
+          `DELETE FROM raw_jobs WHERE unique_id IN (${ph(inserted.length)})`,
+        )
+        .run(...inserted);
+    }
   })();
+  return inserted.length;
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// 入库（分批，防止大表 OOM）
+// ═══════════════════════════════════════════════════════════════════
 
+function archiveNewUsers(archiveDb) {
+  const mainDb = getDb();
+  const BATCH = 1000;
+  const cols = ARCHIVE_COLS.join(", ");
+  const insert = archiveDb.prepare(
+    `INSERT OR IGNORE INTO raw_jobs (${cols}) VALUES (${ph(ARCHIVE_COLS.length)})`,
+  );
+  let moved = 0;
+
+  while (true) {
+    const rows = mainDb
+      .prepare(`SELECT ${cols} FROM raw_jobs LIMIT ?`)
+      .all(BATCH);
+    if (!rows.length) break;
+
+    const ids = rows.map((r) => r.unique_id);
+
+    archiveDb.transaction(() => {
+      for (const r of rows) {
+        if (insert.run(...vals(r, ARCHIVE_COLS)).changes) moved++;
+      }
+    })();
+
+    mainDb
+      .prepare(`DELETE FROM raw_jobs WHERE unique_id IN (${ph(ids.length)})`)
+      .run(...ids);
+  }
+
+  if (moved) log("  ", `归档 +${moved}`);
   return moved;
 }
 
-// ===== 单次同步 =====
-function syncOnce(mainDb, archiveDb) {
-  const start = Date.now();
-  const results = {};
+// ═══════════════════════════════════════════════════════════════════
+// 检测（按国家）
+// ═══════════════════════════════════════════════════════════════════
+
+function countPendingByCountry() {
+  const rows = getDb()
+    .prepare(
+      `SELECT COALESCE(guessed_location,'') as loc, COUNT(*) as c
+       FROM task_queue WHERE status='pending'
+       GROUP BY loc`,
+    )
+    .all();
+  const map = {};
+  for (const r of rows) map[r.loc] = r.c;
+  // 确保所有目标国家都有值
+  for (const loc of LOCATIONS) {
+    if (!(loc in map)) map[loc] = 0;
+  }
+  return map;
+}
+
+function findNeedyCountries(byCountry, threshold) {
+  return LOCATIONS.filter((loc) => (byCountry[loc] || 0) < threshold);
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// 常规 refill（索引直查 + JS 分拣，避免 sources LIKE 大表扫描）
+// ═══════════════════════════════════════════════════════════════════
+
+function refillRegular(archiveDb, limit, locations) {
+  const { sql: w, args: wa } = buildWhere(locations);
+
+  // 取 limit×3 条，JS 分拣 tag > comment > other
+  const rows = archiveDb
+    .prepare(
+      `SELECT unique_id, sources FROM raw_jobs WHERE ${w} ORDER BY video_count DESC LIMIT ?`,
+    )
+    .all(...wa, limit * 3);
+  const ids = pickBySource(rows, limit);
+
+  if (!ids.length) return { moved: 0 };
+  const moved = moveToJobs(archiveDb, ids);
+  return { moved };
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// LLM refill — 逐国：按 scored_count 升序取 PER_COUNTRY 条，LLM 打分，通过进 jobs，不通过 +1
+async function refillLLM(archiveDb, needyLocations) {
+  let totalMoved = 0;
+
+  log("--", `LLM开始 ${needyLocations.length}国: ${needyLocations.join(" ")}`);
 
-  for (const country of TARGET_LOCATIONS) {
-    // 检查主库中该国存量
-    const countRow = mainDb
+  for (const loc of needyLocations) {
+    const { sql: w, args: wa } = buildWhere([loc], true);
+    const { sql: wf, args: wfa } = buildWhere([loc]);
+
+    // 1. 查询候选：取 100 条给 LLM（多于目标 50，增加通过率减少回退）
+    const LLM_BATCH = 100;
+    const tq = Date.now();
+    const samples = archiveDb
       .prepare(
-        `SELECT COUNT(*) as c FROM raw_jobs
-         WHERE UPPER(COALESCE(guessed_location, '')) = ?`,
+        `SELECT * FROM raw_jobs WHERE ${w} AND (llm_scored_count IS NULL OR llm_scored_count<3) ORDER BY COALESCE(llm_scored_count,0) ASC, video_count DESC LIMIT ?`,
       )
-      .get(country);
+      .all(...wa, LLM_BATCH);
+    log("  ", `${loc} 候选${samples.length}条 ${Date.now() - tq}ms`);
+
+    if (!samples.length) {
+      log("  ", `${loc} 回退常规取 ${PER_COUNTRY}条...`);
+      const rows = archiveDb
+        .prepare(
+          `SELECT unique_id, sources FROM raw_jobs WHERE ${wf} ORDER BY video_count DESC LIMIT ?`,
+        )
+        .all(...wfa, PER_COUNTRY * 3);
+      const ids = pickBySource(rows, PER_COUNTRY);
+      const moved = moveToJobs(archiveDb, ids, loc);
+      totalMoved += moved;
+      log("  ", `${loc} → ${moved}条 回退`);
+      continue;
+    }
 
-    const current = countRow?.c || 0;
+    // 2. LLM 打分
+    const ts = Date.now();
+    const scores = await scoreJobsBatch(samples, LOCATIONS);
+    log("  ", `${loc} 打分${scores.length}条 ${Date.now() - ts}ms`);
 
-    if (current >= opts.threshold) {
+    if (
+      scores.every(
+        (s) =>
+          s.score === 50 && LLM_FALLBACK_KW.some((kw) => s.reason.includes(kw)),
+      )
+    ) {
+      log("  ", `${loc} LLM全部不可用，回退...`);
+      const rows = archiveDb
+        .prepare(
+          `SELECT unique_id, sources FROM raw_jobs WHERE ${wf} ORDER BY video_count DESC LIMIT ?`,
+        )
+        .all(...wfa, PER_COUNTRY * 3);
+      const ids = pickBySource(rows, PER_COUNTRY);
+      const moved = moveToJobs(archiveDb, ids, loc);
+      totalMoved += moved;
+      log("  ", `${loc} → ${moved}条 回退`);
       continue;
     }
 
-    const need = opts.threshold - current;
-    const limit = Math.min(need, opts.batch);
+    // 3. 通过 → jobs+归档删；不通过 → scored_count+1
+    const passIds = [],
+      failIds = [];
+    for (const s of scores) {
+      if (s.score >= LLM_MIN) passIds.push(s.uniqueId);
+      else failIds.push(s.uniqueId);
+    }
+    log("  ", `${loc} 通过${passIds.length} 淘汰${failIds.length}`);
+
+    if (failIds.length) {
+      archiveDb
+        .prepare(
+          `UPDATE raw_jobs SET llm_scored_count=COALESCE(llm_scored_count,0)+1 WHERE unique_id IN (${ph(failIds.length)})`,
+        )
+        .run(...failIds);
+    }
 
-    const moved = moveBatch(mainDb, archiveDb, country, limit);
+    // 4. 写入 jobs
+    let moved = 0;
+    if (passIds.length) {
+      moved = moveToJobs(archiveDb, passIds, loc);
+    }
+    // 不够 → 回退补
+    if (moved < PER_COUNTRY) {
+      const gap = PER_COUNTRY - moved;
+      const rows = archiveDb
+        .prepare(
+          `SELECT unique_id, sources FROM raw_jobs WHERE ${wf} ORDER BY video_count DESC LIMIT ?`,
+        )
+        .all(...wfa, gap * 3);
+      const fbIds = pickBySource(rows, gap);
+      moved += moveToJobs(archiveDb, fbIds, loc);
+    }
+    totalMoved += moved;
+    log("  ", `${loc} → ${moved}条 LLM`);
+  }
+
+  log("--", `LLM完成 共写入${totalMoved}条`);
+  return { moved: totalMoved };
+}
+// ═══════════════════════════════════════════════════════════════════
+// 单轮调度
+let tickN = 0;
+
+async function tick(archiveDb, opts) {
+  tickN++;
+  const t0 = Date.now();
+
+  archiveNewUsers(archiveDb);
+  if (opts.llm) reloadLlmConfig(); // 每轮重载，支持热切换模型
+
+  const byCountry = countPendingByCountry();
+  const needy = findNeedyCountries(byCountry, PER_COUNTRY);
+
+  if (!needy.length) {
+    log(
+      "--",
+      `轮${tickN} 全部充足 | ${LOCATIONS.map((l) => `${l}:${byCountry[l]}`).join(" ")}`,
+    );
+    return;
+  }
 
-    results[country] = { before: current, moved, after: current + moved };
+  log(
+    "==",
+    `轮${tickN} 需补 ${needy.map((l) => `${l}(${byCountry[l]}→+${PER_COUNTRY})`).join(" ")}`,
+  );
 
+  if (opts.llm) {
+    const r = await refillLLM(archiveDb, needy);
+    const s = ((Date.now() - t0) / 1000).toFixed(1);
+    log(">>", `轮${tickN} 写入${r.moved}条 ${s}s`);
+  } else {
+    let total = 0;
+    for (const loc of needy) {
+      const r = refillRegular(archiveDb, PER_COUNTRY, [loc]);
+      total += r.moved;
+      log("  ", `${loc} +${r.moved}/${PER_COUNTRY}`);
+    }
+    const s = ((Date.now() - t0) / 1000).toFixed(1);
+    log(">>", `轮${tickN} 写入${total}条 ${s}s`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// 主入口
+// ═══════════════════════════════════════════════════════════════════
+
+async function main() {
+  const opts = parseArgs();
+  if (!opts.db || !opts.archive) {
     console.error(
-      `[sync] ${country}: ${current} → ${current + moved} (搬入 ${moved} 条)`,
+      "用法: node scripts/sync-raw-jobs.mjs --db <主库> --archive <归档库> [--llm] [--once] [--interval 120]",
     );
+    process.exit(1);
   }
 
-  const totalMoved = Object.values(results).reduce((s, r) => s + r.moved, 0);
-  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+  log(
+    "INIT",
+    `LLM=${opts.llm ? "ON" : "OFF"} 每国${PER_COUNTRY}条 ${opts.once ? "单次" : "间隔" + opts.interval + "s"}`,
+  );
 
-  if (totalMoved > 0) {
-    console.error(`[sync] 本轮共搬入 ${totalMoved} 条，耗时 ${elapsed}s`);
+  initDb(opts.db);
+  loadLlmConfig();
+
+  const archiveDb = new Database(opts.archive);
+  archiveDb.pragma("journal_mode = WAL");
+  if (
+    !archiveDb
+      .prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='raw_jobs'",
+      )
+      .get()
+  ) {
+    console.error("[sync] 归档库无 raw_jobs 表");
+    process.exit(1);
   }
+  log(
+    "INIT",
+    `归档 ${archiveDb.prepare("SELECT COUNT(*) as c FROM raw_jobs").get().c.toLocaleString()} 条`,
+  );
 
-  return results;
-}
+  archiveDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_raw_refill ON raw_jobs(guessed_location, video_count DESC, created_at DESC) WHERE video_count>6 AND follower_count>0 AND following_count>0`,
+  );
+  // tag/回退查询用：无国家过滤，按 video_count 排序
+  archiveDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_raw_vc ON raw_jobs(video_count DESC) WHERE video_count>6 AND follower_count>0 AND following_count>0`,
+  );
 
-// ===== 主流程 =====
-console.error("[sync] raw_jobs 同步程序启动");
-console.error(`[sync] 主库: ${opts.db}`);
-console.error(`[sync] 归档库: ${opts.archive}`);
-console.error(`[sync] 最低保有量: ${opts.threshold} 条/国家`);
-console.error(`[sync] 检测间隔: ${opts.once ? "仅一次" : opts.interval + "s"}`);
-console.error("");
-
-// 打开数据库
-const mainDb = new Database(opts.db);
-mainDb.pragma("journal_mode = WAL");
-const archiveDb = new Database(opts.archive);
-archiveDb.pragma("journal_mode = WAL");
-
-// 检查主库 raw_jobs 是否存在
-const mainTables = mainDb
-  .prepare(
-    "SELECT name FROM sqlite_master WHERE type='table' AND name='raw_jobs'",
-  )
-  .get();
-if (!mainTables) {
-  console.error("[sync] 错误: 主库中不存在 raw_jobs 表");
-  process.exit(1);
-}
+  // LLM 打分排序索引
+  archiveDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_raw_llm_score ON raw_jobs(llm_scored_count, video_count DESC) WHERE video_count>6 AND follower_count>0 AND following_count>0`,
+  );
+  try {
+    archiveDb.exec(
+      "ALTER TABLE raw_jobs ADD COLUMN llm_scored_count INTEGER DEFAULT 0",
+    );
+  } catch {
+    /* exists */
+  }
 
-// 检查归档库 raw_jobs 是否存在
-const archiveTables = archiveDb
-  .prepare(
-    "SELECT name FROM sqlite_master WHERE type='table' AND name='raw_jobs'",
-  )
-  .get();
-if (!archiveTables) {
-  console.error("[sync] 错误: 归档库中不存在 raw_jobs 表");
-  process.exit(1);
-}
+  await tick(archiveDb, opts);
+  if (opts.once) {
+    archiveDb.close();
+    getDb().close();
+    log("DONE", "退出");
+    process.exit(0);
+  }
 
-const archiveTotal =
-  archiveDb.prepare("SELECT COUNT(*) as c FROM raw_jobs").get()?.c || 0;
-console.error(
-  `[sync] 归档库 raw_jobs 总量: ${archiveTotal.toLocaleString()} 条`,
-);
-console.error("");
-
-// 执行同步
-syncOnce(mainDb, archiveDb);
-
-if (opts.once) {
-  mainDb.close();
-  archiveDb.close();
-  console.error("[sync] 完成，退出");
-  process.exit(0);
+  const timer = setInterval(() => tick(archiveDb, opts), opts.interval * 1000);
+  const stop = () => {
+    clearInterval(timer);
+    archiveDb.close();
+    getDb().close();
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
 }
 
-// 定时循环
-setInterval(() => {
-  syncOnce(mainDb, archiveDb);
-}, opts.interval * 1000);
-
-// 优雅退出
-process.on("SIGINT", () => {
-  console.error("\n[sync] 收到中断信号，退出...");
-  mainDb.close();
-  archiveDb.close();
-  process.exit(0);
+main().catch((e) => {
+  console.error("[sync] FATAL:", e);
+  process.exit(1);
 });