koishi-plugin-xlon 1.0.1

package/lib/config.d.ts

@@ -0,0 +1,26 @@
+import { Schema } from 'koishi';
+export interface SubscriptionItem {
+    /** Twitter/X 用户名（@ 后面的部分） */
+    id: string;
+    /** 推送目标，格式为 platform:channelId（如 onebot:123456） */
+    targets: string[];
+    /** 违禁词（命中则跳过推送） */
+    blacklist: string[];
+}
+export interface Config {
+    cookies: string;
+    updateInterval: number;
+    messagePrefix: string;
+    screenshot: boolean;
+    translateEnabled: boolean;
+    apiKey?: string;
+    apiUrl: string;
+    model: string;
+    systemPrompt: string;
+    prompt: string;
+    term: Record<string, string>;
+    subscriptions: SubscriptionItem[];
+    outputLogs: boolean;
+    detectXLinks: boolean;
+}
+export declare const Config: Schema<Schemastery.ObjectS<{}>, {} & import("cosmokit").Dict>;

package/lib/db/model.d.ts

@@ -0,0 +1,8 @@
+import { Context } from 'koishi';
+import { XlonRecord } from '../types';
+declare module 'koishi' {
+    interface Tables {
+        xlon: XlonRecord;
+    }
+}
+export declare function extendDatabase(ctx: Context): void;

package/lib/db/repo.d.ts

@@ -0,0 +1,9 @@
+import { Context } from 'koishi';
+import { XlonRecord } from '../types';
+export declare class XlonRepo {
+    private ctx;
+    constructor(ctx: Context);
+    get(id: string): Promise<XlonRecord | null>;
+    upsert(record: XlonRecord): Promise<void>;
+    listIds(): Promise<string[]>;
+}

package/lib/features/commands/index.d.ts

@@ -0,0 +1,7 @@
+import { Context, Session } from 'koishi';
+import { Config } from '../../config';
+export declare function registerCommands(ctx: Context, config: Config, deps: {
+    handleTweetUrl: (session: Session, url: string) => Promise<void>;
+    handleTweetInput: (session: Session, input: string) => Promise<void>;
+    checkOnce: (session?: Session) => Promise<void>;
+}): void;

package/lib/features/link-detector.d.ts

@@ -0,0 +1,3 @@
+import { Context, Session } from 'koishi';
+import { Config } from '../config';
+export declare function registerLinkDetector(ctx: Context, config: Config, handler: (session: Session, url: string) => Promise<void>): void;

package/lib/features/translator.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'koishi';
+import { Config } from '../config';
+/**
+ * 翻译入口。完整流程：
+ * 1. 构建 system prompt（注入术语表）
+ * 2. 调用 LLM → 退化检测
+ * 3. 如退化 → 简化 prompt 重试一次
+ * 4. 事后兜底：术语表强制替换
+ */
+export declare function translateIfEnabled(ctx: Context, config: Config, text: string): Promise<string>;

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import { Context, Logger } from 'koishi';
+import { Config } from './config';
+export declare const name = "xlon";
+export declare const logger: Logger;
+export declare const inject: {
+    required: string[];
+    optional: string[];
+};
+export * from './config';
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,883 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  logger: () => logger7,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi8 = require("koishi");
+
+// src/locales/zh-CN.yml
+var zh_CN_default = { _config: { cookies: "X 的 auth_token Cookie", updateInterval: "检查更新间隔（分钟）", messagePrefix: "推送消息前缀", screenshot: "是否启用推文截图（需要 puppeteer）", translateEnabled: "是否启用翻译", apiKey: "API Key（OpenAI 兼容）", apiUrl: "API 地址", model: "模型名称", systemPrompt: "系统提示词（{glossary} 会被术语表自动替换）", prompt: "用户消息模板（{text} 代表待翻译文本）", term: "术语表（注入 prompt + 翻译后兜底替换）", subscriptions: { id: "博主用户名（@ 后面的部分，不要加 @）", targets: "推送目标（格式 platform:channelId，如 onebot:123456）", blacklist: "违禁词（命中则跳过推送）" }, outputLogs: "日志调试模式", detectXLinks: "是否启用 X/Twitter 链接检测" }, commands: { "xlon.check": { description: "检查一次订阅更新" }, "xlon.tweet": { description: "根据 URL 或用户名获取推文内容" } }, messages: { fetching: "正在获取推文内容...", "empty-url": "请输入推文链接。", "no-latest-tweet": "未找到用户 {0} 的最新推文，请检查用户名是否正确。", checking: "正在检查更新...", busy: "上一轮检查尚未完成，请稍候。", "poll-fail": "轮询 {0} 失败（可能网络/用户名问题）。" } };
+
+// src/locales/en-US.yml
+var en_US_default = { _config: { cookies: "X auth_token cookie", updateInterval: "Poll interval (minutes)", messagePrefix: "Message prefix", screenshot: "Enable tweet screenshot (requires puppeteer)", translateEnabled: "Enable translation", apiKey: "API key (OpenAI-compatible)", apiUrl: "API base URL", model: "Model name", systemPrompt: "System prompt ({glossary} is replaced by glossary)", prompt: "User message template ({text} is replaced by source text)", term: "Glossary (injected into prompt + post-process fallback)", subscriptions: { id: "Username (without @)", targets: "Targets (format platform:channelId, e.g. onebot:123456)", blacklist: "Block words (skip when hit)" }, outputLogs: "Verbose logs", detectXLinks: "Detect X/Twitter links in messages" }, commands: { "xlon.check": { description: "Check subscriptions for updates" }, "xlon.tweet": { description: "Fetch tweet content by URL or username" } }, messages: { fetching: "Fetching tweet content...", "empty-url": "Please provide a tweet URL.", "no-latest-tweet": "No latest tweet found for user {0}. Please check the username.", checking: "Checking for updates...", busy: "Previous check is still running, please wait.", "poll-fail": "Failed to poll {0} (possible network/username issue)." } };
+
+// src/db/model.ts
+var import_koishi = require("koishi");
+var logger = new import_koishi.Logger("xlon/db");
+function extendDatabase(ctx) {
+  ctx.model.extend(
+    "xlon",
+    {
+      id: "string",
+      link: "string",
+      content: "string"
+    },
+    {
+      primary: "id",
+      autoInc: false
+    }
+  );
+  logger.info("数据库初始化成功");
+}
+__name(extendDatabase, "extendDatabase");
+
+// src/db/repo.ts
+var XlonRepo = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  static {
+    __name(this, "XlonRepo");
+  }
+  async get(id) {
+    const rows = await this.ctx.database.get("xlon", { id });
+    return rows[0] ?? null;
+  }
+  async upsert(record) {
+    await this.ctx.database.upsert("xlon", [record]);
+  }
+  async listIds() {
+    const rows = await this.ctx.database.get("xlon", {}, ["id"]);
+    return rows.map((r) => r.id);
+  }
+};
+
+// src/features/commands/index.ts
+function registerCommands(ctx, config, deps) {
+  ctx.command("x.check").alias("check").action(async ({ session }) => {
+    await session.send(session.text("messages.checking"));
+    await deps.checkOnce(session);
+  });
+  ctx.command("x.tweet <input:text>").alias("tweet").action(async ({ session }, input) => {
+    await deps.handleTweetInput(session, input || "");
+  });
+}
+__name(registerCommands, "registerCommands");
+
+// src/features/link-detector.ts
+var import_koishi2 = require("koishi");
+var logger2 = new import_koishi2.Logger("xlon/link-detector");
+var urlRe = /((https?:\/\/)?[^\s'"\)]+\.[^\s'"\)]+)/g;
+function extractUrls(text) {
+  const matches = text.match(urlRe) || [];
+  return matches.map((m) => m.replace(/[\u3002\uFF0C\uFF1F\uFF01\.,!?，。？！、]+$/g, ""));
+}
+__name(extractUrls, "extractUrls");
+function isXDomain(urlStr) {
+  try {
+    const u = new URL(urlStr.includes("://") ? urlStr : `https://${urlStr}`);
+    const hn = (u.hostname || "").toLowerCase();
+    return hn === "t.co" || hn === "x.com" || hn.endsWith(".x.com") || hn === "twitter.com" || hn.endsWith(".twitter.com") || hn === "m.twitter.com" || hn === "mobile.twitter.com";
+  } catch (_) {
+    return false;
+  }
+}
+__name(isXDomain, "isXDomain");
+async function expandShortLink(ctx, url) {
+  try {
+    const axios = ctx.http.axios ?? ctx.http;
+    const res = await axios.get(url, {
+      maxRedirects: 0,
+      validateStatus: /* @__PURE__ */ __name(() => true, "validateStatus")
+    });
+    const location = res?.headers?.location;
+    return location || url;
+  } catch (err) {
+    try {
+      const location = err?.response?.headers?.location;
+      return location || url;
+    } catch (_) {
+      return url;
+    }
+  }
+}
+__name(expandShortLink, "expandShortLink");
+function registerLinkDetector(ctx, config, handler) {
+  ctx.middleware(async (session, next) => {
+    try {
+      if (!config.detectXLinks) return next();
+      const text = session.content || "";
+      if (!text) return next();
+      const candidates = extractUrls(text);
+      if (!candidates.length) return next();
+      const found = [];
+      for (const c of candidates) {
+        const normalized = c.startsWith("http") ? c : `https://${c}`;
+        if (/^https?:\/\/t\.co\//i.test(normalized)) {
+          const exp = await expandShortLink(ctx, normalized);
+          if (isXDomain(exp)) found.push(exp);
+        } else if (isXDomain(normalized)) {
+          found.push(normalized);
+        }
+        if (found.length >= 3) break;
+      }
+      if (found.length && config.outputLogs) {
+        logger2.info("检测到 X/Twitter 链接:", found);
+      }
+      for (const link of found) {
+        try {
+          await handler(session, link);
+        } catch (e) {
+          logger2.error("处理检测到的 X/Twitter 链接时出错", e);
+        }
+      }
+    } catch (err) {
+      logger2.error("X/Twitter 链接检测失败", err);
+    }
+    return next();
+  });
+}
+__name(registerLinkDetector, "registerLinkDetector");
+
+// src/features/translator.ts
+var import_koishi3 = require("koishi");
+var logger3 = new import_koishi3.Logger("xlon/translator");
+function buildGlossaryBlock(term) {
+  const entries = Object.entries(term || {}).filter(([k]) => !!k);
+  if (!entries.length) return "";
+  const lines = entries.map(([from, to]) => `- "${from}" → "${to}"`);
+  return `术语表（翻译时必须使用以下译法）：
+${lines.join("\n")}`;
+}
+__name(buildGlossaryBlock, "buildGlossaryBlock");
+function injectGlossary(systemPrompt, glossaryBlock) {
+  if (!glossaryBlock) return (systemPrompt || "").replace("{glossary}", "");
+  if ((systemPrompt || "").includes("{glossary}")) {
+    return systemPrompt.replace("{glossary}", glossaryBlock);
+  }
+  return `${systemPrompt}
+
+${glossaryBlock}`;
+}
+__name(injectGlossary, "injectGlossary");
+function applyTermMap(text, term) {
+  let out = text;
+  for (const [from, to] of Object.entries(term || {})) {
+    if (!from) continue;
+    out = out.split(from).join(to ?? "");
+  }
+  return out;
+}
+__name(applyTermMap, "applyTermMap");
+function validateTranslation(original, translated) {
+  if (!translated) return { ok: false, reason: "翻译结果为空" };
+  if (translated === original) {
+    return { ok: false, reason: "翻译结果与原文完全相同（回声）" };
+  }
+  const refusalRe = /作为AI|作为一个AI|I cannot|I'm sorry|I am sorry|无法翻译|I can't translate/i;
+  if (refusalRe.test(translated) && !refusalRe.test(original)) {
+    return { ok: false, reason: "翻译结果包含拒绝短语" };
+  }
+  if (original.length > 10 && translated.length > original.length * 3) {
+    return { ok: false, reason: `翻译结果异常膨胀（原文 ${original.length} 字 → 译文 ${translated.length} 字）` };
+  }
+  if (original.length > 30 && translated.length < original.length * 0.15) {
+    return { ok: false, reason: `翻译结果疑似截断（原文 ${original.length} 字 → 译文 ${translated.length} 字）` };
+  }
+  for (let winLen = 8; winLen <= Math.min(30, Math.floor(translated.length / 3)); winLen++) {
+    for (let i = 0; i <= translated.length - winLen * 3; i++) {
+      const seg = translated.slice(i, i + winLen);
+      if (/^[\s\p{P}]+$/u.test(seg)) continue;
+      const rest = translated.slice(i + winLen);
+      let count = 1;
+      let pos = 0;
+      while (pos <= rest.length - winLen) {
+        if (rest.slice(pos, pos + winLen) === seg) {
+          count++;
+          pos += winLen;
+        } else {
+          break;
+        }
+      }
+      if (count >= 3) {
+        return { ok: false, reason: `翻译结果包含连续重复片段："${seg.slice(0, 20)}…" 重复 ${count} 次` };
+      }
+    }
+  }
+  return { ok: true };
+}
+__name(validateTranslation, "validateTranslation");
+async function callTranslateAPI(ctx, config, opts) {
+  const url = `${(config.apiUrl || "").replace(/\/$/, "")}/chat/completions`;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  const data = {
+    model: opts.model,
+    messages: [
+      { role: "system", content: opts.systemContent },
+      { role: "user", content: opts.userContent }
+    ],
+    stream: false
+  };
+  const response = await ctx.http.post(url, data, { headers });
+  return String(response?.choices?.[0]?.message?.content ?? "").trim();
+}
+__name(callTranslateAPI, "callTranslateAPI");
+async function translateIfEnabled(ctx, config, text) {
+  if (!config.translateEnabled) return text;
+  if (!config.apiKey) return text;
+  if (!text?.trim()) return text;
+  const glossaryBlock = buildGlossaryBlock(config.term);
+  const systemContent = injectGlossary(config.systemPrompt || "", glossaryBlock);
+  const userContent = (config.prompt || "{text}").replace("{text}", text);
+  try {
+    const translated = await callTranslateAPI(ctx, config, {
+      systemContent,
+      userContent,
+      model: config.model
+    });
+    const v1 = validateTranslation(text, translated);
+    if (v1.ok) {
+      if (config.outputLogs) logger3.info("翻译通过退化检测");
+      return applyTermMap(translated, config.term);
+    }
+    logger3.warn(`翻译退化（${v1.reason}），使用简化 prompt 重试`);
+    const retrySystem = "你是翻译助手。直接输出简体中文翻译，不要添加任何额外内容。";
+    const retryUser = text;
+    try {
+      const retried = await callTranslateAPI(ctx, config, {
+        systemContent: retrySystem,
+        userContent: retryUser,
+        model: config.model
+      });
+      const v2 = validateTranslation(text, retried);
+      if (v2.ok) {
+        if (config.outputLogs) logger3.info("重试翻译通过退化检测");
+        return applyTermMap(retried, config.term);
+      }
+      logger3.warn(`重试翻译仍退化（${v2.reason}），回退原文`);
+      return text;
+    } catch (retryErr) {
+      logger3.error("重试翻译 API 调用失败", retryErr);
+      return text;
+    }
+  } catch (err) {
+    logger3.error("翻译 API 调用失败", err);
+    return text;
+  }
+}
+__name(translateIfEnabled, "translateIfEnabled");
+
+// src/service/message-builder.ts
+var import_koishi4 = require("koishi");
+var logger4 = new import_koishi4.Logger("xlon/message-builder");
+async function fetchBinary(ctx, url, maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await ctx.http.get(url, {
+        responseType: "arraybuffer",
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+      });
+    } catch (e) {
+      if (attempt >= maxRetries) throw e;
+      await ctx.sleep(1200 * attempt);
+    }
+  }
+}
+__name(fetchBinary, "fetchBinary");
+async function buildTweetMessages(ctx, config, detail, translated, opts) {
+  const segments = [];
+  const altOriginalText = detail.altTexts && detail.altTexts.length ? "\n" + detail.altTexts.map(
+    (alt, i) => `[图片${detail.altTexts.length > 1 ? i + 1 : ""}描述原文: ${alt}]`
+  ).join("\n") : "";
+  const isVideo = detail.mediaUrls?.some((u) => u.endsWith(".mp4"));
+  const prefixUser = opts?.username ? `【${opts.username}】 ` : "";
+  const retweetNote = opts?.isRetweet ? "[转发推文]\n" : "";
+  let textMsg = `${prefixUser}${config.messagePrefix}一条${isVideo ? "视频" : "图片"}推文：
+${translated}${altOriginalText}
+${retweetNote}`;
+  if (detail.screenshotBuffer) textMsg += `${import_koishi4.h.image(detail.screenshotBuffer, "image/webp")}`;
+  segments.push({ content: textMsg });
+  const imageUrls = (detail.mediaUrls || []).filter((u) => !u.endsWith(".mp4"));
+  if (imageUrls.length) {
+    const images = [];
+    for (const imgUrl of imageUrls) {
+      try {
+        const bin = await fetchBinary(ctx, imgUrl);
+        images.push(import_koishi4.h.image(bin, "image/jpeg"));
+      } catch (e) {
+        logger4.error(`下载图片失败：${imgUrl}`, e);
+      }
+    }
+    if (images.length) segments.push({ content: images.join("\n") });
+  }
+  const videoUrl = (detail.mediaUrls || []).find((u) => u.endsWith(".mp4"));
+  if (videoUrl) {
+    try {
+      const bin = await fetchBinary(ctx, videoUrl);
+      segments.push({ content: import_koishi4.h.video(bin, "video/mp4") });
+    } catch (e) {
+      logger4.error(`下载视频失败：${videoUrl}`, e);
+    }
+  }
+  return segments;
+}
+__name(buildTweetMessages, "buildTweetMessages");
+
+// src/scheduler/poller.ts
+var import_koishi5 = require("koishi");
+var logger5 = new import_koishi5.Logger("xlon/poller");
+function createPoller(ctx, config, repo, fetcher, deps) {
+  let checking = false;
+  async function init() {
+    const existingIds = new Set(await repo.listIds());
+    const newSubs = config.subscriptions.filter((s) => !existingIds.has(s.id));
+    if (config.outputLogs) {
+      logger5.info(`[初始化] 已存在订阅：${Array.from(existingIds).join(", ")}`);
+      logger5.info(`[初始化] 需要初始化：${newSubs.map((s) => s.id).join(", ")}`);
+    }
+    for (const sub of newSubs) {
+      try {
+        const latest = await fetcher.getLatestTweet(sub.id);
+        const link = latest.tweets[0]?.link;
+        if (!link) continue;
+        await repo.upsert({ id: sub.id, link, content: latest.wordContent || "" });
+      } catch (e) {
+        logger5.error(`[初始化] 获取 ${sub.id} 最新推文失败（请检查用户名/网络）`, e);
+      }
+    }
+    logger5.info("初始化完成");
+  }
+  __name(init, "init");
+  async function checkOnce(session) {
+    if (checking) {
+      if (session) await session.send(session.text("messages.busy"));
+      return;
+    }
+    checking = true;
+    try {
+      for (const sub of config.subscriptions) {
+        const username = sub.id;
+        try {
+          const latest = await fetcher.getLatestTweet(username);
+          const latestLink = latest.tweets[0]?.link;
+          if (!latestLink) continue;
+          const stored = await repo.get(username);
+          const storedLink = stored?.link || "";
+          if (!storedLink || storedLink !== latestLink) {
+            await repo.upsert({
+              id: username,
+              link: latestLink,
+              content: latest.wordContent || ""
+            });
+            await deps.pushTweet({
+              username,
+              url: latestLink,
+              isRetweet: latest.tweets[0]?.isRetweet || false
+            });
+          } else if (config.outputLogs) {
+            logger5.info(`已是最新：${username}`);
+          }
+        } catch (e) {
+          logger5.error(`轮询 ${username} 失败`, e);
+          if (session) await session.send(session.text("messages.poll-fail", [username]));
+        }
+      }
+    } finally {
+      checking = false;
+    }
+  }
+  __name(checkOnce, "checkOnce");
+  function start() {
+    const ms = Math.max(1, config.updateInterval) * 60 * 1e3;
+    ctx.setInterval(() => checkOnce().catch((e) => logger5.error("定时任务异常", e)), ms);
+  }
+  __name(start, "start");
+  return { init, checkOnce, start };
+}
+__name(createPoller, "createPoller");
+
+// src/service/fetcher.ts
+var import_koishi6 = require("koishi");
+var logger6 = new import_koishi6.Logger("xlon/fetcher");
+var UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36";
+function toAbsoluteUrl(input) {
+  const raw = (input || "").trim();
+  if (!raw) return raw;
+  return raw.includes("://") ? raw : `https://${raw}`;
+}
+__name(toAbsoluteUrl, "toAbsoluteUrl");
+function buildVxApiUrl(tweetUrl) {
+  return tweetUrl.replace(/(twitter\.com|x\.com)/i, "api.vxtwitter.com");
+}
+__name(buildVxApiUrl, "buildVxApiUrl");
+async function screenshotTweetArticle(page, selector = 'article[data-testid="tweet"]') {
+  const element = await page.waitForSelector(selector, { timeout: 15e3 });
+  if (!element) throw new Error("未能找到推文容器");
+  await page.waitForFunction(
+    (sel) => {
+      const a = document.querySelector(sel);
+      if (!a) return false;
+      const imgs = Array.from(a.querySelectorAll("img"));
+      return imgs.every((img) => img.complete && img.naturalWidth > 0);
+    },
+    { timeout: 8e3 },
+    selector
+  ).catch(() => {
+  });
+  await page.evaluate(() => {
+    const column = document.querySelector('div[data-testid="primaryColumn"]');
+    if (!column) return;
+    for (const child of Array.from(column.querySelectorAll(":scope > div > div"))) {
+      if (!child.querySelector("section") && !child.querySelector("article")) {
+        ;
+        child.style.display = "none";
+      }
+    }
+  }).catch(() => {
+  });
+  await page.evaluate((sel) => {
+    const article = document.querySelector(sel);
+    if (!article) return;
+    const group = article.querySelector('[role="group"]');
+    if (!group) return;
+    let node = group;
+    while (node && node !== article) {
+      let sibling = node.nextElementSibling;
+      while (sibling) {
+        ;
+        sibling.style.display = "none";
+        sibling = sibling.nextElementSibling;
+      }
+      node = node.parentElement;
+    }
+  }, selector).catch(() => {
+  });
+  const box = await element.boundingBox();
+  if (!box) return await element.screenshot({ type: "webp" });
+  try {
+    return await page.screenshot({
+      clip: {
+        x: Math.max(0, Math.floor(box.x)),
+        y: Math.max(0, Math.floor(box.y)),
+        width: Math.ceil(box.width + 16),
+        height: Math.ceil(box.height + 12)
+      },
+      type: "webp"
+    });
+  } catch {
+    return await element.screenshot({ type: "webp" });
+  }
+}
+__name(screenshotTweetArticle, "screenshotTweetArticle");
+async function preparePage(page, cookies) {
+  await page.setViewport({ width: 650, height: 900 });
+  await page.setCookie({
+    name: "auth_token",
+    value: cookies,
+    domain: ".x.com",
+    path: "/",
+    httpOnly: true,
+    secure: true
+  });
+  await page.setUserAgent(UA);
+  await page.setDefaultNavigationTimeout(6e4);
+  await page.setDefaultTimeout(6e4);
+}
+__name(preparePage, "preparePage");
+var XFetcher = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+  }
+  static {
+    __name(this, "XFetcher");
+  }
+  /** puppeteer 是否可用 */
+  get hasPuppeteer() {
+    return !!this.ctx.puppeteer;
+  }
+  /**
+   * 获取博主最新推文链接（用于轮询判重）。
+   * 依赖 puppeteer 打开博主主页抓取。
+   */
+  async getLatestTweet(username, maxRetries = 3) {
+    if (!this.hasPuppeteer) {
+      logger6.warn("puppeteer 不可用，无法获取最新推文");
+      return { tweets: [], wordContent: "" };
+    }
+    const url = `https://x.com/${username}`;
+    let page;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        page = await this.ctx.puppeteer.page();
+        await page.setRequestInterception(true);
+        page.on("request", (req) => {
+          const t = req.resourceType();
+          if (["image", "stylesheet", "font"].includes(t)) req.abort();
+          else req.continue();
+        });
+        await preparePage(page, this.config.cookies);
+        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 6e4 });
+        await page.waitForSelector("article", { timeout: 3e4 });
+        const result = await page.evaluate(() => {
+          const articles = Array.from(document.querySelectorAll("article"));
+          const collected = [];
+          for (const article of articles) {
+            const socialContext = article.querySelector('[data-testid="socialContext"]');
+            const cell = article.closest('div[data-testid="cellInnerDiv"]');
+            const pinnedText = [
+              (socialContext || {}).textContent || "",
+              (article.previousElementSibling || {}).textContent || "",
+              (cell || {}).textContent || ""
+            ].join("\n");
+            const isPinned = !!(article.querySelector('svg[aria-label="Pinned"]') || article.querySelector('svg[aria-label*="Pin"]') || Array.from(article.querySelectorAll("span, div")).some(
+              (n) => /pinned|pin(ned)?\s*tweet|置顶|置頂|釘選|已置顶|已置頂/i.test(
+                n.textContent || ""
+              )
+            ) || /pinned|pin(ned)?\s*tweet|置顶|置頂|釘選|已置顶|已置頂/i.test(
+              pinnedText
+            ));
+            if (isPinned) continue;
+            const textEl = article.querySelector(
+              'div[data-testid="tweetText"], div[lang]'
+            );
+            const word_content = (textEl && textEl.textContent ? textEl.textContent : "").trim();
+            const timeEl = article.querySelector('a[href*="/status/"] time');
+            const linkEl = timeEl && timeEl.parentElement || article.querySelector('a[href*="/status/"]');
+            const href = linkEl && linkEl.getAttribute("href") || "";
+            if (!href) continue;
+            const headerText = ((article.previousElementSibling || {}).textContent || "") + ((article.parentElement || {}).textContent || "") + ((socialContext || {}).textContent || "");
+            const isRetweet = /retweeted|转推|轉推/i.test(headerText);
+            const isVideo = !!(article.querySelector('div[data-testid="videoPlayer"]') || article.querySelector("video") || Array.from(
+              article.querySelectorAll("svg[aria-label], div[aria-label]")
+            ).some(
+              (n) => /video|播放|影片|视频/i.test(
+                n.getAttribute("aria-label") || ""
+              )
+            ));
+            let absolute = href;
+            if (absolute.startsWith("/")) absolute = "https://x.com" + absolute;
+            if (!absolute.startsWith("http")) absolute = "https://x.com/" + absolute;
+            collected.push({ link: absolute, isRetweet, isVideo, word_content });
+          }
+          const latest = collected.slice(0, 1);
+          return {
+            tweets: latest.map((t) => ({
+              link: t.link,
+              isRetweet: t.isRetweet,
+              isVideo: t.isVideo
+            })),
+            wordContent: latest.length ? latest[0].word_content : ""
+          };
+        });
+        return result;
+      } catch (error) {
+        logger6.error(`抓取最新推文失败（第 ${attempt} 次）: ${username}`, error);
+        if (attempt >= maxRetries) return { tweets: [], wordContent: "" };
+        await this.ctx.sleep(2e3 * attempt);
+      } finally {
+        if (page) await page.close().catch(() => {
+        });
+      }
+    }
+    return { tweets: [], wordContent: "" };
+  }
+  /**
+   * 获取推文详情（截图 + 媒体 + ALT + 正文）。
+   * puppeteer 可用时截图，否则仅走 vxtwitter API。
+   */
+  async getTweetDetail(tweetUrlInput, maxRetries = 3) {
+    const tweetUrl = toAbsoluteUrl(tweetUrlInput);
+    let page;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        let screenshotBuffer = null;
+        let protectedAccount = false;
+        if (this.config.screenshot && this.hasPuppeteer) {
+          page = await this.ctx.puppeteer.page();
+          await page.setRequestInterception(true);
+          page.on("request", (req) => {
+            if (req.resourceType() === "font") req.abort();
+            else req.continue();
+          });
+          await preparePage(page, this.config.cookies);
+          await page.goto(tweetUrl, { waitUntil: "domcontentloaded", timeout: 6e4 });
+          await page.waitForSelector("article", { timeout: 3e4 });
+          protectedAccount = await page.evaluate(() => {
+            return !!(document.querySelector('[data-testid="icon-lock"]') || document.querySelector('[aria-label*="rotect"]') || document.querySelector('[aria-label*="保护"]') || document.querySelector('[aria-label*="保護"]'));
+          });
+          screenshotBuffer = await screenshotTweetArticle(page);
+          if (protectedAccount) {
+            const wordContent = await page.evaluate(() => {
+              const el = document.querySelector('div[data-testid="tweetText"]');
+              return el ? (el.textContent || "").trim() : "";
+            });
+            return {
+              url: tweetUrl,
+              wordContent: `${wordContent}
+（注：此账号为受保护账号，故不提供具体媒体内容）`,
+              altTexts: [],
+              mediaUrls: [],
+              screenshotBuffer,
+              protectedAccount: true
+            };
+          }
+        }
+        const apiUrl = buildVxApiUrl(tweetUrl);
+        const apiResponse = await this.ctx.http.get(apiUrl, {
+          headers: { "User-Agent": UA }
+        });
+        const mediaExt = apiResponse && apiResponse.media_extended || [];
+        const altTexts = mediaExt.filter((m) => m && m.altText && String(m.altText).trim()).map((m) => String(m.altText).trim());
+        let wordContentForTranslation = String(apiResponse.text || "");
+        if (altTexts.length > 0) {
+          wordContentForTranslation += "\n\n" + altTexts.map(
+            (alt, i) => `[图片${altTexts.length > 1 ? i + 1 : ""}描述: ${alt}]`
+          ).join("\n");
+        }
+        const mediaUrls = mediaExt.map((m) => String(m.url)).filter(Boolean);
+        return {
+          url: tweetUrl,
+          wordContent: wordContentForTranslation,
+          altTexts,
+          mediaUrls,
+          screenshotBuffer,
+          protectedAccount
+        };
+      } catch (error) {
+        logger6.error(`抓取推文详情失败（第 ${attempt} 次）: ${tweetUrlInput}`, error);
+        if (attempt >= maxRetries) {
+          return {
+            url: tweetUrlInput,
+            wordContent: "",
+            altTexts: [],
+            mediaUrls: [],
+            screenshotBuffer: null
+          };
+        }
+        await this.ctx.sleep(2e3 * attempt);
+      } finally {
+        if (page) await page.close().catch(() => {
+        });
+      }
+    }
+    return {
+      url: tweetUrlInput,
+      wordContent: "",
+      altTexts: [],
+      mediaUrls: [],
+      screenshotBuffer: null
+    };
+  }
+};
+
+// src/config.ts
+var import_koishi7 = require("koishi");
+var Config = import_koishi7.Schema.intersect([
+  import_koishi7.Schema.object({
+    cookies: import_koishi7.Schema.string().required(),
+    updateInterval: import_koishi7.Schema.number().min(1).default(5),
+    messagePrefix: import_koishi7.Schema.string().default("获取了"),
+    screenshot: import_koishi7.Schema.boolean().default(true)
+  }).description("基础设置"),
+  import_koishi7.Schema.object({
+    translateEnabled: import_koishi7.Schema.boolean().default(false)
+  }).description("翻译设置"),
+  import_koishi7.Schema.union([
+    import_koishi7.Schema.object({
+      translateEnabled: import_koishi7.Schema.const(true).required(),
+      apiKey: import_koishi7.Schema.string().required(),
+      apiUrl: import_koishi7.Schema.string().default("https://api.deepseek.com"),
+      model: import_koishi7.Schema.string().default("deepseek-chat"),
+      systemPrompt: import_koishi7.Schema.string().role("textarea").default(
+        "你是一名推文翻译专员，负责将推文翻译为简体中文。规则：\n1. 直接输出翻译结果，不添加任何前缀、解释或注释\n2. 保留原文中的 @用户名、#话题标签、URL 不翻译\n3. 保留原文的 emoji\n4. 不要修改标点符号的使用习惯\n{glossary}"
+      ),
+      prompt: import_koishi7.Schema.string().role("textarea").default("{text}"),
+      term: import_koishi7.Schema.dict(String).role("table").default({})
+    }),
+    import_koishi7.Schema.object({})
+  ]),
+  import_koishi7.Schema.object({
+    subscriptions: import_koishi7.Schema.array(
+      import_koishi7.Schema.object({
+        id: import_koishi7.Schema.string().required(),
+        targets: import_koishi7.Schema.array(String).role("table").default([]),
+        blacklist: import_koishi7.Schema.array(import_koishi7.Schema.string()).default([])
+      })
+    ).default([])
+  }).description("订阅列表"),
+  import_koishi7.Schema.object({
+    outputLogs: import_koishi7.Schema.boolean().default(true),
+    detectXLinks: import_koishi7.Schema.boolean().default(true)
+  }).description("调试设置")
+]).i18n({
+  "en-US": en_US_default._config,
+  "zh-CN": zh_CN_default._config
+});
+
+// src/index.ts
+var name = "xlon";
+var logger7 = new import_koishi8.Logger("xlon");
+var inject = {
+  required: ["database"],
+  optional: ["puppeteer"]
+};
+async function sendToTarget(ctx, target, content) {
+  const idx = target.indexOf(":");
+  if (idx < 0) {
+    logger7.warn(`无效 target 格式（应为 platform:channelId）：${target}`);
+    return;
+  }
+  const platform = target.slice(0, idx);
+  const channelId = target.slice(idx + 1);
+  const bot = ctx.bots.find((b) => b.platform === platform);
+  if (!bot) {
+    logger7.warn(`未找到平台 ${platform} 上的 bot，跳过 target: ${target}`);
+    return;
+  }
+  await bot.sendMessage(channelId, content);
+}
+__name(sendToTarget, "sendToTarget");
+function isLikelyTweetUrl(input) {
+  const value = (input || "").trim();
+  if (!value) return false;
+  return /^(https?:\/\/)?(www\.)?(x\.com|twitter\.com)\//i.test(value);
+}
+__name(isLikelyTweetUrl, "isLikelyTweetUrl");
+function apply(ctx, config) {
+  ctx.i18n.define("zh-CN", zh_CN_default);
+  ctx.i18n.define("en-US", en_US_default);
+  extendDatabase(ctx);
+  const repo = new XlonRepo(ctx);
+  const fetcher = new XFetcher(ctx, config);
+  async function processAndSend(send, url, opts) {
+    const detail = await fetcher.getTweetDetail(url);
+    const translated = await translateIfEnabled(ctx, config, detail.wordContent);
+    if (opts?.username) {
+      const sub = config.subscriptions.find((s) => s.id === opts.username);
+      const blacklist = sub?.blacklist || [];
+      if (blacklist.length) {
+        const lowerTranslated = translated.toLowerCase();
+        const lowerOriginal = detail.wordContent.toLowerCase();
+        const hit = blacklist.filter((w) => {
+          const lw = String(w).toLowerCase();
+          return lw && (lowerTranslated.includes(lw) || lowerOriginal.includes(lw));
+        });
+        if (hit.length) {
+          if (config.outputLogs)
+            logger7.info(`命中违禁词，跳过推送：${opts.username} -> ${hit.join(", ")}`);
+          return;
+        }
+      }
+    }
+    const segments = await buildTweetMessages(ctx, config, detail, translated, opts);
+    for (const seg of segments) {
+      await send(seg.content);
+    }
+  }
+  __name(processAndSend, "processAndSend");
+  async function handleTweetUrl(session, url) {
+    const u = (url || "").trim();
+    if (!u) {
+      await session.send(session.text("messages.empty-url"));
+      return;
+    }
+    if (config.outputLogs) logger7.info("处理推文链接:", u);
+    await session.send(session.text("messages.fetching"));
+    await processAndSend((content) => session.send(content), u);
+  }
+  __name(handleTweetUrl, "handleTweetUrl");
+  async function handleTweetInput(session, input) {
+    const raw = (input || "").trim();
+    if (!raw) {
+      await session.send(session.text("messages.empty-url"));
+      return;
+    }
+    if (isLikelyTweetUrl(raw)) {
+      await handleTweetUrl(session, raw);
+      return;
+    }
+    const username = raw.replace(/^@+/, "").trim();
+    if (!username) {
+      await session.send(session.text("messages.empty-url"));
+      return;
+    }
+    if (config.outputLogs) logger7.info("按用户名处理最新推文:", username);
+    await session.send(session.text("messages.fetching"));
+    const latest = await fetcher.getLatestTweet(username);
+    const first = latest.tweets[0];
+    if (!first?.link) {
+      await session.send(session.text("messages.no-latest-tweet", [username]));
+      return;
+    }
+    await processAndSend((content) => session.send(content), first.link, {
+      username,
+      isRetweet: first.isRetweet
+    });
+  }
+  __name(handleTweetInput, "handleTweetInput");
+  const poller = createPoller(ctx, config, repo, fetcher, {
+    pushTweet: /* @__PURE__ */ __name(async ({ username, url, isRetweet }) => {
+      const sub = config.subscriptions.find((s) => s.id === username);
+      if (!sub || !sub.targets?.length) return;
+      const send = /* @__PURE__ */ __name(async (content) => {
+        for (const target of sub.targets) {
+          try {
+            await sendToTarget(ctx, target, content);
+          } catch (e) {
+            logger7.error(`推送到 ${target} 失败`, e);
+          }
+        }
+      }, "send");
+      await processAndSend(send, url, { username, isRetweet });
+    }, "pushTweet")
+  });
+  registerCommands(ctx, config, {
+    handleTweetUrl,
+    handleTweetInput,
+    checkOnce: poller.checkOnce
+  });
+  registerLinkDetector(ctx, config, handleTweetUrl);
+  ctx.on("ready", async () => {
+    await poller.init();
+    poller.start();
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  logger,
+  name
+});

package/lib/scheduler/poller.d.ts

@@ -0,0 +1,15 @@
+import { Context, Session } from 'koishi';
+import { Config } from '../config';
+import { XlonRepo } from '../db/repo';
+import { XFetcher } from '../service/fetcher';
+export declare function createPoller(ctx: Context, config: Config, repo: XlonRepo, fetcher: XFetcher, deps: {
+    pushTweet: (args: {
+        username: string;
+        url: string;
+        isRetweet: boolean;
+    }) => Promise<void>;
+}): {
+    init: () => Promise<void>;
+    checkOnce: (session?: Session) => Promise<void>;
+    start: () => void;
+};

package/lib/service/fetcher.d.ts

@@ -0,0 +1,20 @@
+import { Context } from 'koishi';
+import { Config } from '../config';
+import { LatestResult, TweetDetail } from '../types';
+export declare class XFetcher {
+    private ctx;
+    private config;
+    constructor(ctx: Context, config: Config);
+    /** puppeteer 是否可用 */
+    private get hasPuppeteer();
+    /**
+     * 获取博主最新推文链接（用于轮询判重）。
+     * 依赖 puppeteer 打开博主主页抓取。
+     */
+    getLatestTweet(username: string, maxRetries?: number): Promise<LatestResult>;
+    /**
+     * 获取推文详情（截图 + 媒体 + ALT + 正文）。
+     * puppeteer 可用时截图，否则仅走 vxtwitter API。
+     */
+    getTweetDetail(tweetUrlInput: string, maxRetries?: number): Promise<TweetDetail>;
+}

package/lib/service/message-builder.d.ts

@@ -0,0 +1,15 @@
+import { Context, h } from 'koishi';
+import { Config } from '../config';
+import { TweetDetail } from '../types';
+export interface MessageSegment {
+    content: string | ReturnType<typeof h.image> | ReturnType<typeof h.video>;
+}
+export interface BuildOptions {
+    username?: string;
+    isRetweet?: boolean;
+}
+/**
+ * 根据推文详情 + 翻译结果构建消息段列表。
+ * 不负责发送，由调用方决定发送方式（session.send / bot.sendMessage）。
+ */
+export declare function buildTweetMessages(ctx: Context, config: Config, detail: TweetDetail, translated: string, opts?: BuildOptions): Promise<MessageSegment[]>;

package/lib/types.d.ts

@@ -0,0 +1,29 @@
+export interface XlonRecord {
+    /** 订阅的博主用户名 */
+    id: string;
+    /** 最新推文链接（用于判重） */
+    link: string;
+    /** 最新推文正文（用于判重/辅助） */
+    content: string;
+}
+export interface LatestResult {
+    tweets: Array<{
+        link: string;
+        isRetweet: boolean;
+        isVideo: boolean;
+    }>;
+    wordContent: string;
+}
+export interface TweetDetail {
+    url: string;
+    /** 供展示/翻译的正文（可能包含图片描述拼接） */
+    wordContent: string;
+    /** 图片 ALT 原文（单独展示用） */
+    altTexts: string[];
+    /** 媒体 URL（图片/视频） */
+    mediaUrls: string[];
+    /** 推文截图（webp），可能为空 */
+    screenshotBuffer: Buffer | null;
+    /** 是否为受保护账号（protected tweet 只返回部分内容） */
+    protectedAccount?: boolean;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "koishi-plugin-xlon",
+    "description": "x subscriber",
+    "version": "1.0.1",
+    "contributors": [
+        "Logthm <logthm@outlook.com>"
+    ],
+    "main": "lib/index.js",
+    "typings": "lib/index.d.ts",
+    "files": [
+        "lib",
+        "dist"
+    ],
+    "license": "MIT",
+    "keywords": [
+        "chatbot",
+        "koishi",
+        "plugin"
+    ],
+    "koishi": {
+        "service": {
+            "required": [
+                "database"
+            ],
+            "optional": [
+                "puppeteer"
+            ]
+        }
+    },
+    "peerDependencies": {
+        "koishi": "^4.18.10"
+    },
+    "devDependencies": {
+        "koishi-plugin-puppeteer": "^3.9.0",
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "yml-register": "^1.2.5"
+    }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-xlon
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-xlon?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-xlon)
+
+x subscriber