@llblab/pi-telegram 0.2.9 → 0.2.10

package/lib/preview.ts

@@ -23,6 +23,8 @@ export interface TelegramPreviewStateLike {
 
 export interface TelegramPreviewRuntimeState extends TelegramPreviewStateLike {
   flushTimer?: ReturnType<typeof setTimeout>;
+  flushPromise?: Promise<void>;
+  flushRequested?: boolean;
 }
 
 export interface TelegramSentPreviewMessageLike {
@@ -105,13 +107,11 @@ export async function clearTelegramPreview(
   }
 }
 
-export async function flushTelegramPreview(
+async function performTelegramPreviewFlush(
   chatId: number,
+  state: TelegramPreviewRuntimeState,
   deps: TelegramPreviewRuntimeDeps,
 ): Promise<void> {
-  const state = deps.getState();
-  if (!state) return;
-  state.flushTimer = undefined;
   const snapshot = buildTelegramPreviewSnapshot({
     state,
     maxMessageLength: deps.maxMessageLength,
@@ -166,6 +166,33 @@ export async function flushTelegramPreview(
   state.lastSentStrategy = snapshot.strategy;
 }
 
+export async function flushTelegramPreview(
+  chatId: number,
+  deps: TelegramPreviewRuntimeDeps,
+): Promise<void> {
+  const state = deps.getState();
+  if (!state) return;
+  if (state.flushPromise) {
+    state.flushRequested = true;
+    await state.flushPromise;
+    return;
+  }
+  state.flushTimer = undefined;
+  state.flushPromise = (async () => {
+    do {
+      state.flushRequested = false;
+      await performTelegramPreviewFlush(chatId, state, deps);
+    } while (deps.getState() === state && state.flushRequested);
+  })();
+  try {
+    await state.flushPromise;
+  } finally {
+    if (deps.getState() === state) {
+      state.flushPromise = undefined;
+    }
+  }
+}
+
 export async function finalizeTelegramPreview(
   chatId: number,
   deps: TelegramPreviewRuntimeDeps,

package/lib/rendering.ts

@@ -14,6 +14,10 @@ function escapeHtml(text: string): string {
     .replace(/>/g, ">");
 }
 
+function escapeHtmlAttribute(text: string): string {
+  return escapeHtml(text).replace(/"/g, """).replace(/'/g, "'");
+}
+
 // --- Plain Preview Rendering ---
 
 function splitPlainMarkdownLine(line: string, maxLength = 1500): string[] {
@@ -746,12 +750,12 @@ function renderInlineMarkdown(text: string): string {
       const renderedLabel =
         plainLabel.length > 0 ? plainLabel : link.destination;
       return makeToken(
-        `<a href="${escapeHtml(link.destination)}">${escapeHtml(renderedLabel)}</a>`,
+        `<a href="${escapeHtmlAttribute(link.destination)}">${escapeHtml(renderedLabel)}</a>`,
       );
     },
     renderAutolink: (link) => {
       return makeToken(
-        `<a href="${escapeHtml(link.destination)}">${escapeHtml(link.destination)}</a>`,
+        `<a href="${escapeHtmlAttribute(link.destination)}">${escapeHtml(link.destination)}</a>`,
       );
     },
   });
@@ -877,9 +881,14 @@ function renderMarkdownTextLines(block: string): string[] {
   return rendered;
 }
 
+function sanitizeTelegramCodeLanguage(language: string): string {
+  return language.split(/\s+/)[0]?.replace(/[^A-Za-z0-9_+.-]/g, "") ?? "";
+}
+
 function renderMarkdownCodeBlock(code: string, language?: string): string[] {
-  const open = language
-    ? `<pre><code class="language-${escapeHtml(language)}">`
+  const safeLanguage = language ? sanitizeTelegramCodeLanguage(language) : "";
+  const open = safeLanguage
+    ? `<pre><code class="language-${escapeHtmlAttribute(safeLanguage)}">`
     : "<pre><code>";
   const close = "</code></pre>";
   const maxContentLength = MAX_MESSAGE_LENGTH - open.length - close.length;
@@ -1236,6 +1245,94 @@ function chunkParagraphs(text: string): string[] {
   return chunks;
 }
 
+interface OpenHtmlTag {
+  name: string;
+  openTag: string;
+}
+
+const TELEGRAM_VOID_HTML_TAGS = new Set(["br", "hr"]);
+
+function getHtmlTagName(tag: string): string | undefined {
+  return tag.match(/^<\/?\s*([a-zA-Z][\w-]*)/)?.[1]?.toLowerCase();
+}
+
+function isHtmlClosingTag(tag: string): boolean {
+  return /^<\//.test(tag);
+}
+
+function isHtmlSelfClosingTag(tag: string): boolean {
+  return /\/\s*>$/.test(tag);
+}
+
+function getHtmlClosingTags(openTags: OpenHtmlTag[]): string {
+  return [...openTags]
+    .reverse()
+    .map((tag) => `</${tag.name}>`)
+    .join("");
+}
+
+function getHtmlOpeningTags(openTags: OpenHtmlTag[]): string {
+  return openTags.map((tag) => tag.openTag).join("");
+}
+
+function updateOpenHtmlTags(tag: string, openTags: OpenHtmlTag[]): void {
+  const name = getHtmlTagName(tag);
+  if (!name || TELEGRAM_VOID_HTML_TAGS.has(name)) return;
+  if (isHtmlClosingTag(tag)) {
+    const index = openTags.map((openTag) => openTag.name).lastIndexOf(name);
+    if (index !== -1) openTags.splice(index, 1);
+    return;
+  }
+  if (isHtmlSelfClosingTag(tag)) return;
+  openTags.push({ name, openTag: tag });
+}
+
+function chunkHtmlPreservingTags(html: string): string[] {
+  if (html.length <= MAX_MESSAGE_LENGTH) return [html];
+  const chunks: string[] = [];
+  const openTags: OpenHtmlTag[] = [];
+  const tagPattern = /<\/?[a-zA-Z][^>]*>/g;
+  let current = "";
+  let index = 0;
+  const flushCurrent = (): void => {
+    if (current.length === 0) return;
+    chunks.push(`${current}${getHtmlClosingTags(openTags)}`);
+    current = getHtmlOpeningTags(openTags);
+  };
+  const appendText = (text: string): void => {
+    let remaining = text;
+    while (remaining.length > 0) {
+      const closingTags = getHtmlClosingTags(openTags);
+      const available =
+        MAX_MESSAGE_LENGTH - current.length - closingTags.length;
+      if (available <= 0) {
+        flushCurrent();
+        continue;
+      }
+      const slice = remaining.slice(0, available);
+      current += slice;
+      remaining = remaining.slice(slice.length);
+      if (remaining.length > 0) flushCurrent();
+    }
+  };
+  const appendTag = (tag: string): void => {
+    const closingTags = getHtmlClosingTags(openTags);
+    if (current.length + tag.length + closingTags.length > MAX_MESSAGE_LENGTH) {
+      flushCurrent();
+    }
+    current += tag;
+    updateOpenHtmlTags(tag, openTags);
+  };
+  for (const match of html.matchAll(tagPattern)) {
+    appendText(html.slice(index, match.index));
+    appendTag(match[0]);
+    index = match.index + match[0].length;
+  }
+  appendText(html.slice(index));
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+
 export function renderTelegramMessage(
   text: string,
   options?: { mode?: TelegramRenderMode },
@@ -1245,7 +1342,10 @@ export function renderTelegramMessage(
     return chunkParagraphs(text).map((chunk) => ({ text: chunk }));
   }
   if (mode === "html") {
-    return [{ text, parseMode: "HTML" }];
+    return chunkHtmlPreservingTags(text).map((chunk) => ({
+      text: chunk,
+      parseMode: "HTML",
+    }));
   }
   return renderMarkdownToTelegramHtmlChunks(text).map((chunk) => ({
     text: chunk,

package/lib/turns.ts

@@ -89,6 +89,92 @@ export function buildTelegramTurnPrompt(options: {
   return prompt;
 }
 
+function splitTelegramPromptAttachmentSuffix(prompt: string): {
+  promptWithoutAttachments: string;
+  attachmentSuffix: string;
+  attachmentFiles: DownloadedTelegramTurnFileLike[];
+} {
+  const marker = "\n\nTelegram attachments were saved locally:";
+  const markerIndex = prompt.indexOf(marker);
+  if (markerIndex === -1) {
+    return {
+      promptWithoutAttachments: prompt,
+      attachmentSuffix: "",
+      attachmentFiles: [],
+    };
+  }
+  const promptWithoutAttachments = prompt.slice(0, markerIndex);
+  const attachmentSuffix = prompt.slice(markerIndex);
+  const attachmentFiles = attachmentSuffix
+    .split("\n")
+    .map((line) => line.match(/^- (.+)$/)?.[1]?.trim())
+    .filter((path): path is string => !!path)
+    .map((path) => ({ path, fileName: basename(path), isImage: false }));
+  return { promptWithoutAttachments, attachmentSuffix, attachmentFiles };
+}
+
+function buildEditedTelegramPromptText(options: {
+  existingPrompt: string;
+  telegramPrefix: string;
+  rawText: string;
+}): { text: string; attachmentFiles: DownloadedTelegramTurnFileLike[] } {
+  const { promptWithoutAttachments, attachmentSuffix, attachmentFiles } =
+    splitTelegramPromptAttachmentSuffix(options.existingPrompt);
+  const currentMessageMarker = "Current Telegram message:";
+  const currentMessageIndex = promptWithoutAttachments.lastIndexOf(
+    currentMessageMarker,
+  );
+  if (currentMessageIndex !== -1) {
+    const prefix = promptWithoutAttachments.slice(
+      0,
+      currentMessageIndex + currentMessageMarker.length,
+    );
+    const separator = options.rawText.length > 0 ? "\n" : "";
+    return {
+      text: `${prefix}${separator}${options.rawText}${attachmentSuffix}`,
+      attachmentFiles,
+    };
+  }
+  const promptText =
+    options.rawText.length > 0
+      ? `${options.telegramPrefix} ${options.rawText}`
+      : options.telegramPrefix;
+  return {
+    text: `${promptText}${attachmentSuffix}`,
+    attachmentFiles,
+  };
+}
+
+export function updateTelegramPromptTurnText(options: {
+  turn: PendingTelegramTurn;
+  telegramPrefix: string;
+  rawText: string;
+}): PendingTelegramTurn {
+  let attachmentFiles: DownloadedTelegramTurnFileLike[] = [];
+  const nextContent = options.turn.content.map((block, index) => {
+    if (index !== 0 || block.type !== "text") return block;
+    const updated = buildEditedTelegramPromptText({
+      existingPrompt: block.text,
+      telegramPrefix: options.telegramPrefix,
+      rawText: options.rawText,
+    });
+    attachmentFiles = updated.attachmentFiles;
+    return {
+      ...block,
+      text: updated.text,
+    };
+  });
+  return {
+    ...options.turn,
+    content: nextContent,
+    historyText: formatTelegramHistoryText(options.rawText, attachmentFiles),
+    statusSummary: formatTelegramTurnStatusSummary(
+      options.rawText,
+      attachmentFiles,
+    ),
+  };
+}
+
 export async function buildTelegramPromptTurn(options: {
   telegramPrefix: string;
   messages: TelegramTurnMessageLike[];

package/lib/types.ts

@@ -0,0 +1,137 @@
+/**
+ * Telegram Bot API transport shape types
+ * Centralizes Telegram update, message, callback, reaction, and response shapes used by the runtime
+ */
+
+export interface TelegramApiResponse<T> {
+  ok: boolean;
+  result?: T;
+  description?: string;
+  error_code?: number;
+}
+
+export interface TelegramUser {
+  id: number;
+  is_bot: boolean;
+  first_name: string;
+  username?: string;
+}
+
+export interface TelegramChat {
+  id: number;
+  type: string;
+}
+
+export interface TelegramPhotoSize {
+  file_id: string;
+  file_size?: number;
+}
+
+export interface TelegramDocument {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramVideo {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramAudio {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramVoice {
+  file_id: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramAnimation {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramSticker {
+  file_id: string;
+  emoji?: string;
+}
+
+export interface TelegramMessage {
+  message_id: number;
+  chat: TelegramChat;
+  from?: TelegramUser;
+  text?: string;
+  caption?: string;
+  media_group_id?: string;
+  photo?: TelegramPhotoSize[];
+  document?: TelegramDocument;
+  video?: TelegramVideo;
+  audio?: TelegramAudio;
+  voice?: TelegramVoice;
+  animation?: TelegramAnimation;
+  sticker?: TelegramSticker;
+}
+
+export interface TelegramCallbackQuery {
+  id: string;
+  from: TelegramUser;
+  message?: TelegramMessage;
+  data?: string;
+}
+
+export interface TelegramReactionTypeEmoji {
+  type: "emoji";
+  emoji: string;
+}
+
+export interface TelegramReactionTypeCustomEmoji {
+  type: "custom_emoji";
+  custom_emoji_id: string;
+}
+
+export interface TelegramReactionTypePaid {
+  type: "paid";
+}
+
+export type TelegramReactionType =
+  | TelegramReactionTypeEmoji
+  | TelegramReactionTypeCustomEmoji
+  | TelegramReactionTypePaid;
+
+export interface TelegramMessageReactionUpdated {
+  chat: TelegramChat;
+  message_id: number;
+  user?: TelegramUser;
+  actor_chat?: TelegramChat;
+  old_reaction: TelegramReactionType[];
+  new_reaction: TelegramReactionType[];
+  date: number;
+}
+
+export interface TelegramUpdate {
+  update_id: number;
+  message?: TelegramMessage;
+  edited_message?: TelegramMessage;
+  callback_query?: TelegramCallbackQuery;
+  message_reaction?: TelegramMessageReactionUpdated;
+  deleted_business_messages?: { message_ids?: unknown };
+}
+
+export interface TelegramSentMessage {
+  message_id: number;
+}
+
+export interface TelegramBotCommand {
+  command: string;
+  description: string;
+}

package/lib/updates.ts

@@ -119,7 +119,22 @@ export function getAuthorizedTelegramCallbackQuery(
 export function getAuthorizedTelegramMessage(
   update: TelegramUpdateRoutingLike,
 ): TelegramMessageLike | undefined {
-  const message = update.message || update.edited_message;
+  const message = update.message;
+  if (
+    !message ||
+    message.chat.type !== "private" ||
+    !message.from ||
+    message.from.is_bot
+  ) {
+    return undefined;
+  }
+  return message;
+}
+
+export function getAuthorizedTelegramEditedMessage(
+  update: TelegramUpdateRoutingLike,
+): TelegramMessageLike | undefined {
+  const message = update.edited_message;
   if (
     !message ||
     message.chat.type !== "private" ||
@@ -156,6 +171,11 @@ export type TelegramUpdateFlowAction =
       kind: "message";
       message: TelegramMessageLike & { from: TelegramUserLike };
       authorization: TelegramAuthorizationState;
+    }
+  | {
+      kind: "edited-message";
+      message: TelegramMessageLike & { from: TelegramUserLike };
+      authorization: TelegramAuthorizationState;
     };
 
 export function buildTelegramUpdateFlowAction(
@@ -191,6 +211,19 @@ export function buildTelegramUpdateFlowAction(
       ),
     };
   }
+  const editedMessage = getAuthorizedTelegramEditedMessage(update);
+  if (editedMessage?.from) {
+    return {
+      kind: "edited-message",
+      message: editedMessage as TelegramMessageLike & {
+        from: TelegramUserLike;
+      },
+      authorization: getTelegramAuthorizationState(
+        editedMessage.from.id,
+        allowedUserId,
+      ),
+    };
+  }
   return { kind: "ignore" };
 }
 
@@ -215,6 +248,12 @@ export type TelegramUpdateExecutionPlan =
       shouldPair: boolean;
       shouldNotifyPaired: boolean;
       shouldDeny: boolean;
+    }
+  | {
+      kind: "edited-message";
+      message: TelegramMessageLike & { from: TelegramUserLike };
+      shouldPair: boolean;
+      shouldDeny: boolean;
     };
 
 export function buildTelegramUpdateExecutionPlan(
@@ -242,6 +281,13 @@ export function buildTelegramUpdateExecutionPlan(
         shouldNotifyPaired: action.authorization.kind === "pair",
         shouldDeny: action.authorization.kind === "deny",
       };
+    case "edited-message":
+      return {
+        kind: "edited-message",
+        message: action.message,
+        shouldPair: action.authorization.kind === "pair",
+        shouldDeny: action.authorization.kind === "deny",
+      };
   }
 }
 
@@ -296,6 +342,13 @@ export interface TelegramUpdateRuntimeDeps {
     >["message"],
     ctx: ExtensionContext,
   ) => Promise<void>;
+  handleAuthorizedTelegramEditedMessage: (
+    message: Extract<
+      TelegramUpdateExecutionPlan,
+      { kind: "edited-message" }
+    >["message"],
+    ctx: ExtensionContext,
+  ) => Promise<void>;
 }
 
 function getTelegramCallbackQueryId(
@@ -368,7 +421,12 @@ export async function executeTelegramUpdatePlan(
     ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
     : false;
   const replyTarget = getTelegramMessageReplyTarget(plan.message);
-  if (pairedNow && plan.shouldNotifyPaired && replyTarget) {
+  if (
+    plan.kind === "message" &&
+    pairedNow &&
+    plan.shouldNotifyPaired &&
+    replyTarget
+  ) {
     await deps.sendTextReply(
       replyTarget.chatId,
       replyTarget.messageId,
@@ -385,5 +443,9 @@ export async function executeTelegramUpdatePlan(
     }
     return;
   }
+  if (plan.kind === "edited-message") {
+    await deps.handleAuthorizedTelegramEditedMessage(plan.message, deps.ctx);
+    return;
+  }
   await deps.handleAuthorizedTelegramMessage(plan.message, deps.ctx);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "private": false,
   "description": "Better Telegram DM bridge extension for pi",
   "type": "module",