tt-help-cli-ycl 1.3.35 → 1.3.36

package/src/watch/data-store.js

@@ -1,6 +1,878 @@
 import fs from "fs";
-import { promises as fsPromises } from "fs";
 import path from "path";
+import Database from "better-sqlite3";
+
+// SQLite 用户表（用于判重）
+let db = null;
+let dbPath = null;
+
+function normalizeDbFilePath(filePath) {
+  if (!filePath) {
+    throw new Error("db path is required");
+  }
+  const resolved = path.resolve(filePath);
+  if (path.extname(resolved).toLowerCase() !== ".db") {
+    throw new Error(`仅支持 .db 路径，当前为: ${filePath}`);
+  }
+  return resolved;
+}
+
+function resetDbConnection() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+  dbPath = null;
+}
+
+function loadLegacyUsersFromFiles(userFilePath, doneFilePath) {
+  const merged = new Map();
+
+  const tryLoad = (targetPath, label) => {
+    if (!targetPath) return;
+    if (!fs.existsSync(targetPath)) return;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(targetPath, "utf-8"));
+      if (!Array.isArray(parsed)) return;
+      for (const item of parsed) {
+        const uniqueId = item?.uniqueId || item?.unique_id;
+        if (!uniqueId) continue;
+        merged.set(uniqueId, {
+          ...merged.get(uniqueId),
+          ...item,
+          uniqueId,
+        });
+      }
+    } catch (e) {
+      console.error(`[data-store] SQLite 导入 ${label} 失败: ${e.message}`);
+    }
+  };
+
+  tryLoad(userFilePath, "result.json");
+  tryLoad(doneFilePath, "result-done.json");
+
+  return [...merged.values()];
+}
+
+function loadLegacyVideosFromFile(videoPath) {
+  if (!videoPath) return [];
+  if (!fs.existsSync(videoPath)) return [];
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(videoPath, "utf-8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (e) {
+    console.error(
+      `[data-store] SQLite 导入 result-videos.json 失败: ${e.message}`,
+    );
+    return [];
+  }
+}
+
+function initUserDb(filePath) {
+  dbPath = normalizeDbFilePath(filePath);
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS users (
+      unique_id TEXT PRIMARY KEY,
+      tt_seller TEXT,
+      verified INTEGER,
+      location_created TEXT,
+      created_at TEXT,
+      updated_at TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS jobs (
+      unique_id TEXT PRIMARY KEY,
+      nickname TEXT,
+      status TEXT DEFAULT 'pending',
+      sources TEXT,
+      claimed_by TEXT,
+      claimed_at INTEGER,
+      error TEXT,
+      pinned INTEGER DEFAULT 0,
+      no_video INTEGER DEFAULT 0,
+      restricted INTEGER DEFAULT 0,
+      user_update_count INTEGER DEFAULT 0,
+      tt_seller INTEGER,
+      verified INTEGER,
+      video_count INTEGER DEFAULT 0,
+      comment_count INTEGER DEFAULT 0,
+      guessed_location TEXT,
+      location_created TEXT,
+      follower_count INTEGER DEFAULT 0,
+      following_count INTEGER DEFAULT 0,
+      heart_count INTEGER DEFAULT 0,
+      refresh_time INTEGER,
+      processed INTEGER DEFAULT 0,
+      processed_at INTEGER,
+      created_at INTEGER,
+      updated_at INTEGER,
+      region TEXT,
+      signature TEXT,
+      sec_uid TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS videos (
+      id TEXT PRIMARY KEY,
+      href TEXT,
+      author_unique_id TEXT,
+      location_created TEXT,
+      tt_seller INTEGER DEFAULT 0,
+      registered_at INTEGER,
+      user_update_count INTEGER DEFAULT 0,
+      play_count INTEGER,
+      digg_count INTEGER,
+      comment_count INTEGER,
+      share_count INTEGER,
+      collect_count INTEGER,
+      stats_updated_at INTEGER
+    )
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_status_video
+    ON jobs(status, video_count DESC)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_claimed_by_status
+    ON jobs(claimed_by, status, claimed_at)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_status_claimed_at
+    ON jobs(status, claimed_at)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_redo_target
+    ON jobs(tt_seller, verified, location_created, refresh_time)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_pending_priority
+    ON jobs(status, pinned DESC, guessed_location, follower_count DESC)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_claim_pending_pinned
+    ON jobs(created_at ASC, unique_id ASC)
+    WHERE status = 'pending' AND COALESCE(pinned, 0) = 1
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_claim_pending_seller
+    ON jobs(UPPER(COALESCE(guessed_location, '')), follower_count DESC, created_at ASC, unique_id ASC)
+    WHERE status = 'pending'
+      AND COALESCE(pinned, 0) = 0
+      AND tt_seller = 1
+      AND verified = 0
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_claim_pending_follow
+    ON jobs(UPPER(COALESCE(guessed_location, '')), follower_count DESC, created_at ASC, unique_id ASC)
+    WHERE status = 'pending'
+      AND COALESCE(pinned, 0) = 0
+      AND (
+        instr(COALESCE(sources, ''), '"following"') > 0
+        OR instr(COALESCE(sources, ''), '"follower"') > 0
+      )
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_claim_pending_other
+    ON jobs(UPPER(COALESCE(guessed_location, '')), follower_count DESC, created_at ASC, unique_id ASC)
+    WHERE status = 'pending' AND COALESCE(pinned, 0) = 0
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_user_update_queue
+    ON jobs(created_at ASC, unique_id ASC)
+    WHERE (tt_seller IS NULL OR tt_seller = '')
+      AND (user_update_count IS NULL OR user_update_count <= 0)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_jobs_user_update_queue_expr
+    ON jobs(created_at ASC, unique_id ASC)
+    WHERE COALESCE(tt_seller, '') = ''
+      AND COALESCE(user_update_count, 0) <= 0
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_videos_comment_queue
+    ON videos(user_update_count, tt_seller DESC, registered_at ASC)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_videos_comment_queue_pending
+    ON videos(tt_seller DESC, registered_at ASC, id)
+    WHERE user_update_count IS NULL OR user_update_count <= 0
+  `);
+
+  const existingVideoColumns = new Set(
+    db
+      .prepare("PRAGMA table_info(videos)")
+      .all()
+      .map((column) => column.name),
+  );
+  const requiredVideoColumns = {
+    play_count: "INTEGER",
+    digg_count: "INTEGER",
+    comment_count: "INTEGER",
+    share_count: "INTEGER",
+    collect_count: "INTEGER",
+    stats_updated_at: "INTEGER",
+  };
+  for (const [column, type] of Object.entries(requiredVideoColumns)) {
+    if (!existingVideoColumns.has(column)) {
+      db.exec(`ALTER TABLE videos ADD COLUMN ${column} ${type}`);
+    }
+  }
+
+  const count = db.prepare("SELECT COUNT(*) as c FROM users").get().c;
+  console.log(`[data-store] SQLite users 表初始化完成: ${count} 条`);
+}
+
+export function importLegacyJsonToDb({
+  dbFilePath,
+  usersFilePath,
+  doneFilePath,
+  videosFilePath,
+}) {
+  resetDbConnection();
+  initUserDb(dbFilePath);
+
+  const legacyUsers = loadLegacyUsersFromFiles(usersFilePath, doneFilePath);
+  const legacyVideos = loadLegacyVideosFromFile(videosFilePath);
+
+  const beforeUsers = db.prepare("SELECT COUNT(*) as c FROM users").get().c;
+  const beforeJobs = db.prepare("SELECT COUNT(*) as c FROM jobs").get().c;
+  const beforeVideos = db.prepare("SELECT COUNT(*) as c FROM videos").get().c;
+
+  const insertUserStmt = db.prepare(`
+    INSERT OR IGNORE INTO users (unique_id) VALUES (?)
+  `);
+  const insertVideoStmt = db.prepare(`
+    INSERT OR IGNORE INTO videos (
+      id,
+      href,
+      author_unique_id,
+      location_created,
+      tt_seller,
+      registered_at,
+      user_update_count
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  const importUsersTxn = db.transaction((items) => {
+    for (const item of items) {
+      const uniqueId = item.uniqueId || item.unique_id;
+      if (!uniqueId) continue;
+      insertUserStmt.run(uniqueId);
+      addJobToDb({ ...item, uniqueId });
+    }
+  });
+
+  const importVideosTxn = db.transaction((items) => {
+    for (const item of items) {
+      if (!item?.id) continue;
+      insertVideoStmt.run(
+        item.id,
+        item.href || null,
+        item.authorUniqueId || item.author_unique_id || null,
+        item.locationCreated || item.location_created || null,
+        item.ttSeller ? 1 : 0,
+        item.registeredAt || item.registered_at || Date.now(),
+        item.userUpdateCount || item.user_update_count || 0,
+      );
+    }
+  });
+
+  importUsersTxn(legacyUsers);
+  importVideosTxn(legacyVideos);
+
+  const afterUsers = db.prepare("SELECT COUNT(*) as c FROM users").get().c;
+  const afterJobs = db.prepare("SELECT COUNT(*) as c FROM jobs").get().c;
+  const afterVideos = db.prepare("SELECT COUNT(*) as c FROM videos").get().c;
+
+  return {
+    dbPath,
+    usersImported: afterUsers - beforeUsers,
+    jobsImported: afterJobs - beforeJobs,
+    videosImported: afterVideos - beforeVideos,
+    totalUsers: afterUsers,
+    totalJobs: afterJobs,
+    totalVideos: afterVideos,
+  };
+}
+
+export function closeStoreDb() {
+  resetDbConnection();
+}
+
+function hasUserInDb(uid) {
+  if (!db) return false;
+  const row = db.prepare("SELECT 1 FROM users WHERE unique_id = ?").get(uid);
+  return !!row;
+}
+
+function addUserToDb(user) {
+  if (!db) return;
+  db.prepare(
+    `
+    INSERT OR IGNORE INTO users (unique_id, tt_seller, verified, location_created, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `,
+  ).run(
+    user.uniqueId,
+    user.ttSeller === undefined ||
+      user.ttSeller === null ||
+      user.ttSeller === ""
+      ? null
+      : user.ttSeller
+        ? 1
+        : 0,
+    user.verified === undefined ||
+      user.verified === null ||
+      user.verified === ""
+      ? null
+      : user.verified
+        ? 1
+        : 0,
+    user.locationCreated || null,
+    new Date().toISOString(),
+    new Date().toISOString(),
+  );
+}
+
+function addJobToDb(user) {
+  if (!db) return;
+  const now = Date.now();
+  db.prepare(
+    `
+    INSERT OR IGNORE INTO jobs (
+      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,
+      follower_count,
+      following_count,
+      heart_count,
+      refresh_time,
+      processed,
+      processed_at,
+      created_at,
+      updated_at,
+      region,
+      signature,
+      sec_uid
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `,
+  ).run(
+    user.uniqueId,
+    user.nickname || null,
+    user.status || inferStatus(user),
+    JSON.stringify(
+      Array.isArray(user.sources) ? [...new Set(user.sources)] : [],
+    ),
+    user.claimedBy || null,
+    user.claimedAt || null,
+    user.error || null,
+    user.pinned ? 1 : 0,
+    user.noVideo ? 1 : 0,
+    user.restricted ? 1 : 0,
+    user.userUpdateCount || 0,
+    user.ttSeller === undefined ||
+      user.ttSeller === null ||
+      user.ttSeller === ""
+      ? null
+      : user.ttSeller
+        ? 1
+        : 0,
+    user.verified === undefined ||
+      user.verified === null ||
+      user.verified === ""
+      ? null
+      : user.verified
+        ? 1
+        : 0,
+    user.videoCount || 0,
+    user.commentCount || 0,
+    user.guessedLocation || null,
+    user.locationCreated || null,
+    user.followerCount || 0,
+    user.followingCount || 0,
+    user.heartCount || 0,
+    user.refreshTime || null,
+    user.processed ? 1 : 0,
+    user.processedAt || null,
+    user.createdAt || now,
+    user.updatedAt || now,
+    user.region || null,
+    user.signature || null,
+    user.secUid || null,
+  );
+}
+
+function getUserDbCount() {
+  if (!db) return 0;
+  return db.prepare("SELECT COUNT(*) as c FROM users").get().c;
+}
+
+function getJobsCount() {
+  if (!db) return 0;
+  return db.prepare("SELECT COUNT(*) as c FROM jobs").get().c;
+}
+
+function getPendingJobsCount() {
+  if (!db) return 0;
+  return db
+    .prepare("SELECT COUNT(*) as c FROM jobs WHERE status = 'pending'")
+    .get().c;
+}
+
+function getPendingJobsUserUpdateCount() {
+  if (!db) return 0;
+  return db
+    .prepare(
+      `
+      SELECT COUNT(*) as c
+      FROM jobs
+      WHERE COALESCE(tt_seller, '') = ''
+        AND COALESCE(user_update_count, 0) <= 0
+    `,
+    )
+    .get().c;
+}
+
+function getDashboardStatsFromDb(targetLocations = []) {
+  if (!db) return null;
+
+  const total = getJobsCount();
+  const statusCounts = {
+    pending: 0,
+    processing: 0,
+    done: 0,
+    error: 0,
+    restricted: 0,
+  };
+  const rows = db
+    .prepare(
+      `
+      SELECT status, COUNT(*) as count
+      FROM jobs
+      GROUP BY status
+    `,
+    )
+    .all();
+  for (const row of rows) {
+    if (row.status && statusCounts[row.status] !== undefined) {
+      statusCounts[row.status] = row.count;
+    }
+  }
+
+  const targetPlaceholders = targetLocations.map(() => "?").join(", ");
+  const targetUsers = targetLocations.length
+    ? db
+        .prepare(
+          `
+          SELECT COUNT(*) as c
+          FROM jobs
+          WHERE tt_seller = 1
+            AND verified = 0
+            AND location_created IN (${targetPlaceholders})
+        `,
+        )
+        .get(...targetLocations).c
+    : 0;
+
+  const countryStats = db
+    .prepare(
+      `
+      SELECT
+        COALESCE(location_created, '未知') as country,
+        COUNT(*) as count,
+        SUM(CASE
+          WHEN tt_seller = 1 AND verified = 0 ${
+            targetLocations.length
+              ? `AND location_created IN (${targetPlaceholders})`
+              : "AND 1 = 0"
+          }
+          THEN 1 ELSE 0 END) as targetCount
+      FROM jobs
+      WHERE status = 'done'
+      GROUP BY COALESCE(location_created, '未知')
+      ORDER BY count DESC
+    `,
+    )
+    .all(...targetLocations);
+
+  const targetCountryStats = targetLocations.length
+    ? db
+        .prepare(
+          `
+          SELECT location_created as country, COUNT(*) as count
+          FROM jobs
+          WHERE tt_seller = 1
+            AND verified = 0
+            AND location_created IN (${targetPlaceholders})
+          GROUP BY location_created
+          ORDER BY count DESC
+        `,
+        )
+        .all(...targetLocations)
+    : [];
+
+  const sourceRow = db
+    .prepare(
+      `
+      SELECT
+        SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as processed,
+        SUM(CASE WHEN status = 'restricted' THEN 1 ELSE 0 END) as restricted,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
+        SUM(CASE WHEN no_video = 1 THEN 1 ELSE 0 END) as noVideo,
+        SUM(CASE WHEN status != 'done' AND instr(COALESCE(sources, ''), '"video"') > 0 THEN 1 ELSE 0 END) as video,
+        SUM(CASE WHEN status != 'done' AND instr(COALESCE(sources, ''), '"comment"') > 0 THEN 1 ELSE 0 END) as comment,
+        SUM(CASE WHEN status != 'done' AND instr(COALESCE(sources, ''), '"guess"') > 0 THEN 1 ELSE 0 END) as guess,
+        SUM(CASE WHEN status != 'done' AND instr(COALESCE(sources, ''), '"following"') > 0 THEN 1 ELSE 0 END) as following,
+        SUM(CASE WHEN status != 'done' AND instr(COALESCE(sources, ''), '"follower"') > 0 THEN 1 ELSE 0 END) as follower,
+        SUM(CASE
+          WHEN status != 'done'
+            AND instr(COALESCE(sources, ''), '"video"') = 0
+            AND instr(COALESCE(sources, ''), '"comment"') = 0
+            AND instr(COALESCE(sources, ''), '"guess"') = 0
+            AND instr(COALESCE(sources, ''), '"following"') = 0
+            AND instr(COALESCE(sources, ''), '"follower"') = 0
+          THEN 1 ELSE 0 END) as seed
+      FROM jobs
+    `,
+    )
+    .get();
+
+  return {
+    totalUsers: total,
+    dbTotalUsers: getUserDbCount(),
+    jobsTotal: total,
+    jobsPending: getPendingJobsCount(),
+    processedUsers: statusCounts.done,
+    pendingUsers: statusCounts.pending,
+    processingUsers: statusCounts.processing,
+    restrictedUsers: statusCounts.restricted,
+    errorUsers: statusCounts.error,
+    targetUsers,
+    userUpdateTasks: getPendingJobsUserUpdateCount(),
+    targetCountryStats,
+    countryStats,
+    sourceStats: {
+      seed: sourceRow.seed || 0,
+      video: sourceRow.video || 0,
+      comment: sourceRow.comment || 0,
+      guess: sourceRow.guess || 0,
+      following: sourceRow.following || 0,
+      follower: sourceRow.follower || 0,
+      processed: sourceRow.processed || 0,
+      restricted: sourceRow.restricted || 0,
+      error: sourceRow.error || 0,
+      noVideo: sourceRow.noVideo || 0,
+    },
+  };
+}
+
+function getUsersPageFromDb({
+  status,
+  search,
+  location,
+  target,
+  targetLocation,
+  limit,
+  offset,
+  targetLocations = [],
+}) {
+  if (!db) return null;
+
+  const safeLimit = Math.max(1, Math.min(200, parseInt(limit) || 50));
+  const safeOffset = Math.max(0, parseInt(offset) || 0);
+  const where = [];
+  const args = [];
+
+  if (status && status !== "all") {
+    where.push("status = ?");
+    args.push(status);
+  }
+  if (target === "1") {
+    if (targetLocation) {
+      where.push("tt_seller = 1 AND verified = 0 AND location_created = ?");
+      args.push(targetLocation);
+    } else if (targetLocations.length > 0) {
+      where.push(
+        `tt_seller = 1 AND verified = 0 AND location_created IN (${targetLocations
+          .map(() => "?")
+          .join(", ")})`,
+      );
+      args.push(...targetLocations);
+    } else {
+      where.push("1 = 0");
+    }
+  }
+  if (search) {
+    where.push(
+      "(LOWER(unique_id) LIKE ? OR LOWER(COALESCE(nickname, '')) LIKE ?)",
+    );
+    const pattern = `%${String(search).toLowerCase()}%`;
+    args.push(pattern, pattern);
+  }
+  if (location) {
+    where.push("location_created = ?");
+    args.push(location);
+  }
+
+  const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
+  const total = db
+    .prepare(`SELECT COUNT(*) as c FROM jobs ${whereSql}`)
+    .get(...args).c;
+
+  const rows = db
+    .prepare(
+      `
+      SELECT *
+      FROM jobs
+      ${whereSql}
+      ORDER BY
+        pinned DESC,
+        CASE status
+          WHEN 'processing' THEN 0
+          WHEN 'pending' THEN 1
+          WHEN 'done' THEN 2
+          WHEN 'error' THEN 3
+          WHEN 'restricted' THEN 4
+          ELSE 9
+        END ASC,
+        CASE
+          WHEN status = 'done' THEN -COALESCE(processed_at, 0)
+          ELSE 0
+        END ASC,
+        CASE
+          WHEN status = 'pending' AND tt_seller = 1 AND verified = 0 THEN 0
+          ELSE 1
+        END ASC,
+        CASE
+          WHEN status = 'pending' AND UPPER(COALESCE(guessed_location, '')) IN ('PL', 'NL', 'BE', 'AT') THEN 0
+          WHEN status = 'pending' AND UPPER(COALESCE(guessed_location, '')) IN ('DE', 'FR', 'IT', 'IE', 'ES') THEN 1
+          ELSE 2
+        END ASC,
+        COALESCE(follower_count, 0) DESC,
+        COALESCE(processed_at, 0) DESC,
+        unique_id ASC
+      LIMIT ? OFFSET ?
+    `,
+    )
+    .all(...args, safeLimit, safeOffset)
+    .map(mapJobRow);
+
+  return {
+    total,
+    users: rows,
+  };
+}
+
+function getTargetUsersFromDb(targetLocations = []) {
+  if (!db) return null;
+  if (!targetLocations.length) {
+    return { total: 0, users: [] };
+  }
+
+  const placeholders = targetLocations.map(() => "?").join(", ");
+  const rows = db
+    .prepare(
+      `
+      SELECT
+        unique_id,
+        nickname,
+        follower_count,
+        tt_seller,
+        verified,
+        location_created,
+        status,
+        sources
+      FROM jobs
+      WHERE tt_seller = 1
+        AND verified = 0
+        AND location_created IN (${placeholders})
+      ORDER BY COALESCE(follower_count, 0) DESC, unique_id ASC
+    `,
+    )
+    .all(...targetLocations)
+    .map(mapJobRow);
+
+  return {
+    total: rows.length,
+    users: rows,
+  };
+}
+
+function snakeToCamel(key) {
+  return key.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase());
+}
+
+function camelToSnake(key) {
+  return key.replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`);
+}
+
+const jobBooleanColumns = new Set([
+  "pinned",
+  "no_video",
+  "restricted",
+  "processed",
+  "tt_seller",
+  "verified",
+]);
+
+const videoBooleanColumns = new Set(["tt_seller"]);
+
+const writableJobColumns = new Set([
+  "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",
+  "follower_count",
+  "following_count",
+  "heart_count",
+  "refresh_time",
+  "processed",
+  "processed_at",
+  "updated_at",
+  "region",
+  "signature",
+  "sec_uid",
+]);
+
+function normalizeJobValue(column, value) {
+  if (column === "sources") {
+    if (!Array.isArray(value)) return JSON.stringify([]);
+    return JSON.stringify([...new Set(value)]);
+  }
+  if (jobBooleanColumns.has(column)) {
+    if (value === undefined || value === null || value === "") return null;
+    return value ? 1 : 0;
+  }
+  return value;
+}
+
+function mapJobRow(row) {
+  if (!row) return undefined;
+  const mapped = {};
+  for (const [key, value] of Object.entries(row)) {
+    const camelKey = snakeToCamel(key);
+    if (key === "sources") {
+      try {
+        mapped[camelKey] = value ? JSON.parse(value) : [];
+      } catch {
+        mapped[camelKey] = [];
+      }
+      continue;
+    }
+    if (jobBooleanColumns.has(key)) {
+      mapped[camelKey] = value === null || value === undefined ? null : !!value;
+      continue;
+    }
+    mapped[camelKey] = value;
+  }
+  return mapped;
+}
+
+function getJobRow(uniqueId) {
+  if (!db) return null;
+  return db.prepare("SELECT * FROM jobs WHERE unique_id = ?").get(uniqueId);
+}
+
+function getJob(uniqueId) {
+  return mapJobRow(getJobRow(uniqueId));
+}
+
+function getAllJobs() {
+  if (!db) return [];
+  return db.prepare("SELECT * FROM jobs").all().map(mapJobRow);
+}
+
+function mapVideoRow(row) {
+  if (!row) return undefined;
+  const mapped = {};
+  for (const [key, value] of Object.entries(row)) {
+    const camelKey = snakeToCamel(key);
+    if (videoBooleanColumns.has(key)) {
+      mapped[camelKey] = value === null || value === undefined ? null : !!value;
+      continue;
+    }
+    mapped[camelKey] = value;
+  }
+  return mapped;
+}
+
+function getVideoRow(videoId) {
+  if (!db) return null;
+  return db.prepare("SELECT * FROM videos WHERE id = ?").get(videoId);
+}
+
+function getAllVideoRows() {
+  if (!db) return [];
+  return db.prepare("SELECT * FROM videos").all();
+}
+
+function updateJobInfo(uniqueId, info, incrementCount = true) {
+  if (!db) return { error: "db not initialized" };
+  const existing = getJobRow(uniqueId);
+  if (!existing) return { error: "user not found" };
+
+  const nextValues = {};
+  for (const [key, value] of Object.entries(info || {})) {
+    if (key === "uniqueId" || key === "unique_id") continue;
+    if (value === undefined || value === "") continue;
+    const column = camelToSnake(key);
+    if (!writableJobColumns.has(column)) continue;
+    nextValues[column] = normalizeJobValue(column, value);
+  }
+
+  nextValues.updated_at = Date.now();
+  if (incrementCount) {
+    nextValues.user_update_count = (existing.user_update_count || 0) + 1;
+  }
+
+  const columns = Object.keys(nextValues);
+  if (columns.length > 0) {
+    const sql = `UPDATE jobs SET ${columns.map((column) => `${column} = ?`).join(", ")} WHERE unique_id = ?`;
+    db.prepare(sql).run(
+      ...columns.map((column) => nextValues[column]),
+      uniqueId,
+    );
+  }
+
+  return {
+    ok: true,
+    userUpdateCount:
+      nextValues.user_update_count ?? existing.user_update_count ?? 0,
+  };
+}
 
 function inferStatus(u) {
   if (u.restricted) return "restricted";
@@ -9,27 +881,32 @@ function inferStatus(u) {
   return "pending";
 }
 
+function addJob(user) {
+  if (!db) {
+    addUserToDb(user);
+    return;
+  }
+  if (!user.status) user.status = inferStatus(user);
+  if (!user.createdAt) user.createdAt = Date.now();
+  if (!user.updatedAt) user.updatedAt = user.createdAt;
+  const writeTxn = db.transaction((job) => {
+    addUserToDb(job);
+    addJobToDb(job);
+  });
+  writeTxn(user);
+}
+
 export function createStore(filePath) {
+  if (!filePath) {
+    throw new Error("createStore requires an explicit .db path");
+  }
   let data = [];
   // uniqueId → index 内存索引，O(1) 查找
   let uidIndex = new Map();
   let clientErrors = new Map();
-
-  // done 用户归档（独立文件，主文件只保留活跃用户）
-  let doneArchive = [];
-  let doneArchivePath = null;
-  let doneUidIndex = new Map();
   if (filePath) {
-    doneArchivePath = path.resolve(filePath).replace(/\.json$/, "-done.json");
-    if (fs.existsSync(doneArchivePath)) {
-      try {
-        const content = fs.readFileSync(doneArchivePath, "utf-8");
-        const parsed = JSON.parse(content);
-        if (Array.isArray(parsed)) doneArchive = parsed;
-      } catch (e) {
-        console.error(`[data-store] 读取 done 归档失败: ${e.message}`);
-      }
-    }
+    // 初始化 SQLite 用户表（用于判重）
+    initUserDb(filePath);
   }
 
   // stats 缓存
@@ -42,6 +919,34 @@ export function createStore(filePath) {
   }
 
   function computeStatsInternal() {
+    if (db) {
+      const total = getJobsCount();
+      const statusCounts = {
+        pending: 0,
+        processing: 0,
+        done: 0,
+        error: 0,
+        restricted: 0,
+      };
+      const rows = db
+        .prepare(
+          `
+          SELECT status, COUNT(*) as count
+          FROM jobs
+          GROUP BY status
+        `,
+        )
+        .all();
+      for (const row of rows) {
+        if (row.status && statusCounts[row.status] !== undefined) {
+          statusCounts[row.status] = row.count;
+        }
+      }
+      statsCache = { total, statusCounts };
+      statsDirty = false;
+      return statsCache;
+    }
+
     const total = data.length;
     const statusCounts = {
       pending: 0,
@@ -99,6 +1004,26 @@ export function createStore(filePath) {
   }
 
   function rebuildStatusGroups() {
+    if (db) {
+      statusGroups = {
+        pending: [],
+        processing: [],
+        done: [],
+        error: [],
+        restricted: [],
+      };
+      for (const u of getAllJobs()) {
+        const key = u.status || "pending";
+        if (statusGroups[key]) statusGroups[key].push(u);
+        else statusGroups[key] = [u];
+      }
+      for (const key of Object.keys(statusGroups)) {
+        statusGroups[key] = sortGroup(key, statusGroups[key]);
+      }
+      groupsDirty = false;
+      return;
+    }
+
     statusGroups = {
       pending: [],
       processing: [],
@@ -111,10 +1036,6 @@ export function createStore(filePath) {
       if (statusGroups[key]) statusGroups[key].push(u);
       else statusGroups[key] = [u];
     }
-    // done 归档单独处理
-    if (doneArchive.length > 0) {
-      statusGroups.done = statusGroups.done.concat(doneArchive);
-    }
     // 各组内排序
     for (const key of Object.keys(statusGroups)) {
       statusGroups[key] = sortGroup(key, statusGroups[key]);
@@ -131,69 +1052,8 @@ export function createStore(filePath) {
     groupsDirty = true;
   }
 
-  // 视频存储（独立 JSON 文件）
+  // 视频存储（SQLite 真相源）
   let videos = [];
-  let videoFilePath = null;
-  if (filePath) {
-    const resolved = path.resolve(filePath);
-    videoFilePath = resolved.replace(/\.json$/, "-videos.json");
-    if (fs.existsSync(videoFilePath)) {
-      try {
-        const content = fs.readFileSync(videoFilePath, "utf-8");
-        const parsed = JSON.parse(content);
-        if (Array.isArray(parsed)) {
-          videos = parsed;
-        }
-      } catch (e) {
-        console.error(`[data-store] 读取视频文件失败: ${e.message}`);
-      }
-    }
-  }
-
-  let backupTimer = null;
-
-  if (filePath) {
-    const resolved = path.resolve(filePath);
-    const backupDir = path.join(path.dirname(resolved), ".backup");
-    const maxBackups = 3;
-
-    if (fs.existsSync(resolved)) {
-      try {
-        const content = fs.readFileSync(resolved, "utf-8");
-        data = JSON.parse(content);
-        if (!Array.isArray(data)) {
-          data = [];
-        }
-      } catch (e) {
-        console.error(`[data-store] 读取文件失败: ${e.message}`);
-        data = [];
-      }
-    }
-
-    function runBackup() {
-      if (!fs.existsSync(resolved)) return;
-      if (!fs.existsSync(backupDir))
-        fs.mkdirSync(backupDir, { recursive: true });
-      const now = new Date();
-      const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 13);
-      const backupFile = path.join(backupDir, `data-${timestamp}.json`);
-      try {
-        fs.copyFileSync(resolved, backupFile);
-        const files = fs
-          .readdirSync(backupDir)
-          .filter((f) => f.startsWith("data-") && f.endsWith(".json"))
-          .sort()
-          .map((f) => path.join(backupDir, f));
-        while (files.length > maxBackups) {
-          fs.unlinkSync(files.shift());
-        }
-      } catch (e) {
-        console.error(`[data-store] 备份失败: ${e.message}`);
-      }
-    }
-
-    backupTimer = setInterval(runBackup, 60 * 60 * 1000);
-  }
 
   // 构建索引 + 推断 status
   for (let i = 0; i < data.length; i++) {
@@ -202,189 +1062,69 @@ export function createStore(filePath) {
     uidIndex.set(u.uniqueId, i);
   }
 
-  // 构建 done 归档索引
-  for (let i = 0; i < doneArchive.length; i++) {
-    doneUidIndex.set(doneArchive[i].uniqueId, i);
-  }
-
-  function rebuildIndex() {
-    uidIndex = new Map();
-    for (let i = 0; i < data.length; i++) {
-      uidIndex.set(data[i].uniqueId, i);
-    }
-  }
-
-  let saveTimer = null;
-  let savePending = false;
-
-  function scheduleSave() {
-    if (saveTimer) return;
-    savePending = true;
-    saveTimer = setTimeout(() => {
-      saveTimer = null;
-      savePending = false;
-      doSave();
-    }, 2000);
-    saveTimer.unref();
-  }
-
-  function doSave() {
-    if (!filePath) return;
-    const resolved = path.resolve(filePath);
-
-    // 将 done 用户归档到独立文件
-    if (doneArchivePath && data.length > 1000) {
-      const active = [];
-      const toArchive = [];
-      for (const u of data) {
-        if (u.status === "done") {
-          toArchive.push(u);
-        } else {
-          active.push(u);
-        }
-      }
-      if (toArchive.length > 0) {
-        doneArchive = doneArchive.concat(toArchive);
-        data = active;
-        rebuildIndex();
-        // 重建 done 归档索引
-        doneUidIndex = new Map();
-        for (let i = 0; i < doneArchive.length; i++) {
-          doneUidIndex.set(doneArchive[i].uniqueId, i);
-        }
-      }
-    }
-
-    const json = JSON.stringify(data);
-    const tmpPath = resolved + ".tmp";
-    fsPromises
-      .writeFile(tmpPath, json, "utf-8")
-      .then(() => fsPromises.rename(tmpPath, resolved))
-      .then(() => {
-        if (doneArchivePath && doneArchive.length > 0) {
-          const doneJson = JSON.stringify(doneArchive);
-          const doneTmp = doneArchivePath + ".tmp";
-          return fsPromises
-            .writeFile(doneTmp, doneJson, "utf-8")
-            .then(() => fsPromises.rename(doneTmp, doneArchivePath));
-        }
-      })
-      .catch((err) => {
-        console.error(`[data-store] save 写入失败: ${err.message}`);
-      });
-  }
-
   function save() {
-    scheduleSave();
+    return;
   }
 
   function flushSave() {
-    return new Promise((resolve) => {
-      if (saveTimer) {
-        clearTimeout(saveTimer);
-        saveTimer = null;
-        savePending = false;
-      }
-      if (!filePath) {
-        resolve();
-        return;
-      }
-      const resolved = path.resolve(filePath);
-
-      // 将 done 用户归档到独立文件
-      if (doneArchivePath && data.length > 1000) {
-        const active = [];
-        const toArchive = [];
-        for (const u of data) {
-          if (u.status === "done") {
-            toArchive.push(u);
-          } else {
-            active.push(u);
-          }
-        }
-        if (toArchive.length > 0) {
-          doneArchive = doneArchive.concat(toArchive);
-          data = active;
-          rebuildIndex();
-          doneUidIndex = new Map();
-          for (let i = 0; i < doneArchive.length; i++) {
-            doneUidIndex.set(doneArchive[i].uniqueId, i);
-          }
-        }
-      }
-
-      const json = JSON.stringify(data);
-      const tmpPath = resolved + ".tmp";
-      fsPromises
-        .writeFile(tmpPath, json, "utf-8")
-        .then(() => fsPromises.rename(tmpPath, resolved))
-        .then(() => {
-          if (doneArchivePath && doneArchive.length > 0) {
-            const doneJson = JSON.stringify(doneArchive);
-            const doneTmp = doneArchivePath + ".tmp";
-            return fsPromises
-              .writeFile(doneTmp, doneJson, "utf-8")
-              .then(() => fsPromises.rename(doneTmp, doneArchivePath));
-          }
-          resolve();
-        })
-        .catch((err) => {
-          console.error(`[data-store] flushSave 写入失败: ${err.message}`);
-          resolve();
-        });
-    });
+    return Promise.resolve();
   }
 
-  let videosSaveTimer = null;
-
   function saveVideos() {
-    if (!videoFilePath) return;
-    if (videosSaveTimer) return;
-    videosSaveTimer = setTimeout(() => {
-      videosSaveTimer = null;
-      const json = JSON.stringify(videos, null, 2);
-      fsPromises.writeFile(videoFilePath, json, "utf-8").catch((err) => {
-        console.error(`[data-store] saveVideos 写入失败: ${err.message}`);
-      });
-    }, 2000);
-    videosSaveTimer.unref();
+    return;
   }
 
   function stopBackup() {
-    if (backupTimer) {
-      clearInterval(backupTimer);
-      backupTimer = null;
-    }
+    return;
   }
 
   function getUser(uid) {
     const idx = uidIndex.get(uid);
     if (idx !== undefined) return data[idx];
-    const doneIdx = doneUidIndex.get(uid);
-    if (doneIdx !== undefined) return doneArchive[doneIdx];
+    if (db) return getJob(uid);
     return undefined;
   }
 
   function hasUser(uid) {
-    return uidIndex.has(uid) || doneUidIndex.has(uid);
+    // 优先用内存索引，兜底用 SQLite
+    if (uidIndex.has(uid)) return true;
+    return hasUserInDb(uid);
   }
 
   function userExists(uid) {
-    return uidIndex.has(uid) || doneUidIndex.has(uid);
+    // 优先用内存索引，兜底用 SQLite
+    if (uidIndex.has(uid)) return true;
+    return hasUserInDb(uid);
   }
 
   function addUser(user, append) {
+    const memoryIdx = uidIndex.get(user.uniqueId);
+    if (db && memoryIdx === undefined) {
+      const existingJob = getJobRow(user.uniqueId);
+      if (existingJob) {
+        return updateJobInfo(user.uniqueId, user, false);
+      }
+      addJob(user);
+      return;
+    }
+
     const existing = getUser(user.uniqueId);
     if (existing) {
+      let changed = false;
       for (const key of Object.keys(user)) {
         if (key === "uniqueId" || key === "sources") continue;
         if (user[key] !== undefined && user[key] !== null && user[key] !== "") {
-          existing[key] = user[key];
+          if (existing[key] !== user[key]) {
+            existing[key] = user[key];
+            changed = true;
+          }
         }
       }
+      if (changed) save();
     } else {
       if (!user.status) user.status = inferStatus(user);
       if (user.processed) user.processedAt = user.processedAt || Date.now();
+      if (!user.createdAt) user.createdAt = Date.now();
       if (append) {
         const idx = data.length;
         data.push(user);
@@ -393,23 +1133,30 @@ export function createStore(filePath) {
         data.unshift(user);
         uidIndex.set(user.uniqueId, 0);
       }
+      // 同步写入 SQLite
+      addUserToDb(user);
       markStatsDirty();
+      save();
     }
   }
 
   function getPendingUsers() {
+    if (db) {
+      return getAllJobs().filter((u) => u.status === "pending");
+    }
     return data.filter((u) => u.status === "pending");
   }
 
   function getProcessedUsers() {
-    return doneArchive.length > 0
-      ? data.filter((u) => u.status === "done").concat(doneArchive)
-      : data.filter((u) => u.status === "done");
+    if (db) {
+      return getAllJobs().filter((u) => u.status === "done");
+    }
+    return data.filter((u) => u.status === "done");
   }
 
   function getAllUsers() {
-    if (doneArchive.length > 0) {
-      return data.concat(doneArchive);
+    if (db) {
+      return getAllJobs();
     }
     return data;
   }
@@ -420,6 +1167,269 @@ export function createStore(filePath) {
     locations = null,
     loggedIn = true,
   ) {
+    if (db) {
+      const now = Date.now();
+      const ongoingRow = db
+        .prepare(
+          `
+          SELECT *
+          FROM jobs
+          WHERE status = 'processing'
+            AND claimed_by = ?
+            AND claimed_at IS NOT NULL
+            AND ? - claimed_at < ?
+          ORDER BY claimed_at DESC
+          LIMIT 1
+        `,
+        )
+        .get(userId, now, expireMs);
+      if (ongoingRow) {
+        db.prepare("UPDATE jobs SET claimed_at = ? WHERE unique_id = ?").run(
+          now,
+          ongoingRow.unique_id,
+        );
+        return {
+          uniqueId: ongoingRow.unique_id,
+          nickname: ongoingRow.nickname,
+          claimedAt: now,
+          claimedBy: userId,
+        };
+      }
+
+      const tier1 = new Set(["PL", "NL", "BE"]);
+      const tier2 = new Set(["DE", "FR", "IT", "IE", "ES"]);
+      const normalizedLocations = Array.isArray(locations)
+        ? locations
+            .map((loc) => String(loc).trim().toUpperCase())
+            .filter(Boolean)
+        : [];
+
+      function getLocationGroups() {
+        const selected = normalizedLocations.length
+          ? normalizedLocations
+          : null;
+        const tier1List = selected
+          ? selected.filter((loc) => tier1.has(loc))
+          : [...tier1];
+        const tier2List = selected
+          ? selected.filter((loc) => tier2.has(loc))
+          : [...tier2];
+        const otherList = selected
+          ? selected.filter((loc) => !tier1.has(loc) && !tier2.has(loc))
+          : null;
+        const groups = [];
+        if (tier1List.length > 0)
+          groups.push({ type: "include", values: tier1List });
+        if (tier2List.length > 0)
+          groups.push({ type: "include", values: tier2List });
+        if (selected) {
+          if (otherList.length > 0)
+            groups.push({ type: "include", values: otherList });
+        } else {
+          groups.push({ type: "exclude", values: [...tier1, ...tier2] });
+        }
+        return groups;
+      }
+
+      const locationGroups = getLocationGroups();
+
+      function applyLocationGroup(where, args, group) {
+        if (!group) return;
+        if (group.type === "include") {
+          where.push(
+            `UPPER(COALESCE(guessed_location, '')) IN (${group.values.map(() => "?").join(", ")})`,
+          );
+          args.push(...group.values);
+          return;
+        }
+        where.push(
+          `UPPER(COALESCE(guessed_location, '')) NOT IN (${group.values.map(() => "?").join(", ")})`,
+        );
+        args.push(...group.values);
+      }
+
+      function queryPendingOne({ requireVideo, group, filters = [] }) {
+        const where = ["status = 'pending'"];
+        const args = [];
+        if (!loggedIn) {
+          where.push("COALESCE(tt_seller, 0) != 1");
+        }
+        if (requireVideo) {
+          where.push("COALESCE(video_count, 0) > 0");
+        }
+        applyLocationGroup(where, args, group);
+        for (const filter of filters) {
+          where.push(filter);
+        }
+        return db
+          .prepare(
+            `
+            SELECT *
+            FROM jobs
+            WHERE ${where.join(" AND ")}
+            ORDER BY follower_count DESC, created_at ASC, unique_id ASC
+            LIMIT 1
+          `,
+          )
+          .get(...args);
+      }
+
+      function queryPendingByGroup({ requireVideo, group, filters = [] }) {
+        if (group?.type === "include" && group.values.length > 1) {
+          for (const location of group.values) {
+            const row = queryPendingOne({
+              requireVideo,
+              group: { type: "include", values: [location] },
+              filters,
+            });
+            if (row) return row;
+          }
+          return null;
+        }
+        return queryPendingOne({ requireVideo, group, filters });
+      }
+
+      function findPinnedPending(requireVideo) {
+        const where = ["status = 'pending'", "COALESCE(pinned, 0) = 1"];
+        const args = [];
+        if (!loggedIn) {
+          where.push("COALESCE(tt_seller, 0) != 1");
+        }
+        if (requireVideo) {
+          where.push("COALESCE(video_count, 0) > 0");
+        }
+        if (normalizedLocations.length > 0) {
+          where.push(
+            `UPPER(COALESCE(guessed_location, '')) IN (${normalizedLocations.map(() => "?").join(", ")})`,
+          );
+          args.push(...normalizedLocations);
+        }
+        return db
+          .prepare(
+            `
+            SELECT *
+            FROM jobs
+            WHERE ${where.join(" AND ")}
+            ORDER BY created_at ASC, unique_id ASC
+            LIMIT 1
+          `,
+          )
+          .get(...args);
+      }
+
+      function findPrioritizedPending(requireVideo) {
+        for (const group of locationGroups) {
+          const seed = queryPendingByGroup({
+            requireVideo,
+            group,
+            filters: [
+              "COALESCE(pinned, 0) = 0",
+              `instr(COALESCE(sources, ''), '"seed"') > 0`,
+            ],
+          });
+          if (seed) return seed;
+        }
+
+        if (loggedIn) {
+          for (const group of locationGroups) {
+            const seller = queryPendingByGroup({
+              requireVideo,
+              group,
+              filters: [
+                "COALESCE(pinned, 0) = 0",
+                "tt_seller = 1",
+                "verified = 0",
+              ],
+            });
+            if (seller) return seller;
+          }
+        }
+
+        for (const group of locationGroups) {
+          const follow = queryPendingByGroup({
+            requireVideo,
+            group,
+            filters: [
+              "COALESCE(pinned, 0) = 0",
+              `(
+                instr(COALESCE(sources, ''), '"following"') > 0
+                OR instr(COALESCE(sources, ''), '"follower"') > 0
+              )`,
+            ],
+          });
+          if (follow) return follow;
+        }
+
+        for (const group of locationGroups) {
+          const other = queryPendingByGroup({
+            requireVideo,
+            group,
+            filters: ["COALESCE(pinned, 0) = 0"],
+          });
+          if (other) return other;
+        }
+
+        return null;
+      }
+
+      function claimRow(row) {
+        if (!row) return null;
+        db.prepare(
+          "UPDATE jobs SET status = 'processing', claimed_at = ?, claimed_by = ? WHERE unique_id = ?",
+        ).run(now, userId, row.unique_id);
+        markStatsDirty();
+        return {
+          uniqueId: row.unique_id,
+          nickname: row.nickname,
+          claimedAt: now,
+          claimedBy: userId,
+        };
+      }
+
+      const expiredRow = db
+        .prepare(
+          `
+          SELECT *
+          FROM jobs
+          WHERE status = 'processing'
+            AND claimed_at IS NOT NULL
+            AND ? - claimed_at > ?
+          ORDER BY claimed_at ASC
+          LIMIT 1
+        `,
+        )
+        .get(now, expireMs);
+      let expiredCandidate = null;
+      if (expiredRow) {
+        db.prepare(
+          "UPDATE jobs SET status = 'pending', claimed_at = NULL WHERE unique_id = ?",
+        ).run(expiredRow.unique_id);
+        expiredCandidate = mapJobRow({
+          ...expiredRow,
+          status: "pending",
+          claimed_at: null,
+        });
+      }
+
+      for (const requireVideo of [true, false]) {
+        const pinned = findPinnedPending(requireVideo);
+        if (pinned) {
+          return claimRow(pinned);
+        }
+        if (expiredCandidate) {
+          return claimRow({
+            unique_id: expiredCandidate.uniqueId,
+            nickname: expiredCandidate.nickname,
+          });
+        }
+        const ranked = findPrioritizedPending(requireVideo);
+        if (ranked) {
+          return claimRow(ranked);
+        }
+      }
+      return null;
+    }
+
     const now = Date.now();
 
     // 0. 该客户端有未过期的任务，续期返回
@@ -432,6 +1442,7 @@ export function createStore(filePath) {
     );
     if (ongoing) {
       ongoing.claimedAt = now;
+      save();
       return {
         uniqueId: ongoing.uniqueId,
         nickname: ongoing.nickname,
@@ -529,6 +1540,7 @@ export function createStore(filePath) {
       markStatsDirty();
       next.claimedAt = now;
       next.claimedBy = userId;
+      save();
       return {
         uniqueId: next.uniqueId,
         nickname: next.nickname,
@@ -621,7 +1633,7 @@ export function createStore(filePath) {
     const newUsers = [];
     for (const d of unique) {
       if (!hasUser(d.uniqueId)) {
-        addUser(d, true);
+        addJob(d);
         newUsers.push(d.uniqueId);
       }
     }
@@ -715,6 +1727,20 @@ export function createStore(filePath) {
   }
 
   function commitJob(uniqueId, result) {
+    if (db) {
+      const user = getJob(uniqueId);
+      if (!user) return { saved: false, error: "user not found" };
+
+      updateUserFromResult(user, result);
+      user.claimedAt = null;
+      const newUsers = processDiscoveredUsers(result);
+      const persistRet = updateJobInfo(uniqueId, user, false);
+      if (persistRet.error) {
+        return { saved: false, error: persistRet.error };
+      }
+      return { saved: true, status: user.status, newUsers };
+    }
+
     const user = getUser(uniqueId);
     if (!user) return { saved: false, error: "user not found" };
 
@@ -727,6 +1753,34 @@ export function createStore(filePath) {
   }
 
   function commitNewExplore(uniqueId, result) {
+    if (db) {
+      const existing = getJob(uniqueId);
+      if (existing) {
+        updateUserFromResult(existing, result);
+        const persistRet = updateJobInfo(uniqueId, existing, false);
+        if (persistRet.error) {
+          return { saved: false, error: persistRet.error };
+        }
+        const newUsers = processDiscoveredUsers(result);
+        return {
+          saved: true,
+          created: false,
+          status: existing.status,
+          newUsers,
+        };
+      }
+
+      const userObj = {
+        uniqueId,
+        ...(result.userInfo || {}),
+        sources: ["refresh-explore"],
+      };
+      updateUserFromResult(userObj, result);
+      addJob(userObj);
+      const newUsers = processDiscoveredUsers(result);
+      return { saved: true, created: true, status: userObj.status, newUsers };
+    }
+
     const existing = getUser(uniqueId);
     if (existing) {
       updateUserFromResult(existing, result);
@@ -749,6 +1803,22 @@ export function createStore(filePath) {
   }
 
   function resetJob(uniqueId) {
+    if (db) {
+      const user = getJob(uniqueId);
+      if (!user) return { saved: false, error: "user not found" };
+      user.status = "pending";
+      user.claimedAt = null;
+      user.processedAt = null;
+      user.processed = false;
+      user.error = null;
+      user.restricted = false;
+      user.noVideo = false;
+      const ret = updateJobInfo(uniqueId, user, false);
+      if (ret.error) return { saved: false, error: ret.error };
+      markStatsDirty();
+      return { saved: true };
+    }
+
     const user = getUser(uniqueId);
     if (!user) return { saved: false, error: "user not found" };
     user.status = "pending";
@@ -764,6 +1834,15 @@ export function createStore(filePath) {
   }
 
   function togglePin(uniqueId) {
+    if (db) {
+      const user = getJob(uniqueId);
+      if (!user) return { saved: false, error: "user not found" };
+      const nextPinned = !user.pinned;
+      const ret = updateJobInfo(uniqueId, { pinned: nextPinned }, false);
+      if (ret.error) return { saved: false, error: ret.error };
+      return { saved: true, pinned: nextPinned };
+    }
+
     const user = getUser(uniqueId);
     if (!user) return { saved: false, error: "user not found" };
     user.pinned = !user.pinned;
@@ -772,6 +1851,35 @@ export function createStore(filePath) {
   }
 
   function getNextRedoJob(userId) {
+    if (db) {
+      const now = Date.now();
+      const defaultTime = new Date("2016-01-01T00:00:00Z").getTime();
+      const targetLocations = ["ES", "PL", "NL", "BE", "DE", "FR", "IT", "IE"];
+      const placeholders = targetLocations.map(() => "?").join(",");
+      const row = db
+        .prepare(
+          `
+          SELECT *
+          FROM jobs
+          WHERE tt_seller = 1
+            AND verified = 0
+            AND location_created IN (${placeholders})
+          ORDER BY COALESCE(refresh_time, ?) ASC
+          LIMIT 1
+        `,
+        )
+        .get(...targetLocations, defaultTime);
+      if (!row) return null;
+      db.prepare(
+        "UPDATE jobs SET refresh_time = ?, updated_at = ? WHERE unique_id = ?",
+      ).run(now, now, row.unique_id);
+      return {
+        uniqueId: row.unique_id,
+        nickname: row.nickname,
+        refreshTime: now,
+      };
+    }
+
     const now = Date.now();
     const defaultTime = new Date("2016-01-01T00:00:00Z").getTime();
 
@@ -793,6 +1901,7 @@ export function createStore(filePath) {
 
     const next = targetUsers[0];
     next.refreshTime = now;
+    save();
     return {
       uniqueId: next.uniqueId,
       nickname: next.nickname,
@@ -801,6 +1910,28 @@ export function createStore(filePath) {
   }
 
   function commitRedoJob(uniqueId, result) {
+    if (db) {
+      const user = getJob(uniqueId);
+      if (!user) return { saved: false, error: "user not found" };
+      user.refreshTime = Date.now();
+      if (result.userInfo) {
+        const info = result.userInfo;
+        for (const key of Object.keys(info)) {
+          if (key === "uniqueId" || key === "sources") continue;
+          if (
+            info[key] !== undefined &&
+            info[key] !== null &&
+            info[key] !== ""
+          ) {
+            user[key] = info[key];
+          }
+        }
+      }
+      const ret = updateJobInfo(uniqueId, user, false);
+      if (ret.error) return { saved: false, error: ret.error };
+      return { saved: true };
+    }
+
     const user = getUser(uniqueId);
     if (!user) return { saved: false, error: "user not found" };
 
@@ -871,6 +2002,44 @@ export function createStore(filePath) {
   }
 
   function getPendingUserUpdateTasks(limit) {
+    if (db) {
+      const l = Math.max(1, parseInt(limit) || 5);
+      const rows = db
+        .prepare(
+          `
+          SELECT *
+          FROM jobs
+          WHERE COALESCE(tt_seller, '') = ''
+            AND COALESCE(user_update_count, 0) <= 0
+          ORDER BY created_at ASC, unique_id ASC
+          LIMIT ?
+        `,
+        )
+        .all(l);
+      if (rows.length === 0) return [];
+      const now = Date.now();
+      const bumpStmt = db.prepare(
+        `
+        UPDATE jobs
+        SET user_update_count = COALESCE(user_update_count, 0) + 1,
+            updated_at = ?
+        WHERE unique_id = ?
+      `,
+      );
+      const bumpTxn = db.transaction((items) => {
+        for (const item of items) {
+          bumpStmt.run(now, item.unique_id);
+        }
+      });
+      bumpTxn(rows);
+      return rows.map((row) => {
+        const mapped = mapJobRow(row);
+        mapped.userUpdateCount = (mapped.userUpdateCount || 0) + 1;
+        mapped.updatedAt = now;
+        return mapped;
+      });
+    }
+
     const l = Math.max(1, parseInt(limit) || 5);
     const pending = data
       .filter((u) => {
@@ -893,6 +2062,10 @@ export function createStore(filePath) {
   }
 
   function updateUserInfo(uniqueId, info) {
+    if (db) {
+      return updateJobInfo(uniqueId, info, true);
+    }
+
     const user = getUser(uniqueId);
     if (!user) return { error: "user not found" };
     for (const key of Object.keys(info)) {
@@ -908,6 +2081,21 @@ export function createStore(filePath) {
   }
 
   function batchUpdateUserInfo(updates) {
+    if (db) {
+      const txn = db.transaction((items) =>
+        items.map((item) => updateJobInfo(item.uniqueId, item.info, true)),
+      );
+      return txn(updates).map((result, index) =>
+        result.error
+          ? { uniqueId: updates[index].uniqueId, error: result.error }
+          : {
+              uniqueId: updates[index].uniqueId,
+              ok: true,
+              userUpdateCount: result.userUpdateCount,
+            },
+      );
+    }
+
     const results = [];
     for (const item of updates) {
       const user = getUser(item.uniqueId);
@@ -943,6 +2131,41 @@ export function createStore(filePath) {
       return { registered: 0, skipped: 0 };
     }
 
+    if (db) {
+      const insertStmt = db.prepare(`
+        INSERT OR IGNORE INTO videos (
+          id,
+          href,
+          author_unique_id,
+          location_created,
+          tt_seller,
+          registered_at,
+          user_update_count
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `);
+      let registered = 0;
+      let skipped = 0;
+      const now = Date.now();
+      const txn = db.transaction((items) => {
+        for (const item of items) {
+          const result = insertStmt.run(
+            item.id,
+            item.href || null,
+            sourceUser,
+            locationCreated || null,
+            ttSeller ? 1 : 0,
+            now,
+            0,
+          );
+          if (result.changes > 0) registered++;
+          else skipped++;
+        }
+      });
+      txn(videoList.filter((item) => item?.id));
+      return { registered, skipped };
+    }
+
     const existingIds = new Set(videos.map((v) => v.id));
     let registered = 0;
     let skipped = 0;
@@ -969,14 +2192,92 @@ export function createStore(filePath) {
   }
 
   function getVideos() {
+    if (db) {
+      return getAllVideoRows().map(mapVideoRow);
+    }
     return videos;
   }
 
+  function getVideo(videoId) {
+    if (!videoId) return null;
+    if (db) {
+      return mapVideoRow(getVideoRow(videoId));
+    }
+    return videos.find((video) => video.id === videoId) || null;
+  }
+
+  function getVideosPage(limit, offset) {
+    const safeLimit = Math.max(1, Math.min(200, parseInt(limit) || 50));
+    const safeOffset = Math.max(0, parseInt(offset) || 0);
+
+    if (db) {
+      const rows = db
+        .prepare(
+          `
+            SELECT *
+            FROM videos
+            ORDER BY registered_at DESC, id DESC
+            LIMIT ? OFFSET ?
+          `,
+        )
+        .all(safeLimit, safeOffset);
+      const total = db.prepare("SELECT COUNT(*) as c FROM videos").get().c;
+      return {
+        total,
+        limit: safeLimit,
+        offset: safeOffset,
+        videos: rows.map(mapVideoRow),
+      };
+    }
+
+    return {
+      total: videos.length,
+      limit: safeLimit,
+      offset: safeOffset,
+      videos: videos.slice(safeOffset, safeOffset + safeLimit),
+    };
+  }
+
   function getVideoCount() {
+    if (db) {
+      return db.prepare("SELECT COUNT(*) as c FROM videos").get().c;
+    }
     return videos.length;
   }
 
   function getPendingCommentTasks(limit) {
+    if (db) {
+      const l = Math.max(1, parseInt(limit) || 1);
+      const rows = db
+        .prepare(
+          `
+          SELECT *
+          FROM videos
+          WHERE user_update_count IS NULL OR user_update_count <= 0
+          ORDER BY tt_seller DESC, registered_at ASC
+          LIMIT ?
+        `,
+        )
+        .all(l);
+      if (rows.length === 0) return [];
+      const bumpStmt = db.prepare(
+        `
+        UPDATE videos
+        SET user_update_count = COALESCE(user_update_count, 0) + 1
+        WHERE id = ?
+      `,
+      );
+      const bumpTxn = db.transaction((items) => {
+        for (const item of items) bumpStmt.run(item.id);
+      });
+      bumpTxn(rows);
+      return rows.map((row) => {
+        const mapped = mapVideoRow(row);
+        mapped.userUpdateCount = (mapped.userUpdateCount || 0) + 1;
+        return mapped;
+      });
+    }
+
     // 筛选待处理视频（userUpdateCount <= 0 或 null/undefined）
     const pending = videos.filter((v) => (v.userUpdateCount || 0) <= 0);
     // ttSeller=true 优先
@@ -996,6 +2297,20 @@ export function createStore(filePath) {
   }
 
   function commitCommentTask(videoId) {
+    if (db) {
+      const video = getVideoRow(videoId);
+      if (!video) return { ok: false, error: "video not found" };
+      const nextCount = (video.user_update_count || 0) + 1;
+      db.prepare(
+        `
+        UPDATE videos
+        SET user_update_count = ?
+        WHERE id = ?
+      `,
+      ).run(nextCount, videoId);
+      return { ok: true, userUpdateCount: nextCount };
+    }
+
     const video = videos.find((v) => v.id === videoId);
     if (!video) return { ok: false, error: "video not found" };
     video.userUpdateCount = (video.userUpdateCount || 0) + 1;
@@ -1013,6 +2328,13 @@ export function createStore(filePath) {
     getPendingUsers,
     getProcessedUsers,
     getAllUsers,
+    getUserDbCount,
+    getJobsCount,
+    getPendingJobsCount,
+    getPendingJobsUserUpdateCount,
+    getDashboardStats: getDashboardStatsFromDb,
+    getUsersPage: getUsersPageFromDb,
+    getTargetUsers: getTargetUsersFromDb,
     getStats,
     getStatusGroups,
     markGroupsDirty,
@@ -1030,7 +2352,9 @@ export function createStore(filePath) {
     deleteClientError,
     getClientErrors,
     registerVideos,
+    getVideo,
     getVideos,
+    getVideosPage,
     getVideoCount,
     getPendingCommentTasks,
     commitCommentTask,