talon-agent 1.0.0 → 1.2.0

package/src/frontend/telegram/handlers.ts

@@ -18,7 +18,10 @@ import {
 } from "../../core/prompt-builder.js";
 import { writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { appendDailyLog, appendDailyLogResponse } from "../../storage/daily-log.js";
+import {
+  appendDailyLog,
+  appendDailyLogResponse,
+} from "../../storage/daily-log.js";
 import { setMessageFilePath } from "../../storage/history.js";
 import { addMedia } from "../../storage/media-index.js";
 import { recordMessageProcessed, recordError } from "../../util/watchdog.js";
@@ -40,9 +43,7 @@ function trackDmUser(
     const evictCount = Math.floor(KNOWN_DM_USERS_CAP * 0.1);
     const iter = knownDmUsers.values();
     for (let i = 0; i < evictCount; i++) {
-      const val = iter.next();
-      if (val.done) break;
-      knownDmUsers.delete(val.value);
+      knownDmUsers.delete(iter.next().value as number);
     }
   }
   knownDmUsers.add(senderId);
@@ -51,6 +52,51 @@ function trackDmUser(
   appendDailyLog("System", `New DM user: ${senderName}${tag} [id:${senderId}]`);
 }
 
+// ── Access control ──────────────────────────────────────────────────────────
+
+let allowedUserIds: Set<number> | null = null; // null = no whitelist (allow all)
+let adminId = 0;
+const verifiedGroups = new Map<number, boolean>(); // chatId → admin is member
+
+export function setAccessControl(cfg: {
+  allowedUsers?: number[];
+  adminUserId?: number;
+}): void {
+  allowedUserIds = cfg.allowedUsers?.length ? new Set(cfg.allowedUsers) : null;
+  adminId = cfg.adminUserId ?? 0;
+}
+
+/**
+ * Check if a DM user is allowed. Returns true if no whitelist is set.
+ */
+function isDmAllowed(senderId: number | undefined): boolean {
+  if (!allowedUserIds) return true;
+  return senderId !== undefined && allowedUserIds.has(senderId);
+}
+
+/**
+ * Check if the admin is a member of a group. Caches results for 10 minutes.
+ */
+async function isAdminInGroup(bot: Bot, chatId: number): Promise<boolean> {
+  if (!adminId) return true; // no admin configured, allow all groups
+  const cached = verifiedGroups.get(chatId);
+  if (cached !== undefined) return cached;
+
+  try {
+    const member = await bot.api.getChatMember(chatId, adminId);
+    const isMember = !["left", "kicked"].includes(member.status);
+    verifiedGroups.set(chatId, isMember);
+    // Expire cache after 10 minutes
+    setTimeout(() => verifiedGroups.delete(chatId), 10 * 60 * 1000);
+    return isMember;
+  } catch {
+    // API error (e.g. bot can't query members) — deny by default
+    verifiedGroups.set(chatId, false);
+    setTimeout(() => verifiedGroups.delete(chatId), 10 * 60 * 1000);
+    return false;
+  }
+}
+
 // ── Shared utilities ─────────────────────────────────────────────────────────
 
 export function shouldHandleInGroup(ctx: Context): boolean {
@@ -61,12 +107,82 @@ export function shouldHandleInGroup(ctx: Context): boolean {
   const botUser = ctx.me.username;
   // Word-boundary match — @botname must not be followed by alphanumeric/underscore
   const mentioned =
-    botUser &&
-    new RegExp(`@${botUser}(?![a-zA-Z0-9_])`, "i").test(text);
+    botUser && new RegExp(`@${botUser}(?![a-zA-Z0-9_])`, "i").test(text);
   const repliedToBot = ctx.message.reply_to_message?.from?.id === ctx.me.id;
   return !!(mentioned || repliedToBot);
 }
 
+// Rate-limit unauthorized access warnings (one per user/group per 10 minutes)
+const unauthorizedCooldown = new Map<string, number>();
+const UNAUTHORIZED_COOLDOWN_MS = 10 * 60 * 1000;
+
+/**
+ * Full access check: DM whitelist + group admin membership.
+ * Returns true if the message should be processed.
+ * Warns unauthorized users and notifies the admin.
+ */
+export async function isAccessAllowed(
+  ctx: Context,
+  bot: Bot,
+): Promise<boolean> {
+  if (!ctx.chat) return false;
+  const isGroup = ctx.chat.type === "group" || ctx.chat.type === "supergroup";
+
+  if (!isGroup) {
+    if (isDmAllowed(ctx.from?.id)) return true;
+    await notifyUnauthorized(bot, ctx, "dm");
+    return false;
+  }
+
+  if (await isAdminInGroup(bot, ctx.chat.id)) return true;
+  await notifyUnauthorized(bot, ctx, "group");
+  return false;
+}
+
+async function notifyUnauthorized(
+  bot: Bot,
+  ctx: Context,
+  type: "dm" | "group",
+): Promise<void> {
+  const key = type === "dm" ? `dm:${ctx.from?.id}` : `group:${ctx.chat?.id}`;
+  const now = Date.now();
+  const lastWarned = unauthorizedCooldown.get(key);
+  if (lastWarned && now - lastWarned < UNAUTHORIZED_COOLDOWN_MS) return;
+  unauthorizedCooldown.set(key, now);
+
+  const sender = getSenderName(ctx.from);
+  const username = ctx.from?.username ? ` (@${ctx.from.username})` : "";
+  const userId = ctx.from?.id ?? "unknown";
+
+  // Warn the user
+  try {
+    await bot.api.sendMessage(
+      ctx.chat!.id,
+      "⚠️ Unauthorized access. This bot is private. This attempt has been reported to the bot owner.",
+    );
+  } catch {
+    /* can't send — ignore */
+  }
+
+  // Notify admin
+  if (adminId) {
+    const detail =
+      type === "dm"
+        ? `🚨 Unauthorized DM from ${sender}${username} [id:${userId}]`
+        : `🚨 Unauthorized group access: "${(ctx.chat as { title?: string })?.title ?? ctx.chat!.id}" [id:${ctx.chat!.id}] by ${sender}${username}`;
+    try {
+      await bot.api.sendMessage(adminId, detail);
+    } catch {
+      /* admin unreachable — ignore */
+    }
+  }
+
+  logWarn(
+    "access",
+    `Unauthorized ${type}: ${sender}${username} [id:${userId}] in chat ${ctx.chat!.id}`,
+  );
+}
+
 export function getSenderName(
   from: { first_name?: string; last_name?: string } | undefined,
 ): string {
@@ -95,23 +211,31 @@ export function getReplyContext(
 ): string {
   if (!replyMsg) return "";
 
-  const author = replyMsg.from?.id === botId
-    ? "bot"
-    : [replyMsg.from?.first_name, replyMsg.from?.last_name]
-        .filter(Boolean)
-        .join(" ") || "User";
+  const author =
+    replyMsg.from?.id === botId
+      ? "bot"
+      : [replyMsg.from?.first_name, replyMsg.from?.last_name]
+          .filter(Boolean)
+          .join(" ") || "User";
   const text = replyMsg.text || replyMsg.caption || "";
   const msgIdTag = replyMsg.message_id ? ` msg_id:${replyMsg.message_id}` : "";
 
   // Detect media type
-  const mediaType = replyMsg.photo ? "photo"
-    : replyMsg.video ? "video"
-    : replyMsg.document ? "document"
-    : replyMsg.voice ? "voice"
-    : replyMsg.audio ? "audio"
-    : replyMsg.sticker ? "sticker"
-    : replyMsg.animation ? "animation"
-    : null;
+  const mediaType = replyMsg.photo
+    ? "photo"
+    : replyMsg.video
+      ? "video"
+      : replyMsg.document
+        ? "document"
+        : replyMsg.voice
+          ? "voice"
+          : replyMsg.audio
+            ? "audio"
+            : replyMsg.sticker
+              ? "sticker"
+              : replyMsg.animation
+                ? "animation"
+                : null;
   const mediaPart = mediaType ? ` [${mediaType}]` : "";
 
   // Build context — always include if there's a message_id (even if no text)
@@ -127,7 +251,16 @@ export function getReplyContext(
  * line pointing to the saved file so Claude can see it. Returns "" if no photo.
  */
 async function downloadReplyPhoto(
-  replyMsg: { photo?: { file_id: string; file_unique_id: string; width?: number; height?: number }[] } | undefined,
+  replyMsg:
+    | {
+        photo?: {
+          file_id: string;
+          file_unique_id: string;
+          width?: number;
+          height?: number;
+        }[];
+      }
+    | undefined,
   bot: Bot,
   config: TalonConfig,
 ): Promise<string> {
@@ -143,7 +276,10 @@ async function downloadReplyPhoto(
     );
     return `[Replied-to message contains a photo saved to: ${savedPath} — read it to view]\n`;
   } catch (err) {
-    logWarn("bot", `Failed to download reply photo: ${err instanceof Error ? err.message : err}`);
+    logWarn(
+      "bot",
+      `Failed to download reply photo: ${err instanceof Error ? err.message : err}`,
+    );
     return "";
   }
 }
@@ -191,26 +327,39 @@ async function downloadTelegramFile(
   const MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024;
   const contentLength = resp.headers.get("content-length");
   if (contentLength && parseInt(contentLength, 10) > MAX_DOWNLOAD_BYTES) {
-    throw new Error(`File too large (${Math.round(parseInt(contentLength, 10) / 1024 / 1024)}MB, max 50MB)`);
+    throw new Error(
+      `File too large (${Math.round(parseInt(contentLength, 10) / 1024 / 1024)}MB, max 50MB)`,
+    );
   }
 
   const buffer = Buffer.from(await resp.arrayBuffer());
-  if (buffer.length === 0) throw new Error("Downloaded file is empty (0 bytes)");
+  if (buffer.length === 0)
+    throw new Error("Downloaded file is empty (0 bytes)");
 
   // Validate image files — prevent saving HTML/garbage as .jpg/.png
   // (corrupt "images" poison the Claude session permanently on resume)
   const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".webp"];
-  const isImageExt = imageExts.some((ext) => fileName.toLowerCase().endsWith(ext));
+  const isImageExt = imageExts.some((ext) =>
+    fileName.toLowerCase().endsWith(ext),
+  );
   if (isImageExt) {
     const m = buffer.subarray(0, 16);
     const validImage =
-      (m[0] === 0xFF && m[1] === 0xD8) || // JPEG
-      (m[0] === 0x89 && m[1] === 0x50 && m[2] === 0x4E && m[3] === 0x47) || // PNG
+      (m[0] === 0xff && m[1] === 0xd8) || // JPEG
+      (m[0] === 0x89 && m[1] === 0x50 && m[2] === 0x4e && m[3] === 0x47) || // PNG
       (m[0] === 0x47 && m[1] === 0x49 && m[2] === 0x46) || // GIF
-      (m[0] === 0x52 && m[1] === 0x49 && m[2] === 0x46 && m[3] === 0x46 &&
-       m[8] === 0x57 && m[9] === 0x45 && m[10] === 0x42 && m[11] === 0x50); // WebP
+      (m[0] === 0x52 &&
+        m[1] === 0x49 &&
+        m[2] === 0x46 &&
+        m[3] === 0x46 &&
+        m[8] === 0x57 &&
+        m[9] === 0x45 &&
+        m[10] === 0x42 &&
+        m[11] === 0x50); // WebP
     if (!validImage) {
-      throw new Error(`File "${fileName}" has image extension but invalid content — not saving to prevent session corruption`);
+      throw new Error(
+        `File "${fileName}" has image extension but invalid content — not saving to prevent session corruption`,
+      );
     }
   }
 
@@ -219,10 +368,6 @@ async function downloadTelegramFile(
 
   const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
   const destPath = resolve(uploadsDir, safeName);
-  // Prevent path traversal — ensure resolved path stays within uploads dir
-  if (!destPath.startsWith(resolve(uploadsDir))) {
-    throw new Error("Invalid file name");
-  }
   writeFileSync(destPath, buffer);
   return destPath;
 }
@@ -313,7 +458,10 @@ function enqueueMessage(
     // Show hourglass reaction on the queued message to indicate it's been seen
     bot.api
       .setMessageReaction(numericChatId, msg.messageId, [
-        { type: "emoji", emoji: "\u23F3" as "\uD83D\uDC4D" /* grammY wants union type */ },
+        {
+          type: "emoji",
+          emoji: "\u23F3" as "\uD83D\uDC4D" /* grammY wants union type */,
+        },
       ])
       .catch(() => {});
     existing.queuedReactionMsgIds.push(msg.messageId);
@@ -339,12 +487,14 @@ async function flushQueue(chatId: string): Promise<void> {
   messageQueues.delete(chatId);
 
   const { messages, bot, config, numericChatId, queuedReactionMsgIds } = entry;
-  if (messages.length === 0) return;
 
   // Clear hourglass reactions on queued messages now that we're processing
   for (const msgId of queuedReactionMsgIds) {
     bot.api.setMessageReaction(numericChatId, msgId, []).catch((err) => {
-      logWarn("bot", `Failed to clear reaction on msg ${msgId}: ${err instanceof Error ? err.message : err}`);
+      logWarn(
+        "bot",
+        `Failed to clear reaction on msg ${msgId}: ${err instanceof Error ? err.message : err}`,
+      );
     });
   }
 
@@ -357,12 +507,18 @@ async function flushQueue(chatId: string): Promise<void> {
       ? messages[0].prompt
       : messages.map((m) => m.prompt).join("\n\n");
 
-  const chatContext = { chatTitle: last.chatTitle, username: last.senderUsername };
+  const chatContext = {
+    chatTitle: last.chatTitle,
+    username: last.senderUsername,
+  };
   appendDailyLog(last.senderName, combinedPrompt, chatContext);
 
   try {
     await processAndReply({
-      bot, config, chatId, numericChatId,
+      bot,
+      config,
+      chatId,
+      numericChatId,
       replyToId: last.replyToId,
       messageId: last.messageId,
       prompt: combinedPrompt,
@@ -386,11 +542,17 @@ async function flushQueue(chatId: string): Promise<void> {
     // Retry once for transient errors (rate_limit, overloaded, network)
     if (classified.retryable) {
       const delayMs = classified.retryAfterMs ?? 2000;
-      log("bot", `[${chatId}] Retrying after ${classified.reason} (${delayMs}ms)...`);
+      log(
+        "bot",
+        `[${chatId}] Retrying after ${classified.reason} (${delayMs}ms)...`,
+      );
       try {
         await new Promise((r) => setTimeout(r, delayMs));
         await processAndReply({
-          bot, config, chatId, numericChatId,
+          bot,
+          config,
+          chatId,
+          numericChatId,
           replyToId: last.replyToId,
           messageId: last.messageId,
           prompt: combinedPrompt,
@@ -442,7 +604,10 @@ async function sendHtml(
     const sent = await bot.api.sendMessage(chatId, html, params);
     return sent.message_id;
   } catch (err) {
-    logWarn("bot", `HTML send failed, falling back to plain text: ${err instanceof Error ? err.message : err}`);
+    logWarn(
+      "bot",
+      `HTML send failed, falling back to plain text: ${err instanceof Error ? err.message : err}`,
+    );
     const plain = html.replace(/<[^>]+>/g, "");
     const sent = await bot.api.sendMessage(chatId, plain, {
       reply_parameters: replyToId ? { message_id: replyToId } : undefined,
@@ -497,9 +662,10 @@ function createStreamCallbacks(
 
     state.editing = true;
     try {
-      const display = accumulated.length > 3900
-        ? accumulated.slice(0, 3900) + "\u2026"
-        : accumulated;
+      const display =
+        accumulated.length > 3900
+          ? accumulated.slice(0, 3900) + "\u2026"
+          : accumulated;
 
       await bot.api.sendMessageDraft(chatId, state.draftId, display);
       if (draftsSupported === null) draftsSupported = true;
@@ -523,23 +689,20 @@ function createStreamCallbacks(
   return { onStreamDelta, onTextBlock };
 }
 
-async function deliverFinalText(
-  bot: Bot,
-  chatId: number,
-  text: string,
-  replyToId: number,
-  maxLen: number,
-): Promise<void> {
-  const chunks = splitMessage(text, maxLen);
-  for (const chunk of chunks) {
-    await sendHtml(bot, chatId, markdownToTelegramHtml(chunk), replyToId);
-  }
-}
-
 async function processAndReply(params: ProcessAndReplyParams): Promise<void> {
   const {
-    bot, config, chatId, numericChatId, replyToId, messageId,
-    prompt, senderName, isGroup, senderUsername, senderId, chatTitle,
+    bot,
+    config,
+    chatId,
+    numericChatId,
+    replyToId,
+    messageId,
+    prompt,
+    senderName,
+    isGroup,
+    senderUsername,
+    senderId,
+    chatTitle,
   } = params;
 
   const stream: StreamState = {
@@ -549,11 +712,16 @@ async function processAndReply(params: ProcessAndReplyParams): Promise<void> {
     editing: false,
   };
   // Wait 1s before starting streaming — avoids flickering on fast responses
-  const streamTimer = setTimeout(() => { stream.started = true; }, 1000);
+  const streamTimer = setTimeout(() => {
+    stream.started = true;
+  }, 1000);
 
   try {
     const { onStreamDelta, onTextBlock } = createStreamCallbacks(
-      bot, numericChatId, replyToId, stream,
+      bot,
+      numericChatId,
+      replyToId,
+      stream,
     );
 
     // Enrich prompt with sender context
@@ -576,7 +744,11 @@ async function processAndReply(params: ProcessAndReplyParams): Promise<void> {
       onStreamDelta,
       onTextBlock,
       onToolUse: (toolName, input) => {
-        if (toolName === "send" && input.type === "text" && typeof input.text === "string") {
+        if (
+          toolName === "send" &&
+          input.type === "text" &&
+          typeof input.text === "string"
+        ) {
           appendDailyLogResponse("Talon", input.text, { chatTitle });
         }
       },
@@ -586,7 +758,10 @@ async function processAndReply(params: ProcessAndReplyParams): Promise<void> {
     // Do NOT send fallback text — if Claude chose not to use send,
     // it's either choosing not to respond or outputting internal reasoning.
     if (result.bridgeMessageCount === 0 && result.text?.trim()) {
-      log("bot", `Suppressed fallback text (${result.text.length} chars) — no send tool used`);
+      log(
+        "bot",
+        `Suppressed fallback text (${result.text.length} chars) — no send tool used`,
+      );
     }
   } finally {
     clearTimeout(streamTimer);
@@ -653,7 +828,14 @@ async function handleMediaMessage(
       chatId,
       msgId: ctx.message.message_id,
       senderName: sender,
-      type: media.type as "photo" | "document" | "voice" | "video" | "animation" | "audio" | "sticker",
+      type: media.type as
+        | "photo"
+        | "document"
+        | "voice"
+        | "video"
+        | "animation"
+        | "audio"
+        | "sticker",
       filePath: savedPath,
       caption: media.caption,
       timestamp: Date.now(),
@@ -716,6 +898,7 @@ export async function handleTextMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
   if (ctx.from?.id && isUserRateLimited(ctx.from.id)) return;
 
   const chatId = String(ctx.chat.id);
@@ -755,6 +938,7 @@ export async function handlePhotoMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
 
   const photos = ctx.message.photo;
   if (!photos?.length) return;
@@ -779,6 +963,7 @@ export async function handleDocumentMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
 
   const doc = ctx.message.document;
   if (!doc) return;
@@ -806,6 +991,7 @@ export async function handleVoiceMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
 
   const voice = ctx.message.voice;
   if (!voice) return;
@@ -827,6 +1013,7 @@ export async function handleStickerMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
 
   const chatId = String(ctx.chat.id);
   const isGroup = ctx.chat.type === "group" || ctx.chat.type === "supergroup";
@@ -871,6 +1058,7 @@ export async function handleVideoMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
 
   const video = ctx.message.video;
   if (!video) return;
@@ -896,6 +1084,7 @@ export async function handleAnimationMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
 
   const anim = ctx.message.animation;
   if (!anim) return;
@@ -921,6 +1110,7 @@ export async function handleAudioMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
   if (ctx.from?.id && isUserRateLimited(ctx.from.id)) return;
 
   const audio = ctx.message.audio;
@@ -950,6 +1140,7 @@ export async function handleVideoNoteMessage(
   config: TalonConfig,
 ): Promise<void> {
   if (!ctx.message || !ctx.chat || !shouldHandleInGroup(ctx)) return;
+  if (!(await isAccessAllowed(ctx, bot))) return;
   if (ctx.from?.id && isUserRateLimited(ctx.from.id)) return;
 
   const videoNote = ctx.message.video_note;
@@ -987,11 +1178,16 @@ export async function handleCallbackQuery(
     const prompt = `[Button pressed] User clicked inline button with callback data: "${callbackData}"`;
     const replyToId = ctx.callbackQuery.message?.message_id ?? 0;
 
-    const chatTitle = isGroup ? (ctx.chat as { title?: string })?.title : undefined;
+    const chatTitle = isGroup
+      ? (ctx.chat as { title?: string })?.title
+      : undefined;
     appendDailyLog(sender, `Button: ${callbackData}`, { chatTitle });
 
     await processAndReply({
-      bot, config, chatId, numericChatId,
+      bot,
+      config,
+      chatId,
+      numericChatId,
       replyToId,
       messageId: replyToId,
       prompt,

package/src/frontend/telegram/index.ts

@@ -13,11 +13,9 @@ 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 { initUserClient, disconnectUserClient } from "./userbot.js";
 import { registerCommands, setAdminUserId } from "./commands.js";
+import { setAccessControl } from "./handlers.js";
 import { registerMiddleware } from "./middleware.js";
 import { registerCallbacks } from "./callbacks.js";
 import { log, logError } from "../../util/log.js";
@@ -36,7 +34,10 @@ export type TelegramFrontend = {
 
 // ── Factory ─────────────────────────────────────────────────────────────────
 
-export function createTelegramFrontend(config: TalonConfig, gateway: Gateway): TelegramFrontend {
+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 }));
@@ -61,12 +62,18 @@ export function createTelegramFrontend(config: TalonConfig, gateway: Gateway): T
 
     async init() {
       // Register Telegram action handler with the core gateway
-      gateway.setFrontendHandler(createTelegramActionHandler(bot, InputFile, config.botToken!, 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);
+      setAccessControl({
+        allowedUsers: config.allowedUsers,
+        adminUserId: config.adminUserId,
+      });
 
       registerCommands(bot, config);
       registerMiddleware(bot, config);
@@ -75,7 +82,10 @@ export function createTelegramFrontend(config: TalonConfig, gateway: Gateway): T
       await bot.api.deleteMyCommands();
       await bot.api.setMyCommands([
         { command: "start", description: "Introduction" },
-        { command: "settings", description: "View and change all chat settings" },
+        {
+          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" },
@@ -100,7 +110,10 @@ export function createTelegramFrontend(config: TalonConfig, gateway: Gateway): T
           })
           .catch((err) => logError("userbot", "Init failed", err));
       } else {
-        log("userbot", "TALON_API_ID/TALON_API_HASH not set -- using in-memory history only.");
+        log(
+          "userbot",
+          "TALON_API_ID/TALON_API_HASH not set -- using in-memory history only.",
+        );
       }
     },
 
@@ -119,12 +132,24 @@ export function createTelegramFrontend(config: TalonConfig, gateway: Gateway): T
     },
 
     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); }
+      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);
+      }
     },
   };
 }