@llblab/pi-telegram 0.7.2 → 0.8.1

package/lib/menu-queue.ts

@@ -11,11 +11,14 @@ import * as Queue from "./queue.ts";
 
 // --- Queue Menu ---
 
+const QUEUE_ITEM_PROMPT_HTML_LIMIT = 3600;
+const QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX = "\n… [truncated]";
 type TelegramQueueMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 interface TelegramQueueMenuItem {
   chatId: number;
   replyToMessageId: number;
   isPriority: boolean;
+  priorityEmoji?: string;
   hasAttachments: boolean;
   statusSummary: string;
   promptText: string;
@@ -40,6 +43,7 @@ function toTelegramQueueMenuItems<Context>(
       chatId: item.chatId,
       replyToMessageId: item.replyToMessageId,
       isPriority: item.queueLane === "priority",
+      priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
       hasAttachments:
         item.kind === "prompt" && item.queuedAttachments.length > 0,
       statusSummary: item.statusSummary,
@@ -53,7 +57,11 @@ function buildTelegramQueueMenuReplyMarkup(
   const backRow = [{ text: "⬆️ Main menu", callback_data: "menu:back" }];
   if (items.length === 0) return { inline_keyboard: [backRow] };
   const rows = items.map(function buildTelegramQueueMenuRow(item, index) {
-    const prefix = item.isPriority ? "⚡ " : item.hasAttachments ? "📎 " : "";
+    const prefix = item.isPriority
+      ? `${item.priorityEmoji ?? "⚡"} `
+      : item.hasAttachments
+        ? "📎 "
+        : "";
     const label = `${index + 1}. ${prefix}${item.statusSummary}`;
     return [
       {
@@ -82,21 +90,44 @@ function findTelegramQueueMenuItem(
     return item.chatId === chatId && item.replyToMessageId === replyToMessageId;
   });
 }
+function escapeTelegramQueueMenuHtmlChar(char: string): string {
+  if (char === "&") return "&amp;";
+  if (char === "<") return "&lt;";
+  if (char === ">") return "&gt;";
+  return char;
+}
 function escapeTelegramQueueMenuHtml(text: string): string {
-  return text
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
+  return Array.from(text).map(escapeTelegramQueueMenuHtmlChar).join("");
+}
+function escapeTelegramQueueMenuHtmlPreview(text: string): string {
+  const suffix = escapeTelegramQueueMenuHtml(QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX);
+  let escaped = "";
+  let truncated = false;
+  for (const char of text) {
+    const next = escapeTelegramQueueMenuHtmlChar(char);
+    if (
+      escaped.length + next.length + suffix.length >
+      QUEUE_ITEM_PROMPT_HTML_LIMIT
+    ) {
+      truncated = true;
+      break;
+    }
+    escaped += next;
+  }
+  return truncated ? escaped + suffix : escaped;
 }
 function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
-  return escapeTelegramQueueMenuHtml(item.promptText);
+  return `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
 }
 function buildTelegramQueueItemSubmenuReplyMarkup(
   chatId: number,
   replyToMessageId: number,
   isPriority: boolean,
+  priorityEmoji?: string,
 ): TelegramQueueMenuReplyMarkup {
-  const priorityLabel = isPriority ? "🐢 Deprioritize" : "⚡ Prioritize";
+  const priorityLabel = isPriority
+    ? `🐢 Deprioritize ${priorityEmoji ?? "⚡"}`
+    : "⚡ Prioritize";
   return {
     inline_keyboard: [
       [{ text: "⬆️ Back", callback_data: "queue:list" }],
@@ -108,8 +139,29 @@ function buildTelegramQueueItemSubmenuReplyMarkup(
       ],
       [
         {
-          text: "❌ Cancel",
-          callback_data: `queue:cancel:${chatId}:${replyToMessageId}`,
+          text: "🗑 Delete",
+          callback_data: `queue:delete:${chatId}:${replyToMessageId}`,
+        },
+      ],
+    ],
+  };
+}
+function buildTelegramQueueDeleteConfirmationReplyMarkup(
+  chatId: number,
+  replyToMessageId: number,
+): TelegramQueueMenuReplyMarkup {
+  return {
+    inline_keyboard: [
+      [
+        {
+          text: "🗑 Yes, delete",
+          callback_data: `queue:confirm-delete:${chatId}:${replyToMessageId}`,
+        },
+      ],
+      [
+        {
+          text: "❌ No",
+          callback_data: `queue:keep:${chatId}:${replyToMessageId}`,
         },
       ],
     ],
@@ -186,14 +238,38 @@ async function handleTelegramQueueMenuCallback<Context>(
     );
     return true;
   }
-  const cancelMatch = data.match(/^queue:cancel:(\d+):(\d+)$/);
-  if (cancelMatch) {
-    await handleTelegramQueueMenuCancel(
+  const deleteMatch = data.match(/^queue:(?:delete|cancel):(\d+):(\d+)$/);
+  if (deleteMatch) {
+    await handleTelegramQueueMenuDeleteRequest(
       callbackQueryId,
       replyChatId,
       replyMessageId,
-      Number(cancelMatch[1]),
-      Number(cancelMatch[2]),
+      Number(deleteMatch[1]),
+      Number(deleteMatch[2]),
+      deps,
+    );
+    return true;
+  }
+  const keepMatch = data.match(/^queue:keep:(\d+):(\d+)$/);
+  if (keepMatch) {
+    await handleTelegramQueueMenuKeep(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      Number(keepMatch[1]),
+      Number(keepMatch[2]),
+      deps,
+    );
+    return true;
+  }
+  const confirmDeleteMatch = data.match(/^queue:confirm-delete:(\d+):(\d+)$/);
+  if (confirmDeleteMatch) {
+    await handleTelegramQueueMenuConfirmDelete(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      Number(confirmDeleteMatch[1]),
+      Number(confirmDeleteMatch[2]),
       ctx,
       deps,
     );
@@ -204,8 +280,8 @@ async function handleTelegramQueueMenuCallback<Context>(
 function getTelegramQueueMenuListText(
   items: readonly TelegramQueueMenuItem[],
 ): string {
-  if (items.length === 0) return "<b>Queue is empty.</b>";
-  return "<b>Queue:</b>";
+  if (items.length === 0) return "<b>⏳ Queue is empty.</b>";
+  return "<b>⏳ Queue:</b>";
 }
 async function updateTelegramQueueMenuList<Context>(
   callbackQueryId: string,
@@ -258,7 +334,12 @@ async function handleTelegramQueueMenuPick<Context>(
     replyChatId,
     replyMessageId,
     getTelegramQueueMenuItemText(item),
-    buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, item.isPriority),
+    buildTelegramQueueItemSubmenuReplyMarkup(
+      chatId,
+      msgId,
+      item.isPriority,
+      item.priorityEmoji,
+    ),
   );
   await deps.answerCallbackQuery(callbackQueryId);
 }
@@ -288,14 +369,74 @@ async function handleTelegramQueueMenuPriority<Context>(
     replyChatId,
     replyMessageId,
     getTelegramQueueMenuItemText(item),
-    buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, newPriority),
+    buildTelegramQueueItemSubmenuReplyMarkup(
+      chatId,
+      msgId,
+      newPriority,
+      updated?.priorityEmoji ?? item.priorityEmoji,
+    ),
   );
   await deps.answerCallbackQuery(
     callbackQueryId,
     newPriority ? "Prioritized." : "Deprioritized.",
   );
 }
-async function handleTelegramQueueMenuCancel<Context>(
+async function handleTelegramQueueMenuDeleteRequest<Context>(
+  callbackQueryId: string,
+  replyChatId: number,
+  replyMessageId: number,
+  chatId: number,
+  msgId: number,
+  deps: TelegramQueueMenuCallbackDeps<Context>,
+): Promise<void> {
+  const item = deps.findItem(chatId, msgId);
+  if (!item) {
+    return refreshStaleTelegramQueueMenuItem(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      deps,
+    );
+  }
+  await deps.updateQueueMessage(
+    replyChatId,
+    replyMessageId,
+    "<b>Delete this queued prompt?</b>",
+    buildTelegramQueueDeleteConfirmationReplyMarkup(chatId, msgId),
+  );
+  await deps.answerCallbackQuery(callbackQueryId);
+}
+async function handleTelegramQueueMenuKeep<Context>(
+  callbackQueryId: string,
+  replyChatId: number,
+  replyMessageId: number,
+  chatId: number,
+  msgId: number,
+  deps: TelegramQueueMenuCallbackDeps<Context>,
+): Promise<void> {
+  const item = deps.findItem(chatId, msgId);
+  if (!item) {
+    return refreshStaleTelegramQueueMenuItem(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      deps,
+    );
+  }
+  await deps.updateQueueMessage(
+    replyChatId,
+    replyMessageId,
+    getTelegramQueueMenuItemText(item),
+    buildTelegramQueueItemSubmenuReplyMarkup(
+      chatId,
+      msgId,
+      item.isPriority,
+      item.priorityEmoji,
+    ),
+  );
+  await deps.answerCallbackQuery(callbackQueryId, "Kept in queue.");
+}
+async function handleTelegramQueueMenuConfirmDelete<Context>(
   callbackQueryId: string,
   replyChatId: number,
   replyMessageId: number,
@@ -311,7 +452,7 @@ async function handleTelegramQueueMenuCancel<Context>(
     replyChatId,
     replyMessageId,
     deps,
-    removed ? "Removed from queue." : "Item not found.",
+    removed ? "Deleted from queue." : "Item not found.",
   );
 }
 

package/lib/menu-status.ts

@@ -160,7 +160,7 @@ export function buildStatusReplyMarkup(
   }
   rows.push([
     {
-      text: `🔢 Queue: ${queueItemCount}`,
+      text: `⏳ Queue: ${queueItemCount}`,
       callback_data: "menu:queue",
     },
   ]);

package/lib/{attachments.ts → outbound-attachments.ts}

@@ -1,7 +1,7 @@
 /**
- * Telegram attachment domain helpers
+ * Telegram outbound attachment helpers
  * Zones: telegram outbound, pi agent tool, filesystem
- * Owns telegram_attach registration, attachment queueing, and attachment delivery so Telegram file output stays in one domain module
+ * Owns telegram_attach registration, outbound attachment queueing, and delivery so Telegram file output stays in one domain module
  */
 
 import { stat } from "node:fs/promises";
@@ -16,7 +16,7 @@ const MAX_ATTACHMENTS_PER_TURN = 10;
 
 export const TELEGRAM_OUTBOUND_ATTACHMENT_DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
 
-export function getTelegramAttachmentByteLimitFromEnv(
+export function getTelegramOutboundAttachmentByteLimitFromEnv(
   env: NodeJS.ProcessEnv,
   names: string[],
   defaultValue = TELEGRAM_OUTBOUND_ATTACHMENT_DEFAULT_MAX_BYTES,
@@ -31,17 +31,17 @@ export function getTelegramAttachmentByteLimitFromEnv(
 }
 
 export const TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES =
-  getTelegramAttachmentByteLimitFromEnv(process.env, [
+  getTelegramOutboundAttachmentByteLimitFromEnv(process.env, [
     "PI_TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES",
     "TELEGRAM_MAX_ATTACHMENT_SIZE_BYTES",
   ]);
 
-export interface TelegramAttachmentToolResult {
+export interface TelegramOutboundAttachmentToolResult {
   content: Array<{ type: "text"; text: string }>;
   details: { paths: string[] };
 }
 
-export interface TelegramAttachmentRuntimeEventRecorderPort {
+export interface TelegramOutboundAttachmentRuntimeEventRecorderPort {
   recordRuntimeEvent?: (
     category: string,
     error: unknown,
@@ -49,28 +49,28 @@ export interface TelegramAttachmentRuntimeEventRecorderPort {
   ) => void;
 }
 
-export interface TelegramAttachmentToolRegistrationDeps extends TelegramAttachmentRuntimeEventRecorderPort {
+export interface TelegramOutboundAttachmentToolRegistrationDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
   maxAttachmentsPerTurn?: number;
   maxAttachmentSizeBytes?: number;
-  getActiveTurn: () => TelegramAttachmentQueueTargetView | undefined;
+  getActiveTurn: () => TelegramOutboundAttachmentQueueTargetView | undefined;
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
 }
 
-export interface TelegramQueuedAttachmentView {
+export interface TelegramQueuedOutboundAttachmentView {
   path: string;
   fileName: string;
 }
 
-export interface TelegramAttachmentQueueTargetView {
-  queuedAttachments: TelegramQueuedAttachmentView[];
+export interface TelegramOutboundAttachmentQueueTargetView {
+  queuedAttachments: TelegramQueuedOutboundAttachmentView[];
 }
 
-export interface TelegramQueuedAttachmentTurnView extends TelegramAttachmentQueueTargetView {
+export interface TelegramQueuedOutboundAttachmentTurnView extends TelegramOutboundAttachmentQueueTargetView {
   chatId: number;
   replyToMessageId: number;
 }
 
-function isTelegramPhotoAttachmentPath(path: string): boolean {
+function isTelegramOutboundPhotoAttachmentPath(path: string): boolean {
   const normalized = path.toLowerCase();
   return (
     normalized.endsWith(".jpg") ||
@@ -81,7 +81,7 @@ function isTelegramPhotoAttachmentPath(path: string): boolean {
   );
 }
 
-function formatTelegramAttachmentSizeLimitError(
+function formatTelegramOutboundAttachmentSizeLimitError(
   size: number,
   maxSize: number,
   path?: string,
@@ -90,14 +90,14 @@ function formatTelegramAttachmentSizeLimitError(
   return path ? `${message}: ${path}` : message;
 }
 
-function formatTelegramAttachmentToolResultText(count: number): string {
+function formatTelegramOutboundAttachmentToolResultText(count: number): string {
   // Pi's compact tool rows need an empty first line to visually separate header and result
   return ["", `Queued ${count} Telegram attachment(s).`].join("\n");
 }
 
-export function registerTelegramAttachmentTool(
+export function registerTelegramOutboundAttachmentTool(
   pi: ExtensionAPI,
-  deps: TelegramAttachmentToolRegistrationDeps,
+  deps: TelegramOutboundAttachmentToolRegistrationDeps,
 ): void {
   const maxAttachmentsPerTurn =
     deps.maxAttachmentsPerTurn ?? MAX_ATTACHMENTS_PER_TURN;
@@ -120,7 +120,7 @@ export function registerTelegramAttachmentTool(
     }),
     async execute(_toolCallId, params) {
       try {
-        return await queueTelegramAttachments({
+        return await queueTelegramOutboundAttachments({
           activeTurn: deps.getActiveTurn(),
           paths: params.paths,
           maxAttachmentsPerTurn,
@@ -138,7 +138,7 @@ export function registerTelegramAttachmentTool(
   });
 }
 
-export interface TelegramQueuedAttachmentDeliveryDeps {
+export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
   sendMultipart: (
     method: string,
     fields: Record<string, string>,
@@ -160,13 +160,13 @@ export interface TelegramQueuedAttachmentDeliveryDeps {
   maxAttachmentSizeBytes?: number;
 }
 
-export async function queueTelegramAttachments(options: {
-  activeTurn: TelegramAttachmentQueueTargetView | undefined;
+export async function queueTelegramOutboundAttachments(options: {
+  activeTurn: TelegramOutboundAttachmentQueueTargetView | undefined;
   paths: string[];
   maxAttachmentsPerTurn: number;
   maxAttachmentSizeBytes?: number;
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
-}): Promise<TelegramAttachmentToolResult> {
+}): Promise<TelegramOutboundAttachmentToolResult> {
   if (!options.activeTurn) {
     throw new Error(
       "telegram_attach can only be used while replying to an active Telegram turn",
@@ -180,7 +180,7 @@ export async function queueTelegramAttachments(options: {
       `Attachment limit reached (${options.maxAttachmentsPerTurn})`,
     );
   }
-  const pendingAttachments: TelegramQueuedAttachmentView[] = [];
+  const pendingAttachments: TelegramQueuedOutboundAttachmentView[] = [];
   for (const inputPath of options.paths) {
     const stats = await (options.statPath ?? stat)(inputPath);
     if (!stats.isFile()) {
@@ -192,7 +192,7 @@ export async function queueTelegramAttachments(options: {
       stats.size > options.maxAttachmentSizeBytes
     ) {
       throw new Error(
-        formatTelegramAttachmentSizeLimitError(
+        formatTelegramOutboundAttachmentSizeLimitError(
           stats.size,
           options.maxAttachmentSizeBytes,
           inputPath,
@@ -210,20 +210,20 @@ export async function queueTelegramAttachments(options: {
     content: [
       {
         type: "text",
-        text: formatTelegramAttachmentToolResultText(added.length),
+        text: formatTelegramOutboundAttachmentToolResultText(added.length),
       },
     ],
     details: { paths: added },
   };
 }
 
-export function createTelegramQueuedAttachmentSender(
-  deps: TelegramQueuedAttachmentDeliveryDeps,
+export function createTelegramQueuedOutboundAttachmentSender(
+  deps: TelegramQueuedOutboundAttachmentDeliveryDeps,
 ) {
   return async function sendQueuedAttachments(
-    turn: TelegramQueuedAttachmentTurnView,
+    turn: TelegramQueuedOutboundAttachmentTurnView,
   ): Promise<void> {
-    await sendQueuedTelegramAttachments(turn, {
+    await sendQueuedTelegramOutboundAttachments(turn, {
       ...deps,
       maxAttachmentSizeBytes:
         deps.maxAttachmentSizeBytes ?? TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES,
@@ -231,9 +231,9 @@ export function createTelegramQueuedAttachmentSender(
   };
 }
 
-export async function sendQueuedTelegramAttachments(
-  turn: TelegramQueuedAttachmentTurnView,
-  deps: TelegramQueuedAttachmentDeliveryDeps,
+export async function sendQueuedTelegramOutboundAttachments(
+  turn: TelegramQueuedOutboundAttachmentTurnView,
+  deps: TelegramQueuedOutboundAttachmentDeliveryDeps,
 ): Promise<void> {
   for (const attachment of turn.queuedAttachments) {
     try {
@@ -241,14 +241,14 @@ export async function sendQueuedTelegramAttachments(
         const stats = await (deps.statPath ?? stat)(attachment.path);
         if (stats.size > deps.maxAttachmentSizeBytes) {
           throw new Error(
-            formatTelegramAttachmentSizeLimitError(
+            formatTelegramOutboundAttachmentSizeLimitError(
               stats.size,
               deps.maxAttachmentSizeBytes,
             ),
           );
         }
       }
-      const isPhoto = isTelegramPhotoAttachmentPath(attachment.path);
+      const isPhoto = isTelegramOutboundPhotoAttachmentPath(attachment.path);
       const method = isPhoto ? "sendPhoto" : "sendDocument";
       const fieldName = isPhoto ? "photo" : "document";
       const replyParameters = buildTelegramMultipartReplyParameters(