rssany 0.1.0

package/dist/index.js

@@ -0,0 +1,4037 @@
+import "dotenv/config";
+import { existsSync, unlinkSync, openSync, writeSync, closeSync, readFileSync, watch } from "node:fs";
+import { platform, homedir, networkInterfaces } from "node:os";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { exec } from "node:child_process";
+import { join, dirname, basename, resolve, sep, relative } from "node:path";
+import { promisify } from "node:util";
+import puppeteerCore from "puppeteer-core";
+import { parse, NodeType } from "node-html-parser";
+import Database from "better-sqlite3";
+import { mkdir, copyFile, access, rename, readFile, writeFile, readdir } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { JSDOM } from "jsdom";
+import { Readability } from "@mozilla/readability";
+import OpenAI from "openai";
+import { EventEmitter } from "node:events";
+import { CronExpressionParser } from "cron-parser";
+import { validate, schedule as schedule$1 } from "node-cron";
+import { streamSSE } from "hono/streaming";
+import { serveStatic } from "@hono/node-server/serve-static";
+const TAGS_TO_REMOVE = [
+  "script",
+  "style",
+  "svg",
+  "symbol",
+  "link",
+  "meta",
+  "input",
+  "embed",
+  "button",
+  "select",
+  "textarea",
+  "nav",
+  "iframe",
+  "noscript",
+  "template",
+  "object",
+  "canvas"
+];
+const BASE64_IMG_PATTERN = /^data:image\/[^;"'\s]+;base64,/i;
+function collectCommentNodes(node, out) {
+  if (node.nodeType === NodeType.COMMENT_NODE) {
+    out.push(node);
+    return;
+  }
+  if ("childNodes" in node && Array.isArray(node.childNodes)) {
+    for (const child of node.childNodes) {
+      collectCommentNodes(child, out);
+    }
+  }
+}
+function stripRssIrrelevantAttributes(root) {
+  const toProcess = [root];
+  const all = root.querySelectorAll("*");
+  for (const el of all) {
+    if (el.nodeType === NodeType.ELEMENT_NODE) toProcess.push(el);
+  }
+  for (const elem of toProcess) {
+    elem.removeAttribute("class");
+    elem.removeAttribute("style");
+    const src = elem.getAttribute("src");
+    if (src && BASE64_IMG_PATTERN.test(src)) {
+      elem.removeAttribute("src");
+    }
+  }
+}
+function applyPurify(html, purify) {
+  if (purify === false) return html;
+  const root = parse(html, { comment: true });
+  for (const tag of TAGS_TO_REMOVE) {
+    const list = root.querySelectorAll(tag);
+    for (const el of list) {
+      el.remove();
+    }
+  }
+  const commentNodes = [];
+  collectCommentNodes(root, commentNodes);
+  for (const node of commentNodes) {
+    node.remove();
+  }
+  stripRssIrrelevantAttributes(root);
+  return root.toString();
+}
+function findChromeExecutable() {
+  const platformName = platform();
+  const paths = [];
+  const envChrome = process.env.CHROME_PATH || process.env.CHROMIUM_PATH;
+  if (envChrome) paths.push(envChrome);
+  if (platformName === "darwin") {
+    paths.push(
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+    );
+  } else if (platformName === "linux") {
+    paths.push(
+      "/usr/bin/google-chrome",
+      "/usr/bin/google-chrome-stable",
+      "/usr/bin/chromium",
+      "/usr/bin/chromium-browser",
+      "/snap/bin/chromium"
+    );
+  } else if (platformName === "win32") {
+    const programFiles = process.env["ProgramFiles"] || "C:\\Program Files";
+    const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+    paths.push(
+      join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+      join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+      join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
+      join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe")
+    );
+  }
+  for (const p of paths) {
+    try {
+      if (existsSync(p)) return p;
+    } catch {
+    }
+  }
+  return null;
+}
+function getEffectiveItemFields(item, lng) {
+  const raw = lng && lng !== "" ? item.translations?.[lng] : void 0;
+  const t = raw && typeof raw === "object" ? raw : void 0;
+  return {
+    title: (t?.title != null && t.title !== "" ? t.title : item.title) ?? "",
+    summary: (t?.summary != null && t.summary !== "" ? t.summary : item.summary) ?? "",
+    content: (t?.content != null && t.content !== "" ? t.content : item.content) ?? ""
+  };
+}
+function normalizeAuthor(author) {
+  if (author == null) return void 0;
+  if (Array.isArray(author)) return author.filter((s2) => typeof s2 === "string" && s2.trim()).map((s2) => s2.trim());
+  const s = String(author).trim();
+  return s ? [s] : void 0;
+}
+const PIPELINE_DROP_EXTRA_KEY = "_rssanyPipelineDrop";
+function markPipelineDrop(item) {
+  item.extra = { ...item.extra, [PIPELINE_DROP_EXTRA_KEY]: true };
+  return item;
+}
+function isPipelineDroppedItem(item) {
+  return item.extra?.[PIPELINE_DROP_EXTRA_KEY] === true;
+}
+const __dir = dirname(fileURLToPath(import.meta.url));
+const base = basename(__dir);
+const PACKAGE_ROOT = base === "app" || base === "dist" ? join(__dir, "..") : __dir;
+const envUserDir = process.env.RSSANY_USER_DIR?.trim();
+const USER_DIR = envUserDir && envUserDir.length > 0 ? envUserDir : join(homedir(), ".rssany");
+const DATA_DIR = join(USER_DIR, "data");
+const CACHE_DIR = process.env.CACHE_DIR ?? join(USER_DIR, "cache");
+join(USER_DIR, "sites.json");
+const SOURCES_CONFIG_PATH = join(USER_DIR, "sources.json");
+const TAGS_CONFIG_PATH = join(USER_DIR, "tags.json");
+const CONFIG_PATH = join(USER_DIR, "config.json");
+const LEGACY_SUBSCRIPTIONS_PATH = join(USER_DIR, "subscriptions.json");
+const BUILTIN_PLUGINS_DIR = join(PACKAGE_ROOT, "plugins");
+const USER_PLUGINS_DIR = join(USER_DIR, "plugins");
+const BUILTIN_SOURCES_DIR = join(BUILTIN_PLUGINS_DIR, "sources");
+const USER_SOURCES_DIR = join(USER_PLUGINS_DIR, "sources");
+const BUILTIN_ENRICH_DIR = join(BUILTIN_PLUGINS_DIR, "enrich");
+const USER_ENRICH_DIR = join(USER_PLUGINS_DIR, "enrich");
+async function pathExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function migrateFile(from, to) {
+  if (!await pathExists(from)) return;
+  if (await pathExists(to)) return;
+  try {
+    await rename(from, to);
+    logger.info("config", "配置已迁移", { from, to });
+  } catch (err) {
+    logger.warn("config", "配置迁移失败", { from, to, err: err instanceof Error ? err.message : String(err) });
+  }
+}
+const EXAMPLE_SOURCES = join(PACKAGE_ROOT, "sources.example.json");
+const EXAMPLE_CONFIG = join(PACKAGE_ROOT, "config.examples.json");
+async function seedExampleConfigsIfMissing() {
+  if (!await pathExists(SOURCES_CONFIG_PATH) && await pathExists(EXAMPLE_SOURCES)) {
+    try {
+      await copyFile(EXAMPLE_SOURCES, SOURCES_CONFIG_PATH);
+      logger.info("config", "已写入默认信源示例", { path: SOURCES_CONFIG_PATH });
+    } catch (err) {
+      logger.warn("config", "写入 sources 示例失败", {
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (!await pathExists(CONFIG_PATH) && await pathExists(EXAMPLE_CONFIG)) {
+    try {
+      await copyFile(EXAMPLE_CONFIG, CONFIG_PATH);
+      logger.info("config", "已写入默认配置示例", { path: CONFIG_PATH });
+    } catch (err) {
+      logger.warn("config", "写入 config 示例失败", {
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+async function initUserDir() {
+  await mkdir(USER_DIR, { recursive: true });
+  await mkdir(DATA_DIR, { recursive: true });
+  await mkdir(CACHE_DIR, { recursive: true });
+  await mkdir(USER_PLUGINS_DIR, { recursive: true });
+  await mkdir(USER_SOURCES_DIR, { recursive: true });
+  await mkdir(USER_ENRICH_DIR, { recursive: true });
+  await seedExampleConfigsIfMissing();
+  if (!await pathExists(SOURCES_CONFIG_PATH) && await pathExists(LEGACY_SUBSCRIPTIONS_PATH)) {
+    await migrateFile(LEGACY_SUBSCRIPTIONS_PATH, SOURCES_CONFIG_PATH);
+  }
+}
+const MAIN_DB_JOURNAL = (process.env.RSSANY_DB_JOURNAL ?? "wal").toLowerCase() === "delete" ? "DELETE" : "WAL";
+let _db = null;
+let _dbInit = null;
+let _writeLock = Promise.resolve();
+const MAIN_DB_LOCK_PATH = join(DATA_DIR, "rssany.db.lock");
+function logCorruptDiagnostic(operation, err) {
+  const code = err?.code;
+  const msg = err instanceof Error ? err.message : String(err);
+  const lines = [
+    "[rssany db] ??????????????",
+    `  ?????: ${operation}`,
+    `  ????: ${code ?? "unknown"} - ${msg}`,
+    "  ????????:",
+    "    1. ??????/????????????????????????? tsx --watch ?????????????????????????????????????????????",
+    "    2. ???????????????????WAL ????? checkpoint",
+    "    3. ????/?????/?????????????????????????",
+    "  ??:",
+    "    - ??????????????? --watch???????????????????????????????",
+    "    - ???????????? RSSANY_DB_JOURNAL=delete ?????? DELETE ???????????????????",
+    "    - ?????? .rssany/data/rssany.db ????? -wal???-shm???rssany.db.lock ??????"
+  ];
+  process.stderr.write(lines.join("\n") + "\n");
+}
+function acquireDbLock(dbDir) {
+  const lockPath = join(dbDir, "rssany.db.lock");
+  const pid = process.pid;
+  const tryCreate = () => {
+    try {
+      const fd = openSync(lockPath, "wx");
+      writeSync(fd, String(pid), 0, "utf8");
+      closeSync(fd);
+      return;
+    } catch (e) {
+      const code = e?.code;
+      if (code !== "EEXIST") throw e;
+    }
+    if (!existsSync(lockPath)) {
+      tryCreate();
+      return;
+    }
+    let oldPid = null;
+    try {
+      const buf = readFileSync(lockPath, "utf8");
+      const n = parseInt(buf.trim(), 10);
+      if (!Number.isNaN(n)) oldPid = n;
+    } catch {
+    }
+    if (oldPid !== null && oldPid !== pid) {
+      const stillRunning = (() => {
+        try {
+          process.kill(oldPid, 0);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      if (stillRunning) {
+        throw new Error(
+          `???????????????????????????PID ${oldPid}??????????? tsx --watch ?????????????????????????????????? ${lockPath} ??????????`
+        );
+      }
+    }
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+    tryCreate();
+  };
+  tryCreate();
+}
+function releaseDbLock() {
+  if (!existsSync(MAIN_DB_LOCK_PATH)) return;
+  try {
+    unlinkSync(MAIN_DB_LOCK_PATH);
+  } catch {
+  }
+}
+function withWriteLock(fn) {
+  const prev = _writeLock;
+  let resolveOut;
+  let rejectOut;
+  const out = new Promise((res, rej) => {
+    resolveOut = res;
+    rejectOut = rej;
+  });
+  _writeLock = prev.then(() => fn()).then(
+    (v) => {
+      resolveOut(v);
+    },
+    (e) => {
+      if (isCorruptError(e)) {
+        logCorruptDiagnostic("???????????? updateItemContent/upsertItems??", e);
+      }
+      rejectOut(e);
+      throw e;
+    }
+  );
+  return out;
+}
+const DATE_ONLY_TITLE_RE = /^(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)\b[\s\d,??./-]*(?:st|nd|rd|th)?[\s\d,??./-]*$/i;
+function normalizeText(text) {
+  return (text ?? "").replace(/\s+/g, " ").trim();
+}
+function isDateOnlyTitle(title) {
+  const normalized = normalizeText(title);
+  if (!normalized) return false;
+  return DATE_ONLY_TITLE_RE.test(normalized);
+}
+function toMs(input) {
+  if (!input) return null;
+  const ms = Date.parse(input);
+  return Number.isNaN(ms) ? null : ms;
+}
+function parseAuthorFromDb(raw) {
+  if (!raw?.trim()) return void 0;
+  try {
+    const p = JSON.parse(raw);
+    if (Array.isArray(p)) return p.filter((s) => typeof s === "string").map((s) => String(s).trim()).filter(Boolean);
+    return [String(p).trim()];
+  } catch {
+    return [raw.trim()];
+  }
+}
+function toDbItem(row) {
+  const author = parseAuthorFromDb(row.author) ?? null;
+  const parseJsonArr = (v) => {
+    try {
+      return v ? JSON.parse(v) : null;
+    } catch {
+      return null;
+    }
+  };
+  const tags = parseJsonArr(row.tags);
+  let translations = null;
+  try {
+    if (row.translations && typeof row.translations === "string") {
+      const p = JSON.parse(row.translations);
+      if (p && typeof p === "object") translations = p;
+    }
+  } catch {
+  }
+  return { ...row, author, tags, translations };
+}
+function mapRowsToDbItems(rows) {
+  return rows.map(toDbItem);
+}
+function isCorruptError(err) {
+  const code = err?.code;
+  const msg = err instanceof Error ? err.message : String(err);
+  return code === "SQLITE_CORRUPT" || code === "SQLITE_CORRUPT_VTAB" || msg.includes("database disk image is malformed");
+}
+async function getDb() {
+  if (_db) return _db;
+  if (_dbInit) return _dbInit;
+  const dbPath = join(DATA_DIR, "rssany.db");
+  _dbInit = (async () => {
+    await mkdir(DATA_DIR, { recursive: true });
+    acquireDbLock(DATA_DIR);
+    let db = null;
+    try {
+      db = new Database(dbPath);
+      db.pragma(`journal_mode = ${MAIN_DB_JOURNAL}`);
+      db.pragma("synchronous = NORMAL");
+      initSchema(db);
+      _db = db;
+      return db;
+    } catch (err) {
+      _dbInit = null;
+      releaseDbLock();
+      if (db) {
+        try {
+          db.close();
+        } catch {
+        }
+        db = null;
+      }
+      if (isCorruptError(err)) {
+        logCorruptDiagnostic("?????/??????????? (getDb)", err);
+      }
+      throw err;
+    }
+  })();
+  return _dbInit;
+}
+async function runIntegrityCheck() {
+  const db = await getDb();
+  try {
+    const row = db.prepare("PRAGMA integrity_check").get();
+    return row?.integrity_check ?? "unknown";
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `integrity_check ???????: ${msg}`;
+  }
+}
+const LOGS_DB_PATH = join(DATA_DIR, "logs.db");
+let _logsDb = null;
+let _logsDbInit = null;
+function initLogsSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS logs (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      level       TEXT NOT NULL,
+      category    TEXT NOT NULL,
+      message     TEXT NOT NULL,
+      payload     TEXT,
+      source_url  TEXT,
+      created_at  TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_logs_level_created ON logs(level, created_at);
+    CREATE INDEX IF NOT EXISTS idx_logs_source_created ON logs(source_url, created_at);
+  `);
+}
+async function getLogsDb() {
+  if (_logsDb) return _logsDb;
+  if (_logsDbInit) return _logsDbInit;
+  _logsDbInit = (async () => {
+    await mkdir(DATA_DIR, { recursive: true });
+    const db = new Database(LOGS_DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    initLogsSchema(db);
+    _logsDb = db;
+    return db;
+  })();
+  return _logsDbInit;
+}
+function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS items (
+      id          TEXT PRIMARY KEY,
+      url         TEXT UNIQUE NOT NULL,
+      source_url  TEXT NOT NULL,
+      title       TEXT,
+      author      TEXT,
+      summary     TEXT,
+      content     TEXT,
+      image_url   TEXT,
+      tags        TEXT,
+      translations TEXT,
+      pub_date    TEXT,
+      fetched_at  TEXT NOT NULL,
+      pushed_at   TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_items_source    ON items(source_url);
+    CREATE INDEX IF NOT EXISTS idx_items_fetched   ON items(fetched_at);
+    CREATE INDEX IF NOT EXISTS idx_items_pushed    ON items(pushed_at);
+  `);
+  db.exec(`
+    CREATE VIEW IF NOT EXISTS items_fts_src AS
+    SELECT rowid, title, summary, content,
+      json_extract(translations, '$."zh-CN".title') AS title_zh,
+      json_extract(translations, '$."zh-CN".summary') AS summary_zh,
+      json_extract(translations, '$."zh-CN".content') AS content_zh
+    FROM items;
+    CREATE VIRTUAL TABLE IF NOT EXISTS items_fts USING fts5(
+      title, summary, content, title_zh, summary_zh, content_zh,
+      content='items_fts_src',
+      content_rowid='rowid'
+    );
+    CREATE TRIGGER IF NOT EXISTS items_fts_after_insert AFTER INSERT ON items
+    BEGIN
+      INSERT INTO items_fts(rowid, title, summary, content, title_zh, summary_zh, content_zh)
+      VALUES (
+        NEW.rowid, NEW.title, NEW.summary, NEW.content,
+        json_extract(NEW.translations, '$."zh-CN".title'),
+        json_extract(NEW.translations, '$."zh-CN".summary'),
+        json_extract(NEW.translations, '$."zh-CN".content')
+      );
+    END;
+    CREATE TRIGGER IF NOT EXISTS items_fts_after_update AFTER UPDATE ON items
+    BEGIN
+      INSERT INTO items_fts(items_fts, rowid, title, summary, content, title_zh, summary_zh, content_zh)
+      VALUES (
+        'delete', OLD.rowid, OLD.title, OLD.summary, OLD.content,
+        json_extract(OLD.translations, '$."zh-CN".title'),
+        json_extract(OLD.translations, '$."zh-CN".summary'),
+        json_extract(OLD.translations, '$."zh-CN".content')
+      );
+      INSERT INTO items_fts(rowid, title, summary, content, title_zh, summary_zh, content_zh)
+      VALUES (
+        NEW.rowid, NEW.title, NEW.summary, NEW.content,
+        json_extract(NEW.translations, '$."zh-CN".title'),
+        json_extract(NEW.translations, '$."zh-CN".summary'),
+        json_extract(NEW.translations, '$."zh-CN".content')
+      );
+    END;
+    CREATE TRIGGER IF NOT EXISTS items_fts_after_delete AFTER DELETE ON items
+    BEGIN
+      INSERT INTO items_fts(items_fts, rowid, title, summary, content, title_zh, summary_zh, content_zh)
+      VALUES (
+        'delete', OLD.rowid, OLD.title, OLD.summary, OLD.content,
+        json_extract(OLD.translations, '$."zh-CN".title'),
+        json_extract(OLD.translations, '$."zh-CN".summary'),
+        json_extract(OLD.translations, '$."zh-CN".content')
+      );
+    END;
+  `);
+  try {
+    const info = db.prepare("PRAGMA table_info(items)").all();
+    if (info && !info.some((c) => c.name === "image_url")) {
+      db.exec("ALTER TABLE items ADD COLUMN image_url TEXT");
+    }
+  } catch {
+  }
+}
+async function upsertItems(items, sourceUrlOverride) {
+  if (items.length === 0) return { newCount: 0, newIds: /* @__PURE__ */ new Set() };
+  const sourceUrl = items[0].sourceRef;
+  if (!sourceUrl) {
+    throw new Error("upsertItems: ???????? item ???? sourceRef????????? sourceUrlOverride");
+  }
+  return withWriteLock(async () => {
+    const db = await getDb();
+    const stmt = db.prepare(`
+    INSERT OR IGNORE INTO items (id, url, source_url, title, author, summary, image_url, tags, pub_date, fetched_at)
+    VALUES (@id, @url, @sourceUrl, @title, @author, @summary, @imageUrl, @tags, @pubDate, @fetchedAt)
+  `);
+    const selectExistingStmt = db.prepare(`
+    SELECT id, title, author, summary, image_url, pub_date, fetched_at
+    FROM items
+    WHERE id = @id
+  `);
+    const repairExistingStmt = db.prepare(`
+    UPDATE items
+    SET title = @title,
+        author = @author,
+        summary = @summary,
+        image_url = @imageUrl,
+        pub_date = @pubDate,
+        fetched_at = @fetchedAt
+    WHERE id = @id
+  `);
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    let newCount = 0;
+    const newIds = /* @__PURE__ */ new Set();
+    const run = db.transaction((rows) => {
+      for (const item of rows) {
+        const nextTitle = normalizeText(item.title) || null;
+        const nextSummary = normalizeText(item.summary) || null;
+        const nextAuthorArr = normalizeAuthor(item.author);
+        const nextAuthor = nextAuthorArr?.length ? JSON.stringify(nextAuthorArr) : null;
+        const nextPubDate = item.pubDate instanceof Date ? item.pubDate.toISOString() : item.pubDate ?? null;
+        const nextTags = item.tags?.length ? JSON.stringify(item.tags) : null;
+        const nextImageUrl = typeof item.imageUrl === "string" && item.imageUrl.trim() ? item.imageUrl.trim() : null;
+        const info = stmt.run({
+          id: item.guid,
+          url: item.link,
+          sourceUrl,
+          title: nextTitle,
+          author: nextAuthor,
+          summary: nextSummary,
+          imageUrl: nextImageUrl,
+          tags: nextTags,
+          pubDate: nextPubDate,
+          fetchedAt: now2
+        });
+        newCount += info.changes;
+        if (info.changes > 0) newIds.add(item.guid);
+        if (info.changes > 0) continue;
+        const existing = selectExistingStmt.get({ id: item.guid });
+        if (!existing) continue;
+        const shouldRepairTitle = !!nextTitle && !isDateOnlyTitle(nextTitle) && (isDateOnlyTitle(existing.title) || !normalizeText(existing.title));
+        const shouldRepairSummary = !!nextSummary && normalizeText(existing.summary).length < nextSummary.length;
+        const shouldRepairImageUrl = !!nextImageUrl && !existing.image_url?.trim();
+        const existingAuthorArr = parseAuthorFromDb(existing.author);
+        const shouldRepairAuthor = !!nextAuthorArr?.length && !existingAuthorArr?.length;
+        const existingPubDateMs = toMs(existing.pub_date);
+        const existingFetchedAtMs = toMs(existing.fetched_at);
+        const nextPubDateMs = toMs(nextPubDate);
+        const existingPubDateLooksFallback = existingPubDateMs != null && existingFetchedAtMs != null && Math.abs(existingPubDateMs - existingFetchedAtMs) <= 5 * 60 * 1e3;
+        const shouldRepairPubDate = nextPubDateMs != null && (existingPubDateMs == null || existingPubDateLooksFallback && nextPubDateMs < existingPubDateMs - 24 * 60 * 60 * 1e3);
+        if (!(shouldRepairTitle || shouldRepairSummary || shouldRepairImageUrl || shouldRepairAuthor || shouldRepairPubDate)) {
+          continue;
+        }
+        repairExistingStmt.run({
+          id: item.guid,
+          title: shouldRepairTitle ? nextTitle : existing.title,
+          author: shouldRepairAuthor ? nextAuthor : existing.author ?? null,
+          summary: shouldRepairSummary ? nextSummary : existing.summary,
+          imageUrl: shouldRepairImageUrl ? nextImageUrl : existing.image_url ?? null,
+          pubDate: shouldRepairPubDate ? nextPubDate : existing.pub_date,
+          fetchedAt: now2
+        });
+      }
+    });
+    run(items);
+    return { newCount, newIds };
+  });
+}
+async function updateItemContent(item) {
+  return withWriteLock(async () => {
+    const db = await getDb();
+    db.prepare(`
+    UPDATE items
+    SET content      = COALESCE(content, @content),
+        image_url   = COALESCE(@imageUrl, image_url),
+        author      = COALESCE(@author, author),
+        pub_date    = COALESCE(@pubDate, pub_date),
+        tags        = @tags,
+        translations = COALESCE(@translations, translations)
+    WHERE id = @id
+  `).run({
+      id: item.guid,
+      content: item.content ?? null,
+      imageUrl: typeof item.imageUrl === "string" && item.imageUrl.trim() ? item.imageUrl.trim() : null,
+      author: (() => {
+        const arr = normalizeAuthor(item.author);
+        return arr?.length ? JSON.stringify(arr) : null;
+      })(),
+      pubDate: item.pubDate instanceof Date ? item.pubDate.toISOString() : item.pubDate ?? null,
+      tags: item.tags?.length ? JSON.stringify(item.tags) : null,
+      translations: item.translations && Object.keys(item.translations).length > 0 ? JSON.stringify(item.translations) : null
+    });
+  });
+}
+async function queryFeedItems(sourceUrls, limit, offset, opts) {
+  if (sourceUrls.length === 0) return { items: [], hasMore: false };
+  const db = await getDb();
+  const placeholders = sourceUrls.map((_, i) => `@u${i}`).join(", ");
+  const conditions = [`source_url IN (${placeholders})`];
+  const params = { lim: limit + 1, off: offset };
+  sourceUrls.forEach((url, i) => {
+    params[`u${i}`] = url;
+  });
+  if (opts?.since) {
+    conditions.push("COALESCE(pub_date, fetched_at) >= @since");
+    params.since = opts.since.length === 10 ? `${opts.since}T00:00:00.000Z` : opts.since;
+  }
+  if (opts?.until) {
+    conditions.push("COALESCE(pub_date, fetched_at) < @until");
+    if (opts.until.length === 10) {
+      const d = /* @__PURE__ */ new Date(opts.until + "T12:00:00Z");
+      d.setUTCDate(d.getUTCDate() + 1);
+      params.until = d.toISOString();
+    } else {
+      params.until = opts.until;
+    }
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(`
+    SELECT * FROM items
+    ${where}
+    ORDER BY COALESCE(pub_date, fetched_at) DESC
+    LIMIT @lim OFFSET @off
+  `).all(params);
+  const hasMore = rows.length > limit;
+  const items = mapRowsToDbItems(hasMore ? rows.slice(0, limit) : rows);
+  return { items, hasMore };
+}
+async function queryItems(opts) {
+  const db = await getDb();
+  const { sourceUrl, sourceUrls, author, q, tags: tagsFilter, limit = 20, offset = 0, since, until } = opts;
+  const conditions = [];
+  const params = { limit, offset };
+  if (sourceUrl) {
+    conditions.push("i.source_url = @sourceUrl");
+    params.sourceUrl = sourceUrl;
+  } else if (sourceUrls && sourceUrls.length > 0) {
+    const placeholders = sourceUrls.map((_, i) => `@src${i}`).join(", ");
+    conditions.push(`i.source_url IN (${placeholders})`);
+    sourceUrls.forEach((s, i) => params[`src${i}`] = s);
+  }
+  if (author && author.trim().length >= 2) {
+    conditions.push("instr(i.author, @author) > 0");
+    params.author = author.trim();
+  }
+  if (q) {
+    conditions.push("i.rowid IN (SELECT rowid FROM items_fts WHERE items_fts MATCH @q)");
+    params.q = q;
+  }
+  if (tagsFilter && tagsFilter.length > 0) {
+    const trimmed = tagsFilter.filter((t) => typeof t === "string" && t.trim()).map((t) => t.trim());
+    if (trimmed.length > 0) {
+      const tagConds = trimmed.map((_, i) => `LOWER(TRIM(json_each.value)) = LOWER(@tag${i})`).join(" OR ");
+      conditions.push(
+        `i.tags IS NOT NULL AND EXISTS (SELECT 1 FROM json_each(i.tags) WHERE ${tagConds})`
+      );
+      trimmed.forEach((t, i) => {
+        params[`tag${i}`] = t;
+      });
+    }
+  }
+  if (since) {
+    conditions.push("COALESCE(i.pub_date, i.fetched_at) >= @since");
+    params.since = since.toISOString();
+  }
+  if (until) {
+    conditions.push("COALESCE(i.pub_date, i.fetched_at) < @until");
+    params.until = until.toISOString();
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(`
+    SELECT i.id, i.url, i.source_url, i.title, i.author, i.summary, i.content, i.tags, i.translations, i.pub_date, i.fetched_at, i.pushed_at
+    FROM items i ${where}
+    ORDER BY COALESCE(i.pub_date, i.fetched_at) DESC
+    LIMIT @limit OFFSET @offset
+  `).all(params);
+  const { count } = db.prepare(`SELECT COUNT(*) as count FROM items i ${where}`).get(params);
+  return { items: mapRowsToDbItems(rows), total: count };
+}
+async function removeTagFromAllItems(tag) {
+  const trimmed = String(tag ?? "").trim();
+  if (!trimmed) return 0;
+  const targetLower = trimmed.toLowerCase();
+  return withWriteLock(async () => {
+    const db = await getDb();
+    const rows = db.prepare("SELECT id, tags FROM items WHERE tags IS NOT NULL AND tags != ''").all();
+    const updateStmt = db.prepare("UPDATE items SET tags = @tags WHERE id = @id");
+    let count = 0;
+    const run = db.transaction(() => {
+      for (const row of rows) {
+        let itemTags;
+        try {
+          itemTags = JSON.parse(row.tags);
+        } catch {
+          continue;
+        }
+        const filtered = itemTags.filter((t) => String(t).trim().toLowerCase() !== targetLower);
+        if (filtered.length === itemTags.length) continue;
+        const nextTags = filtered.length > 0 ? JSON.stringify(filtered) : null;
+        updateStmt.run({ id: row.id, tags: nextTags });
+        count += 1;
+      }
+    });
+    run();
+    return count;
+  });
+}
+async function markPushed(ids) {
+  if (ids.length === 0) return;
+  return withWriteLock(async () => {
+    const db = await getDb();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = db.prepare("UPDATE items SET pushed_at = @now WHERE id = @id");
+    const run = db.transaction((list) => {
+      for (const id of list) stmt.run({ now: now2, id });
+    });
+    run(ids);
+  });
+}
+async function deleteItem(id) {
+  if (!id?.trim()) return false;
+  return withWriteLock(async () => {
+    const db = await getDb();
+    const run = db.transaction(() => {
+      const row = db.prepare("SELECT rowid FROM items WHERE id = @id").get({ id: id.trim() });
+      if (!row) return 0;
+      db.prepare("DELETE FROM items_fts WHERE rowid = @rowid").run({ rowid: row.rowid });
+      const info = db.prepare("DELETE FROM items WHERE id = @id").run({ id: id.trim() });
+      return info.changes;
+    });
+    return run() > 0;
+  });
+}
+async function deleteItemsBySourceUrl(sourceUrl) {
+  if (!sourceUrl?.trim()) return 0;
+  return withWriteLock(async () => {
+    const db = await getDb();
+    const info = db.prepare("DELETE FROM items WHERE source_url = @sourceUrl").run({ sourceUrl: sourceUrl.trim() });
+    return info.changes;
+  });
+}
+async function getPendingPushItems(limit = 100) {
+  const db = await getDb();
+  const rows = db.prepare(`
+    SELECT * FROM items
+    WHERE pushed_at IS NULL AND content IS NOT NULL
+    ORDER BY fetched_at ASC
+    LIMIT @limit
+  `).all({ limit });
+  return mapRowsToDbItems(rows);
+}
+async function getSourceStats() {
+  const db = await getDb();
+  return db.prepare(
+    "SELECT source_url, COUNT(*) as count, MAX(COALESCE(pub_date, fetched_at)) as latest_at FROM items GROUP BY source_url ORDER BY count DESC"
+  ).all();
+}
+async function insertLog(entry) {
+  const db = await getLogsDb();
+  db.prepare(`
+    INSERT INTO logs (level, category, message, payload, source_url, created_at)
+    VALUES (@level, @category, @message, @payload, NULL, @created_at)
+  `).run({
+    level: entry.level,
+    category: entry.category,
+    message: entry.message,
+    payload: entry.payload != null ? JSON.stringify(entry.payload) : null,
+    created_at: entry.created_at
+  });
+}
+async function queryLogs(opts) {
+  const db = await getLogsDb();
+  const { level, category, limit = 50, offset = 0, since } = opts;
+  const conditions = [];
+  const params = { limit, offset };
+  if (level) {
+    conditions.push("level = @level");
+    params.level = level;
+  }
+  if (category) {
+    conditions.push("INSTR(LOWER(category), LOWER(@categoryPattern)) > 0");
+    params.categoryPattern = category;
+  }
+  if (since) {
+    conditions.push("created_at >= @since");
+    params.since = since.toISOString();
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(`
+    SELECT id, level, category, message, payload, created_at
+    FROM logs ${where}
+    ORDER BY created_at DESC
+    LIMIT @limit OFFSET @offset
+  `).all(params);
+  const { count } = db.prepare(`SELECT COUNT(*) as count FROM logs ${where}`).get(params);
+  return { items: rows, total: count };
+}
+async function clearAllLogs() {
+  const db = await getLogsDb();
+  const r = db.prepare("DELETE FROM logs").run();
+  return r.changes;
+}
+async function getSystemTags() {
+  try {
+    const raw = await readFile(TAGS_CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed?.tags)) return [];
+    return parsed.tags.filter((t) => typeof t === "string" && t.trim().length > 0).map((t) => t.trim());
+  } catch {
+    return [];
+  }
+}
+async function saveSystemTagsToFile(tags) {
+  const list = tags.filter((t) => typeof t === "string" && t.trim()).map((t) => t.trim());
+  await writeFile(TAGS_CONFIG_PATH, JSON.stringify({ tags: list }, null, 2), "utf-8");
+}
+async function getSystemTagStats() {
+  const systemTags = await getSystemTags();
+  if (systemTags.length === 0) return [];
+  const db = await getDb();
+  const rows = db.prepare("SELECT tags, pub_date, fetched_at FROM items WHERE tags IS NOT NULL AND tags != ''").all();
+  const now2 = Date.now();
+  const tagMap = /* @__PURE__ */ new Map();
+  for (const name of systemTags) {
+    tagMap.set(name.toLowerCase(), { count: 0, hotness: 0 });
+  }
+  for (const row of rows) {
+    let itemTags;
+    try {
+      itemTags = JSON.parse(row.tags);
+    } catch {
+      continue;
+    }
+    const pubMs = row.pub_date ? Date.parse(row.pub_date) : null;
+    const fetchedMs = Date.parse(row.fetched_at);
+    const factor = recencyFactor(pubMs, fetchedMs, now2);
+    for (const t of itemTags) {
+      const key = String(t).trim().toLowerCase();
+      const entry = tagMap.get(key);
+      if (entry) {
+        entry.count += 1;
+        entry.hotness += factor;
+      }
+    }
+  }
+  return systemTags.map((name) => {
+    const entry = tagMap.get(name.toLowerCase()) ?? { count: 0, hotness: 0 };
+    return {
+      name,
+      count: entry.count,
+      hotness: Math.round(entry.hotness * 100) / 100
+    };
+  });
+}
+function recencyFactor(pubDateMs, fetchedAtMs, nowMs) {
+  const ref = pubDateMs ?? fetchedAtMs;
+  const daysAgo = (nowMs - ref) / (24 * 60 * 60 * 1e3);
+  return 1 / (1 + Math.max(0, daysAgo) / 7);
+}
+async function getSuggestedTags() {
+  const systemTags = await getSystemTags();
+  const systemLower = new Set(systemTags.map((t) => t.toLowerCase().trim()));
+  const db = await getDb();
+  const rows = db.prepare("SELECT tags, pub_date, fetched_at FROM items WHERE tags IS NOT NULL AND tags != ''").all();
+  const tagMap = /* @__PURE__ */ new Map();
+  const now2 = Date.now();
+  for (const row of rows) {
+    let tags;
+    try {
+      tags = JSON.parse(row.tags);
+    } catch {
+      continue;
+    }
+    const pubMs = row.pub_date ? Date.parse(row.pub_date) : null;
+    const fetchedMs = Date.parse(row.fetched_at);
+    const factor = recencyFactor(pubMs, fetchedMs, now2);
+    for (const t of tags) {
+      const trimmed = String(t).trim();
+      if (!trimmed) continue;
+      const key = trimmed.toLowerCase();
+      if (systemLower.has(key)) continue;
+      const existing = tagMap.get(key);
+      if (existing) {
+        existing.count += 1;
+        existing.hotness += factor;
+      } else {
+        tagMap.set(key, { name: trimmed, count: 1, hotness: factor });
+      }
+    }
+  }
+  return Array.from(tagMap.values()).filter((s) => s.hotness > 20).sort((a, b) => b.hotness - a.hotness).slice(0, 5).map((s) => ({ name: s.name, count: s.count, hotness: Math.round(s.hotness * 100) / 100 }));
+}
+function getLogToDb() {
+  const v = process.env.LOG_TO_DB;
+  if (v === "0" || v === "false") return false;
+  if (v === "1" || v === "true") return true;
+  return true;
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function writeDb(entry) {
+  insertLog(entry).catch((err) => {
+    process.stderr.write(`[logger] 写入日志表失败: ${err instanceof Error ? err.message : String(err)}
+`);
+  });
+}
+function emit(level, category, message, meta) {
+  const payload = meta && Object.keys(meta).length > 0 ? { ...meta } : void 0;
+  const entry = {
+    level,
+    category,
+    message,
+    payload: payload && Object.keys(payload).length > 0 ? payload : void 0,
+    created_at: now()
+  };
+  if (getLogToDb()) {
+    writeDb(entry);
+  }
+}
+const logger = {
+  error(category, message, meta) {
+    emit("error", category, message, meta);
+  },
+  warn(category, message, meta) {
+    emit("warn", category, message, meta);
+  },
+  info(category, message, meta) {
+    emit("info", category, message, meta);
+  },
+  debug(category, message, meta) {
+    emit("debug", category, message, meta);
+  }
+};
+const execAsync = promisify(exec);
+function resolveProxy(config) {
+  return config?.proxy ?? process.env.HTTP_PROXY ?? process.env.HTTPS_PROXY;
+}
+function parseProxy(proxy) {
+  const u = new URL(proxy);
+  const serverUrl = u.port ? `${u.protocol}//${u.hostname}:${u.port}` : `${u.protocol}//${u.hostname}`;
+  const username = u.username || void 0;
+  const password = u.password || void 0;
+  return { serverUrl, username, password };
+}
+function launchArgs(config) {
+  const base2 = [
+    "--disable-blink-features=AutomationControlled",
+    "--no-sandbox",
+    "--disable-setuid-sandbox",
+    "--disable-dev-shm-usage",
+    "--disable-web-security",
+    "--disable-features=IsolateOrigins,site-per-process",
+    "--disable-site-isolation-trials",
+    "--disable-infobars"
+  ];
+  const height = config?.headless !== false ? 5e3 : 960;
+  base2.push(`--window-size=1366,${height}`);
+  const proxy = resolveProxy(config);
+  if (proxy) {
+    const { serverUrl } = parseProxy(proxy);
+    base2.push(`--proxy-server=${serverUrl}`);
+  }
+  return base2;
+}
+function getUserDataDir(cacheDir) {
+  if (!cacheDir) return void 0;
+  return join(cacheDir, "browser_data", "main");
+}
+function isAlreadyRunningError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return /already running/i.test(msg) && /userDataDir|user-data-dir|user data dir/i.test(msg);
+}
+async function killStaleChromeProcesses(absUserDataDir) {
+  const plat = platform();
+  if (plat !== "darwin" && plat !== "linux") {
+    return;
+  }
+  try {
+    const psCmd = plat === "darwin" ? `ps -eww -o pid= -o args= 2>/dev/null` : `ps -eo pid,args --no-headers 2>/dev/null`;
+    const { stdout } = await execAsync(psCmd, { maxBuffer: 4 * 1024 * 1024 });
+    const pids = /* @__PURE__ */ new Set();
+    const lineRegex = /^\s*(\d+)\s+/;
+    for (const line of stdout.split("\n")) {
+      if (!line.includes(absUserDataDir)) continue;
+      const m = line.match(lineRegex);
+      if (m) pids.add(parseInt(m[1], 10));
+    }
+    if (pids.size === 0) return;
+    logger.info("scraper", "发现占用 browser_data 的 Chrome 进程，正在结束", { pids: [...pids], userDataDir: absUserDataDir });
+    for (const pid of pids) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, 800));
+    for (const pid of pids) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, 300));
+  } catch (err) {
+    logger.warn("scraper", "结束残留 Chrome 进程时出错", { err: err instanceof Error ? err.message : String(err) });
+  }
+}
+async function stealthPage(page) {
+  await page.evaluateOnNewDocument(() => {
+    Object.defineProperty(navigator, "webdriver", { get: () => false });
+    Object.defineProperty(navigator, "plugins", { get: () => [1, 2, 3, 4, 5] });
+    Object.defineProperty(navigator, "languages", { get: () => ["zh-CN", "zh", "en"] });
+    const originalQuery = window.navigator.permissions.query;
+    window.navigator.permissions.query = (parameters) => parameters.name === "notifications" ? Promise.resolve({ state: Notification.permission }) : originalQuery(parameters);
+    window.chrome = { runtime: {} };
+    Object.defineProperty(Notification, "permission", { get: () => "default" });
+    const nav = navigator;
+    if (nav.getBattery) {
+      nav.getBattery = () => Promise.resolve({ charging: true, chargingTime: 0, dischargingTime: Infinity, level: 1 });
+    }
+  });
+  await page.setExtraHTTPHeaders({
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+    "Cache-Control": "max-age=0",
+    "Sec-Ch-Ua": '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"macOS"',
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Upgrade-Insecure-Requests": "1"
+  });
+}
+function headersToRecord(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    out[k.toLowerCase()] = String(v);
+  }
+  return out;
+}
+async function setupPage(page, headless = true) {
+  const realUserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+  await page.setUserAgent(realUserAgent);
+  await page.setViewport({ width: 1366, height: headless ? 5e3 : 960 });
+  await stealthPage(page);
+}
+let _browser = null;
+let _browserHeadless = true;
+let _launchPromise = null;
+function isFrameDetachedError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return /detached|Navigating frame was detached|Session closed/i.test(msg);
+}
+async function isBrowserAlive() {
+  if (!_browser) return false;
+  try {
+    await _browser.version();
+    return true;
+  } catch {
+    _browser = null;
+    return false;
+  }
+}
+async function getOrCreateBrowser(config) {
+  const wantHeadless = config.headless !== false;
+  if (await isBrowserAlive()) {
+    if (_browserHeadless === wantHeadless) {
+      return _browser;
+    }
+    logger.info("scraper", "浏览器切换模式", { from: _browserHeadless ? "无头" : "有头", to: wantHeadless ? "无头" : "有头" });
+    await _browser.close().catch(() => {
+    });
+    _browser = null;
+    _launchPromise = null;
+  }
+  if (!_launchPromise) {
+    _launchPromise = (async () => {
+      const executablePath = config.chromeExecutablePath ?? process.env.CHROME_PATH ?? findChromeExecutable();
+      if (!executablePath) {
+        throw new Error("未找到 Chrome 可执行文件，请安装 Google Chrome 或设置 CHROME_PATH 环境变量");
+      }
+      const userDataDir = getUserDataDir(config.cacheDir);
+      const maxRetries = 2;
+      let lastErr;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          if (attempt === 0 && userDataDir) {
+            const absUserDataDir = resolve(userDataDir);
+            await killStaleChromeProcesses(absUserDataDir);
+          }
+          if (attempt > 0) {
+            const waitMs = attempt * 2e3;
+            logger.info("scraper", "userDataDir 曾被占用，等待后重试", { waitMs, attempt });
+            await new Promise((r) => setTimeout(r, waitMs));
+          }
+          logger.info("scraper", "启动 Chrome", { headless: wantHeadless, executablePath });
+          const browser = await puppeteerCore.launch({
+            headless: wantHeadless,
+            args: launchArgs({ proxy: config.proxy, headless: wantHeadless }),
+            userDataDir,
+            executablePath,
+            ignoreDefaultArgs: ["--enable-automation"]
+          });
+          browser.on("disconnected", () => {
+            _browser = null;
+            _launchPromise = null;
+          });
+          _browser = browser;
+          _browserHeadless = wantHeadless;
+          return browser;
+        } catch (e) {
+          lastErr = e;
+          if (attempt < maxRetries && isAlreadyRunningError(e)) {
+            continue;
+          }
+          if (isAlreadyRunningError(e)) {
+            const dir = userDataDir ?? "browser_data/main";
+            throw new Error(
+              `Chrome 的 profile 目录已被占用（${dir}）。通常是因为上次未正常退出或同时运行了多个本服务实例。请关闭占用该目录的 Chrome 进程后重试，或设置环境变量 CACHE_DIR 使用不同缓存目录。`
+            );
+          }
+          throw e;
+        }
+      }
+      throw lastErr;
+    })().catch((e) => {
+      _launchPromise = null;
+      throw e;
+    });
+  }
+  return _launchPromise;
+}
+process.once("exit", () => {
+  _browser?.close().catch(() => {
+  });
+});
+process.once("SIGINT", async () => {
+  await _browser?.close().catch(() => {
+  });
+  process.exit(0);
+});
+process.once("SIGTERM", async () => {
+  await _browser?.close().catch(() => {
+  });
+  process.exit(0);
+});
+async function preCheckAuth(authFlow, cacheDir) {
+  const { checkAuth, loginUrl, domain } = authFlow;
+  if (domain == null || !cacheDir) return true;
+  const browser = await getOrCreateBrowser({ headless: true, cacheDir });
+  const page = await browser.newPage();
+  try {
+    await setupPage(page, true);
+    await page.goto(loginUrl, { waitUntil: "domcontentloaded", timeout: 6e4 });
+    await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+    return await checkAuth(page, page.url());
+  } finally {
+    await page.close().catch(() => {
+    });
+  }
+}
+async function ensureAuth(authFlow, cacheDir) {
+  const { checkAuth, loginUrl, loginTimeoutMs = 60 * 1e3, pollIntervalMs = 2e3 } = authFlow;
+  const browser = await getOrCreateBrowser({ headless: false, cacheDir });
+  const page = await browser.newPage();
+  try {
+    await setupPage(page, false);
+    await page.goto(loginUrl, { waitUntil: "domcontentloaded", timeout: 6e4 });
+    await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+    const authenticated = await checkAuth(page, page.url());
+    if (authenticated) return;
+    const startTime = Date.now();
+    while (Date.now() - startTime < loginTimeoutMs) {
+      await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+      const authenticated2 = await checkAuth(page, page.url());
+      if (authenticated2) return;
+    }
+    throw new Error(`登录超时（${loginTimeoutMs}ms）`);
+  } finally {
+    await page.close().catch(() => {
+    });
+  }
+}
+async function fetchHtml(url, config = {}) {
+  const { timeoutMs, headers, cookies, cacheDir, checkAuth, authFlow, purify, headless, waitAfterLoadMs, waitForSelector, waitForSelectorTimeoutMs } = config;
+  const isHeadless = headless !== false;
+  const browser = await getOrCreateBrowser({
+    headless: isHeadless,
+    cacheDir,
+    proxy: resolveProxy(config),
+    chromeExecutablePath: config.chromeExecutablePath
+  });
+  const navigationTimeout = timeoutMs ?? 6e4;
+  const maxAttempts = 2;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const page = await browser.newPage();
+    const isRetry = attempt === 1;
+    const waitUntil = isRetry ? "domcontentloaded" : "load";
+    const extraWaitMs = isRetry ? Math.min(500, Math.max(0, waitAfterLoadMs ?? 2e3)) : Math.max(0, waitAfterLoadMs ?? 2e3);
+    try {
+      if (config.browserContext) {
+        await config.browserContext(page.browserContext());
+      }
+      await setupPage(page, isHeadless);
+      const extraHeaders = { "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", ...headers ?? {} };
+      if (cookies != null && cookies !== "") {
+        extraHeaders.cookie = cookies;
+      }
+      await page.setExtraHTTPHeaders(extraHeaders);
+      const proxy = resolveProxy(config);
+      if (proxy) {
+        const { username, password } = parseProxy(proxy);
+        if (username !== void 0 || password !== void 0) {
+          await page.authenticate({ username: username ?? "", password: password ?? "" });
+        }
+      }
+      if (timeoutMs != null) {
+        await page.setDefaultNavigationTimeout(timeoutMs);
+      }
+      const response = await page.goto(url, { waitUntil, timeout: navigationTimeout });
+      if (extraWaitMs > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, extraWaitMs));
+      }
+      if (waitForSelector != null && waitForSelector !== "" && !isRetry) {
+        const selectorTimeout = waitForSelectorTimeoutMs ?? 2e4;
+        await page.waitForSelector(waitForSelector, { timeout: selectorTimeout });
+      }
+      if (checkAuth != null || authFlow != null) {
+        const authCheck = checkAuth ?? authFlow?.checkAuth;
+        if (authCheck != null) {
+          const ok = await authCheck(page, url);
+          if (!ok) {
+            throw new Error("checkAuth failed: 未通过认证检查，请先调用 ensureAuth 进行预处理登录");
+          }
+        }
+      }
+      const rawBody = await page.content();
+      const finalUrl = response?.url() ?? page.url() ?? String(url);
+      const status = response?.status() ?? 0;
+      const statusText = response?.statusText() ?? "";
+      const rawHeaders = response?.headers() ?? {};
+      const normalizedHeaders = headersToRecord(rawHeaders);
+      const body = applyPurify(rawBody, purify);
+      await page.close().catch(() => {
+      });
+      return { finalUrl, status, statusText, headers: normalizedHeaders, body };
+    } catch (e) {
+      lastError = e;
+      await page.close().catch(() => {
+      });
+      if (isRetry || !isFrameDetachedError(e)) {
+        throw e;
+      }
+      logger.warn("scraper", "fetchHtml 因 frame 分离重试", { url, attempt: attempt + 1, err: e instanceof Error ? e.message : String(e) });
+      await new Promise((r) => setTimeout(r, 800));
+    }
+  }
+  throw lastError;
+}
+const VALID_INTERVALS = ["1min", "5min", "10min", "30min", "1h", "6h", "12h", "1day", "3day", "7day"];
+function cronToRefreshInterval(cronExpr) {
+  const parts = cronExpr.trim().split(/\s+/);
+  const is6Field = parts.length >= 6;
+  const minute = parts[is6Field ? 1 : 0];
+  const hour = parts[is6Field ? 2 : 1];
+  const day = parts[is6Field ? 3 : 2];
+  const weekday = parts[is6Field ? 5 : 4];
+  const minMatch = minute.match(/^\*\/(\d+)$/);
+  if (minute === "*" || minMatch && parseInt(minMatch[1], 10) <= 1) return "1min";
+  if (minMatch) {
+    const n = parseInt(minMatch[1], 10);
+    if (n <= 5) return "5min";
+    if (n <= 10) return "10min";
+    if (n <= 30) return "30min";
+  }
+  if (minute === "0" || minute === "00") {
+    const hourMatch = hour.match(/^\*\/(\d+)$/);
+    if (hour === "*" || hourMatch && parseInt(hourMatch[1], 10) <= 1) return "1h";
+    if (hourMatch) {
+      const n = parseInt(hourMatch[1], 10);
+      if (n <= 2) return "1h";
+      if (n <= 6) return "6h";
+      if (n <= 12) return "12h";
+    }
+    if (day === "*" || day === "?") return "1day";
+    if (weekday !== "*" && weekday !== "?") return "7day";
+  }
+  return "1h";
+}
+function refreshIntervalToCron(interval) {
+  const map = {
+    "1min": "* * * * *",
+    "5min": "*/5 * * * *",
+    "10min": "*/10 * * * *",
+    "30min": "*/30 * * * *",
+    "1h": "0 * * * *",
+    "6h": "0 */6 * * *",
+    "12h": "0 0,12 * * *",
+    "1day": "0 0 * * *",
+    "3day": "0 0 */3 * *",
+    "7day": "0 0 * * 0"
+  };
+  return map[interval];
+}
+function urlHash(url) {
+  return createHash("sha256").update(url).digest("hex");
+}
+function timeBucket(strategy, now2) {
+  const y = now2.getUTCFullYear();
+  const mo = String(now2.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(now2.getUTCDate()).padStart(2, "0");
+  const h = now2.getUTCHours();
+  const hs = String(h).padStart(2, "0");
+  const min = now2.getUTCMinutes();
+  if (strategy === "1min") return `${y}-${mo}-${d}T${hs}:${String(min).padStart(2, "0")}`;
+  if (strategy === "5min") return `${y}-${mo}-${d}T${hs}:${String(Math.floor(min / 5) * 5).padStart(2, "0")}`;
+  if (strategy === "10min") return `${y}-${mo}-${d}T${hs}:${String(Math.floor(min / 10) * 10).padStart(2, "0")}`;
+  if (strategy === "30min") return `${y}-${mo}-${d}T${hs}:${min < 30 ? "00" : "30"}`;
+  if (strategy === "1h") return `${y}-${mo}-${d}T${hs}`;
+  if (strategy === "6h") return `${y}-${mo}-${d}T${String(Math.floor(h / 6) * 6).padStart(2, "0")}`;
+  if (strategy === "12h") return `${y}-${mo}-${d}T${h < 12 ? "00" : "12"}`;
+  if (strategy === "1day") return `${y}-${mo}-${d}`;
+  if (strategy === "3day") {
+    const epochDay = Math.floor(now2.getTime() / 864e5);
+    return `d${Math.floor(epochDay / 3) * 3}`;
+  }
+  if (strategy === "7day") {
+    const adjusted = new Date(now2);
+    adjusted.setUTCHours(0, 0, 0, 0);
+    adjusted.setUTCDate(adjusted.getUTCDate() + 3 - (adjusted.getUTCDay() + 6) % 7);
+    const week1 = new Date(Date.UTC(adjusted.getUTCFullYear(), 0, 4));
+    const isoYear = adjusted.getUTCFullYear();
+    const isoWeek = 1 + Math.round(((adjusted.getTime() - week1.getTime()) / 864e5 - 3 + (week1.getUTCDay() + 6) % 7) / 7);
+    return `${isoYear}-W${String(isoWeek).padStart(2, "0")}`;
+  }
+  return "";
+}
+function cacheKey(url, strategy = "forever", now2 = /* @__PURE__ */ new Date()) {
+  const hash = urlHash(url);
+  if (strategy === "forever") return hash;
+  return `${timeBucket(strategy, now2)}-${hash}`;
+}
+function cacheKeyFromCron(url, cron, now2 = /* @__PURE__ */ new Date()) {
+  return cacheKey(url, cronToRefreshInterval(cron), now2);
+}
+const EXTRACTED_SUBDIR = "extracted";
+async function readCachedExtracted(cacheDir, key) {
+  const filePath = join(cacheDir, EXTRACTED_SUBDIR, `${key}.json`);
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      author: parsed.author,
+      title: parsed.title,
+      summary: parsed.summary,
+      content: parsed.content ?? parsed.contentMarkdown ?? parsed.contentHtml,
+      pubDate: parsed.pubDate
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCachedExtracted(cacheDir, key, result) {
+  const dir = join(cacheDir, EXTRACTED_SUBDIR);
+  await mkdir(dir, { recursive: true });
+  const filePath = join(dir, `${key}.json`);
+  const cache = { ...result, cachedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
+}
+function extractedCacheKey(url, config) {
+  if (config.cacheKey != null && config.cacheKey !== "") return config.cacheKey;
+  if (url) return cacheKey(url, "forever");
+  return "";
+}
+function extractWithReadability(html, url) {
+  const dom = new JSDOM(html, { url });
+  const reader = new Readability(dom.window.document);
+  const article = reader.parse();
+  if (!article) return {};
+  const summary = article.excerpt && article.excerpt.length > 200 ? article.excerpt.slice(0, 200) + "…" : article.excerpt;
+  return {
+    author: article.byline || void 0,
+    title: article.title || void 0,
+    summary: summary || void 0,
+    content: article.content || void 0
+  };
+}
+async function extractHtml(html, config = {}) {
+  const { url = "", mode, customExtractor, cacheDir, useCache = true } = config;
+  const key = extractedCacheKey(url, config);
+  if (useCache !== false && cacheDir != null && cacheDir !== "" && key) {
+    const cached = await readCachedExtracted(cacheDir, key);
+    if (cached != null) return cached;
+  }
+  if (customExtractor != null) {
+    const result = await Promise.resolve(customExtractor(html, url));
+    if (cacheDir != null && cacheDir !== "" && key) {
+      await writeCachedExtracted(cacheDir, key, result);
+    }
+    return result;
+  }
+  if (mode === "readability") {
+    const result = extractWithReadability(html, url);
+    if (cacheDir != null && cacheDir !== "" && key) {
+      await writeCachedExtracted(cacheDir, key, result);
+    }
+    return result;
+  }
+  return {};
+}
+async function extractFromLink(link, extractorConfig = {}, fetchConfig = {}) {
+  const { cacheDir } = extractorConfig;
+  const fetchOpts = {
+    cacheDir: fetchConfig.cacheDir ?? cacheDir,
+    useCache: false,
+    timeoutMs: fetchConfig.timeoutMs ?? 15e3,
+    ...fetchConfig
+  };
+  const res = await fetchHtml(link, fetchOpts);
+  if (res.status !== 200 && res.status !== 304) {
+    throw new Error(`fetch 失败: ${res.status} ${res.statusText} for ${link}`);
+  }
+  const finalUrl = res.finalUrl ?? link;
+  return extractHtml(res.body, {
+    ...extractorConfig,
+    url: finalUrl,
+    cacheKey: extractorConfig.cacheKey ?? (cacheDir ? cacheKey(link, "forever") : void 0)
+  });
+}
+function getLLMConfig() {
+  return {
+    apiKey: process.env.OPENAI_API_KEY,
+    baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
+    model: process.env.OPENAI_MODEL || "gpt-4o-mini"
+  };
+}
+function mergeConfig(override) {
+  const env = getLLMConfig();
+  const apiKey = override?.apiKey ?? env.apiKey;
+  const baseUrl = override?.apiUrl ?? override?.baseUrl ?? env.baseUrl;
+  const model = override?.model ?? env.model;
+  if (!apiKey) throw new Error("LLM API Key 未配置，请设置 OPENAI_API_KEY 或传入 apiKey");
+  return { apiKey, baseUrl, model };
+}
+async function chatJson(prompt, config, options) {
+  const { apiKey, baseUrl, model } = mergeConfig(config);
+  const openai = new OpenAI({ apiKey, baseURL: baseUrl });
+  const completion = await openai.chat.completions.create({
+    model,
+    messages: [{ role: "user", content: prompt }],
+    max_tokens: options?.maxTokens ?? 8192,
+    response_format: { type: "json_object" }
+  });
+  const content = completion.choices[0]?.message?.content;
+  if (!content) throw new Error("LLM 返回空内容");
+  return JSON.parse(content);
+}
+async function chatText(prompt, config, options) {
+  const { apiKey, baseUrl, model } = mergeConfig(config);
+  const openai = new OpenAI({ apiKey, baseURL: baseUrl });
+  const completion = await openai.chat.completions.create({
+    model,
+    messages: [{ role: "user", content: prompt }],
+    max_tokens: options?.maxTokens ?? 8192
+  });
+  const content = completion.choices[0]?.message?.content;
+  if (!content) throw new Error("LLM 返回空内容");
+  return content;
+}
+function generateGuid(link) {
+  return createHash("sha256").update(link).digest("hex");
+}
+async function parseWithLLM(html, url, config) {
+  const prompt = config.prompt ?? `你是一个专业的 HTML 内容提取助手。请仔细分析以下 HTML 页面，提取所有可点击的内容条目（如文章、笔记、帖子、视频等）。
+
+要求：
+1. 返回 JSON 对象，格式为 {"items": [...]}
+2. 每个条目必须包含以下字段：
+   - title: 标题（必填）
+   - link: 完整链接（必填）。**必须从 HTML 的 href 原样提取**：若为绝对路径（以 / 开头）则直接使用；若为相对路径则补全为完整 URL。当前页: ${url}
+   - description: 摘要或描述（200字内，必填）
+   - author: 作者（可选）
+   - published: 发布日期 ISO 字符串（可选）
+3. 如果页面是列表页，提取所有列表项
+4. 如果页面是详情页，将整个页面作为一个条目提取
+5. 如果页面是用户主页/个人资料页：
+   - 优先尝试提取该用户发布的内容列表
+   - 如果无法提取列表，至少提取用户基本信息作为一个条目（title 为用户名称或页面标题，description 为用户简介或页面描述，link 为当前 URL）
+6. 如果页面是单页应用（SPA），尝试从以下位置提取数据：
+   - <title> 标签中的页面标题
+   - <meta name="description"> 或 <meta property="og:description"> 中的描述
+   - <meta property="og:title"> 中的标题
+   - <link rel="canonical" href="..."> 中的规范链接（优先使用）
+   - <script> 标签中的 JSON 数据（搜索包含 "title", "description", "user", "author", "items", "list" 等关键词的 JSON）
+   - 任何包含 href 属性的 <a> 标签，**link 必须使用 href 的原始值**（以 / 开头的路径表示从站根算起）
+   - 任何包含文本内容的元素
+7. **重要**：即使页面看起来是空的 SPA，也必须至少返回一个条目：
+   - 从 <title> 提取标题（如果没有则使用 URL）
+   - 从 <meta> 标签提取描述（如果没有则使用 "页面内容通过 JavaScript 动态加载"）
+   - link 使用当前 URL: ${url}
+   - 如果页面 URL 包含 "user" 或 "profile"，可以推断这是一个用户主页，title 可以是 "用户主页"，description 可以是页面 URL
+
+**强制要求**：绝对不能返回空数组 {"items": []}，至少要返回一个包含页面基本信息的条目。
+
+HTML:
+${html}`;
+  const parsed = await chatJson(
+    prompt,
+    { apiKey: config.apiKey, apiUrl: config.apiUrl, model: config.model },
+    {}
+  );
+  let entries = [];
+  if (parsed.items && Array.isArray(parsed.items)) {
+    entries = parsed.items;
+  } else if (parsed.entries && Array.isArray(parsed.entries)) {
+    entries = parsed.entries;
+  } else if (Array.isArray(parsed)) {
+    entries = parsed;
+  } else if (parsed && typeof parsed === "object") {
+    entries = [parsed];
+  }
+  return entries.map((e) => {
+    const raw = e.link || url;
+    if (raw.startsWith("http")) return { ...e, link: raw };
+    const path = raw.startsWith("/") ? raw : `/${raw}`;
+    try {
+      const base2 = new URL(url);
+      return { ...e, link: new URL(path, base2.origin).href };
+    } catch {
+      return { ...e, link: new URL(raw, url).href };
+    }
+  });
+}
+function toFeedItem(entry, includeContent) {
+  return {
+    guid: entry.guid ?? generateGuid(entry.link),
+    title: entry.title,
+    link: entry.link,
+    pubDate: entry.published ? new Date(entry.published) : /* @__PURE__ */ new Date(),
+    author: entry.author ? [entry.author] : void 0,
+    summary: entry.description,
+    content: includeContent ? entry.content : void 0,
+    imageUrl: entry.imageUrl
+  };
+}
+async function parseHtml(html, config = {}) {
+  const { url = "", mode, customParser, llmConfig, includeContent = false, purify } = config;
+  let entries = [];
+  const actualMode = mode ?? (llmConfig != null ? "llm" : customParser != null ? "custom" : "llm");
+  if (actualMode === "llm") {
+    if (llmConfig == null && !getLLMConfig().apiKey) {
+      throw new Error('mode 为 "llm" 时必须提供 llmConfig 或设置 OPENAI_API_KEY 环境变量');
+    }
+    const htmlForLLM = applyPurify(html, purify !== false);
+    entries = await parseWithLLM(htmlForLLM, url, llmConfig ?? {});
+  } else if (actualMode === "custom") {
+    if (customParser == null) {
+      throw new Error('mode 为 "custom" 时必须提供 customParser');
+    }
+    entries = await customParser(html, url);
+    if (!Array.isArray(entries)) {
+      entries = [entries];
+    }
+  } else {
+    throw new Error(`不支持的解析模式: ${actualMode}`);
+  }
+  const items = entries.map((e) => toFeedItem(e, includeContent));
+  return {
+    items,
+    url,
+    mode: actualMode
+  };
+}
+function patternToRegex(pattern) {
+  if (pattern instanceof RegExp) return pattern;
+  const pathOnly = pattern.split("?")[0];
+  const pl = "<<<__PL__>>>";
+  const s = pathOnly.replace(/\{[^}]*\}/g, pl).replace(/[.*+?^${}()|[\]\\]/g, (c) => "\\" + c).replace(new RegExp(pl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), "[^/]+");
+  return new RegExp("^" + s + "(\\?.*)?$");
+}
+function toAuthFlow(site) {
+  if (!site.checkAuth || !site.loginUrl) return void 0;
+  return {
+    checkAuth: site.checkAuth,
+    loginUrl: site.loginUrl,
+    domain: site.domain ?? void 0,
+    loginTimeoutMs: site.loginTimeoutMs ?? void 0,
+    pollIntervalMs: site.pollIntervalMs ?? void 0
+  };
+}
+function matchesListUrl(site, url) {
+  try {
+    return patternToRegex(site.listUrlPattern).test(url);
+  } catch {
+    return false;
+  }
+}
+function computeSpecificity(site, url) {
+  if (!matchesListUrl(site, url)) return -1;
+  const p = site.listUrlPattern;
+  if (typeof p === "string") {
+    const pathOnly = p.split("?")[0];
+    return 1e3 + pathOnly.split("/").filter(Boolean).length;
+  }
+  return p.source.length;
+}
+function getSiteByUrl(url, sites) {
+  const matched = sites.map((s) => ({ site: s, score: computeSpecificity(s, url) })).filter((x) => x.score >= 0).sort((a, b) => b.score - a.score);
+  return matched[0]?.site;
+}
+class AuthRequiredError extends Error {
+  constructor(message = "需要登录") {
+    super(message);
+    this.name = "AuthRequiredError";
+  }
+}
+class NotFoundError extends Error {
+  constructor(message = "未找到") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+const PLUGIN_EXTENSIONS = [".rssany.js", ".rssany.ts"];
+function isValidSite(obj) {
+  if (obj == null || typeof obj !== "object") return false;
+  const s = obj;
+  return typeof s.id === "string" && (typeof s.listUrlPattern === "string" || s.listUrlPattern instanceof RegExp) && typeof s.fetchItems === "function";
+}
+function isValidSource(obj) {
+  if (obj == null || typeof obj !== "object") return false;
+  const s = obj;
+  return typeof s.id === "string" && (typeof s.pattern === "string" || s.pattern instanceof RegExp) && typeof s.fetchItems === "function" && s.listUrlPattern === void 0;
+}
+function isValidEnrichPlugin(obj) {
+  if (obj == null || typeof obj !== "object") return false;
+  const p = obj;
+  return typeof p.id === "string" && typeof p.match === "function" && typeof p.enrichItem === "function";
+}
+async function loadSourcePluginsFromDir(dir, label) {
+  const siteEntries = [];
+  const sources = [];
+  let entries;
+  try {
+    const raw = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+    entries = raw;
+  } catch {
+    return { siteEntries, sources };
+  }
+  for (const e of entries) {
+    const name = String(e.name);
+    if (!e.isFile()) continue;
+    if (!PLUGIN_EXTENSIONS.some((ext) => name.endsWith(ext))) continue;
+    const filePath = join(dir, name);
+    try {
+      const mod = await import(pathToFileURL(filePath).href);
+      const plugin = mod.default ?? mod;
+      if (isValidSite(plugin)) {
+        siteEntries.push({ site: plugin, filePath });
+      } else if (isValidSource(plugin)) {
+        sources.push({ source: plugin, filePath });
+      } else {
+        logger.warn("plugin", "插件未实现 Site 或 Source 接口，已跳过", { label, name });
+      }
+    } catch (err) {
+      logger.warn("plugin", "插件加载失败", { label, name, err: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { siteEntries, sources };
+}
+async function loadPluginsFromDir(dir, label, validator) {
+  const result = [];
+  let entries;
+  try {
+    const raw = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+    entries = raw;
+  } catch {
+    return result;
+  }
+  for (const e of entries) {
+    const name = String(e.name);
+    if (!e.isFile()) continue;
+    if (!PLUGIN_EXTENSIONS.some((ext) => name.endsWith(ext))) continue;
+    const filePath = join(dir, name);
+    try {
+      const mod = await import(pathToFileURL(filePath).href);
+      const plugin = mod.default ?? mod;
+      if (validator(plugin)) {
+        result.push(plugin);
+      } else {
+        logger.warn("plugin", "插件接口不匹配，已跳过", { label, name });
+      }
+    } catch (err) {
+      logger.warn("plugin", "插件加载失败", { label, name, err: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return result;
+}
+async function loadFromSourcesOrRoot() {
+  const [builtinFromSources, userFromSources] = await Promise.all([
+    loadSourcePluginsFromDir(BUILTIN_SOURCES_DIR, "builtin:sources"),
+    loadSourcePluginsFromDir(USER_SOURCES_DIR, "user:sources")
+  ]);
+  const hasAny = builtinFromSources.siteEntries.length + builtinFromSources.sources.length + userFromSources.siteEntries.length + userFromSources.sources.length > 0;
+  if (hasAny) return { builtin: builtinFromSources, user: userFromSources };
+  const [builtinRoot, userRoot] = await Promise.all([
+    loadSourcePluginsFromDir(BUILTIN_PLUGINS_DIR, "builtin"),
+    loadSourcePluginsFromDir(USER_PLUGINS_DIR, "user")
+  ]);
+  return { builtin: builtinRoot, user: userRoot };
+}
+const pluginSitePaths = /* @__PURE__ */ new Map();
+function mergeSourcePluginPaths(siteIds, pathMap, builtinSources, userSources) {
+  for (const { source, filePath } of builtinSources) {
+    if (siteIds.has(source.id)) {
+      logger.warn("plugin", "Source 插件 id 与 Site 插件冲突，已忽略 Source 路径", { sourceId: source.id });
+      continue;
+    }
+    pathMap.set(source.id, filePath);
+  }
+  for (const { source, filePath } of userSources) {
+    if (siteIds.has(source.id)) {
+      logger.warn("plugin", "Source 插件 id 与 Site 插件冲突，已忽略 Source 路径", { sourceId: source.id });
+      continue;
+    }
+    if (pathMap.has(source.id)) logger.info("plugin", "用户 Source 插件覆盖同名内置", { sourceId: source.id });
+    pathMap.set(source.id, filePath);
+  }
+}
+function getPluginFilePath(id) {
+  return pluginSitePaths.get(id);
+}
+async function loadSiteAndSourcePlugins() {
+  const { builtin, user } = await loadFromSourcesOrRoot();
+  const siteMap = /* @__PURE__ */ new Map();
+  const pathMap = /* @__PURE__ */ new Map();
+  for (const { site: s, filePath } of builtin.siteEntries) {
+    siteMap.set(s.id, s);
+    pathMap.set(s.id, filePath);
+  }
+  for (const { site: s, filePath } of user.siteEntries) {
+    if (siteMap.has(s.id)) logger.info("plugin", "用户插件覆盖同名内置", { pluginId: s.id });
+    siteMap.set(s.id, s);
+    pathMap.set(s.id, filePath);
+  }
+  mergeSourcePluginPaths(new Set(siteMap.keys()), pathMap, builtin.sources, user.sources);
+  const sourceMap = /* @__PURE__ */ new Map();
+  for (const { source } of builtin.sources) sourceMap.set(source.id, source);
+  for (const { source } of user.sources) {
+    if (sourceMap.has(source.id)) logger.info("plugin", "用户 Source 插件覆盖同名内置", { sourceId: source.id });
+    sourceMap.set(source.id, source);
+  }
+  pluginSitePaths.clear();
+  pathMap.forEach((path, id) => pluginSitePaths.set(id, path));
+  return { sites: Array.from(siteMap.values()), sources: Array.from(sourceMap.values()) };
+}
+let registeredEnrichPlugins = [];
+async function loadEnrichPlugins() {
+  const [builtin, user] = await Promise.all([
+    loadPluginsFromDir(BUILTIN_ENRICH_DIR, "builtin:enrich", isValidEnrichPlugin),
+    loadPluginsFromDir(USER_ENRICH_DIR, "user:enrich", isValidEnrichPlugin)
+  ]);
+  const merged = /* @__PURE__ */ new Map();
+  for (const p of builtin) merged.set(p.id, p);
+  for (const p of user) {
+    if (merged.has(p.id)) logger.info("plugin", "用户 Enrich 插件覆盖同名内置", { pluginId: p.id });
+    merged.set(p.id, p);
+  }
+  const list = Array.from(merged.values());
+  list.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+  registeredEnrichPlugins = list;
+  return list;
+}
+function getMatchedEnrichPlugin(item, ctx) {
+  return registeredEnrichPlugins.find((p) => p.match(item, ctx));
+}
+function buildEnrichContext(ctx) {
+  return {
+    cacheDir: ctx.cacheDir,
+    headless: ctx.headless,
+    proxy: ctx.proxy,
+    async fetchHtml(url, opts) {
+      const res = await fetchHtml(url, {
+        cacheDir: ctx.cacheDir,
+        useCache: false,
+        authFlow: void 0,
+        headless: ctx.headless,
+        proxy: ctx.proxy,
+        waitAfterLoadMs: opts?.waitMs,
+        purify: opts?.purify
+      });
+      return { html: res.body, finalUrl: res.finalUrl ?? url, status: res.status };
+    },
+    async extractItem(item, opts) {
+      const res = await fetchHtml(item.link, {
+        cacheDir: ctx.cacheDir,
+        useCache: false,
+        authFlow: void 0,
+        headless: ctx.headless,
+        proxy: ctx.proxy
+      });
+      if (res.status !== 200 && res.status !== 304) {
+        throw new Error(`默认正文提取失败: HTTP ${res.status} ${res.statusText} for ${item.link}`);
+      }
+      const extracted = await extractHtml(res.body, {
+        url: res.finalUrl ?? item.link,
+        cacheDir: ctx.cacheDir ?? void 0,
+        mode: "readability",
+        useCache: true,
+        cacheKey: opts?.cacheKey
+      });
+      const pubDate = extracted.pubDate != null ? typeof extracted.pubDate === "string" ? new Date(extracted.pubDate) : extracted.pubDate : item.pubDate;
+      return {
+        ...item,
+        author: normalizeAuthor(extracted.author ?? item.author),
+        title: extracted.title ?? item.title,
+        summary: extracted.summary ?? item.summary,
+        content: extracted.content ?? item.content,
+        pubDate
+      };
+    }
+  };
+}
+function buildSiteContext(site, ctx) {
+  const proxy = ctx.proxy ?? site.proxy;
+  const authFlow = toAuthFlow(site);
+  return {
+    cacheDir: ctx.cacheDir,
+    headless: ctx.headless,
+    proxy,
+    async fetchHtml(url, opts) {
+      const res = await fetchHtml(url, {
+        cacheDir: ctx.cacheDir,
+        useCache: false,
+        authFlow,
+        headless: ctx.headless,
+        proxy,
+        waitAfterLoadMs: opts?.waitMs,
+        purify: opts?.purify,
+        waitForSelector: opts?.waitForSelector,
+        waitForSelectorTimeoutMs: opts?.waitForSelectorTimeoutMs
+      });
+      return { html: res.body, finalUrl: res.finalUrl ?? url, status: res.status };
+    },
+    async extractItem(item, opts) {
+      const res = await fetchHtml(item.link, {
+        cacheDir: ctx.cacheDir,
+        useCache: false,
+        authFlow,
+        headless: ctx.headless,
+        proxy
+      });
+      if (res.status !== 200 && res.status !== 304) {
+        throw new Error(`默认正文提取失败: HTTP ${res.status} ${res.statusText} for ${item.link}`);
+      }
+      const extracted = await extractHtml(res.body, {
+        url: res.finalUrl ?? item.link,
+        cacheDir: ctx.cacheDir ?? void 0,
+        mode: "readability",
+        useCache: true,
+        cacheKey: opts?.cacheKey
+      });
+      const pubDate = extracted.pubDate != null ? typeof extracted.pubDate === "string" ? new Date(extracted.pubDate) : extracted.pubDate : item.pubDate;
+      return {
+        ...item,
+        author: normalizeAuthor(extracted.author ?? item.author),
+        title: extracted.title ?? item.title,
+        summary: extracted.summary ?? item.summary,
+        content: extracted.content ?? item.content,
+        pubDate
+      };
+    }
+  };
+}
+function createWebSource(site) {
+  const authFlow = toAuthFlow(site);
+  return {
+    id: site.id,
+    pattern: site.listUrlPattern,
+    priority: 50,
+    refreshInterval: site.refreshInterval ?? void 0,
+    proxy: site.proxy ?? void 0,
+    preCheck: authFlow ? async (ctx) => {
+      if (!ctx.cacheDir) return;
+      const passed = await preCheckAuth(authFlow, ctx.cacheDir);
+      if (!passed) throw new AuthRequiredError(`站点 ${site.id} 需要登录，请先执行 ensureAuth`);
+    } : void 0,
+    async fetchItems(sourceId, ctx) {
+      return site.fetchItems(sourceId, buildSiteContext(site, ctx));
+    },
+    enrichItem: site.enrichItem ? async (item, ctx) => {
+      return site.enrichItem(item, buildSiteContext(site, ctx));
+    } : void 0
+  };
+}
+const genericWebSource = {
+  id: "generic",
+  pattern: /^https?:\/\//,
+  priority: 200,
+  async fetchItems(sourceId, ctx) {
+    const res = await fetchHtml(sourceId, {
+      cacheDir: ctx.cacheDir,
+      useCache: true,
+      headless: ctx.headless,
+      proxy: ctx.proxy
+    });
+    if (res.status !== 200 && res.status !== 304) {
+      throw new Error(`抓取失败: HTTP ${res.status} ${res.statusText}`);
+    }
+    const parsed = await parseHtml(res.body, {
+      url: res.finalUrl ?? sourceId
+    });
+    return parsed.items;
+  }
+};
+const loadedSites = [];
+function setLoadedSites(sites) {
+  loadedSites.length = 0;
+  loadedSites.push(...sites);
+}
+function getWebSite(id) {
+  return loadedSites.find((s) => s.id === id);
+}
+function getPluginSites() {
+  return loadedSites.filter((s) => s.id !== "generic");
+}
+function getBestSite(url) {
+  return getSiteByUrl(url, loadedSites);
+}
+const registeredSources = [];
+function sourcePatternToRegex(pattern) {
+  if (pattern instanceof RegExp) return pattern;
+  const pathOnly = pattern.split("?")[0];
+  const pl = "<<<__PL__>>>";
+  const escaped = pathOnly.replace(/\{[^}]*\}/g, pl).replace(/[.*+?^${}()|[\]\\]/g, (c) => "\\" + c).replace(new RegExp(pl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), "[^/]+");
+  return new RegExp("^" + escaped + "(\\?.*)?$");
+}
+function getSource(sourceId) {
+  for (const source of registeredSources) {
+    const matches = source.match ? source.match(sourceId) : (() => {
+      try {
+        return sourcePatternToRegex(source.pattern).test(sourceId);
+      } catch {
+        return false;
+      }
+    })();
+    if (matches) return source;
+  }
+  return genericWebSource;
+}
+async function initSources() {
+  const [siteResult] = await Promise.all([
+    loadSiteAndSourcePlugins(),
+    loadEnrichPlugins()
+  ]);
+  const { sites, sources: sourcePlugins } = siteResult;
+  setLoadedSites(sites);
+  registeredSources.length = 0;
+  const webSources = sites.map((s) => createWebSource(s));
+  const all = [
+    ...sourcePlugins,
+    ...webSources,
+    genericWebSource
+  ];
+  all.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+  registeredSources.push(...all);
+  logger.info("scheduler", "信源已注册", {
+    total: registeredSources.length,
+    siteCount: sites.length,
+    sourcePluginCount: sourcePlugins.length
+  });
+}
+function resolveRef(src) {
+  return src.ref ?? src.url ?? "";
+}
+async function loadSourcesFile() {
+  try {
+    const raw = await readFile(SOURCES_CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return [];
+    if (Array.isArray(parsed.sources)) {
+      return parsed.sources.filter((s) => resolveRef(s));
+    }
+    const entries = Object.values(parsed);
+    const list = [];
+    for (const entry of entries) {
+      if (entry && Array.isArray(entry.sources)) {
+        for (const s of entry.sources) {
+          if (resolveRef(s)) list.push(s);
+        }
+      }
+    }
+    return list;
+  } catch {
+    return [];
+  }
+}
+async function getAllSources() {
+  return loadSourcesFile();
+}
+async function getAllSubscriptionRefs() {
+  const list = await loadSourcesFile();
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of list) {
+    const r = resolveRef(s);
+    if (r && !seen.has(r)) {
+      seen.add(r);
+      out.push(r);
+    }
+  }
+  return out;
+}
+async function saveSourcesFile(sources) {
+  await writeFile(
+    SOURCES_CONFIG_PATH,
+    JSON.stringify({ sources }, null, 2) + "\n",
+    "utf-8"
+  );
+}
+async function getSourcesRaw() {
+  try {
+    const raw = await readFile(SOURCES_CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return JSON.stringify({ sources: [] }, null, 2);
+    if (Array.isArray(parsed.sources)) {
+      return raw;
+    }
+    const list = await loadSourcesFile();
+    return JSON.stringify({ sources: list }, null, 2);
+  } catch {
+    return JSON.stringify({ sources: [] }, null, 2);
+  }
+}
+const MAX_BODY_CHARS = 4e3;
+const SYSTEM$2 = `你是信息质量评估助手。根据标题、摘要与正文片段，判断该条是否值得保留在订阅信息流中。
+- 保留（keep: true）：有实质信息、观点、技术内容、新闻价值，或对读者有参考意义。
+- 过滤（keep: false）：明显垃圾广告、纯日期/站务占位、无意义一句话、乱码或空白、纯导航无内容、重复无信息量的模板句。
+- 只输出 JSON，格式：{"keep": true 或 false, "reason": "一句话中文理由"}`;
+function combinedForJudge(item) {
+  const title = (item.title ?? "").trim();
+  const summary = (item.summary ?? "").trim();
+  let body = (item.content ?? "").trim();
+  if (body.length > MAX_BODY_CHARS) body = body.slice(0, MAX_BODY_CHARS) + "\n\n[... 正文已截断 ...]";
+  const parts = [];
+  if (title) parts.push(`标题：
+${title}`);
+  if (summary) parts.push(`摘要：
+${summary}`);
+  if (body) parts.push(`正文：
+${body}`);
+  return parts.join("\n\n---\n\n");
+}
+function qualityFilterMatch(_item, ctx) {
+  return !!ctx.llm;
+}
+async function runQualityFilter(item, ctx) {
+  if (!ctx.llm) return item;
+  const text = combinedForJudge(item);
+  if (!text.trim()) return item;
+  const prompt = `${SYSTEM$2}
+
+请评估以下条目：
+
+${text}`;
+  let res;
+  try {
+    res = await ctx.llm.chatJson(prompt, void 0, { maxTokens: 256, debugLabel: "qualityFilter" });
+  } catch {
+    return item;
+  }
+  const isKeep = res.keep === true || res.keep === "true";
+  const isDrop = res.keep === false || res.keep === "false";
+  if (isKeep) return item;
+  if (!isDrop) return item;
+  const reason = typeof res.reason === "string" ? res.reason.trim() : "";
+  logger.info("pipeline", "质量过滤移除条目", { link: item.link, reason: reason || void 0 });
+  return markPipelineDrop(item);
+}
+const SYSTEM$1 = `你是一个信息分类助手。根据文章标题和摘要，从候选标签库中选出最匹配的标签，最多 5 个。
+- 只能使用候选标签库中已有的标签，不要输出库中不存在的标签。
+- 如果没有合适的标签，输出空数组 {"tags": []}，不要硬选不相关的标签。
+- 只输出 JSON，格式：{"tags": ["tag1", "tag2", ...]}`;
+function taggerMatch(item, ctx) {
+  return !item.tags?.length && !!ctx.llm;
+}
+async function runTagger(item, ctx) {
+  if (!ctx.db) return item;
+  const systemTags = await ctx.db.getSystemTags();
+  if (!systemTags.length || !ctx.llm) return item;
+  const candidateList = `候选标签库（只能从中选取）：
+${systemTags.join(", ")}
+
+`;
+  const prompt = `${SYSTEM$1}
+
+${candidateList}文章标题：${item.title ?? ""}
+文章摘要：${item.summary ?? item.content?.slice(0, 300) ?? "（无摘要）"}`;
+  let suggested;
+  try {
+    const res = await ctx.llm.chatJson(prompt, void 0, { maxTokens: 256, debugLabel: "tagger" });
+    suggested = Array.isArray(res.tags) ? res.tags.filter((t) => typeof t === "string") : [];
+  } catch {
+    return item;
+  }
+  if (!suggested.length) return item;
+  const set = new Set(systemTags.map((t) => t.toLowerCase()));
+  const confirmed = suggested.filter((t) => set.has(t.toLowerCase()));
+  if (confirmed.length) {
+    item.tags = [.../* @__PURE__ */ new Set([...item.tags ?? [], ...confirmed])];
+  }
+  return item;
+}
+const ZH_CN = "zh-CN";
+const MAX_CONTENT_CHARS = 6e3;
+const DETECT_CONTENT_PREFIX = 2e3;
+const SYSTEM = `你是一个专业翻译助手。将用户提供的英文（或其他语言）内容翻译为简体中文。
+- 保持专业、准确、流畅。
+- 若原文已是中文，则保持原样或轻微润色。
+- 只输出 JSON，格式：{"title": "译文标题", "summary": "译文摘要", "content": "译文正文"}
+- 若某字段为空或用户未提供，对应输出空字符串 ""。`;
+function combinedTextForDetection(item) {
+  const title = (item.title ?? "").trim();
+  const summary = (item.summary ?? item.content?.slice(0, 500) ?? "").trim();
+  const content = (item.content ?? "").trim().slice(0, DETECT_CONTENT_PREFIX);
+  return `${title}
+${summary}
+${content}`;
+}
+function isLikelyChineseContent(text) {
+  const t = text.trim();
+  if (t.length < 8) return false;
+  if (/[\u3040-\u309f\u30a0-\u30ff]/.test(t)) return false;
+  if (/[\uac00-\ud7af]/.test(t)) return false;
+  const cjk = (t.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) ?? []).length;
+  const latin = (t.match(/[A-Za-z]/g) ?? []).length;
+  const letterish = cjk + latin;
+  if (letterish < 12) return false;
+  return cjk / letterish >= 0.55;
+}
+function translatorMatch(item, ctx) {
+  const hasZh = item.translations?.[ZH_CN];
+  if (hasZh || !ctx.llm) return false;
+  if (isLikelyChineseContent(combinedTextForDetection(item))) return false;
+  return true;
+}
+async function runTranslator(item, ctx) {
+  if (!ctx.llm) return item;
+  const title = (item.title ?? "").trim();
+  const summary = (item.summary ?? item.content?.slice(0, 500) ?? "").trim();
+  const content = (item.content ?? "").trim();
+  const contentTruncated = content.length > MAX_CONTENT_CHARS ? content.slice(0, MAX_CONTENT_CHARS) + "\n\n[... 内容已截断 ...]" : content;
+  if (!title && !summary && !content) return item;
+  const parts = [];
+  if (title) parts.push(`标题：
+${title}`);
+  if (summary) parts.push(`摘要：
+${summary}`);
+  if (contentTruncated) parts.push(`正文：
+${contentTruncated}`);
+  const prompt = `${SYSTEM}
+
+请翻译以下内容：
+
+${parts.join("\n\n---\n\n")}`;
+  let res;
+  try {
+    res = await ctx.llm.chatJson(prompt, void 0, {
+      maxTokens: Math.min(8192, Math.ceil((title.length + summary.length + contentTruncated.length) * 1.5)),
+      debugLabel: "translator"
+    });
+  } catch {
+    return item;
+  }
+  const tTitle = typeof res.title === "string" ? res.title.trim() : "";
+  const tSummary = typeof res.summary === "string" ? res.summary.trim() : "";
+  const tContent = typeof res.content === "string" ? res.content.trim() : "";
+  if (!tTitle && !tSummary && !tContent) return item;
+  item.translations = item.translations ?? {};
+  item.translations[ZH_CN] = {
+    title: tTitle || void 0,
+    summary: tSummary || void 0,
+    content: tContent || void 0
+  };
+  return item;
+}
+const DEFAULT_PIPELINE_STEPS = [
+  { id: "qualityFilter", enabled: false },
+  { id: "tagger", enabled: false },
+  { id: "translator", enabled: false }
+];
+const PIPELINE_STEP_IDS = ["qualityFilter", "tagger", "translator"];
+function parseSteps$1(rawSteps) {
+  const steps = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of rawSteps) {
+    if (s && typeof s === "object" && typeof s.id === "string") {
+      const obj = s;
+      const id = obj.id.trim();
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      const enabled = obj.enabled;
+      steps.push({
+        id,
+        enabled: enabled !== false && enabled !== 0
+      });
+    }
+  }
+  return steps;
+}
+function mergeWithDefaultSteps(userSteps) {
+  const map = new Map(userSteps.map((s) => [s.id, s]));
+  return DEFAULT_PIPELINE_STEPS.map((def) => {
+    const u = map.get(def.id);
+    return { id: def.id, enabled: u ? u.enabled : def.enabled };
+  });
+}
+async function loadPipelineConfig() {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    const rawSteps = Array.isArray(parsed?.pipeline?.steps) ? parsed.pipeline.steps : [];
+    const steps = mergeWithDefaultSteps(parseSteps$1(rawSteps));
+    if (steps.length > 0) return { steps };
+  } catch {
+  }
+  return { steps: [...DEFAULT_PIPELINE_STEPS] };
+}
+async function savePipelineConfig(config) {
+  let root = {};
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    root = JSON.parse(raw);
+  } catch {
+  }
+  root.pipeline = { steps: config.steps };
+  await writeFile(CONFIG_PATH, JSON.stringify(root, null, 2), "utf-8");
+}
+const STEP_REGISTRY = {
+  qualityFilter: { match: qualityFilterMatch, run: runQualityFilter },
+  tagger: { match: taggerMatch, run: runTagger },
+  translator: { match: translatorMatch, run: runTranslator }
+};
+async function getResolvedSteps() {
+  const config = await loadPipelineConfig();
+  const out = [];
+  for (const { id, enabled } of config.steps) {
+    if (!enabled) continue;
+    const step = STEP_REGISTRY[id];
+    if (!step) {
+      logger.debug("pipeline", "未知步骤已跳过", { id });
+      continue;
+    }
+    out.push({ id, ...step });
+  }
+  return out;
+}
+async function runPipeline(item, ctx) {
+  const steps = await getResolvedSteps();
+  let current = item;
+  for (const step of steps) {
+    if (!step.match(current, ctx)) continue;
+    try {
+      current = await step.run(current, ctx);
+    } catch (err) {
+      logger.warn("pipeline", "步骤执行失败", {
+        stepId: step.id,
+        item_url: item.link,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return current;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function isoToRfc822(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return "";
+  return d.toUTCString();
+}
+function buildItem(entry) {
+  const title = escapeXml(entry.title ?? "");
+  const link = escapeXml(entry.link ?? "");
+  const descRaw = entry.description ?? "";
+  const desc = descRaw.includes("<") || descRaw.includes(">") ? `<![CDATA[${descRaw.replace(/\]\]>/g, "]]]]><![CDATA[>")}]]>` : escapeXml(descRaw);
+  const pubDate = entry.published ? escapeXml(isoToRfc822(entry.published)) : "";
+  const guid = entry.guid ?? entry.link ?? "";
+  const guidEscaped = escapeXml(guid);
+  let buf = `    <item>
+      <title>${title}</title>
+      <link>${link}</link>
+      <description>${desc}</description>
+`;
+  if (pubDate) buf += `      <pubDate>${pubDate}</pubDate>
+`;
+  if (entry.imageUrl?.trim()) {
+    const encUrl = escapeXml(entry.imageUrl.trim());
+    const encType = escapeXml(entry.imageType?.trim() || "image/jpeg");
+    buf += `      <enclosure url="${encUrl}" length="0" type="${encType}"/>
+`;
+  }
+  buf += `      <guid isPermaLink="true">${guidEscaped}</guid>
+`;
+  buf += `    </item>
+`;
+  return buf;
+}
+function buildRssXml(channel, entries) {
+  const title = escapeXml(channel.title);
+  const link = escapeXml(channel.link);
+  const desc = escapeXml(channel.description ?? "");
+  const lang = escapeXml(channel.language ?? "zh-CN");
+  const now2 = (/* @__PURE__ */ new Date()).toUTCString();
+  const items = entries.map(buildItem).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>${title}</title>
+    <link>${link}</link>
+    <description>${desc}</description>
+    <language>${lang}</language>
+    <lastBuildDate>${now2}</lastBuildDate>
+
+${items}  </channel>
+</rss>`;
+}
+const eventBus = new EventEmitter();
+eventBus.setMaxListeners(200);
+function emitFeedUpdated(payload) {
+  eventBus.emit("feed:updated", payload);
+}
+function onFeedUpdated(fn) {
+  eventBus.on("feed:updated", fn);
+  return () => eventBus.off("feed:updated", fn);
+}
+const DEFAULTS = {
+  concurrency: 2,
+  maxRetries: 2
+};
+async function loadEnrichConfig() {
+  let fileEnrich = {};
+  try {
+    const raw = await readFile(join(USER_DIR, "config.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.enrich && typeof parsed.enrich === "object") {
+      fileEnrich = parsed.enrich;
+    }
+  } catch {
+  }
+  return {
+    concurrency: Number(fileEnrich["concurrency"] ?? process.env.ENRICH_CONCURRENCY ?? DEFAULTS.concurrency),
+    maxRetries: Number(fileEnrich["maxRetries"] ?? process.env.ENRICH_MAX_RETRIES ?? DEFAULTS.maxRetries)
+  };
+}
+const validateCron = validate;
+const tasks$1 = /* @__PURE__ */ new Map();
+const groups = /* @__PURE__ */ new Map();
+const DEFAULT_RETRY_DELAY_MS = 5e3;
+const DEFAULT_GROUP_CONCURRENCY = 10;
+async function runWithRetry(task, options) {
+  const retries = options.retries ?? 0;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await task();
+      return;
+    } catch (err) {
+      lastErr = err;
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, retryDelayMs));
+      }
+    }
+  }
+  throw lastErr;
+}
+async function runWithRetryAndResult(task, options) {
+  const retries = options.retries ?? 0;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await task();
+    } catch (err) {
+      lastErr = err;
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, retryDelayMs));
+      }
+    }
+  }
+  throw lastErr;
+}
+function ensureGroup(group, concurrency) {
+  if (!groups.has(group)) {
+    groups.set(group, { config: { concurrency }, running: 0, queue: [], completedCount: 0 });
+  } else {
+    const g = groups.get(group);
+    g.config.concurrency = concurrency;
+    if (g.completedCount === void 0) g.completedCount = 0;
+  }
+}
+function enqueueAndProcess(group, id, task, options, resolve2, priority, resolveValue, rejectValue) {
+  const g = groups.get(group);
+  if (!g) return;
+  g.queue = g.queue.filter((it) => it.id !== id);
+  const item = { id, task, options, resolve: resolve2, resolveValue, rejectValue };
+  if (priority) {
+    g.queue.unshift(item);
+  } else {
+    g.queue.push(item);
+  }
+  processGroupQueue(group);
+}
+function processGroupQueue(group) {
+  const g = groups.get(group);
+  if (!g || g.running >= g.config.concurrency || g.queue.length === 0) return;
+  const item = g.queue.shift();
+  g.running += 1;
+  const done = () => {
+    g.running -= 1;
+    g.completedCount = (g.completedCount ?? 0) + 1;
+    processGroupQueue(group);
+  };
+  if (item.resolveValue != null || item.rejectValue != null) {
+    runWithRetryAndResult(item.task, item.options).then((result) => {
+      item.resolveValue?.(result);
+    }).catch((err) => {
+      item.rejectValue?.(err);
+    }).finally(done);
+  } else {
+    runWithRetry(item.task, item.options).catch(() => {
+    }).finally(() => {
+      item.resolve?.();
+      done();
+    });
+  }
+}
+function schedule(group, id, task, options = {}) {
+  const cronExpr = options.cron?.trim();
+  ensureGroup(group, options.concurrency ?? groups.get(group)?.config.concurrency ?? DEFAULT_GROUP_CONCURRENCY);
+  if (cronExpr && validate(cronExpr)) {
+    unschedule(id);
+    const optsWithGroup = { ...options, group };
+    const job = schedule$1(cronExpr, () => {
+      const reg = tasks$1.get(id);
+      if (reg) reg.lastRunTime = Date.now();
+      enqueueAndProcess(group, id, task, optsWithGroup);
+    });
+    tasks$1.set(id, {
+      id,
+      cronExpr,
+      task,
+      options: optsWithGroup,
+      stop: () => job.stop(),
+      lastRunTime: 0
+    });
+    if (options.runNow) {
+      runNow(id, true).catch(() => {
+      });
+    }
+    return true;
+  }
+  return new Promise((resolve2, reject) => {
+    enqueueAndProcess(
+      group,
+      id,
+      task,
+      { ...options, group },
+      void 0,
+      options.priority ?? false,
+      resolve2,
+      reject
+    );
+  });
+}
+function unschedule(id) {
+  const reg = tasks$1.get(id);
+  if (reg) {
+    reg.stop();
+    tasks$1.delete(id);
+  }
+}
+function unscheduleGroup(group) {
+  const ids = [...tasks$1.entries()].filter(([, reg]) => reg.options.group === group).map(([id]) => id);
+  for (const id of ids) unschedule(id);
+}
+function runNow(id, priority = false) {
+  const reg = tasks$1.get(id);
+  if (!reg) return Promise.resolve();
+  reg.lastRunTime = Date.now();
+  const group = reg.options.group;
+  if (group) {
+    return new Promise((resolve2) => {
+      enqueueAndProcess(group, id, reg.task, reg.options, resolve2, priority);
+    });
+  }
+  return runWithRetry(reg.task, reg.options);
+}
+function getNextRunForTask(reg) {
+  try {
+    const base2 = reg.lastRunTime > 0 ? new Date(reg.lastRunTime) : /* @__PURE__ */ new Date();
+    const expr = CronExpressionParser.parse(reg.cronExpr, { currentDate: base2 });
+    let next = expr.next().getTime();
+    if (next <= Date.now()) {
+      const retry = CronExpressionParser.parse(reg.cronExpr, { currentDate: /* @__PURE__ */ new Date() });
+      next = retry.next().getTime();
+    }
+    return next;
+  } catch {
+    return -1;
+  }
+}
+function getGroupStats() {
+  const result = {};
+  for (const [name, g] of groups) {
+    const groupTasks = [...tasks$1.values()].filter((t) => t.options.group === name);
+    const scheduledCount = groupTasks.length;
+    let nextRunTime;
+    if (g.running > 0) {
+      nextRunTime = 0;
+    } else if (scheduledCount === 0) {
+      nextRunTime = -1;
+    } else {
+      const times = groupTasks.map(getNextRunForTask).filter((t) => t > 0);
+      nextRunTime = times.length > 0 ? Math.min(...times) : -1;
+    }
+    result[name] = {
+      running: g.running,
+      queued: g.queue.length,
+      concurrency: g.config.concurrency,
+      scheduledCount,
+      completedCount: g.completedCount ?? 0,
+      nextRunTime
+    };
+  }
+  return result;
+}
+const ENRICH_GROUP = "enrich";
+const MAX_STORED_TASKS = 200;
+const RETRY_DELAY_MS = 3e3;
+class EnrichQueue {
+  tasks = /* @__PURE__ */ new Map();
+  taskItems = /* @__PURE__ */ new Map();
+  taskCallbacks = /* @__PURE__ */ new Map();
+  configLoaded = false;
+  async ensureConfig() {
+    if (this.configLoaded) return { concurrency: 2, maxRetries: 2 };
+    const config = await loadEnrichConfig();
+    this.configLoaded = true;
+    logger.info("scraper", "配置加载完成", { concurrency: config.concurrency, maxRetries: config.maxRetries });
+    return config;
+  }
+  evictIfNeeded() {
+    if (this.tasks.size <= MAX_STORED_TASKS) return;
+    const ids = [...this.tasks.keys()];
+    for (const id of ids) {
+      if (this.tasks.get(id)?.status === "done") {
+        this.removeTask(id);
+        if (this.tasks.size <= MAX_STORED_TASKS) return;
+      }
+    }
+    if (this.tasks.size > MAX_STORED_TASKS) this.removeTask(ids[0]);
+  }
+  removeTask(id) {
+    this.tasks.delete(id);
+    this.taskItems.delete(id);
+    this.taskCallbacks.delete(id);
+  }
+  checkTaskComplete(taskId) {
+    const task = this.tasks.get(taskId);
+    const items = this.taskItems.get(taskId);
+    const callbacks = this.taskCallbacks.get(taskId);
+    if (!task || !items) return;
+    const allSettled = task.itemResults.every((r) => r.status === "done" || r.status === "failed");
+    if (!allSettled) return;
+    task.status = "done";
+    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    logger.info("scraper", "任务完成", {
+      source_url: task.sourceUrl,
+      taskId,
+      done: task.progress.done,
+      failed: task.progress.failed
+    });
+    Promise.resolve(callbacks?.onAllDone?.(items)).catch((err) => {
+      logger.warn("scraper", "onAllDone 回调异常", { taskId, err: err instanceof Error ? err.message : String(err) });
+    });
+  }
+  async submit(items, enrichFn, ctx, opts) {
+    const config = await this.ensureConfig();
+    const id = randomUUID();
+    const itemResults = items.map((_, i) => ({
+      index: i,
+      status: "pending",
+      retries: 0
+    }));
+    const task = {
+      id,
+      sourceUrl: opts.sourceUrl,
+      status: items.length === 0 ? "done" : "pending",
+      progress: { total: items.length, done: 0, failed: 0 },
+      itemResults,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completedAt: items.length === 0 ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    };
+    const itemsCopy = [...items];
+    this.tasks.set(id, task);
+    this.taskItems.set(id, itemsCopy);
+    this.taskCallbacks.set(id, opts);
+    this.evictIfNeeded();
+    for (let i = 0; i < items.length; i++) {
+      const itemIndex = i;
+      const workId = `${id}-${i}`;
+      const taskFn = async () => {
+        const t = this.tasks.get(id);
+        const its = this.taskItems.get(id);
+        const cbs = this.taskCallbacks.get(id);
+        if (!t || !its || !cbs) return;
+        const itemResult = t.itemResults[itemIndex];
+        if (!itemResult) return;
+        itemResult.status = "running";
+        if (t.status === "pending") t.status = "running";
+        for (let r = 0; r <= config.maxRetries; r++) {
+          try {
+            const enriched = await enrichFn(its[itemIndex], ctx);
+            its[itemIndex] = enriched;
+            itemResult.item = enriched;
+            itemResult.status = "done";
+            t.progress.done++;
+            await Promise.resolve(cbs.onItemDone?.(enriched, itemIndex));
+            this.checkTaskComplete(id);
+            return;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (r < config.maxRetries) {
+              logger.warn("scraper", "提取失败，重试中", {
+                source_url: t.sourceUrl,
+                item_url: its[itemIndex]?.link,
+                retries: r + 1,
+                maxRetries: config.maxRetries,
+                err: msg
+              });
+              await new Promise((resolve2) => setTimeout(resolve2, RETRY_DELAY_MS));
+            } else {
+              itemResult.status = "failed";
+              itemResult.error = msg;
+              t.progress.failed++;
+              logger.warn("scraper", "提取最终失败", {
+                source_url: t.sourceUrl,
+                item_url: its[itemIndex]?.link,
+                err: msg
+              });
+              const failedItem = { ...its[itemIndex], enrichFailed: true };
+              its[itemIndex] = failedItem;
+              await Promise.resolve(cbs.onItemDone?.(failedItem, itemIndex));
+              this.checkTaskComplete(id);
+            }
+          }
+        }
+      };
+      schedule(ENRICH_GROUP, workId, taskFn, { concurrency: config.concurrency }).catch(() => {
+      });
+    }
+    return id;
+  }
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  getTaskItems(id) {
+    return this.taskItems.get(id);
+  }
+}
+const enrichQueue = new EnrichQueue();
+async function getDeliverUrl() {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    const j = JSON.parse(raw);
+    const u = j?.deliver?.url;
+    return typeof u === "string" ? u.trim() : "";
+  } catch {
+    return "";
+  }
+}
+async function saveDeliverUrl(url) {
+  let root = {};
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    root = JSON.parse(raw);
+  } catch {
+  }
+  root.deliver = { url: url.trim() };
+  await writeFile(CONFIG_PATH, JSON.stringify(root, null, 2) + "\n", "utf-8");
+}
+function feedItemsToPayload(items) {
+  return items.map((i) => ({
+    guid: i.guid,
+    title: i.title,
+    link: i.link,
+    pubDate: i.pubDate instanceof Date ? i.pubDate.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    author: i.author,
+    summary: i.summary,
+    content: i.content,
+    tags: i.tags,
+    sourceRef: i.sourceRef,
+    translations: i.translations
+  }));
+}
+async function postDeliverItems(url, sourceRef, items) {
+  if (!url.trim() || items.length === 0) return;
+  const body = JSON.stringify({ sourceRef, items: feedItemsToPayload(items) });
+  const res = await fetch(url.trim(), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body,
+    signal: AbortSignal.timeout(12e4)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
+  }
+}
+async function postDeliverItemsSafe(url, sourceRef, items) {
+  try {
+    await postDeliverItems(url, sourceRef, items);
+  } catch (err) {
+    logger.warn("deliver", "投递失败", {
+      sourceRef,
+      count: items.length,
+      err: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function buildChannelFromItems(listUrl, items, lng) {
+  const channel = {
+    title: items[0]?.author?.length ? `${items[0].author[0]} 的订阅` : "RSS 订阅",
+    link: listUrl,
+    description: `来自 ${listUrl} 的订阅`
+  };
+  if (lng) channel.language = lng;
+  return channel;
+}
+function toRssEntry(item, lng) {
+  const eff = getEffectiveItemFields(item, lng);
+  const hasContent = eff.content != null && eff.content !== "";
+  const desc = hasContent ? eff.content : eff.summary;
+  return {
+    title: eff.title,
+    link: item.link,
+    description: desc,
+    guid: item.guid,
+    published: item.pubDate?.toISOString?.() ?? void 0,
+    imageUrl: item.imageUrl
+  };
+}
+const generatingKeys = /* @__PURE__ */ new Map();
+const pipelineCtx = {
+  llm: { chatJson, chatText },
+  db: { getSystemTags }
+};
+async function runPipelineOnItem(item, ctx) {
+  return runPipeline(item, { ...pipelineCtx, ...ctx });
+}
+function buildEnrichFn(source, listUrl, ctx) {
+  const enrichCtx = buildEnrichContext(ctx);
+  enrichCtx.sourceUrl = listUrl;
+  return async (item) => {
+    let result = item;
+    if (source.enrichItem) {
+      result = await source.enrichItem(item, ctx);
+    }
+    const plugin = getMatchedEnrichPlugin(result, { sourceUrl: listUrl });
+    if (plugin) {
+      result = await plugin.enrichItem(result, enrichCtx);
+    }
+    return result;
+  };
+}
+async function generateAndCache(listUrl, key, config) {
+  const { cacheDir = "cache", includeContent = true, headless } = config;
+  const source = getSource(listUrl);
+  const ctx = { cacheDir, headless, proxy: config.proxy ?? source.proxy };
+  let items;
+  try {
+    items = await source.fetchItems(listUrl, ctx);
+  } catch (err) {
+    generatingKeys.delete(key);
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error("scraper", "抓取失败", { source_url: listUrl, err: message });
+    throw err;
+  }
+  items.forEach((i) => {
+    i.sourceRef = listUrl;
+    i.author = normalizeAuthor(i.author);
+  });
+  generatingKeys.delete(key);
+  logger.info("scraper", "抓取成功", { source_url: listUrl, count: items.length });
+  const deliverUrl = await getDeliverUrl();
+  let newCount = 0;
+  let newIds = /* @__PURE__ */ new Set();
+  const upsertResult = await upsertItems(items).catch((err) => {
+    logger.warn("db", "upsertItems 失败", { source_url: listUrl, err: err instanceof Error ? err.message : String(err) });
+    return { newCount: 0, newIds: /* @__PURE__ */ new Set() };
+  });
+  newCount = upsertResult.newCount;
+  newIds = upsertResult.newIds;
+  let pipelineDroppedNew = 0;
+  const shouldRunPipelineRow = (guid) => newIds.has(guid);
+  const hasEnrich = source.enrichItem != null || items.some((i) => getMatchedEnrichPlugin(i, { sourceUrl: listUrl }));
+  if (!includeContent || items.length === 0 || !hasEnrich) {
+    for (let i = 0; i < items.length; i++) {
+      if (!shouldRunPipelineRow(items[i].guid)) continue;
+      const processed = await runPipelineOnItem(items[i], { sourceUrl: listUrl, isEnriched: false });
+      items[i] = processed;
+      if (isPipelineDroppedItem(processed)) {
+        await deleteItem(processed.guid).catch(
+          (err) => logger.warn("db", "质量过滤后删除条目失败", { source_url: listUrl, err: err instanceof Error ? err.message : String(err) })
+        );
+        pipelineDroppedNew++;
+      } else {
+        updateItemContent(processed).catch(
+          (err) => logger.warn("db", "updateItemContent 失败", { source_url: listUrl, err: err instanceof Error ? err.message : String(err) })
+        );
+      }
+    }
+    if (newCount > 0) {
+      emitFeedUpdated({ sourceUrl: listUrl, newCount: newCount - pipelineDroppedNew });
+    }
+    const out = items.filter((i) => !isPipelineDroppedItem(i));
+    if (deliverUrl && out.length > 0) {
+      await postDeliverItemsSafe(deliverUrl, listUrl, out);
+    }
+    return { items: out };
+  }
+  const enrichFn = (item, _ctx) => buildEnrichFn(source, listUrl, ctx)(item);
+  await enrichQueue.submit(
+    items,
+    enrichFn,
+    ctx,
+    {
+      sourceUrl: listUrl,
+      onItemDone: async (enrichedItem, index) => {
+        enrichedItem.sourceRef = listUrl;
+        const processed = shouldRunPipelineRow(enrichedItem.guid) ? await runPipelineOnItem(enrichedItem, { sourceUrl: listUrl, isEnriched: true }) : enrichedItem;
+        items[index] = processed;
+        if (isPipelineDroppedItem(processed)) {
+          await deleteItem(processed.guid).catch(
+            (err) => logger.warn("db", "质量过滤后删除条目失败", { source_url: listUrl, err: err instanceof Error ? err.message : String(err) })
+          );
+          pipelineDroppedNew++;
+        } else {
+          updateItemContent(processed).catch(
+            (err) => logger.warn("db", "updateItemContent 失败", { source_url: listUrl, err: err instanceof Error ? err.message : String(err) })
+          );
+        }
+      },
+      onAllDone: async () => {
+        for (let i = items.length - 1; i >= 0; i--) {
+          if (isPipelineDroppedItem(items[i])) items.splice(i, 1);
+        }
+        if (newCount > 0) {
+          emitFeedUpdated({ sourceUrl: listUrl, newCount: newCount - pipelineDroppedNew });
+        }
+        if (deliverUrl && items.length > 0) {
+          await postDeliverItemsSafe(deliverUrl, listUrl, items);
+        }
+      }
+    }
+  );
+  return { items };
+}
+async function getItems(listUrl, config = {}) {
+  const source = getSource(listUrl);
+  const key = config.cron ? cacheKeyFromCron(listUrl, config.cron) : cacheKey(listUrl, config.refreshInterval ?? source.refreshInterval ?? "1day");
+  if (source.preCheck != null) {
+    try {
+      await source.preCheck({ cacheDir: config.cacheDir ?? "cache", headless: config.headless, proxy: config.proxy ?? source.proxy });
+    } catch (err) {
+      if (err instanceof AuthRequiredError) throw err;
+      throw err;
+    }
+  }
+  let task = config.force ? void 0 : generatingKeys.get(key);
+  if (!task) {
+    task = generateAndCache(listUrl, key, config);
+    if (!config.force) generatingKeys.set(key, task);
+  }
+  const { items } = await task;
+  return { items, fromCache: false };
+}
+function feedItemsToRssXml(items, listUrl, lng, opts) {
+  const channel = buildChannelFromItems(listUrl, items, lng);
+  if (opts?.channelTitle) channel.title = opts.channelTitle;
+  if (opts?.channelDesc) channel.description = opts.channelDesc;
+  return buildRssXml(channel, items.map((it) => toRssEntry(it, lng)));
+}
+const DEFAULT_REFRESH = "1day";
+const SOURCES_CONCURRENCY = 5;
+function createPullTask(ref, cacheDir, cronExpr) {
+  return async () => {
+    try {
+      await getItems(ref, {
+        cacheDir,
+        cron: cronExpr
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+}
+const SOURCES_GROUP = "sources";
+async function rescheduleSources(cacheDir, runNow2) {
+  unscheduleGroup(SOURCES_GROUP);
+  let sources;
+  try {
+    sources = await getAllSources();
+  } catch {
+    sources = [];
+  }
+  for (const src of sources) {
+    const ref = resolveRef(src);
+    if (!ref) continue;
+    const cronExpr = src.cron ? src.cron : refreshIntervalToCron(src.refresh ?? DEFAULT_REFRESH);
+    if (!validateCron(cronExpr)) continue;
+    schedule(SOURCES_GROUP, ref, createPullTask(ref, cacheDir, cronExpr), {
+      cron: cronExpr,
+      retries: 2,
+      retryDelayMs: 5e3,
+      concurrency: SOURCES_CONCURRENCY,
+      runNow: runNow2
+    });
+  }
+}
+async function initScheduler(cacheDir) {
+  await rescheduleSources(cacheDir, true);
+  let debounceTimer = null;
+  try {
+    const watcher = watch(SOURCES_CONFIG_PATH, () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        rescheduleSources(cacheDir, false).catch(() => {
+        });
+      }, 500);
+    });
+    watcher.on("error", () => {
+    });
+  } catch {
+  }
+}
+function requireAdmin() {
+  return async (_c, next) => {
+    return next();
+  };
+}
+const PORT$1 = Number(process.env.PORT) || 18473;
+function registerServerRoutes(app) {
+  app.get("/api/server-info", requireAdmin(), (c) => {
+    const lanIp = Object.values(networkInterfaces()).flat().find((iface) => iface?.family === "IPv4" && !iface.internal)?.address;
+    const lanUrl = lanIp ? `http://${lanIp}:${PORT$1}` : null;
+    return c.json({ port: PORT$1, lanUrl });
+  });
+}
+function registerRssApiRoutes(app) {
+  app.get("/api/rss", async (c) => {
+    const url = c.req.query("url");
+    if (!url) return c.json({ error: "url 参数缺失" }, 400);
+    const headlessParam = c.req.query("headless");
+    const headless = headlessParam === "false" || headlessParam === "0" ? false : void 0;
+    const lng = c.req.query("lng") ?? void 0;
+    const limit = Math.min(Number(c.req.query("limit") ?? 20), 200);
+    const offset = Number(c.req.query("offset") ?? 0);
+    try {
+      const httpId = "http-" + createHash("sha256").update(url).digest("hex").slice(0, 16);
+      const { items: allItems, fromCache } = await schedule(
+        SOURCES_GROUP,
+        httpId,
+        () => getItems(url, { cacheDir: CACHE_DIR, headless, lng })
+      );
+      const total = allItems.length;
+      const pageItems = allItems.slice(offset, offset + limit);
+      return c.json({
+        fromCache,
+        total,
+        hasMore: offset + pageItems.length < total,
+        items: pageItems.map((item) => {
+          const { title, summary } = lng ? getEffectiveItemFields(item, lng) : { title: item.title, summary: item.summary ?? "" };
+          return {
+            guid: item.guid,
+            title,
+            link: item.link,
+            summary,
+            author: item.author,
+            pubDate: item.pubDate instanceof Date ? item.pubDate.toISOString() : item.pubDate
+          };
+        })
+      });
+    } catch (err) {
+      if (err instanceof AuthRequiredError) return c.json({ error: "需要登录", code: "AUTH_REQUIRED" }, 401);
+      if (err instanceof NotFoundError) return c.json({ error: err.message, code: "NOT_FOUND" }, 404);
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+}
+function registerEnrichRoutes(app) {
+  app.get("/api/enrich/:taskId", (c) => {
+    const taskId = c.req.param("taskId");
+    const task = enrichQueue.getTask(taskId);
+    if (!task) return c.json({ error: "任务不存在或已过期" }, 404);
+    return c.json(task);
+  });
+}
+function registerSchedulerRoutes(app) {
+  app.get("/api/scheduler/stats", requireAdmin(), (c) => {
+    const stats = getGroupStats();
+    return c.json(stats);
+  });
+}
+const USER_SITE_TEMPLATE = join(BUILTIN_PLUGINS_DIR, "templates", "site.rssany.js");
+const SITE_TEMPLATE_FALLBACK = `/**
+ * Site 插件模板（由管理页添加，位于 .rssany/plugins/sources/）
+ */
+export default {
+  id: "__PLUGIN_ID__",
+  listUrlPattern: "https://example.com/{segment}",
+  refreshInterval: "1day",
+
+  async fetchItems(sourceId, ctx) {
+    const { html, finalUrl } = await ctx.fetchHtml(sourceId, {
+      waitMs: 2000,
+      purify: true,
+    });
+    void html;
+    void finalUrl;
+    return [];
+  },
+};
+`;
+function isValidNewPluginId(id) {
+  return /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(id) && id !== "generic" && id !== "new";
+}
+async function fileExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAllowedPluginPath(absPath) {
+  const f = resolve(absPath);
+  for (const root of [BUILTIN_PLUGINS_DIR, USER_PLUGINS_DIR]) {
+    const r = resolve(root);
+    if (f === r || f.startsWith(r + sep)) return true;
+  }
+  return false;
+}
+function registerPluginsRoutes(app) {
+  app.post("/api/plugins", requireAdmin(), async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "无效 JSON" }, 400);
+    }
+    const id = typeof body.id === "string" ? body.id.trim() : "";
+    if (!id) return c.json({ error: "缺少 id" }, 400);
+    if (!isValidNewPluginId(id)) {
+      return c.json({ error: "id 须为字母开头，仅含字母数字、下划线、连字符；不能为 generic 或 new" }, 400);
+    }
+    await mkdir(USER_PLUGINS_DIR, { recursive: true });
+    await mkdir(USER_SOURCES_DIR, { recursive: true });
+    const outPath = join(USER_SOURCES_DIR, `${id}.rssany.ts`);
+    if (await fileExists(outPath)) return c.json({ error: "该 id 已存在同名文件" }, 409);
+    let tpl = SITE_TEMPLATE_FALLBACK;
+    try {
+      tpl = await readFile(USER_SITE_TEMPLATE, "utf-8");
+    } catch {
+    }
+    const content = tpl.replace(/__PLUGIN_ID__/g, id);
+    if (!isAllowedPluginPath(outPath)) return c.json({ error: "路径不允许" }, 403);
+    try {
+      await writeFile(outPath, content, "utf-8");
+      await initSources();
+      return c.json({ ok: true, filePath: outPath, id });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
+  });
+  app.get("/api/plugins", requireAdmin(), (c) => {
+    const sites = getPluginSites().map((s) => ({
+      kind: "site",
+      id: s.id,
+      listUrlPattern: typeof s.listUrlPattern === "string" ? s.listUrlPattern : String(s.listUrlPattern),
+      hasEnrich: !!s.enrichItem,
+      hasAuth: !!(s.checkAuth && s.loginUrl)
+    }));
+    const siteIds = new Set(sites.map((p) => p.id));
+    const sources = registeredSources.filter((src) => src.id !== "generic" && !siteIds.has(src.id)).map((src) => ({
+      kind: "source",
+      id: src.id,
+      listUrlPattern: typeof src.pattern === "string" ? src.pattern : String(src.pattern),
+      hasEnrich: !!src.enrichItem,
+      hasAuth: false
+    }));
+    return c.json([...sites, ...sources]);
+  });
+  app.get("/api/plugins/:id", requireAdmin(), async (c) => {
+    const id = decodeURIComponent(c.req.param("id") ?? "").trim();
+    if (!id) return c.json({ error: "缺少 id" }, 400);
+    const filePath = getPluginFilePath(id);
+    if (!filePath) return c.json({ error: "未找到该插件或无可编辑文件" }, 404);
+    if (!isAllowedPluginPath(filePath)) return c.json({ error: "路径不允许" }, 403);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return c.json({ id, filePath, content });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
+  });
+  app.put("/api/plugins/:id", requireAdmin(), async (c) => {
+    const id = decodeURIComponent(c.req.param("id") ?? "").trim();
+    if (!id) return c.json({ error: "缺少 id" }, 400);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "无效 JSON" }, 400);
+    }
+    if (typeof body.content !== "string") return c.json({ error: "需要 content 字符串" }, 400);
+    const filePath = getPluginFilePath(id);
+    if (!filePath) return c.json({ error: "未找到该插件" }, 404);
+    if (!isAllowedPluginPath(filePath)) return c.json({ error: "路径不允许" }, 403);
+    try {
+      await writeFile(filePath, body.content, "utf-8");
+      await initSources();
+      return c.json({ ok: true });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
+  });
+}
+function parseSteps(rawSteps) {
+  return rawSteps.filter((s) => s && typeof s === "object" && typeof s.id === "string").map((s) => {
+    const obj = s;
+    const e = obj.enabled;
+    return {
+      id: String(obj.id).trim(),
+      enabled: e !== false && e !== 0
+    };
+  }).filter((s) => s.id.length > 0);
+}
+function dedupeSteps(steps) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of steps) {
+    if (seen.has(s.id)) continue;
+    seen.add(s.id);
+    out.push(s);
+  }
+  return out;
+}
+function registerPipelineRoutes(app) {
+  app.get("/api/pipeline", requireAdmin(), async (c) => {
+    const config = await loadPipelineConfig();
+    return c.json({
+      steps: config.steps,
+      availableIds: [...PIPELINE_STEP_IDS],
+      defaults: DEFAULT_PIPELINE_STEPS
+    });
+  });
+  app.put("/api/pipeline", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const rawSteps = Array.isArray(body?.steps) ? body.steps : [];
+      const steps = dedupeSteps(parseSteps(rawSteps));
+      await savePipelineConfig({ steps });
+      return c.json({ ok: true, steps });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+}
+function registerFeedRoutes(app) {
+  app.get("/api/feed", async (c) => {
+    const limit = Math.min(Number(c.req.query("limit") ?? 50), 200);
+    const offset = Number(c.req.query("offset") ?? 0);
+    const refFilter = c.req.query("ref") ?? c.req.query("source") ?? void 0;
+    const lng = c.req.query("lng") ?? void 0;
+    const since = c.req.query("since");
+    const until = c.req.query("until");
+    const sources = await getAllSources();
+    const refSet = new Set(sources.map((s) => resolveRef(s)).filter(Boolean));
+    let sourceRefs;
+    if (refFilter) {
+      sourceRefs = refSet.has(refFilter) ? [refFilter] : [];
+    } else {
+      sourceRefs = await getAllSubscriptionRefs();
+    }
+    const labelByRef = new Map(sources.map((s) => [resolveRef(s), s.label ?? resolveRef(s)]));
+    const sourcesMeta = sources.map((s) => ({
+      ref: resolveRef(s),
+      label: s.label ?? resolveRef(s)
+    }));
+    const dateOpts = since || until ? { since: since ?? void 0, until: until ?? void 0 } : void 0;
+    const { items: dbItems, hasMore } = await queryFeedItems(sourceRefs, limit, offset, dateOpts);
+    const items = dbItems.map((item) => {
+      const refKey = item.source_url ?? "";
+      const base2 = {
+        ...item,
+        sub_id: refKey,
+        sub_title: labelByRef.get(refKey) ?? ""
+      };
+      if (!lng) return base2;
+      const view = {
+        title: item.title ?? "",
+        summary: item.summary ?? "",
+        content: item.content ?? "",
+        translations: item.translations
+      };
+      const eff = getEffectiveItemFields(view, lng);
+      return { ...base2, title: eff.title, summary: eff.summary, content: eff.content };
+    });
+    return c.json({ sources: sourcesMeta, items, hasMore });
+  });
+  app.get("/api/events", (c) => {
+    return streamSSE(c, async (stream) => {
+      await stream.writeSSE({ data: JSON.stringify({ type: "connected" }) });
+      const off = onFeedUpdated((e) => {
+        stream.writeSSE({ data: JSON.stringify({ type: "feed:updated", sourceUrl: e.sourceUrl, newCount: e.newCount }) }).catch(() => {
+        });
+      });
+      const heartbeat = setInterval(() => {
+        stream.writeSSE({ data: "", event: "ping" }).catch(() => {
+        });
+      }, 25e3);
+      stream.onAbort(() => {
+        off();
+        clearInterval(heartbeat);
+      });
+      await new Promise((resolve2) => stream.onAbort(resolve2));
+    });
+  });
+}
+function parseSubscribedFlag$1(v) {
+  return v === "1" || v === "true" || v === "yes";
+}
+function registerItemsRoutes(app) {
+  app.get("/api/items/pending-push", async (c) => {
+    const limit = Math.min(Number(c.req.query("limit") ?? 100), 500);
+    const items = await getPendingPushItems(limit);
+    return c.json({ items, count: items.length });
+  });
+  app.post("/api/items/mark-pushed", async (c) => {
+    try {
+      const { ids } = await c.req.json();
+      if (!Array.isArray(ids) || ids.length === 0) return c.json({ ok: false, message: "ids 不能为空" }, 400);
+      await markPushed(ids);
+      return c.json({ ok: true, count: ids.length });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+  app.delete("/api/items/:id", async (c) => {
+    const id = decodeURIComponent(c.req.param("id") ?? "").trim();
+    if (!id) return c.json({ ok: false, message: "id 不能为空" }, 400);
+    const deleted = await deleteItem(id);
+    if (!deleted) return c.json({ ok: false, message: "条目不存在或已删除" }, 404);
+    return c.json({ ok: true });
+  });
+  app.delete("/api/items/by-source", requireAdmin(), async (c) => {
+    const sourceUrl = (c.req.query("source_url") ?? "").trim();
+    if (!sourceUrl) return c.json({ ok: false, message: "source_url 不能为空" }, 400);
+    const deleted = await deleteItemsBySourceUrl(sourceUrl);
+    return c.json({ ok: true, deleted });
+  });
+  app.get("/api/items", async (c) => {
+    const ref = c.req.query("ref") ?? c.req.query("source") ?? void 0;
+    const subscribed = parseSubscribedFlag$1(c.req.query("subscribed"));
+    const author = c.req.query("author") ?? void 0;
+    const q = c.req.query("q") ?? void 0;
+    const tagsParam = c.req.query("tags") ?? void 0;
+    const tags = tagsParam ? tagsParam.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+    const daysParam = c.req.query("days");
+    const sinceParam = c.req.query("since") ?? void 0;
+    const untilParam = c.req.query("until") ?? void 0;
+    let since;
+    let until;
+    const daysNum = daysParam !== void 0 && daysParam !== "" ? Number(daysParam) : NaN;
+    if (Number.isFinite(daysNum) && daysNum > 0) {
+      const n = Math.max(1, Math.min(365, Math.floor(daysNum)));
+      const now2 = /* @__PURE__ */ new Date();
+      const todayStart = new Date(now2.getFullYear(), now2.getMonth(), now2.getDate());
+      const todayEnd = new Date(todayStart);
+      todayEnd.setDate(todayEnd.getDate() + 1);
+      since = new Date(todayStart);
+      since.setDate(since.getDate() - (n - 1));
+      until = todayEnd;
+    } else {
+      since = sinceParam ? new Date(sinceParam) : void 0;
+      if (untilParam) {
+        if (untilParam.length === 10) {
+          const d = /* @__PURE__ */ new Date(untilParam + "T12:00:00Z");
+          d.setUTCDate(d.getUTCDate() + 1);
+          until = d;
+        } else {
+          until = new Date(untilParam);
+        }
+      }
+    }
+    const limit = Math.min(Number(c.req.query("limit") ?? 200), 500);
+    const offset = Number(c.req.query("offset") ?? 0);
+    const lng = c.req.query("lng") ?? void 0;
+    let sourceUrls;
+    let effectiveSourceUrl;
+    if (ref) {
+      effectiveSourceUrl = ref;
+      sourceUrls = void 0;
+    } else if (subscribed) {
+      const refs = await getAllSubscriptionRefs();
+      sourceUrls = refs.length > 0 ? refs : [];
+    }
+    if (!effectiveSourceUrl && sourceUrls?.length === 0) {
+      return c.json({ items: [], total: 0, hasMore: false });
+    }
+    const result = await queryItems({
+      sourceUrl: effectiveSourceUrl ?? (sourceUrls ? void 0 : ref),
+      sourceUrls,
+      author,
+      q,
+      tags,
+      since,
+      until,
+      limit,
+      offset
+    });
+    const items = lng && result.items.length > 0 ? result.items.map((it) => {
+      const view = {
+        title: it.title ?? "",
+        summary: it.summary ?? "",
+        content: it.content ?? "",
+        translations: it.translations
+      };
+      const eff = getEffectiveItemFields(view, lng);
+      return { ...it, title: eff.title, summary: eff.summary, content: eff.content };
+    }) : result.items;
+    const hasMore = offset + items.length < result.total;
+    return c.json({ items, total: result.total, hasMore });
+  });
+}
+function registerLogsRoutes(app) {
+  app.delete("/api/logs", requireAdmin(), async (c) => {
+    const deleted = await clearAllLogs();
+    return c.json({ ok: true, deleted });
+  });
+  app.get("/api/logs", requireAdmin(), async (c) => {
+    const levelParam = c.req.query("level");
+    const level = levelParam === "error" || levelParam === "warn" || levelParam === "info" || levelParam === "debug" ? levelParam : void 0;
+    const categoryRaw = c.req.query("category");
+    const category = typeof categoryRaw === "string" && categoryRaw.trim() ? categoryRaw.trim() : void 0;
+    const limit = Math.min(Number(c.req.query("limit") ?? 100), 200);
+    const offset = Number(c.req.query("offset") ?? 0);
+    const sinceParam = c.req.query("since");
+    const since = sinceParam ? new Date(sinceParam) : void 0;
+    const result = await queryLogs({ level, category, limit, offset, since });
+    return c.json(result);
+  });
+}
+function registerAdminApiRoutes(app) {
+  app.get("/api/admin/verify", requireAdmin(), async (c) => {
+    return c.json({ ok: true });
+  });
+  app.get("/api/admin/integrity-check", requireAdmin(), async (c) => {
+    try {
+      const result = await runIntegrityCheck();
+      const ok = result === "ok";
+      return c.json({ ok, result });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ ok: false, result: `error: ${message}` }, 500);
+    }
+  });
+}
+function registerSourcesRoutes(app) {
+  app.get("/api/sources/stats", requireAdmin(), async (c) => {
+    const stats = await getSourceStats();
+    return c.json(stats);
+  });
+  app.post("/api/sources/plugin-match", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const refs = Array.isArray(body?.refs) ? body.refs : [];
+      const pluginIds = new Set(getPluginSites().map((s) => s.id));
+      const result = {};
+      for (const ref of refs) {
+        const source = getSource(ref);
+        result[ref] = pluginIds.has(source.id) ? source.id : null;
+      }
+      return c.json(result);
+    } catch {
+      return c.json({});
+    }
+  });
+  app.get("/api/sources/raw", requireAdmin(), async (c) => {
+    try {
+      const raw = await getSourcesRaw();
+      return c.text(raw, 200, { "Content-Type": "application/json; charset=utf-8" });
+    } catch {
+      return c.text(JSON.stringify({ sources: [] }, null, 2), 200, { "Content-Type": "application/json; charset=utf-8" });
+    }
+  });
+  app.put("/api/sources/raw", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const list = Array.isArray(body?.sources) ? body.sources : [];
+      const sources = list.filter((s) => s != null && typeof s === "object" && typeof s.ref === "string").map((s) => {
+        const t = s.type;
+        const type = t === "web" || t === "rss" || t === "email" ? t : void 0;
+        const r = s.refresh;
+        const refresh = r && VALID_INTERVALS.includes(r) ? r : void 0;
+        const w = s.weight;
+        const weight = typeof w === "number" ? w : void 0;
+        return {
+          ref: String(s.ref),
+          type,
+          label: s.label,
+          description: s.description,
+          refresh,
+          proxy: s.proxy,
+          weight
+        };
+      });
+      await saveSourcesFile(sources);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+}
+function registerTopicsRoutes(app) {
+  app.get("/api/tags", async (c) => {
+    const [tags, stats, suggested] = await Promise.all([
+      getSystemTags(),
+      getSystemTagStats(),
+      getSuggestedTags()
+    ]);
+    return c.json({
+      tags,
+      stats: stats.map((s) => ({ name: s.name, count: s.count, hotness: s.hotness })),
+      suggestedTags: suggested.map((s) => ({ name: s.name, count: s.count, hotness: s.hotness }))
+    });
+  });
+  app.put("/api/tags", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const list = Array.isArray(body?.tags) ? body.tags : [];
+      await saveSystemTagsToFile(list);
+      const [tags, stats, suggested] = await Promise.all([
+        getSystemTags(),
+        getSystemTagStats(),
+        getSuggestedTags()
+      ]);
+      return c.json({
+        ok: true,
+        tags,
+        stats: stats.map((s) => ({ name: s.name, count: s.count, hotness: s.hotness })),
+        suggestedTags: suggested.map((s) => ({ name: s.name, count: s.count, hotness: s.hotness }))
+      });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+  app.post("/api/tags/remove-from-items", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const tag = typeof body?.tag === "string" ? body.tag.trim() : "";
+      if (!tag) return c.json({ ok: false, message: "tag 参数缺失" }, 400);
+      const count = await removeTagFromAllItems(tag);
+      const [tags, stats, suggested] = await Promise.all([
+        getSystemTags(),
+        getSystemTagStats(),
+        getSuggestedTags()
+      ]);
+      return c.json({
+        ok: true,
+        removedCount: count,
+        tags,
+        stats: stats.map((s) => ({ name: s.name, count: s.count, hotness: s.hotness })),
+        suggestedTags: suggested.map((s) => ({ name: s.name, count: s.count, hotness: s.hotness }))
+      });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+}
+function registerDeliverRoutes(app) {
+  app.get("/api/deliver", requireAdmin(), async (c) => {
+    const url = await getDeliverUrl();
+    return c.json({ url });
+  });
+  app.put("/api/deliver", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = typeof body?.url === "string" ? body.url.trim() : "";
+      await saveDeliverUrl(url);
+      return c.json({ ok: true, url });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+  app.post("/api/deliver/test", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = typeof body?.url === "string" ? body.url.trim() : "";
+      if (!url) return c.json({ ok: false, message: "url 不能为空" }, 400);
+      const sample = {
+        guid: "deliver-test-" + Date.now(),
+        title: "投递连通性测试",
+        link: "https://example.com/rssany-deliver-test",
+        pubDate: (/* @__PURE__ */ new Date()).toISOString(),
+        summary: "若下游收到此条，说明投递 URL 可用。"
+      };
+      await postDeliverItems(url, "rssany-deliver-test", [
+        {
+          guid: sample.guid,
+          title: sample.title,
+          link: sample.link,
+          pubDate: new Date(sample.pubDate),
+          summary: sample.summary,
+          sourceRef: "rssany-deliver-test"
+        }
+      ]);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+}
+const tasks = /* @__PURE__ */ new Map();
+let idCounter = 0;
+function nextId() {
+  idCounter += 1;
+  return `t_${Date.now().toString(36)}_${idCounter}`;
+}
+function createTask() {
+  const id = nextId();
+  const now2 = Date.now();
+  tasks.set(id, { id, status: "pending", createdAt: now2, updatedAt: now2 });
+  return id;
+}
+function getTask(id) {
+  return tasks.get(id) ?? null;
+}
+function setTaskRunning(id) {
+  const t = tasks.get(id);
+  if (t) {
+    t.status = "running";
+    t.updatedAt = Date.now();
+  }
+}
+function setTaskDone(id, result) {
+  const t = tasks.get(id);
+  if (t) {
+    t.status = "done";
+    t.result = result;
+    t.updatedAt = Date.now();
+  }
+}
+function setTaskError(id, error) {
+  const t = tasks.get(id);
+  if (t) {
+    t.status = "error";
+    t.error = error;
+    t.updatedAt = Date.now();
+  }
+}
+function registerTasksRoutes(app) {
+  app.get("/api/tasks/:id", (c) => {
+    const id = c.req.param("id") ?? "";
+    const task = getTask(id);
+    if (!task) return c.json({ error: "任务不存在" }, 404);
+    return c.json(task);
+  });
+  app.post("/api/tasks", requireAdmin(), async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const type = body.type ?? "";
+      if (type === "source-pull") {
+        const ref = typeof body.ref === "string" ? body.ref.trim() : "";
+        if (!ref) return c.json({ error: "ref 不能为空" }, 400);
+        const taskId = createTask();
+        schedule(SOURCES_GROUP, taskId, async () => {
+          setTaskRunning(taskId);
+          try {
+            await getItems(ref, { cacheDir: CACHE_DIR, force: true });
+            setTaskDone(taskId, { ok: true });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            setTaskError(taskId, msg);
+            throw err;
+          }
+        }, { priority: true }).catch(() => {
+        });
+        return c.json({ taskId });
+      }
+      return c.json({ error: `未知任务类型: ${type}` }, 400);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+}
+function registerApiRoutes(app) {
+  registerServerRoutes(app);
+  registerRssApiRoutes(app);
+  registerEnrichRoutes(app);
+  registerSchedulerRoutes(app);
+  registerPluginsRoutes(app);
+  registerPipelineRoutes(app);
+  registerFeedRoutes(app);
+  registerItemsRoutes(app);
+  registerLogsRoutes(app);
+  registerAdminApiRoutes(app);
+  registerSourcesRoutes(app);
+  registerTopicsRoutes(app);
+  registerDeliverRoutes(app);
+  registerTasksRoutes(app);
+}
+function registerAuthRoutes(app) {
+  app.get("/auth/check", async (c) => {
+    const siteIdParam = c.req.query("siteId");
+    if (!siteIdParam) {
+      return c.json({ ok: false, message: "请提供 siteId" }, 400);
+    }
+    const site = getWebSite(siteIdParam);
+    if (!site) return c.json({ ok: false, message: "无此站点" }, 404);
+    const authFlow = toAuthFlow(site);
+    if (!authFlow) return c.json({ ok: false, message: "该站点无需登录" }, 400);
+    try {
+      const authenticated = await preCheckAuth(authFlow, CACHE_DIR);
+      return c.json({ ok: true, authenticated });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ ok: false, message: `检查失败: ${msg}` }, 500);
+    }
+  });
+  app.post("/auth/open", async (c) => {
+    const siteIdParam = c.req.query("siteId");
+    if (!siteIdParam) {
+      return c.json({ ok: false, message: "请提供 siteId" }, 400);
+    }
+    const site = getWebSite(siteIdParam);
+    if (!site) return c.json({ ok: false, message: "无此站点" }, 404);
+    const authFlow = toAuthFlow(site);
+    if (!authFlow) return c.json({ ok: false, message: "该站点无需登录" }, 400);
+    const { loginUrl } = authFlow;
+    getOrCreateBrowser({ headless: false, cacheDir: CACHE_DIR }).then(async (browser) => {
+      const page = await browser.newPage();
+      const realUserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+      await page.setUserAgent(realUserAgent);
+      await page.setViewport({ width: 1366, height: 960 });
+      await page.goto(loginUrl, { waitUntil: "domcontentloaded", timeout: 6e4 });
+    }).catch(() => {
+    });
+    return c.json({ ok: true, message: "已打开登录页面" });
+  });
+  app.post("/auth/ensure", async (c) => {
+    const urlParam = c.req.query("url");
+    const siteIdParam = c.req.query("siteId");
+    let site;
+    if (urlParam) {
+      const decoded = decodeURIComponent(urlParam);
+      site = getBestSite(decoded);
+      if (!site) return c.json({ ok: false, message: "无匹配站点" }, 404);
+    } else if (siteIdParam) {
+      site = getWebSite(siteIdParam);
+      if (!site) return c.json({ ok: false, message: "无此站点" }, 404);
+    } else {
+      return c.json({ ok: false, message: "请提供 url 或 siteId" }, 400);
+    }
+    const authFlow = toAuthFlow(site);
+    if (!authFlow) return c.json({ ok: false, message: "该站点无需登录" }, 400);
+    ensureAuth(authFlow, CACHE_DIR).then(() => {
+    }).catch(() => {
+    });
+    return c.json({ ok: true, message: "已打开登录窗口，请在弹出的浏览器中完成登录，完成后刷新订阅页面即可。" });
+  });
+}
+const STATICS_DIR = join(PACKAGE_ROOT, "statics");
+function parseUrlFromPath(path, prefix) {
+  const raw = path.slice(prefix.length) || "";
+  const decoded = decodeURIComponent(raw.startsWith("/") ? raw.slice(1) : raw);
+  if (!decoded) return null;
+  return decoded.startsWith("http") ? decoded : `https://${decoded}`;
+}
+async function readStaticHtml(name, fallback) {
+  try {
+    return await readFile(join(STATICS_DIR, `${name}.html`), "utf-8");
+  } catch {
+    return fallback;
+  }
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function registerAdminRoutes(app) {
+  async function render401(listUrl) {
+    const raw = await readStaticHtml("401", '<!DOCTYPE html><html><head><meta charset="utf-8"><title>401</title></head><body><h1>401 需要登录</h1></body></html>');
+    return raw.replace(/\{\{listUrl\}\}/g, escapeHtml(listUrl));
+  }
+  app.get("/admin/parse/*", requireAdmin(), async (c) => {
+    const url = parseUrlFromPath(c.req.path, "/admin/parse");
+    if (!url) return c.text("无效 URL，格式: /admin/parse/https://... 或 /admin/parse/example.com/...", 400);
+    try {
+      const headlessParam = c.req.query("headless");
+      const headless = headlessParam === "false" || headlessParam === "0" ? false : void 0;
+      const source = getSource(url);
+      const ctx = { cacheDir: CACHE_DIR, headless, proxy: source.proxy };
+      const items = await source.fetchItems(url, ctx);
+      const mode = source.id === "generic" ? "generic" : "plugin";
+      return c.json({ items, url, mode, pluginId: source.id });
+    } catch (err) {
+      if (err instanceof AuthRequiredError) {
+        const html = await render401(url);
+        return c.html(html, 401);
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.text(`解析失败: ${msg}`, 500);
+    }
+  });
+  app.get("/admin/extractor/*", requireAdmin(), async (c) => {
+    const url = parseUrlFromPath(c.req.path, "/admin/extractor");
+    if (!url) return c.text("无效 URL，格式: /admin/extractor/https://... 或 /admin/extractor/example.com/...", 400);
+    try {
+      const headlessParam = c.req.query("headless");
+      const headless = headlessParam === "false" || headlessParam === "0" ? false : void 0;
+      const site = getBestSite(url);
+      if (site?.enrichItem) {
+        const siteCtx = buildSiteContext(site, { cacheDir: CACHE_DIR, headless });
+        const stub = { guid: url, title: "", link: url, pubDate: /* @__PURE__ */ new Date() };
+        const enriched = await site.enrichItem(stub, siteCtx);
+        return c.json({
+          title: enriched.title ?? null,
+          author: enriched.author ?? null,
+          pubDate: enriched.pubDate instanceof Date ? enriched.pubDate.toISOString() : enriched.pubDate ?? null,
+          content: enriched.content ?? null,
+          _extractor: site.id
+        });
+      }
+      const proxy = site?.proxy;
+      const result = await extractFromLink(url, {}, { timeoutMs: 6e4, headless, proxy });
+      return c.json({
+        title: result.title ?? null,
+        author: result.author ?? null,
+        pubDate: result.pubDate ?? null,
+        content: result.content ?? null,
+        _extractor: "readability"
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.text(`提取失败: ${msg}`, 500);
+    }
+  });
+}
+function parseSubscribedFlag(v) {
+  return v === "1" || v === "true" || v === "yes";
+}
+function registerRssRoutes(app) {
+  async function render401(listUrl) {
+    const raw = await readStaticHtml("401", '<!DOCTYPE html><html><head><meta charset="utf-8"><title>401</title></head><body><h1>401 需要登录</h1></body></html>');
+    return raw.replace(/\{\{listUrl\}\}/g, escapeHtml(listUrl));
+  }
+  app.get("/rss", async (c) => {
+    const search = c.req.query("search") ?? c.req.query("q") ?? void 0;
+    const ref = c.req.query("ref") ?? c.req.query("source") ?? c.req.query("sourceUrl") ?? void 0;
+    const subscribed = parseSubscribedFlag(c.req.query("subscribed"));
+    const author = c.req.query("author") ?? void 0;
+    const tagsParam = c.req.query("tags") ?? void 0;
+    const tags = tagsParam ? tagsParam.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+    const lng = c.req.query("lng") ?? void 0;
+    const limit = Math.min(Number(c.req.query("limit") ?? 50), 200);
+    const offset = Number(c.req.query("offset") ?? 0);
+    const title = c.req.query("title") ?? void 0;
+    const daysParam = c.req.query("days");
+    const sinceParam = c.req.query("since") ?? void 0;
+    const untilParam = c.req.query("until") ?? void 0;
+    let since;
+    let until;
+    if (daysParam) {
+      const n = Math.max(1, Math.min(365, Number(daysParam) || 1));
+      const now2 = /* @__PURE__ */ new Date();
+      const todayStart = new Date(now2.getFullYear(), now2.getMonth(), now2.getDate());
+      const todayEnd = new Date(todayStart);
+      todayEnd.setDate(todayEnd.getDate() + 1);
+      since = new Date(todayStart);
+      since.setDate(since.getDate() - (n - 1));
+      until = todayEnd;
+    } else {
+      since = sinceParam ? new Date(sinceParam) : void 0;
+      if (untilParam) {
+        if (untilParam.length === 10) {
+          const d = /* @__PURE__ */ new Date(untilParam + "T12:00:00Z");
+          d.setUTCDate(d.getUTCDate() + 1);
+          until = d;
+        } else {
+          until = new Date(untilParam);
+        }
+      }
+    }
+    let sourceUrls;
+    if (ref) {
+      sourceUrls = void 0;
+    } else if (subscribed) {
+      sourceUrls = await getAllSubscriptionRefs();
+    }
+    if (sourceUrls?.length === 0) {
+      const xml2 = feedItemsToRssXml([], new URL(c.req.url).href, lng, {
+        channelTitle: title ?? "RSS 订阅",
+        channelDesc: "无匹配条目"
+      });
+      return c.body(xml2, 200, { "Content-Type": "application/rss+xml; charset=utf-8" });
+    }
+    const result = await queryItems({
+      sourceUrl: sourceUrls ? void 0 : ref,
+      sourceUrls,
+      author,
+      q: search,
+      tags,
+      since,
+      until,
+      limit,
+      offset
+    });
+    const feedItems = result.items.map((dbItem) => ({
+      guid: dbItem.id,
+      title: dbItem.title ?? "",
+      link: dbItem.url,
+      pubDate: dbItem.pub_date ? new Date(dbItem.pub_date) : /* @__PURE__ */ new Date(),
+      author: dbItem.author ?? void 0,
+      summary: dbItem.summary ?? void 0,
+      content: dbItem.content ?? void 0,
+      imageUrl: dbItem.image_url ?? void 0,
+      tags: dbItem.tags ?? void 0,
+      sourceRef: dbItem.source_url,
+      translations: dbItem.translations ?? void 0
+    }));
+    const rssUrl = new URL(c.req.url);
+    const channelTitle = title ?? "RSS 订阅";
+    const xml = feedItemsToRssXml(feedItems, rssUrl.href, lng, {
+      channelTitle,
+      channelDesc: `来自 ${rssUrl.href} 的订阅`
+    });
+    return c.body(xml, 200, {
+      "Content-Type": "application/rss+xml; charset=utf-8"
+    });
+  });
+  app.get("/rss/*", async (c) => {
+    const url = parseUrlFromPath(c.req.path, "/rss");
+    if (!url) return c.text("无效 URL，格式: /rss/https://... 或 /rss/www.xiaohongshu.com/...", 400);
+    try {
+      const headlessParam = c.req.query("headless");
+      const headless = headlessParam === "false" || headlessParam === "0" ? false : void 0;
+      const lng = c.req.query("lng") ?? void 0;
+      const httpId = "rss-" + createHash("sha256").update(url).digest("hex").slice(0, 16);
+      const { items } = await schedule(
+        SOURCES_GROUP,
+        httpId,
+        () => getItems(url, { cacheDir: CACHE_DIR, headless, lng })
+      );
+      const xml = feedItemsToRssXml(items, url, lng);
+      return c.body(xml, 200, {
+        "Content-Type": "application/rss+xml; charset=utf-8"
+      });
+    } catch (err) {
+      if (err instanceof AuthRequiredError) {
+        const html = await render401(url);
+        return c.html(html, 401);
+      }
+      if (err instanceof NotFoundError) {
+        const html = await readStaticHtml("404", '<!DOCTYPE html><html><head><meta charset="utf-8"><title>404</title></head><body><h1>404 未找到</h1></body></html>');
+        return c.html(html, 404);
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.text(`生成 RSS 失败: ${msg}`, 500);
+    }
+  });
+}
+function getWebUiBuildDir() {
+  const w = process.env.WEBUI_BUILD_DIR?.trim();
+  if (w) {
+    if (w.startsWith("/") || /^[A-Za-z]:[\\/]/.test(w)) return w;
+    return join(process.cwd(), w);
+  }
+  return join(PACKAGE_ROOT, "webui/build");
+}
+function isBackendOnlyPath(pathname) {
+  if (pathname.startsWith("/api")) return true;
+  if (pathname.startsWith("/rss")) return true;
+  if (pathname.startsWith("/auth")) return true;
+  if (pathname.startsWith("/admin/parse") || pathname.startsWith("/admin/extractor")) return true;
+  return false;
+}
+function looksLikeStaticAsset(pathname) {
+  return /\.[a-zA-Z0-9]{1,12}$/.test(pathname);
+}
+function registerWebUiRoutes(app) {
+  const absRoot = getWebUiBuildDir();
+  if (!existsSync(absRoot)) {
+    console.warn(
+      "未找到 WebUI 构建目录，跳过根路径静态托管:",
+      absRoot,
+      "（构建前端：pnpm run webui:build）"
+    );
+    return;
+  }
+  const relRoot = relative(process.cwd(), absRoot).replace(/\\/g, "/");
+  const staticRoot = relRoot === "" || relRoot === "." ? "." : relRoot.startsWith(".") || relRoot.startsWith("/") || /^[A-Za-z]:/.test(relRoot) ? relRoot : `./${relRoot}`;
+  const staticMw = serveStatic({
+    root: staticRoot,
+    index: "200.html"
+  });
+  app.use("*", async (c, next) => {
+    if (isBackendOnlyPath(c.req.path)) return next();
+    return staticMw(c, next);
+  });
+  const spaFallback = async (c) => {
+    const p = c.req.path;
+    if (isBackendOnlyPath(p)) return c.notFound();
+    if (looksLikeStaticAsset(p)) return c.notFound();
+    try {
+      const html = await readFile(join(absRoot, "200.html"), "utf-8");
+      return c.html(html);
+    } catch {
+      return c.notFound();
+    }
+  };
+  app.get("*", spaFallback);
+}
+const PORT = Number(process.env.PORT) || 18473;
+const IS_DEV = process.env.NODE_ENV === "development" || process.argv.includes("--watch");
+const PLUGIN_WATCH_EXTS = [".rssany.js", ".rssany.ts"];
+function createApp() {
+  const app = new Hono();
+  app.use(
+    "*",
+    cors({
+      origin: "*",
+      allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
+      allowHeaders: ["Content-Type", "Authorization", "X-Admin-Token"]
+    })
+  );
+  registerApiRoutes(app);
+  registerAuthRoutes(app);
+  registerAdminRoutes(app);
+  registerRssRoutes(app);
+  registerWebUiRoutes(app);
+  return app;
+}
+function watchPlugins() {
+  let reloadTimer = null;
+  const debouncedReload = async () => {
+    if (reloadTimer) clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(async () => {
+      try {
+        await initSources();
+      } catch (err) {
+        logger.error("plugin", "插件重新加载失败", { err: err instanceof Error ? err.message : String(err) });
+      }
+    }, 300);
+  };
+  for (const dir of [BUILTIN_PLUGINS_DIR, USER_PLUGINS_DIR]) {
+    const watcher = watch(dir, { recursive: true }, (eventType, filename) => {
+      if (!filename || !PLUGIN_WATCH_EXTS.some((ext) => filename.endsWith(ext))) return;
+      if (eventType === "rename" || eventType === "change") debouncedReload();
+    });
+    watcher.on("error", (err) => {
+      logger.warn("plugin", "插件目录监听错误", { dir, err: err.message });
+    });
+  }
+}
+async function main() {
+  await initUserDir();
+  await initSources();
+  await initScheduler(CACHE_DIR);
+  const app = createApp();
+  const server = serve({ fetch: app.fetch, port: PORT, hostname: "0.0.0.0" });
+  server.setMaxListeners(32);
+  console.log(`服务已启动 http://127.0.0.1:${PORT}/（API + 静态前端，需先 pnpm run webui:build）`);
+  const lanIp = Object.values(networkInterfaces()).flat().find((iface) => iface?.family === "IPv4" && !iface.internal)?.address;
+  if (lanIp) console.log(`局域网访问 http://${lanIp}:${PORT}/`);
+  if (IS_DEV) {
+    watchPlugins();
+  }
+}
+main();
+//# sourceMappingURL=index.js.map