added：增加Linux-server

write-server/src/lib/bot/cache.ts

@@ -0,0 +1,30 @@
+interface CacheEntry<T> {
+  data: T;
+  expiresAt: number;
+}
+
+const cache = new Map<string, CacheEntry<unknown>>();
+
+export function getCached<T>(key: string): T | null {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() > entry.expiresAt) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.data as T;
+}
+
+export function setCache<T>(key: string, data: T, ttlMs: number): void {
+  cache.set(key, { data, expiresAt: Date.now() + ttlMs });
+}
+
+export function invalidateCache(key: string): void {
+  cache.delete(key);
+}
+
+export function invalidateByPrefix(prefix: string): void {
+  for (const key of cache.keys()) {
+    if (key.startsWith(prefix)) cache.delete(key);
+  }
+}

write-server/src/lib/bot/config.ts

@@ -0,0 +1,5 @@
+import { TG_BOT_TOKEN, TG_ALLOWED_IDS } from "@/lib/config";
+
+export const TG_TOKEN = TG_BOT_TOKEN;
+export const ALLOWED_IDS = TG_ALLOWED_IDS;
+export const API = TG_TOKEN ? `https://api.telegram.org/bot${TG_TOKEN}` : "";

write-server/src/lib/bot/handlers.ts

@@ -0,0 +1,656 @@
+import { getPost, listPosts } from "@/lib/posts";
+import { getLinks, addLink, updateLink, deleteLink, getFeeds, addFeed, updateFeed, deleteFeed, getFeedsHealth, getArticles } from "@/lib/rssapi";
+import { moveToRecycle } from "@/lib/recycle";
+import { deployQueue } from "@/lib/git";
+import { hugo } from "@/lib/hugo";
+import { getLanIP, DEFAULT_AUTHOR } from "@/lib/config";
+import { sendMessage, tg } from "./tg";
+import { getSession, hasSession, clearSession, saveSession, undoLastChunk, initSessionDir } from "./sessions";
+import { makeSlug, sessionSummary, truncateText } from "./helpers";
+import { getCached, setCache, invalidateByPrefix } from "./cache";
+
+type Handler = (chatId: number, arg?: string) => Promise<void>;
+
+const handlers: Record<string, Handler> = {};
+
+// ---- Cached API wrappers ----
+
+const CACHE_TTL_LINKS = 5 * 60 * 1000;
+const CACHE_TTL_FEEDS = 5 * 60 * 1000;
+const CACHE_TTL_ARTICLES = 3 * 60 * 1000;
+const CACHE_TTL_HEALTH = 10 * 60 * 1000;
+
+async function cachedLinks(all = true) {
+  const key = "links_" + (all ? "all" : "visible");
+  const hit = getCached<ReturnType<typeof getLinks> extends Promise<infer R> ? R : never>(key);
+  if (hit) return hit;
+  const data = await getLinks(all);
+  setCache(key, data, CACHE_TTL_LINKS);
+  return data;
+}
+
+async function cachedFeeds() {
+  const key = "feeds";
+  const hit = getCached<ReturnType<typeof getFeeds> extends Promise<infer R> ? R : never>(key);
+  if (hit) return hit;
+  const data = await getFeeds();
+  setCache(key, data, CACHE_TTL_FEEDS);
+  return data;
+}
+
+async function cachedArticles(limit: number) {
+  const key = "articles_" + limit;
+  const hit = getCached<ReturnType<typeof getArticles> extends Promise<infer R> ? R : never>(key);
+  if (hit) return hit;
+  const data = await getArticles(limit);
+  setCache(key, data, CACHE_TTL_ARTICLES);
+  return data;
+}
+
+async function cachedHealth() {
+  const key = "health";
+  const hit = getCached<ReturnType<typeof getFeedsHealth> extends Promise<infer R> ? R : never>(key);
+  if (hit) return hit;
+  const data = await getFeedsHealth();
+  setCache(key, data, CACHE_TTL_HEALTH);
+  return data;
+}
+
+// ---- 键盘 ----
+
+function mainKeyboard() {
+  return {
+    keyboard: [
+      [{ text: "/new" }, { text: "/list" }],
+      [{ text: "/links" }, { text: "/feeds" }],
+      [{ text: "/stats" }, { text: "/help" }],
+    ],
+    resize_keyboard: true,
+    one_time_keyboard: false,
+  };
+}
+
+function writingKeyboard() {
+  return {
+    keyboard: [
+      [{ text: "/preview" }, { text: "/undo" }],
+      [{ text: "/publish" }, { text: "/deploy" }],
+      [{ text: "/draft" }, { text: "/cancel" }],
+      [{ text: "/title" }, { text: "/categories" }],
+    ],
+    resize_keyboard: true,
+    one_time_keyboard: false,
+  };
+}
+
+async function sendMain(chatId: number, text: string) {
+  await sendMessage(chatId, text, { reply_markup: mainKeyboard() });
+}
+
+async function sendWrite(chatId: number, text: string) {
+  await sendMessage(chatId, text, { reply_markup: writingKeyboard() });
+}
+
+// ---- System ----
+
+handlers.start = async (chatId) => {
+  const ok = await hugo.ensureRunning();
+  const ip = getLanIP();
+  await sendMain(chatId, "✅ <b>已启动</b>\n\n📱 手机: http://" + ip + ":8016/\n💻 电脑: http://localhost:8016/");
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "点下方按钮打开编辑器：",
+    reply_markup: { inline_keyboard: [[{ text: "🌐 打开编辑器", web_app: { url: "http://" + ip + ":8016/" } }]] },
+  });
+};
+
+handlers.stop = async (chatId) => { hugo.stop(); await sendMain(chatId, "⚡ Hugo 已停止。"); };
+
+handlers.status = async (chatId) => {
+  const s = hugo.status();
+  const status = s.running ? "✅ 运行中" : s.starting ? "⏳ 启动中..." : "⏸ 已停止";
+  const lines = ["<b>Hugo:</b> " + status];
+  if (s.running) { const ip = getLanIP(); lines.push("📱 http://" + ip + ":8016", "💻 http://localhost:8016"); }
+  await sendMain(chatId, lines.join("\n"));
+};
+
+handlers.ip = async (chatId) => { await sendMain(chatId, "Phone: http://" + getLanIP() + ":8016"); };
+
+handlers.shutdown = async (chatId) => {
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "⚠️ 确认关机？\n\n电脑将在确认后 10 秒关机。",
+    parse_mode: "HTML",
+    reply_markup: {
+      inline_keyboard: [[
+        { text: "✅ 确认关机", callback_data: "confirm_shutdown" },
+        { text: "❌ 取消", callback_data: "cancel_shutdown" },
+      ]],
+    },
+  });
+};
+
+handlers.confirm_shutdown = async (chatId) => {
+  await sendMessage(chatId, "⏻ 电脑将在 10 秒后关机...");
+  const { exec } = await import("child_process");
+  exec("shutdown /s /t 10", (err) => {
+    if (err) console.error("[shutdown]", err.message);
+  });
+};
+
+handlers.cancel_shutdown = async (chatId) => {
+  const { exec } = await import("child_process");
+  exec("shutdown /a", () => {});
+  await sendMain(chatId, "已取消关机。");
+};
+
+handlers.reboot = async (chatId) => {
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "⚠️ 确认重启？\n\n电脑将在确认后 10 秒重启。",
+    parse_mode: "HTML",
+    reply_markup: {
+      inline_keyboard: [[
+        { text: "✅ 确认重启", callback_data: "confirm_reboot" },
+        { text: "❌ 取消", callback_data: "cancel_reboot" },
+      ]],
+    },
+  });
+};
+
+handlers.confirm_reboot = async (chatId) => {
+  await sendMessage(chatId, "🔄 电脑将在 10 秒后重启...");
+  const { exec } = await import("child_process");
+  exec("shutdown /r /t 10", (err) => {
+    if (err) console.error("[reboot]", err.message);
+  });
+};
+
+handlers.cancel_reboot = async (chatId) => {
+  const { exec } = await import("child_process");
+  exec("shutdown /a", () => {});
+  await sendMain(chatId, "已取消重启。");
+};
+
+handlers.help = async (chatId) => {
+  if (hasSession(chatId)) {
+    await sendWrite(chatId,
+      "✍ <b>写作中</b>\n\n" +
+      "/publish 保存  /draft 草稿  /deploy 部署\n" +
+      "/preview 预览  /undo 撤销  /cancel 取消\n" +
+      "/title 标题  /categories 分类  /tags 标签\n\n" +
+      "直接发消息追加正文，发照片追加图片"
+    );
+  } else {
+    await sendMain(chatId,
+      "🤖 <b>WriteBot 命令</b>\n\n" +
+      "📝 <b>文章</b>\n" +
+      "/new 标题 — 新建\n" +
+      "/edit slug — 编辑\n" +
+      "/delete slug — 删除\n" +
+      "/list — 文章列表\n\n" +
+      "🔗 <b>友链</b>\n" +
+      "/links — 列表\n" +
+      "/link_add url 名称 — 添加\n" +
+      "/link_edit url — 编辑\n" +
+      "/link_del url — 删除\n" +
+      "/link_toggle url — 显示/隐藏\n\n" +
+      "📡 <b>订阅</b>\n" +
+      "/feeds — 列表\n" +
+      "/feed_add url — 添加\n" +
+      "/feed_edit url — 编辑\n" +
+      "/feed_del url — 删除\n" +
+      "/feed_health — 健康检查\n\n" +
+      "📰 /read — 友链最新文章\n" +
+      "📊 /stats — 网站数据\n\n" +
+      "⏻ /shutdown — 关机  🔄 /reboot — 重启"
+    );
+  }
+};
+
+// ---- Articles: New ----
+
+handlers.new = async (chatId, title) => {
+  if (title) {
+    const s = getSession(chatId);
+    s.title = title;
+    s.slug = makeSlug(title);
+    s.content = "";
+    s.categories = [];
+    s.tags = [];
+    s.draft = true;
+    s.author = DEFAULT_AUTHOR;
+    s.chunks = [];
+    initSessionDir(chatId, title);
+    await tg("sendMessage", {
+      chat_id: chatId,
+      text: "📝 开始写：<b>" + title + "</b>\n\n📂 设置分类（可选）",
+      parse_mode: "HTML",
+      reply_markup: {
+        inline_keyboard: [[
+          { text: "跳过", callback_data: "skip_cat" },
+          { text: "设置分类", callback_data: "skip_cat" },
+        ]],
+      },
+    });
+    await tg("sendMessage", {
+      chat_id: chatId,
+      text: "请输入分类（逗号分隔，或发「跳过」）：",
+      reply_markup: { force_reply: true, input_field_placeholder: "技术、生活" },
+    });
+  } else {
+    await tg("sendMessage", { chat_id: chatId, text: "📝 请输入文章标题：", reply_markup: { force_reply: true, input_field_placeholder: "在这里输入标题..." } });
+  }
+};
+
+handlers.skip_categories = async (chatId) => {
+  const s = getSession(chatId);
+  if (!s.title) return;
+  s.categories = [];
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "🏷 设置标签（可选）",
+    reply_markup: {
+      inline_keyboard: [[
+        { text: "跳过", callback_data: "skip_tag" },
+        { text: "设置标签", callback_data: "skip_tag" },
+      ]],
+    },
+  });
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "请输入标签（逗号分隔，或发「跳过」）：",
+    reply_markup: { force_reply: true, input_field_placeholder: "Hugo、博客" },
+  });
+};
+
+handlers.skip_tags = async (chatId) => {
+  const s = getSession(chatId);
+  if (!s.title) return;
+  s.tags = [];
+  await sendWrite(chatId, "✅ 准备就绪，开始写正文吧！\n\n📝 <b>" + s.title + "</b>\n📂 " + (s.categories.join("、") || "无分类") + "\n🏷 " + (s.tags.join("、") || "无标签"));
+};
+
+handlers.categories = async (chatId, cats) => {
+  const s = getSession(chatId);
+  s.categories = cats ? cats.split(/[,;"，、]+/).map((c) => c.trim()).filter(Boolean) : [];
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "📂 分类：" + (s.categories.join("、") || "无") + "\n\n🏷 设置标签（可选）",
+    parse_mode: "HTML",
+    reply_markup: {
+      inline_keyboard: [[
+        { text: "跳过", callback_data: "skip_tag" },
+        { text: "设置标签", callback_data: "skip_tag" },
+      ]],
+    },
+  });
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "请输入标签（逗号分隔，或发「跳过」）：",
+    reply_markup: { force_reply: true, input_field_placeholder: "Hugo、博客" },
+  });
+};
+
+handlers.tags = async (chatId, tags) => {
+  const s = getSession(chatId);
+  s.tags = tags ? tags.split(/[,;"，、]+/).map((t) => t.trim()).filter(Boolean) : [];
+  await sendWrite(chatId, "✅ 准备就绪，开始写正文吧！\n\n📝 <b>" + s.title + "</b>\n📂 " + (s.categories.join("、") || "无分类") + "\n🏷 " + (s.tags.join("、") || "无标签"));
+};
+
+// ---- Articles: Edit (方案 B) ----
+
+handlers.edit = async (chatId, slug) => {
+  if (!slug) { await sendMain(chatId, "格式：/edit slug\n先用 /list 查看文章。"); return; }
+  const post = getPost(slug);
+  if (!post) { await sendMain(chatId, "❌ 未找到该文章"); return; }
+
+  const originalContent = post.content || "";
+  if (originalContent) {
+    const maxLen = 3800;
+    for (let i = 0; i < originalContent.length; i += maxLen) {
+      const chunk = originalContent.slice(i, i + maxLen);
+      const prefix = originalContent.length > maxLen ? "(" + (Math.floor(i / maxLen) + 1) + "/" + Math.ceil(originalContent.length / maxLen) + ")\n" : "";
+      await sendMessage(chatId, prefix + chunk);
+    }
+  }
+
+  const s = getSession(chatId);
+  s.title = post.frontMatter.title;
+  s.slug = post.frontMatter.slug;
+  s.originalSlug = post.frontMatter.slug;
+  s.content = "";
+  s.chunks = [];
+  s.dirPath = post.dirPath;
+  s.categories = (post.frontMatter.categories as string[]) || [];
+  s.tags = (post.frontMatter.tags as string[]) || [];
+  s.author = post.frontMatter.author || DEFAULT_AUTHOR;
+  s.draft = post.frontMatter.draft ?? true;
+
+  await sendWrite(chatId,
+    "✏ 编辑：<b>" + s.title + "</b>\n\n" +
+    "原文已显示，现在重新写正文\n" +
+    "📂 " + (s.categories.join("、") || "无分类") + "\n" +
+    "🏷 " + (s.tags.join("、") || "无标签") + "\n\n" +
+    "直接发消息写正文，完成后点「发布」"
+  );
+};
+
+// ---- Articles: Delete (二次确认) ----
+
+handlers.delete = async (chatId, slug) => {
+  if (!slug) { await sendMain(chatId, "格式：/delete slug\n先用 /list 查看文章。"); return; }
+  const post = getPost(slug);
+  if (!post) { await sendMain(chatId, "❌ 未找到该文章"); return; }
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "⚠️ 确认删除《" + post.frontMatter.title + "》？\n\n删除后移入回收站，30天内可恢复。",
+    parse_mode: "HTML",
+    reply_markup: {
+      inline_keyboard: [[
+        { text: "✅ 确认删除", callback_data: "confirm_del_" + slug },
+        { text: "❌ 取消", callback_data: "cancel_del_" + slug },
+      ]],
+    },
+  });
+};
+
+handlers.confirm_del = async (chatId, slug) => {
+  if (!slug) return;
+  const post = getPost(slug);
+  if (!post) { await sendMain(chatId, "❌ 未找到该文章"); return; }
+  moveToRecycle(slug, post.dirPath, post.frontMatter.title);
+  await sendMain(chatId, "✂ 已移入回收站：" + post.frontMatter.title + "\n30天内可恢复。");
+};
+
+handlers.cancel_del = async (chatId) => {
+  await sendMain(chatId, "已取消删除。");
+};
+
+// ---- Articles: List ----
+
+handlers.list = async (chatId, pageStr) => {
+  const page = parseInt(pageStr || "1") || 1;
+  const perPage = 10;
+  try {
+    const { posts, total, totalPages } = listPosts({ page, perPage });
+    if (total === 0) { await sendMain(chatId, "📖 还没有文章，发 /new 开始写。"); return; }
+    const lines = ["📖 <b>文章列表</b>  共 " + total + " 篇 · 第 " + page + "/" + totalPages + " 页\n"];
+    for (const p of posts) {
+      const draft = p.draft ? " 📝" : "";
+      lines.push(p.title + draft + "\n  <code>" + p.slug + "</code>");
+    }
+    const navRow: { text: string; callback_data: string }[] = [];
+    if (page > 1) navRow.push({ text: "◀ 上一页", callback_data: "list_" + (page - 1) });
+    if (page < totalPages) navRow.push({ text: "下一页 ▶", callback_data: "list_" + (page + 1) });
+    await tg("sendMessage", {
+      chat_id: chatId, text: lines.join("\n"), parse_mode: "HTML", disable_web_page_preview: true,
+      reply_markup: navRow.length ? { inline_keyboard: [navRow] } : undefined,
+    });
+  } catch (e: unknown) { await sendMain(chatId, "❌ " + (e instanceof Error ? e.message : String(e))); }
+};
+
+// ---- Articles: View / Title / Author / Preview ----
+
+handlers.view = async (chatId, slug) => {
+  if (!slug) { await sendMain(chatId, "格式：/view slug"); return; }
+  const ip = getLanIP();
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "🔖 <b>" + slug + "</b>\n\n📱 http://" + ip + ":1313/" + slug + ".html\n💻 http://localhost:1313/" + slug + ".html",
+    parse_mode: "HTML", disable_web_page_preview: true,
+    reply_markup: { inline_keyboard: [[{ text: "🌐 浏览器打开", url: "http://localhost:1313/" + slug + ".html" }]] },
+  });
+};
+
+handlers.title = async (chatId, newTitle) => {
+  if (!newTitle) { await tg("sendMessage", { chat_id: chatId, text: "请输入新标题：", reply_markup: { force_reply: true, input_field_placeholder: "新标题..." } }); return; }
+  const s = getSession(chatId);
+  s.title = newTitle;
+  await sendWrite(chatId, "✏ 标题已更新：<b>" + newTitle + "</b>");
+};
+
+handlers.author = async (chatId, author) => {
+  getSession(chatId).author = author || DEFAULT_AUTHOR;
+  await sendWrite(chatId, "✍ 作者：" + getSession(chatId).author);
+};
+
+handlers.preview = async (chatId) => {
+  const s = getSession(chatId);
+  if (!s || !s.title) { await sendMain(chatId, "还没开始写。发 /new 开始。"); return; }
+  if (!s.content) { await sendWrite(chatId, "正文为空。"); return; }
+  await sendWrite(chatId, "📝 <b>" + s.title + "</b>\n\n" + truncateText(s.content, 3800));
+};
+
+// ---- Writing: Publish / Draft / Deploy / Sync / Undo / Cancel ----
+
+handlers.publish = async (chatId) => {
+  const s = getSession(chatId);
+  if (!s || !s.title) { await sendMain(chatId, "还没开始写。发 /new 开始。"); return; }
+  if (!s.content) { await sendWrite(chatId, "正文为空，先写点内容再发布。"); return; }
+  try {
+    const title = s.title;
+    await saveSession(s, false);
+    clearSession(chatId);
+    await sendMain(chatId, "✅ 已保存：<b>" + title + "</b>\n\n发 /deploy 推送到线上");
+  } catch (e: unknown) { await sendWrite(chatId, "❌ 保存失败：" + (e instanceof Error ? e.message : String(e))); }
+};
+
+handlers.draft = async (chatId) => {
+  const s = getSession(chatId);
+  if (!s || !s.title) { await sendMain(chatId, "还没开始写。发 /new 开始。"); return; }
+  if (!s.content) { await sendWrite(chatId, "正文为空，先写点内容再保存。"); return; }
+  try {
+    const title = s.title;
+    await saveSession(s, true);
+    clearSession(chatId);
+    await sendMain(chatId, "📄 草稿已保存：<b>" + title + "</b>");
+  } catch (e: unknown) { await sendWrite(chatId, "❌ 保存失败：" + (e instanceof Error ? e.message : String(e))); }
+};
+
+handlers.deploy = async (chatId) => {
+  await sendMessage(chatId, "⏳ 正在部署...", { reply_markup: { remove_keyboard: true } });
+  const result = await deployQueue.enqueue("发布文章");
+  if (result.success) await sendMain(chatId, "🚀 <b>已部署！</b>\n\n🌐 https://usj.cc");
+  else if (result.conflict) await sendMain(chatId, "⚠️ " + (result.error || "远程冲突"));
+  else await sendMain(chatId, "❌ 部署失败：" + (result.error || "未知错误"));
+};
+
+handlers.sync = async (chatId) => {
+  await sendMessage(chatId, "⏳ 正在同步远程...");
+  const result = await deployQueue.sync();
+  if (result.success) await sendMain(chatId, "✅ 同步完成\n\n" + (result.output || "").slice(0, 500));
+  else await sendMain(chatId, "❌ " + (result.error || "同步失败"));
+};
+
+handlers.undo = async (chatId) => {
+  if (!hasSession(chatId)) { await sendMain(chatId, "没有活动的草稿。"); return; }
+  const ok = undoLastChunk(chatId);
+  if (!ok) { await sendWrite(chatId, "没有可撤销的内容。"); return; }
+  const s = getSession(chatId);
+  await sendWrite(chatId, "↩ 已撤销\n\n📝 <b>" + s.title + "</b>\n\n" + (s.content ? truncateText(s.content, 3800) : "（正文为空）"));
+};
+
+handlers.cancel = async (chatId) => {
+  if (!hasSession(chatId)) { await sendMain(chatId, "没有活动的草稿。"); return; }
+  clearSession(chatId);
+  await sendMain(chatId, "✂ 草稿已丢弃。");
+};
+
+// ---- Links ----
+
+handlers.links = async (chatId, pageStr) => {
+  const page = parseInt(pageStr || "1") || 1;
+  const perPage = 10;
+  try {
+    const allLinks = await cachedLinks(true);
+    if (allLinks.length === 0) { await sendMain(chatId, "还没有友链。\n\n添加：/link_add url 名称"); return; }
+    const totalPages = Math.ceil(allLinks.length / perPage);
+    const p = Math.min(page, totalPages);
+    const start = (p - 1) * perPage;
+    const pageLinks = allLinks.slice(start, start + perPage);
+    const lines = ["🔗 <b>友链</b>  共 " + allLinks.length + " 个 · 第 " + p + "/" + totalPages + " 页\n"];
+    for (const l of pageLinks) {
+      const icon = l.hidden ? "🔒" : "🌐";
+      lines.push(icon + " " + (l.name || l.url) + "\n  " + l.url);
+    }
+    lines.push("\n/link_add /link_edit /link_del /link_toggle");
+    const navRow: { text: string; callback_data: string }[] = [];
+    if (p > 1) navRow.push({ text: "◀ 上一页", callback_data: "links_" + (p - 1) });
+    if (p < totalPages) navRow.push({ text: "下一页 ▶", callback_data: "links_" + (p + 1) });
+    await tg("sendMessage", {
+      chat_id: chatId, text: lines.join("\n"), parse_mode: "HTML", disable_web_page_preview: true,
+      reply_markup: navRow.length ? { inline_keyboard: [navRow] } : undefined,
+    });
+  } catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.link_add = async (chatId, arg) => {
+  if (!arg) { await tg("sendMessage", { chat_id: chatId, text: "请输入友链信息：\n格式：url 名称", reply_markup: { force_reply: true, input_field_placeholder: "url 名称" } }); return; }
+  const parts = arg.split(/\s+/);
+  let url = parts[0];
+  const name = parts.slice(1).join(" ") || url;
+  if (!url.startsWith("http")) url = "https://" + url;
+  try { await addLink({ name, url }); invalidateByPrefix("links"); await sendMain(chatId, "✅ 友链已添加：" + name); }
+  catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.link_edit = async (chatId, arg) => {
+  if (!arg) { await sendMain(chatId, "格式：/link_edit url\n用 /links 查看友链。"); return; }
+  const s = getSession(chatId);
+  s.originalSlug = arg;
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "当前 URL：" + arg + "\n请输入新名称（空则保持不变）：",
+    reply_markup: { force_reply: true, input_field_placeholder: "新名称" },
+  });
+};
+
+handlers.link_del = async (chatId, url) => {
+  if (!url) { await sendMain(chatId, "格式：/link_del url"); return; }
+  try { await deleteLink(url); invalidateByPrefix("links"); await sendMain(chatId, "✅ 已删除：" + url); }
+  catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.link_toggle = async (chatId, url) => {
+  if (!url) { await sendMain(chatId, "格式：/link_toggle url"); return; }
+  try {
+    const allLinks = await cachedLinks(true);
+    const link = allLinks.find((l) => l.url === url);
+    if (!link) { await sendMain(chatId, "❌ 未找到：" + url); return; }
+    await updateLink(url, { hidden: !link.hidden });
+    invalidateByPrefix("links");
+    await sendMain(chatId, (!link.hidden ? "🔒 已隐藏" : "🌐 已显示") + "：" + (link.name || url));
+  } catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+// ---- Feeds ----
+
+handlers.feeds = async (chatId, pageStr) => {
+  const page = parseInt(pageStr || "1") || 1;
+  const perPage = 10;
+  try {
+    const allFeeds = await cachedFeeds();
+    if (allFeeds.length === 0) { await sendMain(chatId, "还没有订阅源。\n\n添加：/feed_add url"); return; }
+    const totalPages = Math.ceil(allFeeds.length / perPage);
+    const p = Math.min(page, totalPages);
+    const start = (p - 1) * perPage;
+    const pageFeeds = allFeeds.slice(start, start + perPage);
+    const lines = ["📡 <b>订阅源</b>  共 " + allFeeds.length + " 个 · 第 " + p + "/" + totalPages + " 页\n"];
+    for (const f of pageFeeds) {
+      lines.push("📰 " + (f.feedTitle || f.url) + "\n  " + f.url);
+    }
+    lines.push("\n/feed_add /feed_edit /feed_del /feed_health");
+    const navRow: { text: string; callback_data: string }[] = [];
+    if (p > 1) navRow.push({ text: "◀ 上一页", callback_data: "feeds_" + (p - 1) });
+    if (p < totalPages) navRow.push({ text: "下一页 ▶", callback_data: "feeds_" + (p + 1) });
+    await tg("sendMessage", {
+      chat_id: chatId, text: lines.join("\n"), parse_mode: "HTML", disable_web_page_preview: true,
+      reply_markup: navRow.length ? { inline_keyboard: [navRow] } : undefined,
+    });
+  } catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.feed_add = async (chatId, arg) => {
+  if (!arg) { await tg("sendMessage", { chat_id: chatId, text: "请输入订阅源 URL：", reply_markup: { force_reply: true, input_field_placeholder: "https://example.com/rss.xml" } }); return; }
+  const parts = arg.split(/\s+/);
+  const url = parts[0];
+  const feedTitle = parts.slice(1).join(" ") || "";
+  try { await addFeed(url, feedTitle); invalidateByPrefix("feeds"); await sendMain(chatId, "✅ 订阅源已添加：" + url); }
+  catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.feed_edit = async (chatId, arg) => {
+  if (!arg) { await sendMain(chatId, "格式：/feed_edit url\n用 /feeds 查看。"); return; }
+  const s = getSession(chatId);
+  s.originalSlug = arg;
+  await tg("sendMessage", {
+    chat_id: chatId,
+    text: "当前 URL：" + arg + "\n请输入新的订阅信息：\n格式：新URL 新名称",
+    reply_markup: { force_reply: true, input_field_placeholder: "新URL 新名称" },
+  });
+};
+
+handlers.feed_del = async (chatId, url) => {
+  if (!url) { await sendMain(chatId, "格式：/feed_del url"); return; }
+  try { await deleteFeed(url); invalidateByPrefix("feeds"); await sendMain(chatId, "✅ 已删除：" + url); }
+  catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.feed_health = async (chatId) => {
+  try {
+    await sendMessage(chatId, "⏳ 正在检测订阅源...");
+    const result = await cachedHealth();
+    const lines = ["📊 <b>订阅源健康报告</b>\n", "✅ 存活：" + result.alive + "  ❌ 异常：" + result.dead];
+    const dead = (result.results || []).filter((r) => !r.ok);
+    if (dead.length > 0) {
+      lines.push("\n❌ 异常站点：");
+      for (const d of dead.slice(0, 10)) {
+        lines.push("🔴 " + d.url + " — " + (d.error || String(d.status)));
+      }
+    }
+    await sendMain(chatId, lines.join("\n"));
+  } catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+// ---- Data ----
+
+handlers.stats = async (chatId) => {
+  try {
+    const { total } = listPosts({ perPage: 1 });
+    const allLinks = await cachedLinks(true);
+    const allFeeds = await cachedFeeds();
+    const visibleLinks = allLinks.filter((l) => !l.hidden).length;
+
+    let extra = "";
+    try {
+      const healthRes = await cachedHealth();
+      extra = "\n\n📰 友链博客：" + healthRes.total + " 个";
+    } catch (e) { /* ignore */ }
+
+    await sendMain(chatId,
+      "📊 <b>网站数据</b>\n\n" +
+      "📝 本地文章：" + total + " 篇\n" +
+      "🔗 友链：" + visibleLinks + " 个\n" +
+      "📡 订阅源：" + allFeeds.length + " 个" +
+      extra + "\n\n🌐 usj.cc"
+    );
+  } catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+handlers.read = async (chatId, limitStr) => {
+  const limit = parseInt(limitStr || "10") || 10;
+  try {
+    const articles = await cachedArticles(Math.min(limit, 20));
+    if (articles.length === 0) { await sendMain(chatId, "暂无最新文章。"); return; }
+    const lines = ["📰 <b>友链最新文章</b>（" + articles.length + " 篇）\n"];
+    for (const a of articles) {
+      lines.push((a.feedName || "未知") + " — " + a.title + "\n  " + a.link);
+    }
+    await tg("sendMessage", {
+      chat_id: chatId, text: lines.join("\n"), parse_mode: "HTML", disable_web_page_preview: true,
+    });
+  } catch (e) { await sendMain(chatId, "⚠️ API 暂时不可用，请稍后再试"); }
+};
+
+export default handlers;

write-server/src/lib/bot/helpers.ts

@@ -0,0 +1,31 @@
+export function makeSlug(title: string): string {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  return `${y}${m}${d}${h}${mi}${s}`;
+}
+
+export function sessionSummary(s: {
+  title: string;
+  categories: string[];
+  tags: string[];
+  content: string;
+}): string {
+  const lines = s.content ? s.content.split("\n").filter(Boolean).length : 0;
+  const chars = s.content.length;
+  const parts: string[] = [];
+  parts.push(`\u{1f4dd} <b>${s.title || "未命名"}</b>`);
+  if (s.categories.length) parts.push(`\u{1f4c2} ${s.categories.join("、")}`);
+  if (s.tags.length) parts.push(`\u{1f3f7} ${s.tags.join("、")}`);
+  if (chars) parts.push(`✍ ${lines} 行 ${chars} 字`);
+  return parts.filter(Boolean).join("  ·  ");
+}
+
+export function truncateText(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\n... 前 " + maxLen + " 字";
+}

write-server/src/lib/bot/index.ts

@@ -0,0 +1,21 @@
+import { startPolling } from "./poll";
+import { TG_TOKEN } from "./config";
+
+const g = globalThis as Record<string, unknown>;
+
+export async function startBot(): Promise<void> {
+  if (g.__botStarted) return;
+  g.__botStarted = true;
+
+  if (!TG_TOKEN) {
+    console.log("[bot] TG_BOT_TOKEN not configured, bot disabled");
+    return;
+  }
+
+  console.log("[bot] initializing...");
+  await startPolling();
+}
+
+export { TG_TOKEN } from "./config";
+export { sendMessage } from "./tg";
+export { getSession, hasSession, clearSession } from "./sessions";

write-server/src/lib/bot/poll.ts

@@ -0,0 +1,249 @@
+import { TG_TOKEN } from "./config";
+import { tg, allowed, sendMessage } from "./tg";
+import { hasSession, getSession, appendContent } from "./sessions";
+import handlers from "./handlers";
+
+const ARG_COMMANDS = new Set([
+  "new", "title", "categories", "tags", "author",
+  "edit", "view", "delete",
+  "link_add", "link_edit", "link_del", "link_toggle",
+  "feed_add", "feed_edit", "feed_del",
+  "list", "links", "feeds", "read",
+]);
+
+const CALLBACK_PREFIXES: Record<string, string> = {
+  edit: "edit",
+  confirm_del: "delete",
+  cancel_del: "noop",
+  list: "list",
+  links: "links",
+  feeds: "feeds",
+  skip_cat: "skip_categories",
+  skip_tag: "skip_tags",
+  confirm_shutdown: "confirm_shutdown",
+  cancel_shutdown: "cancel_shutdown",
+  confirm_reboot: "confirm_reboot",
+  cancel_reboot: "cancel_reboot",
+};
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+export async function startPolling(): Promise<void> {
+  if (!TG_TOKEN) {
+    console.log("[bot] TG_BOT_TOKEN not set, skipping bot startup");
+    return;
+  }
+
+  console.log("[bot] starting Telegram polling...");
+
+  let lastOffset = 0;
+  let backoff = 3000;
+
+  async function poll() {
+    try {
+      const data = await tg<Record<string, unknown>[]>("getUpdates", {
+        offset: lastOffset + 1,
+        timeout: 30,
+        allowed_updates: ["message", "callback_query"],
+      });
+
+      if (data.ok && data.result) {
+        for (const update of data.result) {
+          lastOffset = update.update_id as number;
+
+          if (update.callback_query) {
+            const cb = update.callback_query as {
+              message?: { chat?: { id: number } };
+              from?: { id: number };
+              id: string;
+              data?: string;
+            };
+            const cbChatId = cb.message?.chat?.id ?? cb.from?.id ?? 0;
+            if (cb.data && allowed(cbChatId)) {
+              await handleInlineCallback(cbChatId, cb.id, cb.data);
+            }
+            continue;
+          }
+
+          const msg = update.message as {
+            chat?: { id: number };
+            photo?: { file_id: string }[];
+            text?: string;
+            caption?: string;
+            reply_to_message?: { text?: string };
+          } | undefined;
+          if (!msg?.chat?.id) continue;
+          const chatId = msg.chat.id;
+          if (!allowed(chatId)) continue;
+
+          if (msg.photo && hasSession(chatId)) {
+            await handlePhoto(chatId, msg.photo, msg.caption);
+            continue;
+          }
+
+          if (!msg.text) continue;
+          const fullText = msg.text.trim();
+
+          // ForceReply routing
+          if (msg.reply_to_message?.text) {
+            const original = msg.reply_to_message.text;
+            if (original.includes("请输入文章标题")) { await handleCommand(chatId, "new", fullText); continue; }
+            if (original.includes("请输入新标题")) { await handleCommand(chatId, "title", fullText); continue; }
+            if (original.includes("请输入分类")) { await handleCommand(chatId, "categories", fullText); continue; }
+            if (original.includes("请输入标签")) { await handleCommand(chatId, "tags", fullText); continue; }
+            if (original.includes("请输入友链信息")) { await handleCommand(chatId, "link_add", fullText); continue; }
+            if (original.includes("请输入新名称")) { await handleCommand(chatId, "link_edit", fullText); continue; }
+            if (original.includes("请输入订阅源 URL")) { await handleCommand(chatId, "feed_add", fullText); continue; }
+            if (original.includes("请输入新的订阅信息")) { await handleCommand(chatId, "feed_edit", fullText); continue; }
+          }
+
+          const parts = fullText.split("@")[0].split(/\s+/);
+          const cmdRaw = parts[0].toLowerCase();
+          const slashCmd = cmdRaw.startsWith("/") ? cmdRaw.slice(1) : "";
+          const slashArg = parts.slice(1).join(" ");
+
+          // In writing session, non-slash text appends to content
+          if (hasSession(chatId) && !cmdRaw.startsWith("/")) {
+            try { appendContent(chatId, fullText); }
+            catch (e) { console.error("[bot:append]", e instanceof Error ? e.message : String(e)); }
+            continue;
+          }
+
+          if (cmdRaw.startsWith("/")) {
+            await handleCommand(chatId, slashCmd, slashArg);
+          }
+        }
+      }
+
+      backoff = 3000;
+    } catch (e) {
+      console.error("[bot:poll]", e instanceof Error ? e.message : String(e));
+      await sleep(backoff);
+      backoff = Math.min(backoff * 2, 60000);
+    }
+
+    await sleep(100);
+    setImmediate(poll);
+  }
+
+  // Register commands with Telegram
+  try {
+    await tg("setMyCommands", {
+      commands: [
+        { command: "new", description: "写一篇文章" },
+        { command: "edit", description: "编辑文章" },
+        { command: "delete", description: "删除文章" },
+        { command: "list", description: "文章列表" },
+        { command: "publish", description: "保存发布" },
+        { command: "draft", description: "保存草稿" },
+        { command: "deploy", description: "推送到线上" },
+        { command: "sync", description: "同步远程" },
+        { command: "undo", description: "撤销最后一段" },
+        { command: "preview", description: "预览" },
+        { command: "links", description: "友链管理" },
+        { command: "link_add", description: "添加友链" },
+        { command: "link_edit", description: "编辑友链" },
+        { command: "link_del", description: "删除友链" },
+        { command: "link_toggle", description: "显示/隐藏友链" },
+        { command: "feeds", description: "订阅管理" },
+        { command: "feed_add", description: "添加订阅源" },
+        { command: "feed_edit", description: "编辑订阅源" },
+        { command: "feed_del", description: "删除订阅源" },
+        { command: "feed_health", description: "订阅源健康检查" },
+        { command: "read", description: "友链最新文章" },
+        { command: "stats", description: "网站数据" },
+        { command: "shutdown", description: "关机" },
+        { command: "reboot", description: "重启" },
+        { command: "help", description: "帮助" },
+      ],
+    });
+    console.log("[bot] commands registered");
+  } catch (e) {
+    console.error("[bot] failed to register commands:", e instanceof Error ? e.message : String(e));
+  }
+
+  poll();
+}
+
+async function handlePhoto(chatId: number, photos: { file_id: string }[], caption?: string) {
+  try {
+    const fs = await import("fs");
+    const path = await import("path");
+    const { getSession } = await import("./sessions");
+
+    const s = getSession(chatId);
+    if (!s.dirPath) {
+      await sendMessage(chatId, "❌ 请先发 /new 或 /edit 开始写作");
+      return;
+    }
+
+    const largestPhoto = photos[photos.length - 1];
+    const fileRes = await tg<{ file_path?: string }>("getFile", { file_id: largestPhoto.file_id });
+    if (!fileRes.ok || !fileRes.result?.file_path) return;
+
+    const filePath = fileRes.result.file_path;
+    const fileUrl = "https://api.telegram.org/file/bot" + TG_TOKEN + "/" + filePath;
+    const imgBuffer = await fetch(fileUrl).then((r) => r.arrayBuffer());
+
+    // Save to article's own folder (Hugo page bundle)
+    const articleDir = s.dirPath;
+    if (!fs.existsSync(articleDir)) fs.mkdirSync(articleDir, { recursive: true });
+
+    const ext = filePath.split(".").pop() || "jpg";
+    const filename = Date.now() + "-" + largestPhoto.file_id.slice(0, 8) + "." + ext;
+    fs.writeFileSync(path.join(articleDir, filename), Buffer.from(imgBuffer));
+
+    const imgCaption = caption || "image";
+    appendContent(chatId, `\n![${imgCaption}](${filename})\n`);
+    await sendMessage(chatId, `📷 图片已保存：${filename}`);
+  } catch (e) {
+    console.error("[bot:photo]", e instanceof Error ? e.message : String(e));
+    await sendMessage(chatId, "❌ 图片保存失败");
+  }
+}
+
+async function handleCommand(chatId: number, cmd: string, arg?: string) {
+  try {
+    if (cmd === "noop") return;
+    if (ARG_COMMANDS.has(cmd)) {
+      const handler = handlers[cmd];
+      if (handler) await handler(chatId, arg);
+      else await sendMessage(chatId, "❌ 未知命令：/" + cmd);
+    } else {
+      const handler = handlers[cmd];
+      if (handler) await handler(chatId);
+      else if (cmd) await sendMessage(chatId, "❌ 未知命令：/" + cmd);
+    }
+  } catch (e) {
+    console.error("[bot:" + cmd + "]", e instanceof Error ? e.message : String(e));
+    try {
+      await sendMessage(chatId, "❌ " + (e instanceof Error ? e.message : "error").slice(0, 200));
+    } catch (e) { /* ignore */ }
+  }
+}
+
+async function handleInlineCallback(chatId: number, queryId: string, data: string) {
+  let prefix = "";
+  let arg = "";
+  // First try prefix match (e.g. "edit_slug", "list_2")
+  for (const p of Object.keys(CALLBACK_PREFIXES)) {
+    if (data.startsWith(p + "_")) {
+      prefix = p;
+      arg = data.slice(p.length + 1);
+      break;
+    }
+  }
+  // Then try exact match (e.g. "confirm_shutdown", "skip_cat")
+  if (!prefix && CALLBACK_PREFIXES[data]) {
+    prefix = data;
+  }
+  if (!prefix) {
+    try { await tg("answerCallbackQuery", { callback_query_id: queryId }); } catch (_e) {}
+    return;
+  }
+  const cmd = CALLBACK_PREFIXES[prefix];
+  await handleCommand(chatId, cmd, arg);
+  try { await tg("answerCallbackQuery", { callback_query_id: queryId }); } catch (_e) {}
+}

write-server/src/lib/bot/sessions.ts

@@ -0,0 +1,101 @@
+import { createPost, updatePost, getPost } from "@/lib/posts";
+import { DEFAULT_AUTHOR, CONTENT_DIR } from "@/lib/config";
+import path from "path";
+
+export interface Session {
+  title: string;
+  slug: string;
+  content: string;
+  categories: string[];
+  tags: string[];
+  author: string;
+  draft: boolean;
+  chunks: string[];
+  originalSlug?: string;
+  dirPath: string;
+}
+
+function computeDirPath(title: string, date?: string): string {
+  const d = date ? new Date(date) : new Date();
+  const year = d.getFullYear().toString();
+  const dateStr = d.toISOString().slice(0, 10);
+  const titlePart = (title || "untitled")
+    .replace(/[^\w一-鿿㐀-䶿]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "post";
+  return path.join(CONTENT_DIR, year, `${dateStr}-${titlePart}`);
+}
+
+const sessions = new Map<number, Session>();
+
+export function getSession(chatId: number): Session {
+  if (!sessions.has(chatId)) {
+    sessions.set(chatId, {
+      title: "",
+      slug: "",
+      content: "",
+      categories: [],
+      tags: [],
+      author: DEFAULT_AUTHOR,
+      draft: true,
+      chunks: [],
+      dirPath: "",
+    });
+  }
+  return sessions.get(chatId)!;
+}
+
+export function hasSession(chatId: number): boolean {
+  return sessions.has(chatId);
+}
+
+export function clearSession(chatId: number): void {
+  sessions.delete(chatId);
+}
+
+export function appendContent(chatId: number, text: string): void {
+  const s = getSession(chatId);
+  s.chunks.push(text + "\n\n");
+  s.content += text + "\n\n";
+}
+
+export function undoLastChunk(chatId: number): boolean {
+  const s = getSession(chatId);
+  if (s.chunks.length === 0) return false;
+  const lastChunk = s.chunks.pop()!;
+  const idx = s.content.lastIndexOf(lastChunk);
+  if (idx >= 0) {
+    s.content = s.content.slice(0, idx) + s.content.slice(idx + lastChunk.length);
+  }
+  return true;
+}
+
+export function initSessionDir(chatId: number, title: string, date?: string): void {
+  const s = getSession(chatId);
+  if (!s.dirPath) {
+    s.dirPath = computeDirPath(title, date);
+  }
+}
+
+export async function saveSession(s: Session, isDraft: boolean): Promise<void> {
+  const dateStr = new Date().toISOString().slice(0, 10);
+  const frontMatter = {
+    title: s.title,
+    slug: s.slug,
+    date: dateStr,
+    draft: isDraft,
+    categories: s.categories,
+    tags: s.tags,
+    author: s.author,
+  };
+
+  const existing = getPost(s.slug);
+  if (existing) {
+    const result = updatePost(s.slug, frontMatter, s.content);
+    if (!result.success) throw new Error("更新文章失败");
+    s.dirPath = result.dirPath;
+  } else {
+    const dirPath = createPost(frontMatter, s.content);
+    s.dirPath = dirPath;
+  }
+}

write-server/src/lib/bot/tg.ts

@@ -0,0 +1,52 @@
+import { API, ALLOWED_IDS } from "./config";
+
+interface TgResponse<T = unknown> {
+  ok: boolean;
+  result?: T;
+  description?: string;
+}
+
+export async function tg<T = unknown>(
+  method: string,
+  body: Record<string, unknown>
+): Promise<TgResponse<T>> {
+  const res = await fetch(`${API}/${method}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  return res.json() as Promise<TgResponse<T>>;
+}
+
+export function allowed(chatId: number): boolean {
+  if (ALLOWED_IDS.length === 0) return true;
+  return ALLOWED_IDS.includes(chatId);
+}
+
+export async function sendMessage(
+  chatId: number,
+  text: string,
+  opts?: Record<string, unknown>
+): Promise<void> {
+  const safeText = String(text || "");
+  try {
+    await tg("sendMessage", {
+      chat_id: chatId,
+      text: safeText,
+      parse_mode: "HTML",
+      disable_web_page_preview: true,
+      ...opts,
+    });
+  } catch (e: unknown) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("parse") || msg.includes("HTML")) {
+      await tg("sendMessage", {
+        chat_id: chatId,
+        text: safeText,
+        ...opts,
+      });
+    } else {
+      throw e;
+    }
+  }
+}