@llblab/pi-telegram 0.8.1 → 0.9.0

package/lib/menu-queue.ts

@@ -17,6 +17,7 @@ type TelegramQueueMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 interface TelegramQueueMenuItem {
   chatId: number;
   replyToMessageId: number;
+  queuePosition: number;
   isPriority: boolean;
   priorityEmoji?: string;
   hasAttachments: boolean;
@@ -38,10 +39,11 @@ function getTelegramQueueItemPromptText<Context>(
 function toTelegramQueueMenuItems<Context>(
   items: readonly Queue.TelegramQueueItem<Context>[],
 ): TelegramQueueMenuItem[] {
-  return items.map(function toTelegramQueueMenuItem(item) {
+  return items.map(function toTelegramQueueMenuItem(item, index) {
     return {
       chatId: item.chatId,
       replyToMessageId: item.replyToMessageId,
+      queuePosition: index + 1,
       isPriority: item.queueLane === "priority",
       priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
       hasAttachments:
@@ -55,7 +57,10 @@ function buildTelegramQueueMenuReplyMarkup(
   items: readonly TelegramQueueMenuItem[],
 ): TelegramQueueMenuReplyMarkup {
   const backRow = [{ text: "⬆️ Main menu", callback_data: "menu:back" }];
-  if (items.length === 0) return { inline_keyboard: [backRow] };
+  if (items.length === 0) {
+    const refreshRow = [{ text: "🌀 Refresh", callback_data: "queue:refresh" }];
+    return { inline_keyboard: [backRow, refreshRow] };
+  }
   const rows = items.map(function buildTelegramQueueMenuRow(item, index) {
     const prefix = item.isPriority
       ? `${item.priorityEmoji ?? "⚡"} `
@@ -100,7 +105,9 @@ function escapeTelegramQueueMenuHtml(text: string): string {
   return Array.from(text).map(escapeTelegramQueueMenuHtmlChar).join("");
 }
 function escapeTelegramQueueMenuHtmlPreview(text: string): string {
-  const suffix = escapeTelegramQueueMenuHtml(QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX);
+  const suffix = escapeTelegramQueueMenuHtml(
+    QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX,
+  );
   let escaped = "";
   let truncated = false;
   for (const char of text) {
@@ -117,24 +124,27 @@ function escapeTelegramQueueMenuHtmlPreview(text: string): string {
   return truncated ? escaped + suffix : escaped;
 }
 function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
-  return `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
+  const badge = item.isPriority ? ` ${item.priorityEmoji ?? "⚡"}` : "";
+  const heading = `<b>${item.queuePosition}.</b>${badge}`;
+  const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
+  return `${heading}\n${preview}`;
 }
 function buildTelegramQueueItemSubmenuReplyMarkup(
   chatId: number,
   replyToMessageId: number,
   isPriority: boolean,
-  priorityEmoji?: string,
 ): TelegramQueueMenuReplyMarkup {
-  const priorityLabel = isPriority
-    ? `🐢 Deprioritize ${priorityEmoji ?? "⚡"}`
-    : "⚡ Prioritize";
   return {
     inline_keyboard: [
       [{ text: "⬆️ Back", callback_data: "queue:list" }],
       [
         {
-          text: priorityLabel,
-          callback_data: `queue:prio:${chatId}:${replyToMessageId}`,
+          text: isPriority ? "🟡 Priority" : "⚫️ Priority",
+          callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
+        },
+        {
+          text: isPriority ? "⚫️ Normal" : "🟡 Normal",
+          callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
         },
       ],
       [
@@ -157,8 +167,6 @@ function buildTelegramQueueDeleteConfirmationReplyMarkup(
           text: "🗑 Yes, delete",
           callback_data: `queue:confirm-delete:${chatId}:${replyToMessageId}`,
         },
-      ],
-      [
         {
           text: "❌ No",
           callback_data: `queue:keep:${chatId}:${replyToMessageId}`,
@@ -174,6 +182,11 @@ interface TelegramQueueMenuCallbackDeps<Context = unknown> {
     replyToMessageId: number,
   ) => TelegramQueueMenuItem | undefined;
   togglePriority: (chatId: number, replyToMessageId: number) => boolean;
+  setPriority: (
+    chatId: number,
+    replyToMessageId: number,
+    enabled: boolean,
+  ) => boolean;
   cancelItem: (
     chatId: number,
     replyToMessageId: number,
@@ -204,7 +217,7 @@ async function handleTelegramQueueMenuCallback<Context>(
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
   }
-  if (data === "queue:list") {
+  if (data === "queue:list" || data === "queue:refresh") {
     await updateTelegramQueueMenuList(
       callbackQueryId,
       replyChatId,
@@ -225,6 +238,22 @@ async function handleTelegramQueueMenuCallback<Context>(
     );
     return true;
   }
+  const prioSetMatch = data.match(
+    /^queue:prio-set:(\d+):(\d+):(priority|normal)$/,
+  );
+  if (prioSetMatch) {
+    await handleTelegramQueueMenuPrioritySet(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      Number(prioSetMatch[1]),
+      Number(prioSetMatch[2]),
+      prioSetMatch[3] === "priority",
+      ctx,
+      deps,
+    );
+    return true;
+  }
   const prioMatch = data.match(/^queue:prio:(\d+):(\d+)$/);
   if (prioMatch) {
     await handleTelegramQueueMenuPriority(
@@ -280,7 +309,7 @@ async function handleTelegramQueueMenuCallback<Context>(
 function getTelegramQueueMenuListText(
   items: readonly TelegramQueueMenuItem[],
 ): string {
-  if (items.length === 0) return "<b>⏳ Queue is empty.</b>";
+  if (items.length === 0) return "<b>⌛ Queue is empty.</b>";
   return "<b>⏳ Queue:</b>";
 }
 async function updateTelegramQueueMenuList<Context>(
@@ -334,12 +363,7 @@ async function handleTelegramQueueMenuPick<Context>(
     replyChatId,
     replyMessageId,
     getTelegramQueueMenuItemText(item),
-    buildTelegramQueueItemSubmenuReplyMarkup(
-      chatId,
-      msgId,
-      item.isPriority,
-      item.priorityEmoji,
-    ),
+    buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, item.isPriority),
   );
   await deps.answerCallbackQuery(callbackQueryId);
 }
@@ -361,24 +385,77 @@ async function handleTelegramQueueMenuPriority<Context>(
       deps,
     );
   }
-  deps.togglePriority(chatId, msgId);
+  await updateTelegramQueueMenuPriority(
+    callbackQueryId,
+    replyChatId,
+    replyMessageId,
+    chatId,
+    msgId,
+    !item.isPriority,
+    ctx,
+    deps,
+  );
+}
+async function handleTelegramQueueMenuPrioritySet<Context>(
+  callbackQueryId: string,
+  replyChatId: number,
+  replyMessageId: number,
+  chatId: number,
+  msgId: number,
+  enabled: boolean,
+  ctx: Context,
+  deps: TelegramQueueMenuCallbackDeps<Context>,
+): Promise<void> {
+  const item = deps.findItem(chatId, msgId);
+  if (!item) {
+    return refreshStaleTelegramQueueMenuItem(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      deps,
+    );
+  }
+  await updateTelegramQueueMenuPriority(
+    callbackQueryId,
+    replyChatId,
+    replyMessageId,
+    chatId,
+    msgId,
+    enabled,
+    ctx,
+    deps,
+  );
+}
+async function updateTelegramQueueMenuPriority<Context>(
+  callbackQueryId: string,
+  replyChatId: number,
+  replyMessageId: number,
+  chatId: number,
+  msgId: number,
+  enabled: boolean,
+  ctx: Context,
+  deps: TelegramQueueMenuCallbackDeps<Context>,
+): Promise<void> {
+  deps.setPriority(chatId, msgId, enabled);
   deps.updateStatus(ctx);
   const updated = deps.findItem(chatId, msgId);
-  const newPriority = updated?.isPriority ?? !item.isPriority;
+  if (!updated) {
+    return refreshStaleTelegramQueueMenuItem(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      deps,
+    );
+  }
   await deps.updateQueueMessage(
     replyChatId,
     replyMessageId,
-    getTelegramQueueMenuItemText(item),
-    buildTelegramQueueItemSubmenuReplyMarkup(
-      chatId,
-      msgId,
-      newPriority,
-      updated?.priorityEmoji ?? item.priorityEmoji,
-    ),
+    getTelegramQueueMenuItemText(updated),
+    buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, updated.isPriority),
   );
   await deps.answerCallbackQuery(
     callbackQueryId,
-    newPriority ? "Prioritized." : "Deprioritized.",
+    updated.isPriority ? "Prioritized." : "Normal priority.",
   );
 }
 async function handleTelegramQueueMenuDeleteRequest<Context>(
@@ -427,12 +504,7 @@ async function handleTelegramQueueMenuKeep<Context>(
     replyChatId,
     replyMessageId,
     getTelegramQueueMenuItemText(item),
-    buildTelegramQueueItemSubmenuReplyMarkup(
-      chatId,
-      msgId,
-      item.isPriority,
-      item.priorityEmoji,
-    ),
+    buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, item.isPriority),
   );
   await deps.answerCallbackQuery(callbackQueryId, "Kept in queue.");
 }
@@ -651,6 +723,12 @@ function createQueueMenuCallbackHandler<
             queueMutationRuntime: deps.queueMutationRuntime,
           });
         },
+        setPriority: function setPriority(cId, rId, enabled) {
+          return setQueuedTelegramPromptPriority(cId, rId, enabled, ctx, {
+            getQueueSnapshot,
+            queueMutationRuntime: deps.queueMutationRuntime,
+          });
+        },
         cancelItem: function cancelItem(cId, rId, c) {
           return cancelQueuedTelegramItem(cId, rId, c, {
             getQueueSnapshot,
@@ -686,6 +764,29 @@ function toggleQueuedTelegramPromptPriority<Context>(
   }
   return true;
 }
+function setQueuedTelegramPromptPriority<Context>(
+  chatId: number,
+  replyToMessageId: number,
+  enabled: boolean,
+  ctx: Context,
+  deps: {
+    getQueueSnapshot: () => Queue.TelegramQueueItem<Context>[];
+    queueMutationRuntime: Queue.TelegramQueueMutationController<Context>;
+  },
+): boolean {
+  const item = findTelegramQueueItem(
+    deps.getQueueSnapshot(),
+    chatId,
+    replyToMessageId,
+  );
+  if (!item) return false;
+  if (enabled) {
+    deps.queueMutationRuntime.prioritizeByMessageId(replyToMessageId, ctx);
+  } else {
+    deps.queueMutationRuntime.clearPriorityByMessageId(replyToMessageId, ctx);
+  }
+  return true;
+}
 function cancelQueuedTelegramItem<Context>(
   chatId: number,
   replyToMessageId: number,

package/lib/menu-settings.ts

@@ -0,0 +1,272 @@
+/**
+ * Telegram settings menu UI helpers
+ * Zones: telegram ui, settings controls, menu composition
+ * Owns hidden settings-menu rendering, settings callbacks, and persisted toggle wiring
+ */
+
+import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
+import type { TelegramModelMenuState } from "./menu-model.ts";
+import type { MenuModel } from "./model.ts";
+
+export type TelegramSettingsMenuReplyMarkup = TelegramInlineKeyboardMarkup;
+
+export interface TelegramSettingsStateDeps {
+  isProactivePushEnabled: () => boolean;
+}
+
+export interface TelegramSettingsMutationDeps extends TelegramSettingsStateDeps {
+  setProactivePushEnabled: (enabled: boolean) => Promise<void>;
+}
+
+export interface TelegramSettingsMenuOpenDeps<
+  TModel extends MenuModel = MenuModel,
+> extends TelegramSettingsStateDeps {
+  getModelMenuState: () => Promise<TelegramModelMenuState<TModel>>;
+  sendSettingsMenu: (
+    state: TelegramModelMenuState<TModel>,
+    text: string,
+    replyMarkup: TelegramSettingsMenuReplyMarkup,
+  ) => Promise<number | undefined>;
+  storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+}
+
+export interface TelegramSettingsMenuCallbackDeps extends TelegramSettingsMutationDeps {
+  updateSettingsMessage: (
+    text: string,
+    replyMarkup: TelegramSettingsMenuReplyMarkup,
+  ) => Promise<void>;
+  answerCallbackQuery: (
+    callbackQueryId: string,
+    text?: string,
+  ) => Promise<void>;
+}
+
+export interface TelegramSettingsMenuRuntime<TContext> {
+  openSettingsMenu: (
+    chatId: number,
+    replyToMessageId: number,
+    ctx: TContext,
+  ) => Promise<void>;
+  handleCallbackQuery: (
+    query: {
+      id: string;
+      data?: string;
+      message?: { message_id?: number };
+    },
+    ctx: TContext,
+  ) => Promise<boolean>;
+  updateSettingsMenuMessage: (
+    state: TelegramModelMenuState,
+    ctx: TContext,
+  ) => Promise<void>;
+}
+
+export interface TelegramSettingsMenuMessageUpdateDeps extends TelegramSettingsStateDeps {
+  updateSettingsMessage: (
+    text: string,
+    replyMarkup: TelegramSettingsMenuReplyMarkup,
+  ) => Promise<void>;
+}
+
+export interface TelegramSettingsMenuRuntimeDeps<
+  TContext,
+  TModel extends MenuModel = MenuModel,
+> extends TelegramSettingsMutationDeps {
+  getModelMenuState: (
+    chatId: number,
+    ctx: TContext,
+  ) => Promise<TelegramModelMenuState<TModel>>;
+  getStoredModelMenuState: (
+    messageId: number | undefined,
+  ) => TelegramModelMenuState<TModel> | undefined;
+  storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+  editInteractiveMessage: (
+    chatId: number,
+    messageId: number,
+    text: string,
+    mode: "html" | "plain",
+    replyMarkup: TelegramSettingsMenuReplyMarkup,
+  ) => Promise<void>;
+  sendInteractiveMessage: (
+    chatId: number,
+    text: string,
+    mode: "html" | "plain",
+    replyMarkup: TelegramSettingsMenuReplyMarkup,
+  ) => Promise<number | undefined>;
+  answerCallbackQuery: (
+    callbackQueryId: string,
+    text?: string,
+  ) => Promise<void>;
+}
+
+export const SETTINGS_MENU_TITLE = "<b>⚙️ Settings:</b>";
+export const PROACTIVE_PUSH_SETTINGS_TITLE = "<b>Proactive push:</b>";
+
+export function buildTelegramSettingsMenuText(): string {
+  return SETTINGS_MENU_TITLE;
+}
+
+export function buildProactivePushSettingsText(): string {
+  return [
+    PROACTIVE_PUSH_SETTINGS_TITLE,
+    "",
+    "Send successful local π task results to Telegram when the bridge is connected.",
+    "Default: off. Persists until disabled or removed from config.",
+  ].join("\n");
+}
+
+export function buildTelegramSettingsMenuReplyMarkup(
+  proactivePushEnabled: boolean,
+): TelegramSettingsMenuReplyMarkup {
+  return {
+    inline_keyboard: [
+      [{ text: "⬆️ Main menu", callback_data: "menu:back" }],
+      [
+        {
+          text: `${proactivePushEnabled ? "🟢" : "⚫️"} Proactive push`,
+          callback_data: "settings:open:proactive",
+        },
+      ],
+    ],
+  };
+}
+
+export async function openTelegramSettingsMenu<
+  TModel extends MenuModel = MenuModel,
+>(deps: TelegramSettingsMenuOpenDeps<TModel>): Promise<void> {
+  const state = await deps.getModelMenuState();
+  const messageId = await deps.sendSettingsMenu(
+    state,
+    buildTelegramSettingsMenuText(),
+    buildTelegramSettingsMenuReplyMarkup(deps.isProactivePushEnabled()),
+  );
+  if (messageId === undefined) return;
+  state.messageId = messageId;
+  state.mode = "settings";
+  deps.storeModelMenuState(state);
+}
+
+export function buildProactivePushSettingsReplyMarkup(
+  proactivePushEnabled: boolean,
+): TelegramSettingsMenuReplyMarkup {
+  return {
+    inline_keyboard: [
+      [{ text: "⬆️ Back", callback_data: "settings:list" }],
+      [
+        {
+          text: proactivePushEnabled ? "🟢 On" : "⚫️ On",
+          callback_data: "settings:set:proactive:on",
+        },
+        {
+          text: proactivePushEnabled ? "⚫️ Off" : "🟡 Off",
+          callback_data: "settings:set:proactive:off",
+        },
+      ],
+    ],
+  };
+}
+
+export async function updateTelegramSettingsMenuMessage(
+  deps: TelegramSettingsMenuMessageUpdateDeps,
+): Promise<void> {
+  await deps.updateSettingsMessage(
+    buildTelegramSettingsMenuText(),
+    buildTelegramSettingsMenuReplyMarkup(deps.isProactivePushEnabled()),
+  );
+}
+
+export async function updateProactivePushSettingsMessage(
+  deps: TelegramSettingsMenuCallbackDeps,
+): Promise<void> {
+  await deps.updateSettingsMessage(
+    buildProactivePushSettingsText(),
+    buildProactivePushSettingsReplyMarkup(deps.isProactivePushEnabled()),
+  );
+}
+
+export async function handleTelegramSettingsMenuCallbackAction(
+  callbackQueryId: string,
+  data: string | undefined,
+  deps: TelegramSettingsMenuCallbackDeps,
+): Promise<boolean> {
+  if (!data?.startsWith("settings:")) return false;
+  if (data === "settings:list") {
+    await updateTelegramSettingsMenuMessage(deps);
+    await deps.answerCallbackQuery(callbackQueryId);
+    return true;
+  }
+  if (data === "settings:open:proactive") {
+    await updateProactivePushSettingsMessage(deps);
+    await deps.answerCallbackQuery(callbackQueryId);
+    return true;
+  }
+  if (
+    data === "settings:set:proactive:on" ||
+    data === "settings:set:proactive:off"
+  ) {
+    const enabled = data.endsWith(":on");
+    await deps.setProactivePushEnabled(enabled);
+    await updateProactivePushSettingsMessage(deps);
+    await deps.answerCallbackQuery(
+      callbackQueryId,
+      `Proactive push ${enabled ? "enabled" : "disabled"}`,
+    );
+    return true;
+  }
+  await deps.answerCallbackQuery(callbackQueryId);
+  return true;
+}
+
+export function createTelegramSettingsMenuRuntime<
+  TContext,
+  TModel extends MenuModel = MenuModel,
+>(
+  deps: TelegramSettingsMenuRuntimeDeps<TContext, TModel>,
+): TelegramSettingsMenuRuntime<TContext> {
+  return {
+    openSettingsMenu: (chatId, _replyToMessageId, ctx) =>
+      openTelegramSettingsMenu({
+        getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
+        isProactivePushEnabled: deps.isProactivePushEnabled,
+        sendSettingsMenu: (state, text, replyMarkup) =>
+          deps.sendInteractiveMessage(state.chatId, text, "html", replyMarkup),
+        storeModelMenuState: deps.storeModelMenuState,
+      }),
+    updateSettingsMenuMessage: (state) =>
+      updateTelegramSettingsMenuMessage({
+        isProactivePushEnabled: deps.isProactivePushEnabled,
+        updateSettingsMessage: (text, replyMarkup) =>
+          deps.editInteractiveMessage(
+            state.chatId,
+            state.messageId,
+            text,
+            "html",
+            replyMarkup,
+          ),
+      }),
+    handleCallbackQuery: async (query) => {
+      if (!query.data?.startsWith("settings:")) return false;
+      const state = deps.getStoredModelMenuState(query.message?.message_id);
+      if (!state) {
+        await deps.answerCallbackQuery(
+          query.id,
+          "Interactive message expired.",
+        );
+        return true;
+      }
+      return handleTelegramSettingsMenuCallbackAction(query.id, query.data, {
+        isProactivePushEnabled: deps.isProactivePushEnabled,
+        setProactivePushEnabled: deps.setProactivePushEnabled,
+        updateSettingsMessage: (text, replyMarkup) =>
+          deps.editInteractiveMessage(
+            state.chatId,
+            state.messageId,
+            text,
+            "html",
+            replyMarkup,
+          ),
+        answerCallbackQuery: deps.answerCallbackQuery,
+      });
+    },
+  };
+}

package/lib/menu-status.ts

@@ -21,6 +21,7 @@ import {
 export interface TelegramStatusMenuCallbackDeps {
   updateModelMenuMessage: () => Promise<void>;
   updateThinkingMenuMessage: () => Promise<void>;
+  updateSettingsMenuMessage?: () => Promise<void>;
   answerCallbackQuery: (
     callbackQueryId: string,
     text?: string,
@@ -49,7 +50,7 @@ export interface TelegramStatusMenuOpenDeps<
 
 function isTelegramStatusMenuCallbackAction(
   data: string | undefined,
-  action: "model" | "thinking",
+  action: "model" | "thinking" | "settings",
 ): boolean {
   return data === `menu:${action}` || data === `status:${action}`;
 }
@@ -119,6 +120,12 @@ export async function handleTelegramStatusMenuCallbackAction(
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
   }
+  if (isTelegramStatusMenuCallbackAction(data, "settings")) {
+    if (!deps.updateSettingsMenuMessage) return false;
+    await deps.updateSettingsMenuMessage();
+    await deps.answerCallbackQuery(callbackQueryId);
+    return true;
+  }
   if (!isTelegramStatusMenuCallbackAction(data, "thinking")) return false;
   if (!activeModel?.reasoning) {
     await deps.answerCallbackQuery(
@@ -160,10 +167,16 @@ export function buildStatusReplyMarkup(
   }
   rows.push([
     {
-      text: `⏳ Queue: ${queueItemCount}`,
+      text: `${queueItemCount === 0 ? "⌛" : "⏳"} Queue: ${queueItemCount}`,
       callback_data: "menu:queue",
     },
   ]);
+  rows.push([
+    {
+      text: "⚙️ Settings",
+      callback_data: "menu:settings",
+    },
+  ]);
   return { inline_keyboard: rows };
 }
 

package/lib/menu-thinking.ts

@@ -109,7 +109,7 @@ export async function handleTelegramThinkingMenuCallbackAction(
 }
 
 export function buildThinkingMenuText(): string {
-  return "<b>Choose a thinking level:</b>";
+  return "<b>🧠 Choose a thinking level:</b>";
 }
 
 export function buildThinkingMenuReplyMarkup(
@@ -119,7 +119,7 @@ export function buildThinkingMenuReplyMarkup(
   rows.push(
     ...THINKING_LEVELS.map((level) => [
       {
-        text: level === currentThinkingLevel ? `✅ ${level}` : level,
+        text: level === currentThinkingLevel ? `🟢 ${level}` : level,
         callback_data: `thinking:set:${level}`,
       },
     ]),