talon-agent 5.4.1 → 5.5.1

package/src/frontend/telegram/formatting.ts

@@ -89,6 +89,36 @@ function applyInlineFormatting(input: string, urls: string[]): string {
   return out;
 }
 
+/**
+ * Block-level passes over already-escaped text: ATX headings → bold lines,
+ * runs of `> ` lines → one `<blockquote>`. Placeholders for code are opaque
+ * `\x00…\x00` tokens, so a `#` inside a fenced block is never seen here.
+ */
+function applyBlockFormatting(input: string): string {
+  const lines = input.split("\n");
+  const out: string[] = [];
+  let quote: string[] | null = null;
+  const flushQuote = () => {
+    if (quote) out.push(`<blockquote>${quote.join("\n")}</blockquote>`);
+    quote = null;
+  };
+  for (const line of lines) {
+    const quoted = /^&gt;[ \t]?(.*)$/.exec(line);
+    if (quoted) {
+      (quote ??= []).push(quoted[1] ?? "");
+      continue;
+    }
+    flushQuote();
+    // `#` must be followed by whitespace to be a heading: `#993` is a
+    // reference, not a title. Trailing closing hashes (`## Title ##`) are
+    // markdown too and are dropped.
+    const heading = /^#{1,6}[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/.exec(line);
+    out.push(heading ? `<b>${heading[1]}</b>` : line);
+  }
+  flushQuote();
+  return out.join("\n");
+}
+
 /**
  * Convert Markdown output to Telegram-safe HTML.
  *
@@ -145,6 +175,15 @@ export function markdownToTelegramHtml(text: string): string {
   // oxlint-disable-next-line no-control-regex
   processed = processed.replace(/[^`\x00]+/g, (segment) => escapeHtml(segment));
 
+  // Step 3b: Block-level markdown. Telegram HTML has no headings, so an
+  // ATX heading becomes a bold line — the alternative is the `###` going
+  // out raw, and `# Title` alone turns `#Title` into a hashtag entity.
+  // Only `#` followed by whitespace is a heading: `#993` is a PR/hashtag
+  // reference and stays literal. Runs of `> ` lines become a blockquote,
+  // which Telegram does render. The text is already escaped here, so the
+  // quote marker is `&gt;`.
+  processed = applyBlockFormatting(processed);
+
   // Step 4: Apply inline formatting, but only keep it if the result is
   // actually parseable. `processed` at this point holds escaped text plus
   // tag-free placeholders, so it is a safe unformatted fallback.

package/src/frontend/telegram/handlers/access.ts

@@ -151,6 +151,47 @@ export async function isAccessAllowed(
   return false;
 }
 
+/**
+ * True when the update is a /command or an inline-button press.
+ *
+ * Both are handled by `bot.command` / `bot.callbackQuery` handlers that
+ * run before — and independently of — the message handlers, so the
+ * message-path access check never sees them.
+ */
+export function isCommandOrCallback(ctx: Context): boolean {
+  if (ctx.callbackQuery) return true;
+  const msg = ctx.message ?? ctx.editedMessage;
+  if (!msg) return false;
+  const entities = msg.entities ?? msg.caption_entities ?? [];
+  return entities.some((e) => e.type === "bot_command" && e.offset === 0);
+}
+
+/**
+ * Gate every /command and button press behind the same access check as
+ * ordinary messages (denylist, DM whitelist, group admin membership).
+ *
+ * Without this, a sender outside `allowedUsers` who DMs the bot is refused
+ * for plain text but can still run /model, /settings, /status, /mesh,
+ * /plugins, /memory and press any inline button, because those handlers
+ * are registered with grammy directly and never pass through
+ * `isAccessAllowed`. Must be installed BEFORE registerCommands and
+ * registerCallbacks so it sees the update first.
+ */
+export function registerCommandAccessGate(bot: Bot): void {
+  bot.use(async (ctx, next) => {
+    if (!isCommandOrCallback(ctx)) return next();
+    if (await isAccessAllowed(ctx, bot)) return next();
+    if (ctx.callbackQuery) {
+      try {
+        await ctx.answerCallbackQuery();
+      } catch {
+        /* stale query — ignore */
+      }
+    }
+    // Dropped: not passed to any command or callback handler.
+  });
+}
+
 /**
  * Maximum length of an unauthorized message body to retain in logs.
  * Keeps abusive payloads (large pastes, attachment captions etc.) bounded

package/src/frontend/telegram/handlers/index.ts

@@ -17,6 +17,7 @@ export {
   setAccessControl,
   shouldHandleInGroup,
   extractUnauthorizedPreview,
+  registerCommandAccessGate,
 } from "./access.js";
 export {
   getSenderName,

package/src/frontend/telegram/index.ts

@@ -21,7 +21,10 @@ import {
   setAdminUserId,
   telegramCommandMenu,
 } from "./commands/index.js";
-import { setAccessControl } from "./handlers/index.js";
+import {
+  setAccessControl,
+  registerCommandAccessGate,
+} from "./handlers/index.js";
 import { registerMiddleware } from "./middleware.js";
 import { confirmUpdates } from "./update-offset.js";
 import { registerCallbacks } from "./callbacks/index.js";
@@ -94,6 +97,9 @@ export function createTelegramFrontend(
         adminUserId: config.adminUserId,
       });
 
+      // Gate /commands and button presses behind the DM whitelist and
+      // group check BEFORE any command/callback handler is registered.
+      registerCommandAccessGate(bot);
       registerCommands(bot, config, gateway);
       registerMiddleware(bot, config);
       registerCallbacks(bot, config, gateway);

package/src/frontend/terminal/builtins/status.ts

@@ -14,7 +14,14 @@ import {
 import { getChatSettings } from "../../../storage/chat-settings.js";
 import { getSessionInfo } from "../../../storage/sessions.js";
 import { getLoadedPlugins } from "../../../core/plugin/index.js";
-import { getPooledBackend } from "../../../core/engine/backend-controller/index.js";
+import {
+  getPoolConfig,
+  getPooledBackend,
+} from "../../../core/engine/backend-controller/index.js";
+import {
+  collectBackendUsage,
+  formatHeadroom,
+} from "../../../core/engine/backend-router/index.js";
 import type { Command, CommandContext } from "../command-registry.js";
 
 type BackendRef = CommandContext["backend"];
@@ -146,6 +153,27 @@ async function writePlan(ctx: CommandContext, be: BackendRef): Promise<void> {
       );
     }
   }
+  await writeHeadroom(ctx);
+}
+
+/**
+ * What the plan-aware router sees: one comparable figure per backend, so
+ * "why did that sub-agent run on agy?" is answerable from `/status`.
+ * Ledger-derived rows say so — they are Talon's own count, not the
+ * provider's.
+ */
+async function writeHeadroom(ctx: CommandContext): Promise<void> {
+  const entries = await collectBackendUsage(getPoolConfig() ?? undefined).catch(
+    () => [],
+  );
+  if (entries.length === 0) return;
+  ctx.renderer.writeln();
+  ctx.renderer.writeln(`  ${pc.bold("Headroom")}`);
+  for (const entry of entries) {
+    ctx.renderer.writeln(
+      `  ${(entry.label || entry.id).padEnd(14)}${pc.dim(formatHeadroom(entry.headroom))}`,
+    );
+  }
 }
 
 function writePlugins(ctx: CommandContext): void {

package/src/util/log.ts

@@ -68,6 +68,7 @@ export type LogComponent =
   | "memory"
   | "stickers"
   | "backup"
+  | "router"
   | "backend-controller";
 
 const LOG_FILE = files.log;