talon-agent 1.0.0

package/src/frontend/telegram/admin.ts

@@ -0,0 +1,178 @@
+/**
+ * Admin command handlers — /admin subcommands for bot operators.
+ */
+
+import type { Bot, Context } from "grammy";
+import { readFileSync } from "node:fs";
+import type { TalonConfig } from "../../util/config.js";
+import { files, dirs } from "../../util/paths.js";
+import { escapeHtml } from "./formatting.js";
+import {
+  resetSession,
+  getAllSessions,
+} from "../../storage/sessions.js";
+import { clearHistory } from "../../storage/history.js";
+import { getChatSettings } from "../../storage/chat-settings.js";
+import { getAllCronJobs, validateCronExpression } from "../../storage/cron-store.js";
+import { getActiveCount } from "../../core/dispatcher.js";
+import { getPulseStatus } from "../../core/pulse.js";
+import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";
+import { formatDuration } from "./helpers.js";
+
+export async function handleAdminCommand(
+  ctx: Context,
+  bot: Bot,
+  config: TalonConfig,
+): Promise<void> {
+  const args = (ctx.match as string ?? "").trim();
+  const [subcommand, ...rest] = args.split(/\s+/);
+
+  switch (subcommand) {
+    case "chats": {
+      const sessions = getAllSessions();
+      if (sessions.length === 0) { await ctx.reply("No active sessions."); return; }
+      sessions.sort((a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0));
+
+      const titles = new Map<string, string>();
+      await Promise.all(sessions.map(async (s) => {
+        try {
+          const id = parseInt(s.chatId, 10);
+          if (isNaN(id)) return;
+          const chat = await bot.api.getChat(id);
+          titles.set(s.chatId, "title" in chat ? (chat.title ?? "DM") : "first_name" in chat ? (chat.first_name ?? "DM") : "DM");
+        } catch { /* inaccessible */ }
+      }));
+
+      const lines = sessions.map((s) => {
+        const age = s.info.lastActive ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago` : "?";
+        const title = titles.get(s.chatId) ?? s.chatId;
+        const model = (getChatSettings(s.chatId).model ?? config.model).replace("claude-", "");
+        return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${model}`;
+      });
+      await ctx.reply(`<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"), { parse_mode: "HTML" });
+      return;
+    }
+
+    case "broadcast": {
+      const text = rest.join(" ");
+      if (!text) { await ctx.reply("Usage: /admin broadcast <text>"); return; }
+      const sessions = getAllSessions();
+      let sent = 0, failed = 0;
+      for (const s of sessions) {
+        const id = parseInt(s.chatId, 10);
+        if (isNaN(id)) continue;
+        try { await bot.api.sendMessage(id, text); sent++; } catch { failed++; }
+      }
+      await ctx.reply(`Broadcast: ${sent} sent, ${failed} failed (${sessions.length} total).`);
+      return;
+    }
+
+    case "kill": {
+      const target = rest[0];
+      if (!target) { await ctx.reply("Usage: /admin kill <chatId>"); return; }
+      resetSession(target);
+      clearHistory(target);
+      await ctx.reply(`Session ${target} reset.`);
+      return;
+    }
+
+    case "logs": {
+      const logPath = files.log;
+      try {
+        const { statSync, openSync, readSync, closeSync } = await import("node:fs");
+        const stat = statSync(logPath);
+        const size = Math.min(8192, stat.size);
+        const buf = Buffer.alloc(size);
+        const fd = openSync(logPath, "r");
+        readSync(fd, buf, 0, size, Math.max(0, stat.size - size));
+        closeSync(fd);
+        const lines = buf.toString("utf-8").trim().split("\n").slice(-20).join("\n");
+        await ctx.reply(`<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`, { parse_mode: "HTML" });
+      } catch { await ctx.reply(`Could not read ${logPath}`); }
+      return;
+    }
+
+    case "stats": {
+      const h = getHealthStatus();
+      const sessions = getAllSessions();
+      const turns = sessions.reduce((s, x) => s + x.info.turns, 0);
+      const mem = process.memoryUsage();
+      await ctx.reply([
+        `<b>\uD83E\uDD85 Talon Stats</b>`, "",
+        `<b>Uptime:</b> ${formatDuration(h.uptimeMs)}`,
+        `<b>Messages:</b> ${h.totalMessagesProcessed}`,
+        `<b>Sessions:</b> ${sessions.length}`,
+        `<b>Turns:</b> ${turns}`,
+        `<b>Last active:</b> ${h.msSinceLastMessage < 60000 ? "now" : formatDuration(h.msSinceLastMessage) + " ago"}`, "",
+        `<b>Memory:</b> ${(mem.heapUsed / 1024 / 1024).toFixed(1)}MB heap / ${(mem.rss / 1024 / 1024).toFixed(1)}MB rss`,
+        `<b>Queue:</b> ${getActiveCount()}`,
+        `<b>Errors:</b> ${h.recentErrorCount}`,
+      ].join("\n"), { parse_mode: "HTML" });
+      return;
+    }
+
+    case "errors": {
+      const errors = getRecentErrors(5);
+      if (errors.length === 0) { await ctx.reply("No recent errors."); return; }
+      const lines = errors.map((e) => `<code>[${new Date(e.timestamp).toISOString().slice(11, 19)}]</code> ${escapeHtml(e.message.slice(0, 200))}`);
+      await ctx.reply(`<b>Recent Errors (${errors.length})</b>\n\n` + lines.join("\n\n"), { parse_mode: "HTML" });
+      return;
+    }
+
+    case "cron": {
+      const jobs = getAllCronJobs();
+      if (jobs.length === 0) { await ctx.reply("No cron jobs."); return; }
+      const lines = jobs.map((j) => {
+        const v = validateCronExpression(j.schedule, j.timezone);
+        const last = j.lastRunAt ? new Date(j.lastRunAt).toISOString().slice(0, 16).replace("T", " ") : "never";
+        const next = v.next ? new Date(v.next).toISOString().slice(0, 16).replace("T", " ") : "?";
+        return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${j.schedule}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
+      });
+      await ctx.reply(`<b>Cron Jobs (${jobs.length})</b>\n\n` + lines.join("\n\n"), { parse_mode: "HTML" });
+      return;
+    }
+
+    case "pulse": {
+      const chats = getPulseStatus();
+      if (chats.length === 0) { await ctx.reply("No pulse chats."); return; }
+      const lines = await Promise.all(chats.map(async (p) => {
+        let title = p.chatId;
+        try {
+          const id = parseInt(p.chatId, 10);
+          if (!isNaN(id)) {
+            const chat = await bot.api.getChat(id);
+            title = "title" in chat ? (chat.title ?? p.chatId) : p.chatId;
+          }
+        } catch { /* skip */ }
+        return `${p.enabled ? "\u2713" : "\u2717"} ${escapeHtml(title)}`;
+      }));
+      await ctx.reply(`<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"), { parse_mode: "HTML" });
+      return;
+    }
+
+    case "daily": {
+      const today = new Date().toISOString().slice(0, 10);
+      const logPath = `${dirs.logs}/${today}.md`;
+      try {
+        const content = readFileSync(logPath, "utf-8");
+        const lines = content.trim().split("\n").slice(-30).join("\n");
+        await ctx.reply(`<b>Daily log (${today})</b>\n\n<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`, { parse_mode: "HTML" });
+      } catch { await ctx.reply(`No daily log for ${today}.`); }
+      return;
+    }
+
+    default:
+      await ctx.reply([
+        "<b>/admin commands</b>", "",
+        "  stats    uptime, messages, memory",
+        "  errors   last 5 errors",
+        "  chats    list all active chats",
+        "  daily    today's interaction log",
+        "  pulse    pulse status per chat",
+        "  cron     list all cron jobs",
+        "  broadcast &lt;text&gt;  send to all chats",
+        "  kill &lt;chatId&gt;     reset a chat session",
+        "  logs     last 20 lines of log",
+      ].join("\n"), { parse_mode: "HTML" });
+  }
+}

package/src/frontend/telegram/callbacks.ts

@@ -0,0 +1,251 @@
+/**
+ * All callback_query handlers (settings panel, model/effort selectors, proactive toggle).
+ */
+
+import type { Bot } from "grammy";
+import type { TalonConfig } from "../../util/config.js";
+
+import {
+  getChatSettings,
+  setChatModel,
+  setChatEffort,
+  resolveModelName,
+  EFFORT_LEVELS,
+  type EffortLevel,
+} from "../../storage/chat-settings.js";
+import {
+  registerChat,
+  disablePulse,
+  enablePulse,
+  isPulseEnabled,
+} from "../../core/pulse.js";
+import { handleCallbackQuery } from "./handlers.js";
+import { escapeHtml } from "./formatting.js";
+import {
+  renderSettingsText,
+  renderSettingsKeyboard,
+} from "./helpers.js";
+
+export function registerCallbacks(bot: Bot, config: TalonConfig): void {
+  // ── Callback query handler ──────────────────────────────────────────────────
+
+  bot.on("callback_query:data", async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    const cid = String(ctx.chat?.id ?? ctx.from.id);
+
+    // Handle unified /settings callbacks
+    if (data.startsWith("settings:")) {
+      const parts = data.split(":");
+      if (!parts[1]) {
+        await ctx.answerCallbackQuery({ text: "Invalid callback data" });
+        return;
+      }
+      const category = parts[1];
+      const value = parts[2] ?? "";
+
+      if (category === "done") {
+        await ctx.answerCallbackQuery({ text: "Done" });
+        try {
+          await ctx.deleteMessage();
+        } catch {
+          // might not have permission to delete
+        }
+        return;
+      }
+
+      if (category === "model") {
+        if (value === "reset") {
+          setChatModel(cid, undefined);
+        } else {
+          const resolved = resolveModelName(value);
+          setChatModel(cid, resolved);
+        }
+        await ctx.answerCallbackQuery({
+          text: `Model: ${getChatSettings(cid).model ?? config.model}`,
+        });
+      } else if (category === "effort") {
+        if (value === "adaptive") {
+          setChatEffort(cid, undefined);
+        } else if (EFFORT_LEVELS.includes(value as EffortLevel)) {
+          setChatEffort(cid, value as EffortLevel);
+        }
+        await ctx.answerCallbackQuery({
+          text: `Effort: ${getChatSettings(cid).effort ?? "adaptive"}`,
+        });
+      } else if (category === "proactive") {
+        if (value === "on") {
+          enablePulse(cid);
+          registerChat(cid);
+        } else {
+          disablePulse(cid);
+        }
+        await ctx.answerCallbackQuery({ text: `Pulse: ${value}` });
+      }
+
+      const chatSets = getChatSettings(cid);
+      const activeModel = chatSets.model ?? config.model;
+      const effortName = chatSets.effort ?? "adaptive";
+      const pulseOn = isPulseEnabled(cid);
+
+      try {
+        await ctx.editMessageText(
+          renderSettingsText(
+            activeModel,
+            effortName,
+            pulseOn,
+            chatSets.pulseIntervalMs,
+          ),
+          {
+            parse_mode: "HTML",
+            reply_markup: {
+              inline_keyboard: renderSettingsKeyboard(
+                activeModel,
+                effortName,
+                pulseOn,
+              ),
+            },
+          },
+        );
+      } catch {
+        /* message unchanged */
+      }
+      return;
+    }
+
+    // Handle pulse callbacks
+    if (data.startsWith("pulse:")) {
+      const val = data.slice(6);
+      if (val === "on") {
+        enablePulse(cid);
+        registerChat(cid);
+        await ctx.answerCallbackQuery({ text: "Pulse: on" });
+      } else if (val === "off") {
+        disablePulse(cid);
+        await ctx.answerCallbackQuery({ text: "Pulse: off" });
+      }
+      const enabled = isPulseEnabled(cid);
+      try {
+        await ctx.editMessageText(
+          `<b>🔔 Pulse:</b> ${enabled ? "on" : "off"}\n\nReads along every few minutes and jumps in when there's something to add.`,
+          {
+            parse_mode: "HTML",
+            reply_markup: {
+              inline_keyboard: [[
+                { text: enabled ? "✓ On" : "On", callback_data: "pulse:on" },
+                { text: !enabled ? "✓ Off" : "Off", callback_data: "pulse:off" },
+              ]],
+            },
+          },
+        );
+      } catch { /* unchanged */ }
+      return;
+    }
+
+    // Handle effort callbacks
+    if (data.startsWith("effort:")) {
+      const level = data.slice(7);
+      if (level === "adaptive") {
+        setChatEffort(cid, undefined);
+        await ctx.answerCallbackQuery({ text: "Effort: adaptive" });
+      } else if (EFFORT_LEVELS.includes(level as EffortLevel)) {
+        setChatEffort(cid, level as EffortLevel);
+        await ctx.answerCallbackQuery({ text: `Effort: ${level}` });
+      }
+      const current = getChatSettings(cid).effort ?? "adaptive";
+      try {
+        await ctx.editMessageText(`<b>Effort:</b> ${current}`, {
+          parse_mode: "HTML",
+          reply_markup: {
+            inline_keyboard: [
+              [
+                {
+                  text: current === "off" ? "\u2713 Off" : "Off",
+                  callback_data: "effort:off",
+                },
+                {
+                  text: current === "low" ? "\u2713 Low" : "Low",
+                  callback_data: "effort:low",
+                },
+                {
+                  text: current === "medium" ? "\u2713 Med" : "Med",
+                  callback_data: "effort:medium",
+                },
+              ],
+              [
+                {
+                  text: current === "high" ? "\u2713 High" : "High",
+                  callback_data: "effort:high",
+                },
+                {
+                  text: current === "max" ? "\u2713 Max" : "Max",
+                  callback_data: "effort:max",
+                },
+                {
+                  text: current === "adaptive" ? "\u2713 Auto" : "Auto",
+                  callback_data: "effort:adaptive",
+                },
+              ],
+            ],
+          },
+        });
+      } catch {
+        /* message unchanged */
+      }
+      return;
+    }
+
+    // Handle model callbacks
+    if (data.startsWith("model:")) {
+      const model = data.slice(6);
+      if (model === "reset") {
+        setChatModel(cid, undefined);
+        await ctx.answerCallbackQuery({
+          text: `Model: ${config.model} (default)`,
+        });
+      } else {
+        const resolved = resolveModelName(model);
+        setChatModel(cid, resolved);
+        await ctx.answerCallbackQuery({
+          text: `Model: ${resolved}`,
+        });
+      }
+      const current = getChatSettings(cid).model ?? config.model;
+      const isModel = (id: string) => current.includes(id);
+      try {
+        await ctx.editMessageText(
+          `<b>Model:</b> <code>${escapeHtml(current)}</code>`,
+          {
+            parse_mode: "HTML",
+            reply_markup: {
+              inline_keyboard: [
+                [
+                  {
+                    text: isModel("sonnet") ? "\u2713 Sonnet 4.6" : "Sonnet 4.6",
+                    callback_data: "model:sonnet",
+                  },
+                  {
+                    text: isModel("opus") ? "\u2713 Opus 4.6" : "Opus 4.6",
+                    callback_data: "model:opus",
+                  },
+                ],
+                [
+                  {
+                    text: isModel("haiku") ? "\u2713 Haiku 4.5" : "Haiku 4.5",
+                    callback_data: "model:haiku",
+                  },
+                  { text: "Reset to default", callback_data: "model:reset" },
+                ],
+              ],
+            },
+          },
+        );
+      } catch {
+        /* message unchanged */
+      }
+      return;
+    }
+
+    // Forward other callbacks to Claude
+    handleCallbackQuery(ctx, bot, config);
+  });
+}