@llblab/pi-telegram 0.11.1 → 0.12.0

package/lib/commands.ts

@@ -307,6 +307,10 @@ export interface TelegramRuntimeEventRecorderPort {
   ) => void;
 }
 
+export interface TelegramCompactConfirmationReplyMarkup {
+  inline_keyboard: { text: string; callback_data: string }[][];
+}
+
 export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorderPort {
   isIdle: () => boolean;
   hasPendingMessages: () => boolean;
@@ -327,6 +331,42 @@ export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorder
     onError: (error: unknown) => void;
   }) => void;
   sendTextReply: (text: string) => Promise<void>;
+  suppressStartNotice?: boolean;
+}
+
+export interface TelegramCompactConfirmationDeps {
+  sendInteractiveMessage: (
+    chatId: number,
+    text: string,
+    mode: "html" | "plain",
+    replyMarkup: TelegramCompactConfirmationReplyMarkup,
+  ) => Promise<number | undefined>;
+}
+
+export interface TelegramCompactConfirmationCallbackQuery {
+  id: string;
+  data?: string;
+  message?: { chat?: { id?: number }; message_id?: number };
+}
+
+export interface TelegramCompactConfirmationCallbackDeps<TContext> {
+  ctx: TContext;
+  answerCallbackQuery: (
+    callbackQueryId: string,
+    text?: string,
+  ) => Promise<void>;
+  editInteractiveMessage: (
+    chatId: number,
+    messageId: number,
+    text: string,
+    mode: "html" | "plain",
+    replyMarkup: TelegramCompactConfirmationReplyMarkup,
+  ) => Promise<void>;
+  runCompact: (
+    ctx: TContext,
+    chatId: number,
+    replyToMessageId: number,
+  ) => Promise<void>;
 }
 
 export type TelegramControlCommandType =
@@ -580,6 +620,7 @@ export interface TelegramCommandRuntimeDeps<
   getPromptTemplateCommands?: () => readonly TelegramPromptTemplateMenuCommand[];
   persistConfig: () => Promise<void>;
   sendTextReply: (message: TMessage, text: string) => Promise<void>;
+  sendInteractiveMessage?: TelegramCompactConfirmationDeps["sendInteractiveMessage"];
 }
 
 export const TELEGRAM_APP_MENU_INTRO_HTML = [
@@ -784,6 +825,69 @@ function dispatchNextQueuedTelegramTurnAfterCompact(
   deps.dispatchNextQueuedTelegramTurn();
 }
 
+export function buildTelegramCompactConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup {
+  return {
+    inline_keyboard: [
+      [
+        { text: "🗜 Yes, compact", callback_data: "compact:confirm" },
+        { text: "❌ No", callback_data: "compact:cancel" },
+      ],
+    ],
+  };
+}
+
+export function getTelegramCompactConfirmationHtml(): string {
+  return "<b>Compact session?</b>";
+}
+
+export async function openTelegramCompactConfirmation(
+  chatId: number,
+  deps: TelegramCompactConfirmationDeps,
+): Promise<void> {
+  await deps.sendInteractiveMessage(
+    chatId,
+    getTelegramCompactConfirmationHtml(),
+    "html",
+    buildTelegramCompactConfirmationReplyMarkup(),
+  );
+}
+
+export async function handleTelegramCompactConfirmationCallback<TContext>(
+  query: TelegramCompactConfirmationCallbackQuery,
+  deps: TelegramCompactConfirmationCallbackDeps<TContext>,
+): Promise<boolean> {
+  if (query.data !== "compact:confirm" && query.data !== "compact:cancel") {
+    return false;
+  }
+  const chatId = query.message?.chat?.id;
+  const messageId = query.message?.message_id;
+  if (typeof chatId !== "number" || typeof messageId !== "number") {
+    await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+    return true;
+  }
+  if (query.data === "compact:cancel") {
+    await deps.editInteractiveMessage(
+      chatId,
+      messageId,
+      "Compaction cancelled.",
+      "plain",
+      { inline_keyboard: [] },
+    );
+    await deps.answerCallbackQuery(query.id);
+    return true;
+  }
+  await deps.editInteractiveMessage(
+    chatId,
+    messageId,
+    "Compaction started.",
+    "plain",
+    { inline_keyboard: [] },
+  );
+  await deps.answerCallbackQuery(query.id);
+  await deps.runCompact(deps.ctx, chatId, messageId);
+  return true;
+}
+
 export async function handleTelegramCompactCommand(
   deps: TelegramCompactCommandDeps,
 ): Promise<void> {
@@ -834,7 +938,9 @@ export async function handleTelegramCompactCommand(
     await deps.sendTextReply(`Compaction failed: ${errorMessage}`);
     return;
   }
-  await deps.sendTextReply("Compaction started.");
+  if (!deps.suppressStartNotice) {
+    await deps.sendTextReply("Compaction started.");
+  }
   if (compactionStillInProgress) deps.startTypingLoop?.();
 }
 
@@ -978,6 +1084,7 @@ export function createTelegramCommandHandlerTargetRuntime<
     stopTypingLoop: deps.stopTypingLoop,
     enqueueContinueTurn: deps.enqueueContinueTurn,
     compact: deps.compact,
+    sendInteractiveMessage: deps.sendInteractiveMessage,
     enqueueControlItem: commandTargetRuntime.enqueueControlItem,
     showStatus: commandTargetRuntime.showStatus,
     openModelMenu: commandTargetRuntime.openModelMenu,
@@ -1110,6 +1217,12 @@ async function handleTelegramCommandRuntime<
         await deps.openQueueMenu(nextMessage, commandCtx);
       },
       handleCompact: async (nextMessage, commandCtx) => {
+        if (deps.sendInteractiveMessage) {
+          await openTelegramCompactConfirmation(nextMessage.chat.id, {
+            sendInteractiveMessage: deps.sendInteractiveMessage,
+          });
+          return;
+        }
         await handleTelegramCompactCommand({
           isIdle: () => deps.isIdle(commandCtx),
           hasPendingMessages: () => deps.hasPendingMessages(commandCtx),

package/lib/config.ts

@@ -1,7 +1,7 @@
 /**
  * Telegram bridge config and pairing helpers
  * Zones: telegram config, pairing, filesystem
- * Owns persisted bot/session pairing state, local config storage, authorization policy, and first-user pairing side effects
+ * Owns persisted bot/session pairing state, local config storage, live config controls, authorization policy, and first-user pairing side effects
  */
 
 import { existsSync } from "node:fs";
@@ -9,7 +9,7 @@ import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
-import type { TelegramInboundHandlerConfig } from "./inbound-handlers.ts";
+import type { TelegramInboundHandlerConfig } from "./inbound.ts";
 import type { CommandTemplateObjectConfig } from "./command-templates.ts";
 
 const CONFIG_RUNTIME_KEY = "__piTelegramConfigRuntime__";
@@ -35,7 +35,7 @@ export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConf
   timeout?: number;
 }
 
-export type TelegramTimeMode = "off" | "always" | "interval";
+export type TelegramTimeMode = "hidden" | "always" | "interval";
 
 export interface TelegramTimeConfig {
   injectionMode?: TelegramTimeMode;
@@ -110,6 +110,22 @@ export function updateTelegramVoiceConfig(
   return true;
 }
 
+export function bindGlobalTelegramConfigRuntime(
+  configStore: Pick<TelegramConfigStore, "get" | "set" | "persist">,
+): void {
+  setGlobalTelegramConfigRuntime({
+    updateVoiceConfig(voice) {
+      const current = configStore.get();
+      const next = {
+        ...current,
+        voice: { ...(current.voice ?? {}), ...voice },
+      };
+      configStore.set(next);
+      void configStore.persist(next);
+    },
+  });
+}
+
 export async function readTelegramConfig(
   configPath: string,
 ): Promise<TelegramConfig> {
@@ -240,7 +256,7 @@ export function resolveTelegramTimeConfig(
   const injectionMode: TelegramTimeMode =
     raw?.injectionMode === "always" || raw?.injectionMode === "interval"
       ? raw.injectionMode
-      : "off";
+      : "hidden";
   const interval =
     typeof raw?.interval === "number" && raw.interval > 0
       ? raw.interval
@@ -266,6 +282,16 @@ export function createTelegramTimeInjectionModeSetter(
 ): (injectionMode: TelegramTimeMode) => Promise<void> {
   return async (injectionMode) => {
     const current = configStore.get();
+    if (injectionMode === "hidden") {
+      const { injectionMode: _injectionMode, ...remainingTime } =
+        current.time ?? {};
+      const next = { ...current };
+      if (Object.keys(remainingTime).length > 0) next.time = remainingTime;
+      else delete next.time;
+      configStore.set(next);
+      await configStore.persist(next);
+      return;
+    }
     const next = {
       ...current,
       time: { ...(current.time ?? {}), injectionMode },
@@ -282,6 +308,21 @@ export function createTelegramProactivePushChatIdGetter(deps: {
   return () => deps.getActiveTurnChatId() ?? deps.getAllowedUserId();
 }
 
+export function createTelegramConfigControls(
+  configStore: Pick<TelegramConfigStore, "get" | "set" | "persist">,
+) {
+  return {
+    isProactivePushEnabled: createTelegramProactivePushChecker(configStore),
+    setProactivePushEnabled: createTelegramProactivePushSetter(configStore),
+    getVoiceReplyMode: createTelegramVoiceReplyModeGetter(configStore),
+    isVoiceReplyModeConfigured:
+      createTelegramVoiceReplyModeConfiguredChecker(configStore),
+    setVoiceReplyMode: createTelegramVoiceReplyModeSetter(configStore),
+    getTimeInjectionMode: createTelegramTimeInjectionModeGetter(configStore),
+    setTimeInjectionMode: createTelegramTimeInjectionModeSetter(configStore),
+  };
+}
+
 export type TelegramAuthorizationState =
   | { kind: "pair"; userId: number }
   | { kind: "allow" }

package/lib/{inbound-handlers.ts → inbound.ts}

@@ -216,9 +216,7 @@ function matchesWildcard(pattern: string, value: string | undefined): boolean {
   return new RegExp(`^${escaped}$`).test(normalizedValue);
 }
 
-function handlerHasSelectors(
-  handler: TelegramInboundHandlerConfig,
-): boolean {
+function handlerHasSelectors(handler: TelegramInboundHandlerConfig): boolean {
   return (
     normalizeStringList(handler.match).length > 0 ||
     normalizeStringList(handler.mime).length > 0 ||
@@ -642,7 +640,10 @@ async function readBuiltInTelegramTextAttachment(
   if (!isTelegramTextMimeType(file.mimeType)) return undefined;
   const content = await readFile(file.path, "utf8");
   const normalized = content.trim();
-  if (!normalized || Buffer.byteLength(normalized, "utf8") > BUILT_IN_TEXT_ATTACHMENT_MAX_BYTES) {
+  if (
+    !normalized ||
+    Buffer.byteLength(normalized, "utf8") > BUILT_IN_TEXT_ATTACHMENT_MAX_BYTES
+  ) {
     return undefined;
   }
   const name = file.fileName || basename(file.path);

package/lib/lifecycle.ts

@@ -1,7 +1,7 @@
 /**
  * Telegram lifecycle hook registration helpers
  * Zones: pi agent lifecycle, telegram session
- * Owns binding prepared Telegram lifecycle runtimes to pi extension lifecycle events
+ * Binds prepared Telegram lifecycle runtimes to pi extension lifecycle events
  */
 
 import type {
@@ -10,6 +10,8 @@ import type {
   BeforeAgentStartEvent,
   ExtensionAPI,
   ExtensionContext,
+  SessionBeforeCompactEvent,
+  SessionCompactEvent,
   SessionShutdownEvent,
   SessionStartEvent,
 } from "./pi.ts";
@@ -50,6 +52,14 @@ export interface TelegramLifecycleRegistrationDeps {
     event: SessionShutdownEvent,
     ctx: ExtensionContext,
   ) => Promise<void>;
+  onSessionBeforeCompact?: (
+    event: SessionBeforeCompactEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
+  onSessionCompact?: (
+    event: SessionCompactEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
   onBeforeAgentStart: (
     event: BeforeAgentStartEvent,
     ctx: ExtensionContext,
@@ -92,6 +102,111 @@ export interface TelegramSessionLifecycleHooks {
   ) => Promise<void>;
 }
 
+type TelegramLifecycleTimer = number | ReturnType<typeof setTimeout>;
+
+export interface TelegramCompactionObserverRuntimeDeps<TContext> {
+  setCompactionInProgress: (inProgress: boolean) => void;
+  updateStatus: (ctx: TContext) => void;
+  startTypingLoop?: (ctx: TContext) => void;
+  stopTypingLoop?: () => void;
+  requestDeferredDispatchNextQueuedTelegramTurn: (
+    dispatch: (ctx: TContext) => void,
+  ) => void;
+  dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  recordRuntimeEvent?: (category: string, error: unknown) => void;
+  timeoutMs?: number;
+  setTimer?: (callback: () => void, ms: number) => TelegramLifecycleTimer;
+  clearTimer?: (timer: TelegramLifecycleTimer) => void;
+}
+
+export interface TelegramCompactionObserverRuntime<TContext> {
+  onSessionBeforeCompact: (
+    event: SessionBeforeCompactEvent,
+    ctx: TContext,
+  ) => void;
+  onSessionCompact: (event: SessionCompactEvent, ctx: TContext) => void;
+  onSessionShutdown: () => void;
+}
+
+export function createTelegramCompactionObserverRuntime<TContext>(
+  deps: TelegramCompactionObserverRuntimeDeps<TContext>,
+): TelegramCompactionObserverRuntime<TContext> {
+  const timeoutMs = deps.timeoutMs ?? 300_000;
+  const setTimer = deps.setTimer ?? setTimeout;
+  const clearTimer = deps.clearTimer ?? clearTimeout;
+  let fallbackTimer: TelegramLifecycleTimer | undefined;
+  const clearFallbackTimer = (): void => {
+    if (!fallbackTimer) return;
+    clearTimer(fallbackTimer);
+    fallbackTimer = undefined;
+  };
+  const requestDispatch = (): void => {
+    deps.requestDeferredDispatchNextQueuedTelegramTurn(
+      deps.dispatchNextQueuedTelegramTurn,
+    );
+  };
+  return {
+    onSessionBeforeCompact: (_event, ctx) => {
+      deps.setCompactionInProgress(true);
+      deps.startTypingLoop?.(ctx);
+      deps.updateStatus(ctx);
+      clearFallbackTimer();
+      fallbackTimer = setTimer(() => {
+        fallbackTimer = undefined;
+        deps.setCompactionInProgress(false);
+        deps.stopTypingLoop?.();
+        deps.updateStatus(ctx);
+        deps.recordRuntimeEvent?.(
+          "compact",
+          new Error("Compaction observer timed out"),
+        );
+        requestDispatch();
+      }, timeoutMs);
+    },
+    onSessionCompact: (_event, ctx) => {
+      clearFallbackTimer();
+      deps.setCompactionInProgress(false);
+      deps.stopTypingLoop?.();
+      deps.updateStatus(ctx);
+      requestDispatch();
+    },
+    onSessionShutdown: () => {
+      clearFallbackTimer();
+      deps.stopTypingLoop?.();
+    },
+  };
+}
+
+export interface TelegramMessageActivityTypingDeps<TContext> {
+  hasActiveTurn: () => boolean;
+  startTypingLoop: (ctx: TContext) => void;
+  onMessageStart: TelegramLifecycleRegistrationDeps["onMessageStart"];
+  onMessageUpdate: TelegramLifecycleRegistrationDeps["onMessageUpdate"];
+}
+
+export function createTelegramMessageActivityTypingHooks<
+  TContext extends ExtensionContext,
+>(
+  deps: TelegramMessageActivityTypingDeps<TContext>,
+): Pick<
+  TelegramLifecycleRegistrationDeps,
+  "onMessageStart" | "onMessageUpdate"
+> {
+  const ensureTyping = (ctx: TContext): void => {
+    if (deps.hasActiveTurn()) deps.startTypingLoop(ctx);
+  };
+  return {
+    onMessageStart: async (event, ctx) => {
+      ensureTyping(ctx as TContext);
+      await deps.onMessageStart(event, ctx);
+    },
+    onMessageUpdate: async (event, ctx) => {
+      ensureTyping(ctx as TContext);
+      await deps.onMessageUpdate(event, ctx);
+    },
+  };
+}
+
 export function createDedupAgentStartHook(
   dedup: { reset(): void },
   inner: (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void>,
@@ -139,6 +254,12 @@ export function registerTelegramLifecycleHooks(
   pi.on("session_shutdown", async (event, ctx) => {
     await deps.onSessionShutdown(event, ctx);
   });
+  pi.on("session_before_compact", async (event, ctx) => {
+    await deps.onSessionBeforeCompact?.(event, ctx);
+  });
+  pi.on("session_compact", async (event, ctx) => {
+    await deps.onSessionCompact?.(event, ctx);
+  });
   pi.on("before_agent_start", async (event, ctx) => {
     return deps.onBeforeAgentStart(event, ctx);
   });

package/lib/menu-model.ts

@@ -983,7 +983,7 @@ export function buildModelMenuReplyMarkup(
         callback_data: "model:scope:scoped",
       },
       {
-        text: state.scope === "all" ? "🟡 All" : "⚫️ All",
+        text: state.scope === "all" ? "🟣 All" : "⚫️ All",
         callback_data: "model:scope:all",
       },
     ]);
@@ -1050,7 +1050,7 @@ export function buildModelDetailMenuReplyMarkup(
           callback_data: "model:scope-enable",
         },
         {
-          text: scoped ? "⚫️ All" : "🟡 All",
+          text: scoped ? "⚫️ All" : "🟣 All",
           callback_data: "model:scope-disable",
         },
       ],
@@ -1091,7 +1091,7 @@ export function buildModelPageMenuReplyMarkup(
           return {
             text:
               pageIndex === menuPage.page
-                ? `🟢 ${pageIndex + 1}`
+                ? `🟣 ${pageIndex + 1}`
                 : String(pageIndex + 1),
             callback_data: `model:page:${pageIndex}`,
           };

package/lib/menu-queue.ts

@@ -162,7 +162,7 @@ function buildTelegramQueueItemSubmenuReplyMarkup(
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
         },
         {
-          text: isPriority ? "⚫️ Normal" : "🟡 Normal",
+          text: isPriority ? "⚫️ Normal" : "🟣 Normal",
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
         },
       ],