@llblab/pi-telegram 0.19.3 → 0.20.1

package/lib/routing.ts

@@ -5,6 +5,7 @@
  */
 
 import { readFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
 import * as Commands from "./commands.ts";
 import type { TelegramConfigStore } from "./config.ts";
 import type { TelegramSectionRegistry } from "./sections.ts";
@@ -20,6 +21,31 @@ import * as TextGroups from "./text-groups.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
 import * as Turns from "./turns.ts";
 
+function formatTelegramPromptPeer(user: { id?: unknown; username?: unknown } | undefined): string | undefined {
+  if (!user) return undefined;
+  if (typeof user.username === "string" && user.username.length > 0) return user.username;
+  return typeof user.id === "number" ? String(user.id) : undefined;
+}
+
+function appendTelegramSourceAttachmentSection(
+  text: string,
+  from: string | undefined,
+  files: Pick<Media.DownloadedTelegramFile, "path">[],
+): string {
+  if (files.length === 0) return text;
+  const dirs = [...new Set(files.map((file) => dirname(file.path)))];
+  const sameDir = dirs.length === 1;
+  const source = from ? `|from:${from}` : "";
+  const header = sameDir
+    ? `[attachments${source}] ${dirs[0]}`
+    : `[attachments${source}]`;
+  const items = sameDir
+    ? files.map((file) => `/${basename(file.path)}`)
+    : files.map((file) => file.path);
+  const prefix = text.length > 0 ? `${text}\n\n` : "";
+  return `${prefix}${header}\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+
 function getContextCwd(ctx: unknown): string | undefined {
   if (!ctx || typeof ctx !== "object") return undefined;
   const cwd = (ctx as { cwd?: unknown }).cwd;
@@ -1248,22 +1274,25 @@ export function createTelegramInboundRouteRuntime<
             if (typeof chatId !== "number" || typeof messageId !== "number")
               return;
             const queueOrder = deps.bridgeRuntime.queue.allocateItemOrder();
-            deps.queueMutationRuntime.append(
-              OutboundHandlers.createTelegramButtonPromptTurn({
-                chatId,
-                target:
-                  typeof buttonQuery.message?.message_thread_id === "number"
-                    ? {
-                        chatId,
-                        threadId: buttonQuery.message.message_thread_id,
-                      }
-                    : { chatId },
-                replyToMessageId: messageId,
-                queueOrder,
-                action,
-              }),
-              context,
+            const turn = OutboundHandlers.createTelegramButtonPromptTurn({
+              chatId,
+              target:
+                typeof buttonQuery.message?.message_thread_id === "number"
+                  ? {
+                      chatId,
+                      threadId: buttonQuery.message.message_thread_id,
+                    }
+                  : { chatId },
+              replyToMessageId: messageId,
+              queueOrder,
+              action,
+            });
+            const result = Queue.appendTelegramPromptTurnOnce(
+              deps.telegramQueueStore.getQueuedItems(),
+              turn,
             );
+            if (!result.appended) return;
+            deps.telegramQueueStore.setQueuedItems(result.items);
             deps.updateStatus(context);
             requestDispatchNextQueuedTelegramTurn(context);
           },
@@ -1323,15 +1352,39 @@ export function createTelegramInboundRouteRuntime<
     );
     if (handledBySettings) return;
     const callbackData = query.data;
-    if (
-      deps.sendUserMessage &&
-      callbackData &&
-      !isTelegramOwnedCallbackData(callbackData)
-    ) {
-      deps.sendUserMessage(
-        `[callback] ${callbackData}`,
-        Queue.TELEGRAM_PROMPT_FOLLOW_UP_DELIVERY,
-      );
+    if (callbackData && !isTelegramOwnedCallbackData(callbackData)) {
+      const chatId = query.message?.chat?.id;
+      const messageId = query.message?.message_id;
+      if (typeof chatId === "number" && typeof messageId === "number") {
+        const queueOrder = deps.bridgeRuntime.queue.allocateItemOrder();
+        const target =
+          typeof query.message?.message_thread_id === "number"
+            ? { chatId, threadId: query.message.message_thread_id }
+            : { chatId };
+        const turn: Queue.PendingTelegramTurn = {
+          kind: "prompt",
+          chatId,
+          target,
+          replyToMessageId: messageId,
+          sourceMessageIds: [messageId],
+          queueOrder,
+          queueLane: "priority",
+          laneOrder: queueOrder,
+          queuedAttachments: [],
+          content: [{ type: "text", text: `[callback] ${callbackData}` }],
+          historyText: callbackData,
+          statusSummary: callbackData,
+        };
+        const result = Queue.appendTelegramPromptTurnOnce(
+          deps.telegramQueueStore.getQueuedItems(),
+          turn,
+        );
+        if (result.appended) {
+          deps.telegramQueueStore.setQueuedItems(result.items);
+          deps.updateStatus(ctx);
+          requestDispatchNextQueuedTelegramTurn(ctx);
+        }
+      }
       await deps.answerCallbackQuery(query.id);
       return;
     }
@@ -1345,6 +1398,7 @@ export function createTelegramInboundRouteRuntime<
     downloadFile: deps.downloadFile,
     processAttachments: deps.inboundHandlerRuntime.process,
     resolveTimeLine: deps.resolveTimeLine,
+    getAllowedUserId: deps.configStore.getAllowedUserId,
 
     // Voice policy for the current turn. Missing config still behaves as manual,
     // but only explicit telegram.json voice.replyMode is shown in prompt context.
@@ -1757,30 +1811,37 @@ export function createTelegramInboundRouteRuntime<
     const text = guestMessage.text ?? "";
     const gm = guestMessage as unknown as Record<string, unknown>;
     // Build telegram prefix with guest context
-    const fromRaw = gm.from as Record<string, unknown> | undefined;
-    const fromName =
-      (fromRaw?.username as string) || (fromRaw?.first_name as string) || "";
     const chatRaw = gm.chat as Record<string, unknown>;
     const chatTitle = chatRaw?.title as string | undefined;
     const chatType = chatRaw?.type as string;
+    const fromRaw = gm.from as Record<string, unknown> | undefined;
+    const replyMsg = gm.reply_to_message as Record<string, unknown> | undefined;
+    const replyFromRaw = replyMsg?.from as Record<string, unknown> | undefined;
+    const fromPeer = formatTelegramPromptPeer(fromRaw);
+    const replyPeer = formatTelegramPromptPeer(replyFromRaw);
+    const fromIsOwner = fromRaw?.id === deps.configStore.getAllowedUserId();
+    const guestPeer = chatType === "private" && fromIsOwner && replyPeer
+      ? replyPeer
+      : fromPeer;
     const prefixParts = ["telegram"];
-    if (fromName) prefixParts.push(`from:${fromName}`);
     if (chatType !== "private" && chatTitle) {
       prefixParts.push(`guest:${chatTitle}`);
+    } else if (chatType === "private" && guestPeer) {
+      prefixParts.push(`guest:${guestPeer}`);
     }
     const telegramPrefix = `[${prefixParts.join("|")}]`;
     // Extract reply context
-    const replyMsg = gm.reply_to_message as Record<string, unknown> | undefined;
     const replyText = replyMsg
       ? ((replyMsg.text as string) || (replyMsg.caption as string) || "").trim()
       : "";
-    const replyFrom = replyMsg
-      ? ((replyMsg.from as Record<string, unknown> | undefined)?.username as
-          | string
-          | undefined)
-      : undefined;
     // Download files, run inbound handlers
     const guestMsg = guestMessage as unknown as Media.TelegramMediaMessage;
+    const replyFiles = guestMsg.reply_to_message
+      ? await Media.downloadTelegramMessageFiles(
+          [guestMsg.reply_to_message as Media.TelegramMediaMessage],
+          { downloadFile: deps.downloadFile },
+        )
+      : [];
     const files = await Media.downloadTelegramMessageFiles([guestMsg], {
       downloadFile: deps.downloadFile,
     });
@@ -1789,13 +1850,16 @@ export function createTelegramInboundRouteRuntime<
       text,
       ctx,
     );
-    let rawText = processed.rawText || text;
-    // Append reply context after handler processing
-    if (replyText) {
-      const replyBlock = replyFrom
-        ? `[reply|from:${replyFrom}] ${replyText}`
-        : `[reply] ${replyText}`;
-      rawText = `${rawText}\n\n${replyBlock}`;
+    const rawText = processed.rawText || text;
+    let sourceContext = "";
+    if (replyMsg) {
+      const replyHeader = replyPeer ? `[reply|from:${replyPeer}]` : "[reply]";
+      const replyBlock = replyText ? `${replyHeader} ${replyText}` : replyHeader;
+      sourceContext = appendTelegramSourceAttachmentSection(
+        replyBlock,
+        replyPeer,
+        replyFiles,
+      );
     }
     const promptText = Turns.buildTelegramTurnPrompt({
       telegramPrefix,
@@ -1803,6 +1867,7 @@ export function createTelegramInboundRouteRuntime<
       files,
       promptFiles: processed.promptFiles,
       handlerOutputs: processed.handlerOutputs,
+      sourceContext,
     });
     const order = deps.bridgeRuntime.queue.allocateItemOrder();
     const content: Queue.TelegramPromptContent[] = [

package/lib/status.ts

@@ -180,6 +180,7 @@ export type TelegramBridgeBusLifecyclePhase = "electing";
 export interface TelegramBridgeStatusLineState {
   hasBotToken?: boolean;
   botUsername?: string;
+  activeProfileName?: string;
   allowedUserId?: number;
   botThreadMode?: "unknown" | "enabled" | "disabled";
   botThreadModeUpdatedAtMs?: number;
@@ -257,6 +258,7 @@ export interface TelegramBridgeStatusRuntimeDeps<
 > {
   statusKey?: string;
   getConfig: () => TelegramBridgeStatusConfig;
+  getActiveProfileName?: () => string | undefined;
   isPollingActive: () => boolean;
   getActiveSourceMessageIds: () => number[] | undefined;
   hasActiveTurn: () => boolean;
@@ -621,6 +623,7 @@ export function createTelegramBridgeStatusRuntime<
       return {
         hasBotToken: Boolean(config.botToken),
         botUsername: config.botUsername,
+        activeProfileName: deps.getActiveProfileName?.(),
         allowedUserId: config.allowedUserId,
         botThreadMode: botThreadMode?.threadMode,
         botThreadModeUpdatedAtMs: botThreadMode?.updatedAtMs,
@@ -770,7 +773,7 @@ export function buildTelegramStatusBarText(
   if (state.busLifecyclePhase === "electing")
     return `${label} ${theme.fg("warning", "electing")}${queued}`;
   if (!state.pollingActive && state.busRole !== "follower")
-    return `${label} ${theme.fg("muted", "disconnected")}${queued}`;
+    return `${theme.fg("accent", "telegram")} ${theme.fg("muted", "disconnected")}${queued}`;
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("warning", "compacting")}${queued}`;
   }
@@ -1065,6 +1068,7 @@ function buildTelegramBridgeCompactStatusLines(
   return [
     "connection:",
     `- bot: ${formatTelegramBridgeBotStatus(state)}`,
+    ...(state.activeProfileName ? [`- profile: ${state.activeProfileName}`] : []),
     `- user: ${state.allowedUserId ?? "not paired"}`,
     ...(state.botThreadMode ? [`- thread mode: ${state.botThreadMode}`] : []),
     ...(state.busRole ? [`- role: ${state.busRole}`] : []),
@@ -1119,6 +1123,7 @@ export function buildTelegramBridgeDiagnosticStatusLines(
   return [
     "connection:",
     `- bot: ${formatTelegramBridgeBotStatus(state)}`,
+    ...(state.activeProfileName ? [`- profile: ${state.activeProfileName}`] : []),
     `- allowed user: ${state.allowedUserId ?? "not paired"}`,
     ...(state.botThreadMode
       ? [

package/lib/sync.ts

@@ -24,6 +24,7 @@ export interface TelegramLeaderThreadSyncDeps {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
   cwd?: string;
+  telegramProfile?: string;
   forceFreshUnnamed?: boolean;
   getNowMs?: () => number;
   getRandom?: () => number;
@@ -110,7 +111,7 @@ export interface TelegramLeaderHealthRuntime {
 export interface TelegramManualThreadDisconnectDeps<TSyncState> {
   instanceId: string;
   getCurrentThreadRecord: () =>
-    | { target: TelegramTarget; instanceId?: string }
+    | { target: TelegramTarget; instanceId?: string; owner?: { kind?: string } }
     | undefined;
   topicTargetStore: Pick<
     TelegramTopicTargetStore,
@@ -160,23 +161,26 @@ export function createTelegramManualThreadDisconnectHandler<
   return async () => {
     const currentRecord = deps.getCurrentThreadRecord();
     if (currentRecord?.target.threadId) {
-      await ThreadReconciler.applyThreadReconciliationPlan(
-        ThreadReconciler.planDisconnectedInstanceThreadCleanup({
-          target: currentRecord.target as TelegramTarget & { threadId: number },
-          instanceId: deps.instanceId,
-        }),
-        {
-          callApi(method, body) {
-            return deps.callApi(method, body);
-          },
-          persist() {
-            return deps.topicTargetStore.persist();
+      const isManualFollower = currentRecord.owner?.kind === "manual-follower";
+      if (!isManualFollower) {
+        await ThreadReconciler.applyThreadReconciliationPlan(
+          ThreadReconciler.planDisconnectedInstanceThreadCleanup({
+            target: currentRecord.target as TelegramTarget & { threadId: number },
+            instanceId: deps.instanceId,
+          }),
+          {
+            callApi(method, body) {
+              return deps.callApi(method, body);
+            },
+            persist() {
+              return deps.topicTargetStore.persist();
+            },
+            recordRuntimeEvent: deps.recordRuntimeEvent,
           },
-          recordRuntimeEvent: deps.recordRuntimeEvent,
-        },
-      );
-      if (deps.topicTargetStore.markOfflineByInstanceId(deps.instanceId) > 0) {
-        await deps.topicTargetStore.persist();
+        );
+        if (deps.topicTargetStore.markOfflineByInstanceId(deps.instanceId) > 0) {
+          await deps.topicTargetStore.persist();
+        }
       }
       const leaderTarget = deps.getLeaderTarget();
       if (
@@ -360,6 +364,7 @@ export async function ensureTelegramLeaderThreadBinding(
     getAllowedUserId: deps.getAllowedUserId,
     instanceId: deps.instanceId,
     cwd: deps.cwd,
+    telegramProfile: deps.telegramProfile,
     getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
     getThreadReconciliationMachineState:
       deps.getThreadReconciliationMachineState,

package/lib/telegram-api.ts

@@ -10,8 +10,8 @@ import { randomUUID } from "node:crypto";
 import { createWriteStream, openAsBlob } from "node:fs";
 import { mkdir, readdir, stat, unlink, writeFile } from "node:fs/promises";
 import { request as requestHttps } from "node:https";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
+import { resolveTelegramTempDir } from "./paths.ts";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -34,10 +34,7 @@ export function getTelegramInboundFileByteLimitFromEnv(
 }
 
 function getTelegramApiTempDir(): string {
-  const agentDir = process.env.PI_CODING_AGENT_DIR
-    ? resolve(process.env.PI_CODING_AGENT_DIR)
-    : join(homedir(), ".pi", "agent");
-  return join(agentDir, "tmp", "telegram");
+  return resolveTelegramTempDir();
 }
 const TELEGRAM_TEMP_FILE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const TELEGRAM_INBOUND_FILE_MAX_BYTES = getTelegramInboundFileByteLimitFromEnv(
@@ -47,10 +44,7 @@ const TELEGRAM_INBOUND_FILE_MAX_BYTES = getTelegramInboundFileByteLimitFromEnv(
 );
 
 export type TelegramNetworkFamilyPolicy =
-  | "auto"
-  | "ipv4"
-  | "ipv6"
-  | "ipv4-fallback";
+  "auto" | "ipv4" | "ipv6" | "ipv4-fallback";
 
 const TELEGRAM_NETWORK_FAMILY_ENV = "PI_TELEGRAM_NETWORK_FAMILY";
 const TELEGRAM_NETWORK_FAMILY_VALUES = new Set<TelegramNetworkFamilyPolicy>([
@@ -1123,10 +1117,15 @@ export function createTelegramAssistantDraftSender(deps: {
     if (text === undefined || deps.getAssistantRenderingMode() === "rich") {
       return sendNativeDraft(chatId, draftId, text, options);
     }
-    return deps.sendMessageDraft(chatId, draftId, deps.renderMarkdownToHtmlDraft(text), {
-      ...options,
-      parse_mode: "HTML",
-    });
+    return deps.sendMessageDraft(
+      chatId,
+      draftId,
+      deps.renderMarkdownToHtmlDraft(text),
+      {
+        ...options,
+        parse_mode: "HTML",
+      },
+    );
   };
 }