6.2

write/src/app/api/bot/restart/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import { hugo } from "@/lib/hugo";
+
+export async function POST() {
+  try {
+    hugo.stop();
+    const result = await hugo.start();
+    return NextResponse.json({ ok: result.ok });
+  } catch (error: unknown) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed" },
+      { status: 500 }
+    );
+  }
+}

write/src/app/api/bot/status/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from "next/server";
+import { hugo } from "@/lib/hugo";
+import { TG_BOT_TOKEN } from "@/lib/config";
+
+export async function GET() {
+  const hugoStatus = hugo.status();
+  return NextResponse.json({
+    bot: {
+      enabled: !!TG_BOT_TOKEN,
+      polling: !!TG_BOT_TOKEN,
+    },
+    hugo: hugoStatus,
+  });
+}

write/src/app/api/deploy/route.ts

@@ -1,39 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { BLOG_ROOT } from "@/lib/config";
-
-const execFileAsync = promisify(execFile);
-
-type GitExecError = Error & {
-  stdout?: string;
-  stderr?: string;
-  code?: number;
-};
-
-async function runGit(args: string[], allowFailure = false) {
-  try {
-    const { stdout, stderr } = await execFileAsync("git", args, {
-      cwd: BLOG_ROOT,
-      windowsHide: true,
-      maxBuffer: 1024 * 1024,
-    });
-    return { stdout, stderr, code: 0 };
-  } catch (error) {
-    const err = error as GitExecError;
-    const result = {
-      stdout: err.stdout || "",
-      stderr: err.stderr || err.message,
-      code: typeof err.code === "number" ? err.code : 1,
-    };
-    if (allowFailure) return result;
-    throw new Error((result.stderr || result.stdout || err.message).trim());
-  }
-}
-
-function isRebaseConflict(message: string) {
-  return /conflict|CONFLICT|Resolve all conflicts|Automatic merge failed|could not apply|rebase/i.test(message);
-}
+import { deployQueue } from "@/lib/git";
 
 export async function POST(request: NextRequest) {
   try {
@@ -44,40 +10,23 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: "Title is required" }, { status: 400 });
     }
 
-    let output = "";
+    const result = await deployQueue.enqueue(`发布: ${title}`);
 
-    const addResult = await runGit(["add", "content/post", "static"]);
-    output += addResult.stdout + addResult.stderr;
-
-    const diffResult = await runGit(["diff", "--cached", "--quiet"], true);
-    if (diffResult.code === 1) {
-      const commitResult = await runGit(["commit", "-m", `发布: ${title}`]);
-      output += commitResult.stdout + commitResult.stderr;
-    } else if (diffResult.code !== 0) {
-      throw new Error((diffResult.stderr || diffResult.stdout || "检查暂存区失败").trim());
+    if (result.success) {
+      return NextResponse.json({ success: true, output: result.output });
     }
 
-    try {
-      const pullResult = await runGit(["pull", "--rebase", "--autostash", "origin", "main"]);
-      output += pullResult.stdout + pullResult.stderr;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (isRebaseConflict(message)) {
-        return NextResponse.json(
-          {
-            error: "远程仓库有新内容，自动合并失败。请在终端解决冲突后执行 git rebase --continue，再重新发布。",
-            detail: message.slice(0, 1000),
-          },
-          { status: 409 }
-        );
-      }
-      throw error;
+    if (result.conflict) {
+      return NextResponse.json(
+        {
+          error: result.error,
+          detail: result.output,
+        },
+        { status: 409 }
+      );
     }
 
-    const pushResult = await runGit(["push"]);
-    output += pushResult.stdout + pushResult.stderr;
-
-    return NextResponse.json({ success: true, output: output.slice(0, 1000) });
+    return NextResponse.json({ error: result.error }, { status: 500 });
   } catch (error: unknown) {
     return NextResponse.json(
       { error: error instanceof Error ? error.message : "Deploy failed" },

write/src/app/api/hugo/route.ts

@@ -1,50 +1,27 @@
 import { NextResponse } from "next/server";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { BLOG_ROOT, HUGO_PREVIEW } from "@/lib/config";
-
-const execAsync = promisify(exec);
-
-async function isHugoRunning(): Promise<boolean> {
-  try {
-    const res = await fetch(HUGO_PREVIEW, { signal: AbortSignal.timeout(1500) });
-    return res.ok || res.status < 500;
-  } catch {
-    return false;
-  }
-}
-
-let starting = false;
+import { hugo } from "@/lib/hugo";
+import { HUGO_PREVIEW } from "@/lib/config";
 
 export async function GET() {
   try {
-    const running = await isHugoRunning();
-    if (running) {
+    const result = await hugo.start();
+    if (result.alreadyRunning || result.ok) {
       return NextResponse.json({ running: true, url: HUGO_PREVIEW });
     }
-
-    if (starting) {
-      return NextResponse.json({ running: false, starting: true, url: HUGO_PREVIEW });
-    }
-
-    starting = true;
-    // Kill existing process on port 1313, then start hugo serve
-    const killCmd = `for /f "tokens=5" %a in ('netstat -ano ^| findstr :1313 ^| findstr LISTENING') do taskkill /F /PID %a 2>nul`;
-    const startCmd = `cd "${BLOG_ROOT}" && hugo serve --port 1313 --noHTTPCache`;
-
-    try { await execAsync(killCmd); } catch { /* nothing to kill */ }
-    exec(startCmd, (err) => {
-      if (err) console.error("Hugo start error:", err.message);
-    });
-
-    // Wait a moment for Hugo to start
-    await new Promise((r) => setTimeout(r, 2000));
-    starting = false;
-
-    const started = await isHugoRunning();
-    return NextResponse.json({ running: started, url: HUGO_PREVIEW });
+    return NextResponse.json({ running: false, url: HUGO_PREVIEW });
+  } catch (error: unknown) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE() {
+  try {
+    hugo.stop();
+    return NextResponse.json({ running: false });
   } catch (error: unknown) {
-    starting = false;
     return NextResponse.json(
       { error: error instanceof Error ? error.message : "Failed" },
       { status: 500 }

write/src/app/bot/page.tsx

@@ -0,0 +1,101 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Bot, RefreshCw, Server } from "lucide-react";
+
+interface BotStatus {
+  bot: { enabled: boolean; polling: boolean };
+  hugo: { running: boolean; starting: boolean };
+}
+
+export default function BotPage() {
+  const [status, setStatus] = useState<BotStatus | null>(null);
+  const [restarting, setRestarting] = useState(false);
+
+  async function fetchStatus() {
+    try {
+      const res = await fetch("/api/bot/status");
+      const data = await res.json();
+      setStatus(data);
+    } catch {
+      setStatus(null);
+    }
+  }
+
+  async function restartHugo() {
+    setRestarting(true);
+    try {
+      await fetch("/api/bot/restart", { method: "POST" });
+    } catch { /* ignore */ }
+    setTimeout(async () => {
+      await fetchStatus();
+      setRestarting(false);
+    }, 3000);
+  }
+
+  useEffect(() => {
+    fetchStatus();
+    const timer = setInterval(fetchStatus, 10000);
+    return () => clearInterval(timer);
+  }, []);
+
+  return (
+    <div className="p-6 max-w-2xl mx-auto space-y-6">
+      <h1 className="text-2xl font-bold">Bot 管理</h1>
+
+      {/* Bot Status */}
+      <div className="rounded-lg border border-[var(--border)] p-5 space-y-4">
+        <h2 className="font-semibold text-lg flex items-center gap-2">
+          <Bot size={20} /> Telegram Bot
+        </h2>
+        <div className="flex items-center gap-3">
+          <div
+            className={`w-3 h-3 rounded-full ${
+              status?.bot.enabled
+                ? "bg-green-500"
+                : "bg-gray-400"
+            }`}
+          />
+          <span className="text-sm">
+            {status?.bot.enabled
+              ? "已配置，随服务自动启动"
+              : "未配置 TG_BOT_TOKEN"}
+          </span>
+        </div>
+      </div>
+
+      {/* Hugo Status */}
+      <div className="rounded-lg border border-[var(--border)] p-5 space-y-4">
+        <h2 className="font-semibold text-lg flex items-center gap-2">
+          <Server size={20} /> Hugo Server
+        </h2>
+        <div className="flex items-center gap-3">
+          <div
+            className={`w-3 h-3 rounded-full ${
+              status?.hugo.running
+                ? "bg-green-500"
+                : status?.hugo.starting
+                ? "bg-yellow-500"
+                : "bg-gray-400"
+            }`}
+          />
+          <span className="text-sm">
+            {status?.hugo.running
+              ? "运行中 — localhost:1313"
+              : status?.hugo.starting
+              ? "启动中..."
+              : "已停止"}
+          </span>
+        </div>
+        <button
+          onClick={restartHugo}
+          disabled={restarting}
+          className="px-4 py-2 rounded-md bg-blue-600 text-white text-sm font-medium hover:bg-blue-700 disabled:opacity-50 flex items-center gap-2"
+        >
+          <RefreshCw size={14} className={restarting ? "animate-spin" : ""} />
+          {restarting ? "重启中..." : "重启 Hugo"}
+        </button>
+      </div>
+    </div>
+  );
+}

write/src/components/Sidebar.tsx

@@ -3,7 +3,7 @@
 import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { useEffect, useState } from "react";
-import { FileText, PenSquare, MessageSquare, Trash2, Rss, Link2, MessageCircle, Image, Menu, X } from "lucide-react";
+import { FileText, PenSquare, MessageSquare, Trash2, Rss, Link2, MessageCircle, Image, Menu, X, Bot } from "lucide-react";
 import ThemeToggle from "./ThemeToggle";
 
 const navItems = [
@@ -15,6 +15,7 @@ const navItems = [
   { href: "/images", label: "图片", icon: Image },
   { href: "/wechat", label: "公众号", icon: MessageCircle },
   { href: "/recycle", label: "回收站", icon: Trash2 },
+  { href: "/bot", label: "Bot", icon: Bot },
 ];
 
 export default function Sidebar() {

write/src/instrumentation.ts

@@ -0,0 +1,8 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    const { startBot } = await import("@/lib/bot");
+    startBot().catch((e) => {
+      console.error("[instrumentation] bot startup failed:", e);
+    });
+  }
+}

write/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/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/src/lib/bot/handlers.ts

@@ -0,0 +1,654 @@
+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 } 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 = [];
+    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.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/src/lib/bot/helpers.ts

@@ -0,0 +1,37 @@
+import path from "path";
+import { CONTENT_DIR } from "@/lib/config";
+
+export function makeSlug(title: string): string {
+  const dateStr = new Date().toISOString().slice(0, 10);
+  const slugPart = (title || "untitled")
+    .replace(/[^\w一-鿿㐀-䶿]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "post";
+  return dateStr + "-" + slugPart;
+}
+
+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 getArticleDirPath(slug: string): string {
+  const year = slug.slice(0, 4);
+  return path.join(CONTENT_DIR, year, slug);
+}
+
+export function truncateText(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\n... 前 " + maxLen + " 字";
+}

write/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/src/lib/bot/poll.ts

@@ -0,0 +1,246 @@
+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 { CONTENT_DIR } = await import("@/lib/config");
+    const { getSession } = await import("./sessions");
+    const { getArticleDirPath } = await import("./helpers");
+
+    const s = getSession(chatId);
+    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 = getArticleDirPath(s.slug);
+    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/src/lib/bot/sessions.ts

@@ -0,0 +1,77 @@
+import { createPost, updatePost, getPost } from "@/lib/posts";
+import { DEFAULT_AUTHOR } from "@/lib/config";
+
+export interface Session {
+  title: string;
+  slug: string;
+  content: string;
+  categories: string[];
+  tags: string[];
+  author: string;
+  draft: boolean;
+  chunks: string[];
+  originalSlug?: string;
+}
+
+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: [],
+    });
+  }
+  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 async function saveSession(s: Session, isDraft: boolean): Promise<void> {
+  const frontMatter = {
+    title: s.title,
+    slug: s.slug,
+    date: new Date().toISOString().slice(0, 10),
+    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("更新文章失败");
+  } else {
+    createPost(frontMatter, s.content);
+  }
+}

write/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;
+    }
+  }
+}

write/src/lib/config.ts

@@ -1,7 +1,9 @@
 import path from "path";
+import os from "os";
 
 export const BLOG_ROOT = path.resolve(process.cwd(), "..");
 export const CONTENT_DIR = path.join(BLOG_ROOT, "content", "post");
+export const STATIC_DIR = path.join(BLOG_ROOT, "static");
 export const RECYCLE_DIR = path.join(process.cwd(), ".recycle");
 export const RECYCLE_POSTS_DIR = path.join(RECYCLE_DIR, "posts");
 export const RECYCLE_META_DIR = path.join(RECYCLE_DIR, "meta");
@@ -14,3 +16,33 @@ export const RSS_API_BASE = process.env.RSS_API_BASE || "https://api.usj.cc";
 export const RSS_API_TOKEN = process.env.RSS_API_TOKEN || "";
 export const WECHAT_APP_ID = process.env.WECHAT_APP_ID || "";
 export const WECHAT_APP_SECRET = process.env.WECHAT_APP_SECRET || "";
+
+// Bot 配置
+export const TG_BOT_TOKEN = process.env.TG_BOT_TOKEN || "";
+export const TG_ALLOWED_IDS: number[] = (process.env.TG_ALLOWED_CHAT_IDS || "")
+  .split(",").map((s) => s.trim()).filter(Boolean).map(Number);
+export const PREFER_IFACE = process.env.PREFER_IFACE || "WLAN";
+export const DEFAULT_AUTHOR = process.env.DEFAULT_AUTHOR || "小赵";
+
+export function getLanIP(): string {
+  const ifs = os.networkInterfaces();
+  const candidates: { name: string; address: string }[] = [];
+  for (const [name, addrs] of Object.entries(ifs)) {
+    if (!addrs) continue;
+    for (const a of addrs) {
+      if (a.family !== "IPv4" || a.internal) continue;
+      if (a.address.startsWith("169.254.")) continue;
+      candidates.push({ name, address: a.address });
+    }
+  }
+  const pref = candidates.find((c) =>
+    c.name.toLowerCase().includes(PREFER_IFACE.toLowerCase())
+  );
+  if (pref) return pref.address;
+  const real = candidates.find((c) => {
+    const n = c.name.toLowerCase();
+    return !n.includes("vmware") && !n.includes("virtual") && !n.includes("vethernet");
+  });
+  if (real) return real.address;
+  return candidates[0]?.address || "0.0.0.0";
+}

write/src/lib/git.ts

@@ -0,0 +1,137 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { BLOG_ROOT } from "./config";
+
+const execFileAsync = promisify(execFile);
+
+type GitExecError = Error & {
+  stdout?: string;
+  stderr?: string;
+  code?: number;
+};
+
+export interface DeployResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+  conflict?: boolean;
+}
+
+interface QueueItem {
+  message: string;
+  resolve: (result: DeployResult) => void;
+  reject: (err: Error) => void;
+}
+
+class GitDeployQueue {
+  private queue: QueueItem[] = [];
+  private running = false;
+
+  async enqueue(commitMessage: string): Promise<DeployResult> {
+    return new Promise<DeployResult>((resolve, reject) => {
+      this.queue.push({ message: commitMessage, resolve, reject });
+      if (!this.running) this.next();
+    });
+  }
+
+  async sync(): Promise<DeployResult> {
+    try {
+      const result = await this.runGit(["pull", "--rebase", "--autostash", "origin", "main"]);
+      return { success: true, output: result.stdout + result.stderr };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (this.isRebaseConflict(msg)) {
+        await this.runGit(["rebase", "--abort"], true);
+        return { success: false, conflict: true, error: "远程冲突，已放弃合并" };
+      }
+      return { success: false, error: msg };
+    }
+  }
+
+  private async next(): Promise<void> {
+    const item = this.queue.shift();
+    if (!item) {
+      this.running = false;
+      return;
+    }
+    this.running = true;
+    try {
+      const result = await this.execute(item.message);
+      item.resolve(result);
+    } catch (e) {
+      item.reject(e instanceof Error ? e : new Error(String(e)));
+    }
+    this.next();
+  }
+
+  private async runGit(args: string[], allowFailure = false) {
+    try {
+      const { stdout, stderr } = await execFileAsync("git", args, {
+        cwd: BLOG_ROOT,
+        windowsHide: true,
+        maxBuffer: 1024 * 1024,
+      });
+      return { stdout, stderr, code: 0 };
+    } catch (error) {
+      const err = error as GitExecError;
+      const result = {
+        stdout: err.stdout || "",
+        stderr: err.stderr || err.message,
+        code: typeof err.code === "number" ? err.code : 1,
+      };
+      if (allowFailure) return result;
+      throw new Error((result.stderr || result.stdout || err.message).trim());
+    }
+  }
+
+  private isRebaseConflict(message: string): boolean {
+    return /conflict|CONFLICT|Resolve all conflicts|Automatic merge failed|could not apply|rebase/i.test(message);
+  }
+
+  private async execute(message: string): Promise<DeployResult> {
+    let output = "";
+
+    // git add
+    const addResult = await this.runGit(["add", "content"]);
+    output += addResult.stdout + addResult.stderr;
+
+    // git diff --cached --quiet  (exit 1 = staged changes exist)
+    const diffResult = await this.runGit(["diff", "--cached", "--quiet"], true);
+    if (diffResult.code === 1) {
+      const commitResult = await this.runGit(["commit", "-m", message]);
+      output += commitResult.stdout + commitResult.stderr;
+    } else if (diffResult.code !== 0) {
+      return { success: false, error: (diffResult.stderr || diffResult.stdout || "检查暂存区失败").trim() };
+    }
+
+    // git pull --rebase --autostash
+    try {
+      const pullResult = await this.runGit(["pull", "--rebase", "--autostash", "origin", "main"]);
+      output += pullResult.stdout + pullResult.stderr;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (this.isRebaseConflict(msg)) {
+        await this.runGit(["rebase", "--abort"], true);
+        return {
+          success: false,
+          conflict: true,
+          error: "远程有冲突，已自动放弃合并。请先 /sync 同步，手动解决后再 deploy。",
+          output: msg.slice(0, 1000),
+        };
+      }
+      return { success: false, error: msg };
+    }
+
+    // git push
+    try {
+      const pushResult = await this.runGit(["push"]);
+      output += pushResult.stdout + pushResult.stderr;
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+
+    return { success: true, output: output.slice(0, 1000) };
+  }
+}
+
+export const deployQueue = new GitDeployQueue();

write/src/lib/hugo.ts

@@ -0,0 +1,114 @@
+import { spawn, execSync, type ChildProcess } from "child_process";
+import { BLOG_ROOT } from "./config";
+
+class HugoManager {
+  private process: ChildProcess | null = null;
+  private ready = false;
+  private starting = false;
+  private healthTimer: NodeJS.Timeout | null = null;
+
+  async start(): Promise<{ ok: boolean; alreadyRunning?: boolean }> {
+    if (this.process && this.ready) {
+      return { ok: true, alreadyRunning: true };
+    }
+    if (this.starting) {
+      return { ok: false };
+    }
+
+    this.starting = true;
+    this.ready = false;
+
+    this.process = spawn("hugo", ["server", "--bind", "0.0.0.0", "--port", "1313", "--disableFastRender", "--noHTTPCache"], {
+      cwd: BLOG_ROOT,
+      shell: true,
+      stdio: "pipe",
+      windowsHide: true,
+    });
+
+    this.process.stdout?.on("data", (d: Buffer) => process.stdout.write(`[hugo] ${d}`));
+    this.process.stderr?.on("data", (d: Buffer) => process.stderr.write(`[hugo] ${d}`));
+
+    this.process.on("exit", (code) => {
+      console.log(`[hugo] exited ${code}`);
+      this.process = null;
+      this.ready = false;
+      this.starting = false;
+    });
+
+    // 等待 Hugo 就绪（最多 15 秒）
+    const ok = await this.waitForReady(15000);
+    this.starting = false;
+    if (ok) {
+      this.ready = true;
+      this.startHealthCheck();
+      console.log("[hugo] ready on 0.0.0.0:1313");
+    }
+    return { ok };
+  }
+
+  stop(): void {
+    this.stopHealthCheck();
+    if (!this.process) return;
+    try {
+      const pid = this.process.pid;
+      if (process.platform === "win32" && pid) {
+        execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore" });
+      } else {
+        this.process.kill();
+      }
+    } catch (_e) { /* nothing to kill */ }
+    this.process = null;
+    this.ready = false;
+    this.starting = false;
+  }
+
+  status(): { running: boolean; starting: boolean } {
+    return { running: !!(this.process && this.ready), starting: this.starting };
+  }
+
+  async ensureRunning(): Promise<boolean> {
+    if (this.process && this.ready) return true;
+    const result = await this.start();
+    return result.ok;
+  }
+
+  private async waitForReady(timeoutMs: number): Promise<boolean> {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (await this.ping()) return true;
+      await new Promise((r) => setTimeout(r, 1500));
+    }
+    return false;
+  }
+
+  private async ping(): Promise<boolean> {
+    try {
+      const res = await fetch("http://127.0.0.1:1313", { signal: AbortSignal.timeout(1500) });
+      return res.ok || res.status < 500;
+    } catch (_e) {
+      return false;
+    }
+  }
+
+  private startHealthCheck(): void {
+    this.stopHealthCheck();
+    this.healthTimer = setInterval(async () => {
+      if (!this.process) return;
+      const alive = await this.ping();
+      if (!alive) {
+        console.warn("[hugo] health check failed, marking as not ready");
+        this.ready = false;
+        this.stopHealthCheck();
+      }
+    }, 30_000);
+  }
+
+  private stopHealthCheck(): void {
+    if (this.healthTimer) {
+      clearInterval(this.healthTimer);
+      this.healthTimer = null;
+    }
+  }
+}
+
+export const hugo = new HugoManager();

write/src/lib/posts.ts

@@ -164,7 +164,7 @@ export function createPost(frontMatter: PostFrontMatter, content: string): strin
   const dirName = `${dateStr}-${titlePart}`;
   const dirPath = path.join(CONTENT_DIR, year, dirName);
 
-  if (fs.existsSync(dirPath)) {
+  if (fs.existsSync(path.join(dirPath, "index.md"))) {
     throw new Error(`Post already exists at ${dirPath}`);
   }
 

write/src/lib/rssapi.ts

@@ -48,6 +48,23 @@ export interface LinkHealth {
   error?: string;
 }
 
+export interface Article {
+  title: string;
+  link: string;
+  pubDate: string;
+  feedName: string;
+  siteUrl: string;
+  favicon: string;
+  author: string;
+}
+
+export interface HealthResult {
+  total: number;
+  alive: number;
+  dead: number;
+  results: FeedHealth[];
+}
+
 // ---- Feeds API ----
 
 export async function getFeeds(): Promise<Feed[]> {
@@ -80,13 +97,17 @@ export async function deleteFeed(url: string): Promise<void> {
   await rssFetch(`/api/feeds?${qs}`, { method: "DELETE" });
 }
 
-export async function getFeedsHealth(): Promise<{
-  total: number; alive: number; dead: number;
-  results: FeedHealth[];
-}> {
+export async function getFeedsHealth(): Promise<HealthResult> {
   return rssFetch("/api/health");
 }
 
+// ---- Articles API ----
+
+export async function getArticles(limit = 10): Promise<Article[]> {
+  const data = await rssFetch<{ articles: Article[] }>(`/api/articles?limit=${limit}`);
+  return data.articles || [];
+}
+
 // ---- Links API ----
 
 export async function getLinks(all = false): Promise<Link[]> {

write/src/types/marked.d.ts

@@ -0,0 +1,4 @@
+declare module "marked" {
+  export function marked(src: string): string;
+  export function parse(src: string): string;
+}