tt-help-cli-ycl 1.4.22 → 1.4.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.22",
+  "version": "1.4.24",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/migrate-raw-jobs.mjs

@@ -0,0 +1,243 @@
+/**
+ * raw_jobs 分库迁移脚本
+ *
+ * 用途: 将主库中 raw_jobs 表数据全部迁至归档库，主库仅保留空表结构。
+ * 用法: node scripts/migrate-raw-jobs.mjs [--db <主库路径>] [--archive <归档库路径>]
+ * 示例:
+ *   node scripts/migrate-raw-jobs.mjs
+ *   node scripts/migrate-raw-jobs.mjs --db D:\tiktok\data\result.db
+ *   node scripts/migrate-raw-jobs.mjs --db data/result.db --archive data/archive.db
+ * 前提: 主程序（watch server）已停止
+ */
+
+import Database from "better-sqlite3";
+import { copyFileSync, existsSync, statSync } from "fs";
+import { resolve, dirname, extname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ===== 命令行参数解析 =====
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {
+    mainDb: null,
+    archiveDb: null,
+  };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--db" && i + 1 < args.length) {
+      opts.mainDb = resolve(args[++i]);
+    } else if (args[i] === "--archive" && i + 1 < args.length) {
+      opts.archiveDb = resolve(args[++i]);
+    }
+  }
+  return opts;
+}
+
+const cliArgs = parseArgs();
+
+// ===== 配置 =====
+const MAIN_DB = cliArgs.mainDb || resolve(__dirname, "..", "data", "result.db");
+const ARCHIVE_DB =
+  cliArgs.archiveDb ||
+  (() => {
+    const ext = extname(MAIN_DB);
+    const base = MAIN_DB.slice(0, -ext.length);
+    return `${base}-archive${ext}`;
+  })();
+
+// ===== 工具函数 =====
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024)
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+// ===== 前置检查 =====
+console.error("=== raw_jobs 分库迁移 ===\n");
+
+if (!existsSync(MAIN_DB)) {
+  console.error(`错误: 主库不存在: ${MAIN_DB}`);
+  process.exit(1);
+}
+
+// 检查 WAL 文件，提示用户确保程序已停止
+const walPath = MAIN_DB + "-wal";
+const shmPath = MAIN_DB + "-shm";
+const hasWal = existsSync(walPath);
+const hasShm = existsSync(shmPath);
+
+if (hasWal || hasShm) {
+  console.error("警告: 检测到 WAL 文件，请先确保主程序已停止！");
+  console.error(`  ${walPath}: ${hasWal ? "存在" : "不存在"}`);
+  console.error(`  ${shmPath}: ${hasShm ? "存在" : "不存在"}`);
+  console.error("");
+}
+
+// ===== 步骤 0: 备份主库 =====
+console.error("[0/6] 备份主库...");
+
+const BACKUP_DB = MAIN_DB.replace(/\.db$/, `-bak-${Date.now()}.db`);
+copyFileSync(MAIN_DB, BACKUP_DB);
+console.error(`  备份已保存: ${BACKUP_DB}`);
+
+// ===== 步骤 1: 检查主库状态 =====
+console.error("\n[1/6] 检查主库...");
+
+const main = new Database(MAIN_DB);
+main.pragma("journal_mode = WAL");
+
+// 先做一次 CHECKPOINT，把 WAL 合并回主文件
+main.pragma("wal_checkpoint(TRUNCATE)");
+
+const rawCount = main.prepare("SELECT COUNT(*) as c FROM raw_jobs").get().c;
+const mainSize = statSync(MAIN_DB).size;
+
+console.error(`  主库大小: ${formatSize(mainSize)}`);
+console.error(`  raw_jobs 记录数: ${rawCount.toLocaleString()}`);
+
+if (rawCount === 0) {
+  console.error("  raw_jobs 已为空，无需迁移");
+  main.close();
+  process.exit(0);
+}
+
+// ===== 步骤 2: 提取 raw_jobs 完整 DDL =====
+console.error("\n[2/6] 提取 raw_jobs 表结构...");
+
+const createTableSql = main
+  .prepare(
+    "SELECT sql FROM sqlite_master WHERE type='table' AND name='raw_jobs'",
+  )
+  .get()?.sql;
+
+if (!createTableSql) {
+  console.error("  错误: 未找到 raw_jobs 建表语句");
+  main.close();
+  process.exit(1);
+}
+
+// 提取所有 raw_jobs 相关的索引
+const indexes = main
+  .prepare(
+    "SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name='raw_jobs' AND sql IS NOT NULL",
+  )
+  .all()
+  .map((r) => r.sql);
+
+console.error(`  建表语句: ${createTableSql.substring(0, 60)}...`);
+console.error(`  索引数量: ${indexes.length}`);
+
+main.close();
+
+// ===== 步骤 3: 拷贝主库 → 归档库 =====
+console.error("\n[3/6] 拷贝主库 → 归档库...");
+
+if (existsSync(ARCHIVE_DB)) {
+  console.error(`  归档库已存在，将覆盖: ${ARCHIVE_DB}`);
+}
+
+const startCopy = Date.now();
+copyFileSync(MAIN_DB, ARCHIVE_DB);
+const copyElapsed = ((Date.now() - startCopy) / 1000).toFixed(1);
+const archiveSize = statSync(ARCHIVE_DB).size;
+console.error(`  拷贝完成: ${formatSize(archiveSize)}，耗时 ${copyElapsed}s`);
+
+// ===== 步骤 4: 归档库清理 =====
+console.error("\n[4/6] 归档库清理（仅保留 raw_jobs）...");
+
+const archive = new Database(ARCHIVE_DB);
+archive.pragma("journal_mode = WAL");
+
+// 删除 raw_jobs 以外的所有表（排除 SQLite 系统表）
+const SKIP_TABLES = new Set(["raw_jobs", "sqlite_sequence"]);
+const tables = archive
+  .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+  .all()
+  .filter((t) => !SKIP_TABLES.has(t.name) && !t.name.startsWith("sqlite_"));
+
+for (const t of tables) {
+  archive.exec(`DROP TABLE IF EXISTS "${t.name}"`);
+  console.error(`  删除表: ${t.name}`);
+}
+
+// 删除 raw_jobs 以外的所有索引（排除 SQLite 系统索引）
+const otherIndexes = archive
+  .prepare("SELECT name FROM sqlite_master WHERE type='index'")
+  .all()
+  .filter(
+    (idx) => idx.tbl_name !== "raw_jobs" && !idx.name.startsWith("sqlite_"),
+  );
+for (const idx of otherIndexes) {
+  archive.exec(`DROP INDEX IF EXISTS "${idx.name}"`);
+}
+
+// 回收空间
+archive.exec("VACUUM");
+const archiveFinalSize = statSync(ARCHIVE_DB).size;
+archive.close();
+
+console.error(`  归档库最终大小: ${formatSize(archiveFinalSize)}`);
+
+// ===== 步骤 5: 主库清空 raw_jobs =====
+console.error("\n[5/6] 主库清空 raw_jobs...");
+
+const main2 = new Database(MAIN_DB);
+main2.pragma("journal_mode = WAL");
+main2.pragma("wal_checkpoint(TRUNCATE)");
+
+// DROP + 重建（使用原始建表语句）
+main2.exec("DROP TABLE IF EXISTS raw_jobs");
+main2.exec(createTableSql);
+
+// 重建索引
+for (const idxSql of indexes) {
+  main2.exec(idxSql);
+}
+
+main2.pragma("wal_checkpoint(TRUNCATE)");
+main2.close();
+
+console.error("  raw_jobs 已重建（空表）");
+
+// ===== 步骤 6: 主库 VACUUM，回收空间 =====
+console.error("\n[6/6] 主库空间回收 (VACUUM)...");
+
+const beforeVacuum = statSync(MAIN_DB).size;
+const startVacuum = Date.now();
+
+const main3 = new Database(MAIN_DB);
+main3.pragma("journal_mode = WAL");
+main3.exec("VACUUM");
+main3.close();
+
+const afterVacuum = statSync(MAIN_DB).size;
+const vacuumElapsed = ((Date.now() - startVacuum) / 1000).toFixed(1);
+console.error(
+  `  主库: ${formatSize(beforeVacuum)} → ${formatSize(afterVacuum)}，耗时 ${vacuumElapsed}s`,
+);
+
+// 验证
+const verifyDb = new Database(MAIN_DB);
+const verifyCount = verifyDb
+  .prepare("SELECT COUNT(*) as c FROM raw_jobs")
+  .get().c;
+verifyDb.close();
+
+// ===== 结果 =====
+console.error("\n=== 迁移完成 ===");
+console.error(`备份:     ${BACKUP_DB}`);
+console.error(`主库:     ${MAIN_DB}`);
+console.error(`  大小:   ${formatSize(afterVacuum)}`);
+console.error(`  raw_jobs: ${verifyCount} 条`);
+console.error("");
+console.error(`归档库:   ${ARCHIVE_DB}`);
+console.error(`  大小:   ${formatSize(archiveFinalSize)}`);
+console.error(`  raw_jobs: ${rawCount.toLocaleString()} 条`);
+console.error("");
+console.error("下一步:");
+console.error("  1. 启动主程序: tt-help watch -o data/result.db");
+console.error("  2. raw_jobs 空表，refill 不再卡顿");
+console.error("  3. 后续需编写同步程序，从归档库补充数据到主库 raw_jobs");

package/scripts/sync-raw-jobs.mjs

@@ -0,0 +1,281 @@
+/**
+ * raw_jobs 同步程序
+ *
+ * 定时检测主库中各目标国家的 raw_jobs 数量，不足时从归档库搬移补充。
+ * 搬移逻辑复用 refillJobsFromRaw 非 LLM 模式的排序规则。
+ *
+ * 用法:
+ *   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
+ */
+
+import Database from "better-sqlite3";
+
+// ===== 目标国家 =====
+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();
+
+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_CONDITIONS = [
+  "COALESCE(video_count, 0) > 6",
+  "COALESCE(follower_count, 0) > 0",
+  "COALESCE(following_count, 0) > 0",
+];
+
+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 = [
+  "unique_id",
+  "nickname",
+  "status",
+  "sources",
+  "claimed_by",
+  "claimed_at",
+  "error",
+  "pinned",
+  "no_video",
+  "restricted",
+  "user_update_count",
+  "tt_seller",
+  "verified",
+  "video_count",
+  "comment_count",
+  "guessed_location",
+  "location_created",
+  "confirmed_location",
+  "modified_at",
+  "follower_count",
+  "following_count",
+  "heart_count",
+  "refresh_time",
+  "processed",
+  "processed_at",
+  "created_at",
+  "updated_at",
+  "region",
+  "signature",
+  "bio_link",
+  "sec_uid",
+  "status_code",
+  "latest_video_time",
+  "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 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;
+  })();
+
+  return moved;
+}
+
+// ===== 单次同步 =====
+function syncOnce(mainDb, archiveDb) {
+  const start = Date.now();
+  const results = {};
+
+  for (const country of TARGET_LOCATIONS) {
+    // 检查主库中该国存量
+    const countRow = mainDb
+      .prepare(
+        `SELECT COUNT(*) as c FROM raw_jobs
+         WHERE UPPER(COALESCE(guessed_location, '')) = ?`,
+      )
+      .get(country);
+
+    const current = countRow?.c || 0;
+
+    if (current >= opts.threshold) {
+      continue;
+    }
+
+    const need = opts.threshold - current;
+    const limit = Math.min(need, opts.batch);
+
+    const moved = moveBatch(mainDb, archiveDb, country, limit);
+
+    results[country] = { before: current, moved, after: current + moved };
+
+    console.error(
+      `[sync] ${country}: ${current} → ${current + moved} (搬入 ${moved} 条)`,
+    );
+  }
+
+  const totalMoved = Object.values(results).reduce((s, r) => s + r.moved, 0);
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+
+  if (totalMoved > 0) {
+    console.error(`[sync] 本轮共搬入 ${totalMoved} 条，耗时 ${elapsed}s`);
+  }
+
+  return results;
+}
+
+// ===== 主流程 =====
+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);
+}
+
+// 检查归档库 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);
+}
+
+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);
+}
+
+// 定时循环
+setInterval(() => {
+  syncOnce(mainDb, archiveDb);
+}, opts.interval * 1000);
+
+// 优雅退出
+process.on("SIGINT", () => {
+  console.error("\n[sync] 收到中断信号，退出...");
+  mainDb.close();
+  archiveDb.close();
+  process.exit(0);
+});

package/src/cli/raw-sync.js

@@ -0,0 +1,41 @@
+/**
+ * raw-sync CLI 入口
+ *
+ * 启动 raw_jobs 同步程序（独立子进程）。
+ */
+
+import { spawn } from "child_process";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SCRIPT = resolve(__dirname, "..", "..", "scripts", "sync-raw-jobs.mjs");
+
+export function handleRawSync(parsed) {
+  const args = ["--db", parsed.rawSyncDb, "--archive", parsed.rawSyncArchive];
+
+  if (parsed.rawSyncInterval != null)
+    args.push("--interval", String(parsed.rawSyncInterval));
+  if (parsed.rawSyncThreshold != null)
+    args.push("--threshold", String(parsed.rawSyncThreshold));
+  if (parsed.rawSyncBatch != null)
+    args.push("--batch", String(parsed.rawSyncBatch));
+  if (parsed.rawSyncOnce) args.push("--once");
+
+  console.error(`[raw-sync] 启动同步程序: node ${SCRIPT} ${args.join(" ")}`);
+
+  const child = spawn("node", [SCRIPT, ...args], {
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code) => {
+    if (code !== 0) {
+      console.error(`[raw-sync] 同步程序退出，退出码: ${code}`);
+    }
+    process.exit(code);
+  });
+
+  // 转发信号给子进程
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+}

package/src/cli/refresh.js

@@ -541,7 +541,7 @@ export async function handleRefresh(options) {
 
       const payload = {
         userInfo: refreshUserInfo,
-        topRecentVideo: result.topRecentVideo || null,
+        recentEcVideos: result.recentEcVideos || null,
         discoveredFollowing: (result.discoveredFollowing || []).map((f) => ({
           handle: Array.isArray(f) ? f[0] : f,
           displayName: Array.isArray(f) ? f[1] : null,

package/src/lib/args.js

@@ -686,6 +686,52 @@ function parseOpenArgs(args) {
   };
 }
 
+function parseRawSyncArgs(args) {
+  let rawSyncDb = null;
+  let rawSyncArchive = null;
+  let rawSyncInterval = null;
+  let rawSyncThreshold = null;
+  let rawSyncBatch = null;
+  let rawSyncOnce = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--db" && i + 1 < args.length) {
+      rawSyncDb = args[++i];
+    } else if (arg === "--archive" && i + 1 < args.length) {
+      rawSyncArchive = args[++i];
+    } else if (arg === "--interval" && i + 1 < args.length) {
+      rawSyncInterval = parseInt(args[++i]) || null;
+    } else if (arg === "--threshold" && i + 1 < args.length) {
+      rawSyncThreshold = parseInt(args[++i]) || null;
+    } else if (arg === "--batch" && i + 1 < args.length) {
+      rawSyncBatch = parseInt(args[++i]) || null;
+    } else if (arg === "--once") {
+      rawSyncOnce = true;
+    }
+  }
+
+  return {
+    subcommand: "raw-sync",
+    rawSyncDb,
+    rawSyncArchive,
+    rawSyncInterval,
+    rawSyncThreshold,
+    rawSyncBatch,
+    rawSyncOnce,
+    urls: [],
+    outputFormat: "json",
+    exploreCount: 0,
+    showConfig: false,
+    showHelp: false,
+    customProxy: null,
+    configAction: null,
+    configValue: null,
+    pipeMode: false,
+    filterStr: null,
+  };
+}
+
 function parseVideoStatsArgs(args) {
   let statsSource = null;
   let statsParallel = 3;
@@ -1097,6 +1143,10 @@ export function parseArgs() {
     return parseRefreshArgs(args.slice(1));
   }
 
+  if (args.length > 0 && args[0] === "raw-sync") {
+    return parseRawSyncArgs(args.slice(1));
+  }
+
   const urls = [];
   let inputFile = null;
   let outputFile = null;

package/src/lib/constants.js

@@ -314,6 +314,19 @@ const HELP_TEXT = [
   "          tt-help tag refresh -s http://127.0.0.1:3001",
   "          tt-help tag refresh --port 8222 -s http://127.0.0.1:3001",
   "",
+  "  raw-sync --db <主库路径> --archive <归档库路径> [选项]",
+  "    从归档库向主库 raw_jobs 同步数据，按国家保持最低保有量",
+  "    选项:",
+  "      --db <路径>            主库路径（必填）",
+  "      --archive <路径>       归档库路径（必填）",
+  "      --interval <秒>        检测间隔，默认 30",
+  "      --threshold <条>       每个国家最低保有量，默认 1000",
+  "      --batch <条>           每次搬移上限，默认 500",
+  "      --once                 只执行一次后退出",
+  "    示例: tt-help raw-sync --db data/result.db --archive data/result-archive.db",
+  "          tt-help raw-sync --db data/result.db --archive data/result-archive.db --once",
+  "          tt-help raw-sync --db data/result.db --archive data/result-archive.db --interval 60 --threshold 2000",
+  "",
   "  config  [show|set|unset|reset]",
   "    config                    查看当前配置",
   "    config set <key> <value>  设置配置（key: proxy, server, browser, userId, maxFollowing, maxFollowers, maxVideos, maxComments）",
@@ -331,6 +344,7 @@ const HELP_TEXT = [
   "        tt-help attach -p 5 -i 10",
   "        tt-help watch -o data/result.db",
   "        tt-help videostats data/result.db -p 3",
+  "        tt-help raw-sync --db data/result.db --archive data/result-archive.db",
   "        tt-help tag discover ES FR --count 5",
   "        tt-help tag score ventas --countries ES",
   "        tt-help tag score-all --countries ES,FR -s http://127.0.0.1:3001",

package/src/main.js

@@ -19,6 +19,7 @@ import {
   handleScoreAll,
   handleTagRefresh,
 } from "./cli/tag.js";
+import { handleRawSync } from "./cli/raw-sync.js";
 
 async function main() {
   const parsed = parseArgs();
@@ -48,6 +49,8 @@ async function main() {
       return handleRefresh(parsed);
     case "tag":
       return handleTag(parsed);
+    case "raw-sync":
+      return handleRawSync(parsed);
     case "tag-discover":
       return handleDiscover(parsed);
     case "tag-score":