talon-agent 1.0.0

package/src/frontend/telegram/helpers.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared helpers used by commands, callbacks, and the settings panel.
+ */
+
+import { escapeHtml } from "./formatting.js";
+const DEFAULT_PULSE_INTERVAL_MS = 5 * 60 * 1000;
+
+/** Parse a duration string like "30m", "2h", "1h30m" into milliseconds. */
+export function parseInterval(input: string): number | null {
+  const match = input.match(/^(?:(\d+)h)?(?:(\d+)m)?$/);
+  if (!match || (!match[1] && !match[2])) return null;
+  const hours = parseInt(match[1] || "0", 10);
+  const minutes = parseInt(match[2] || "0", 10);
+  const ms = (hours * 60 + minutes) * 60 * 1000;
+  return ms > 0 ? ms : null;
+}
+
+export function formatDuration(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+
+export function formatTokenCount(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+  return String(n);
+}
+
+export function formatBytes(bytes: number): string {
+  if (bytes >= 1_073_741_824) return `${(bytes / 1_073_741_824).toFixed(1)} GB`;
+  if (bytes >= 1_048_576) return `${(bytes / 1_048_576).toFixed(1)} MB`;
+  if (bytes >= 1_024) return `${(bytes / 1_024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+export function renderSettingsText(
+  model: string,
+  effort: string,
+  proactive: boolean,
+  pulseIntervalMs?: number,
+): string {
+  const intervalStr = pulseIntervalMs
+    ? formatDuration(pulseIntervalMs)
+    : formatDuration(DEFAULT_PULSE_INTERVAL_MS);
+  return [
+    "<b>\uD83E\uDD85 Settings</b>",
+    "",
+    `<b>Model:</b> <code>${escapeHtml(model)}</code>`,
+    `<b>Effort:</b> ${effort}`,
+    `<b>Pulse:</b> ${proactive ? "on" : "off"} (every ${intervalStr})`,
+  ].join("\n");
+}
+
+export function renderSettingsKeyboard(
+  model: string,
+  effort: string,
+  proactive: boolean,
+): Array<Array<{ text: string; callback_data: string }>> {
+  const isModel = (id: string) => model.includes(id);
+  return [
+    [
+      {
+        text: isModel("sonnet") ? "\u2713 Sonnet" : "Sonnet",
+        callback_data: "settings:model:sonnet",
+      },
+      {
+        text: isModel("opus") ? "\u2713 Opus" : "Opus",
+        callback_data: "settings:model:opus",
+      },
+      {
+        text: isModel("haiku") ? "\u2713 Haiku" : "Haiku",
+        callback_data: "settings:model:haiku",
+      },
+    ],
+    [
+      {
+        text: effort === "low" ? "\u2713 Low" : "Low",
+        callback_data: "settings:effort:low",
+      },
+      {
+        text: effort === "medium" ? "\u2713 Med" : "Med",
+        callback_data: "settings:effort:medium",
+      },
+      {
+        text: effort === "high" ? "\u2713 High" : "High",
+        callback_data: "settings:effort:high",
+      },
+      {
+        text: effort === "adaptive" ? "\u2713 Auto" : "Auto",
+        callback_data: "settings:effort:adaptive",
+      },
+    ],
+    [
+      {
+        text: proactive ? "Pulse: ON" : "Pulse: OFF",
+        callback_data: `settings:proactive:${proactive ? "off" : "on"}`,
+      },
+      { text: "Done", callback_data: "settings:done" },
+    ],
+  ];
+}

package/src/frontend/telegram/index.ts

@@ -0,0 +1,130 @@
+/**
+ * Telegram frontend factory.
+ *
+ * Encapsulates everything Telegram-specific: Bot instance, command registration,
+ * GramJS userbot, graceful shutdown. Registers its action handler with the
+ * core gateway so MCP tool calls route to Telegram API.
+ */
+
+import { Bot, InputFile } from "grammy";
+import { autoRetry } from "@grammyjs/auto-retry";
+import { apiThrottler } from "@grammyjs/transformer-throttler";
+import type { TalonConfig } from "../../util/config.js";
+import type { ContextManager } from "../../core/types.js";
+import type { Gateway } from "../../core/gateway.js";
+import { createTelegramActionHandler, sendText } from "./actions.js";
+import {
+  initUserClient,
+  disconnectUserClient,
+} from "./userbot.js";
+import { registerCommands, setAdminUserId } from "./commands.js";
+import { registerMiddleware } from "./middleware.js";
+import { registerCallbacks } from "./callbacks.js";
+import { log, logError } from "../../util/log.js";
+
+// ── Frontend interface ──────────────────────────────────────────────────────
+
+export type TelegramFrontend = {
+  context: ContextManager;
+  sendTyping: (chatId: number) => Promise<void>;
+  sendMessage: (chatId: number, text: string) => Promise<void>;
+  getBridgePort: () => number;
+  init: () => Promise<void>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+};
+
+// ── Factory ─────────────────────────────────────────────────────────────────
+
+export function createTelegramFrontend(config: TalonConfig, gateway: Gateway): TelegramFrontend {
+  const bot = new Bot(config.botToken!);
+  bot.api.config.use(apiThrottler());
+  bot.api.config.use(autoRetry({ maxRetryAttempts: 3, maxDelaySeconds: 60 }));
+
+  const context: ContextManager = {
+    acquire: (chatId: number) => gateway.setContext(chatId),
+    release: (chatId: number) => gateway.clearContext(chatId),
+    getMessageCount: (chatId: number) => gateway.getMessageCount(chatId),
+  };
+
+  return {
+    context,
+
+    sendTyping: (chatId: number) =>
+      bot.api.sendChatAction(chatId, "typing").then(() => {}),
+
+    sendMessage: async (chatId: number, text: string) => {
+      await sendText(bot, chatId, text);
+    },
+
+    getBridgePort: () => gateway.getPort(),
+
+    async init() {
+      // Register Telegram action handler with the core gateway
+      gateway.setFrontendHandler(createTelegramActionHandler(bot, InputFile, config.botToken!, gateway));
+
+      const port = await gateway.start(19876);
+      log("bot", `Gateway started on port ${port}`);
+
+      setAdminUserId(config.adminUserId);
+
+      registerCommands(bot, config);
+      registerMiddleware(bot, config);
+      registerCallbacks(bot, config);
+
+      await bot.api.deleteMyCommands();
+      await bot.api.setMyCommands([
+        { command: "start", description: "Introduction" },
+        { command: "settings", description: "View and change all chat settings" },
+        { command: "memory", description: "View what Talon remembers" },
+        { command: "status", description: "Session info, usage, and stats" },
+        { command: "ping", description: "Health check with latency" },
+        { command: "model", description: "Show or change model" },
+        { command: "effort", description: "Set thinking effort level" },
+        { command: "pulse", description: "Conversation engagement settings" },
+        { command: "reset", description: "Clear session and start fresh" },
+        { command: "restart", description: "Restart the bot (admin)" },
+        { command: "dream", description: "Force memory consolidation" },
+        { command: "plugins", description: "List loaded plugins" },
+        { command: "help", description: "All commands and features" },
+      ]);
+      log("commands", "Registered bot commands with Telegram");
+
+      const apiId = config.apiId ?? 0;
+      const apiHash = config.apiHash ?? "";
+      if (apiId && apiHash) {
+        initUserClient({ apiId, apiHash })
+          .then((ok) => {
+            if (ok) log("userbot", "Full Telegram history access enabled.");
+            else log("userbot", "Not authorized. Run: npx tsx src/login.ts");
+          })
+          .catch((err) => logError("userbot", "Init failed", err));
+      } else {
+        log("userbot", "TALON_API_ID/TALON_API_HASH not set -- using in-memory history only.");
+      }
+    },
+
+    async start() {
+      bot.catch((err: unknown) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("bot", "Unhandled bot error", err);
+        if (/unauthorized|401|not found|404/i.test(msg)) {
+          logError("bot", "Bot token appears invalid — shutting down");
+          process.exit(1);
+        }
+      });
+      await bot.start({
+        onStart: (info) => log("bot", `Talon running as @${info.username}`),
+      });
+    },
+
+    async stop() {
+      try { await bot.stop(); log("shutdown", "Bot disconnected"); }
+      catch (err) { logError("shutdown", "Bot stop error", err); }
+      try { await disconnectUserClient(); log("shutdown", "User client disconnected"); }
+      catch (err) { logError("shutdown", "User client disconnect error", err); }
+      try { await gateway.stop(); log("shutdown", "Gateway stopped"); }
+      catch (err) { logError("shutdown", "Gateway stop error", err); }
+    },
+  };
+}

package/src/frontend/telegram/middleware.ts

@@ -0,0 +1,177 @@
+/**
+ * History capture middleware — runs for ALL messages, before handlers.
+ * Records every message into the in-memory history buffer.
+ */
+
+import type { Bot } from "grammy";
+import type { TalonConfig } from "../../util/config.js";
+import { pushMessage } from "../../storage/history.js";
+import { allowChat, revokeChat } from "./userbot.js";
+import { registerChat } from "../../core/pulse.js";
+import { log } from "../../util/log.js";
+import { getSenderName } from "./handlers.js";
+import {
+  handleTextMessage,
+  handlePhotoMessage,
+  handleDocumentMessage,
+  handleVoiceMessage,
+  handleStickerMessage,
+  handleVideoMessage,
+  handleAnimationMessage,
+  handleAudioMessage,
+  handleVideoNoteMessage,
+} from "./handlers.js";
+
+export function registerMiddleware(bot: Bot, config: TalonConfig): void {
+  // ── History capture (runs for ALL messages, before handlers) ─────────────
+  bot.on("message", (ctx, next) => {
+    const chatId = String(ctx.chat.id);
+    const sender = getSenderName(ctx.from);
+    const senderId = ctx.from?.id ?? 0;
+    const msgId = ctx.message.message_id;
+    const replyToMsgId = ctx.message.reply_to_message?.message_id;
+
+    // Register this chat for userbot access
+    allowChat(ctx.chat.id);
+    // Only register groups for pulse (DMs don't need it — bot always responds)
+    const isGroup = ctx.chat.type === "group" || ctx.chat.type === "supergroup";
+    if (isGroup) registerChat(chatId);
+    const timestamp = ctx.message.date * 1000;
+
+    if ("text" in ctx.message && ctx.message.text) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.text,
+        replyToMsgId,
+        timestamp,
+      });
+    } else if ("photo" in ctx.message && ctx.message.photo) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.caption || "(photo)",
+        replyToMsgId,
+        timestamp,
+        mediaType: "photo",
+      });
+    } else if ("document" in ctx.message && ctx.message.document) {
+      const name = ctx.message.document.file_name || "file";
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.caption || `(sent ${name})`,
+        replyToMsgId,
+        timestamp,
+        mediaType: "document",
+      });
+    } else if ("voice" in ctx.message && ctx.message.voice) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: "(voice message)",
+        replyToMsgId,
+        timestamp,
+        mediaType: "voice",
+      });
+    } else if ("sticker" in ctx.message && ctx.message.sticker) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.sticker.emoji || "(sticker)",
+        replyToMsgId,
+        timestamp,
+        mediaType: "sticker",
+        stickerFileId: ctx.message.sticker.file_id,
+      });
+    } else if ("video" in ctx.message && ctx.message.video) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.caption || "(video)",
+        replyToMsgId,
+        timestamp,
+        mediaType: "video",
+      });
+    } else if ("animation" in ctx.message && ctx.message.animation) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.caption || "(GIF)",
+        replyToMsgId,
+        timestamp,
+        mediaType: "animation",
+      });
+    } else if ("audio" in ctx.message && ctx.message.audio) {
+      const title = ctx.message.audio.title || ctx.message.audio.file_name || "audio";
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: ctx.message.caption || `(audio: ${title})`,
+        replyToMsgId,
+        timestamp,
+        mediaType: "document", // treat audio like documents in history
+      });
+    } else if ("video_note" in ctx.message && ctx.message.video_note) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: "(video note)",
+        replyToMsgId,
+        timestamp,
+        mediaType: "video",
+      });
+    } else if ("location" in ctx.message && ctx.message.location) {
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: `(shared location: ${ctx.message.location.latitude}, ${ctx.message.location.longitude})`,
+        replyToMsgId,
+        timestamp,
+      });
+    } else if ("contact" in ctx.message && ctx.message.contact) {
+      const name = [ctx.message.contact.first_name, ctx.message.contact.last_name].filter(Boolean).join(" ");
+      pushMessage(chatId, {
+        msgId,
+        senderId,
+        senderName: sender,
+        text: `(shared contact: ${name})`,
+        replyToMsgId,
+        timestamp,
+      });
+    }
+
+    return next();
+  });
+
+  // ── Bot removed from group — revoke userbot access ─────────────────────
+  bot.on("my_chat_member", (ctx) => {
+    const newStatus = ctx.myChatMember.new_chat_member.status;
+    if (newStatus === "left" || newStatus === "kicked") {
+      const chatId = ctx.chat.id;
+      revokeChat(chatId);
+      log("bot", `Removed from chat ${chatId} — revoked userbot access`);
+    }
+  });
+
+  // ── Message handlers (delegated to handlers.ts) ──────────────────────────
+  bot.on("message:text", (ctx) => handleTextMessage(ctx, bot, config));
+  bot.on("message:photo", (ctx) => handlePhotoMessage(ctx, bot, config));
+  bot.on("message:document", (ctx) => handleDocumentMessage(ctx, bot, config));
+  bot.on("message:voice", (ctx) => handleVoiceMessage(ctx, bot, config));
+  bot.on("message:sticker", (ctx) => handleStickerMessage(ctx, bot, config));
+  bot.on("message:video", (ctx) => handleVideoMessage(ctx, bot, config));
+  bot.on("message:animation", (ctx) => handleAnimationMessage(ctx, bot, config));
+  bot.on("message:audio", (ctx) => handleAudioMessage(ctx, bot, config));
+  bot.on("message:video_note", (ctx) => handleVideoNoteMessage(ctx, bot, config));
+}