@llblab/pi-telegram 0.18.3 → 0.18.5

package/lib/preview.ts

@@ -12,7 +12,6 @@ import {
 } from "./target.ts";
 import { shouldSuppressPreviewForVoice } from "./voice.ts";
 
-const TELEGRAM_PREVIEW_THROTTLE_MS = 0;
 const TELEGRAM_DRAFT_ID_MAX = 2_147_483_647;
 const TELEGRAM_DRAFT_PREVIEW_MAX_CHARS = 4096;
 
@@ -26,7 +25,6 @@ export interface TelegramPreviewState {
 }
 
 export interface TelegramPreviewRuntimeState extends TelegramPreviewState {
-  flushTimer?: ReturnType<typeof setTimeout>;
   flushPromise?: Promise<void>;
   flushRequested?: boolean;
 }
@@ -36,7 +34,6 @@ export type TelegramPreviewReplyMarkup = unknown;
 export interface TelegramPreviewRuntimeDeps {
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
-  clearScheduledFlush: (state: TelegramPreviewRuntimeState) => void;
   maxMessageLength: number;
   getDraftSupport: () => TelegramDraftSupport;
   setDraftSupport: (support: TelegramDraftSupport) => void;
@@ -132,13 +129,7 @@ export interface TelegramPreviewControllerDeps {
     },
   ) => Promise<unknown>;
   canSend?: () => boolean;
-  throttleMs?: number;
   maxDraftId?: number;
-  setTimer?: (
-    callback: () => void,
-    ms: number,
-  ) => ReturnType<typeof setTimeout>;
-  clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
   recordRuntimeEvent?: (
     category: string,
     error: unknown,
@@ -154,7 +145,7 @@ export interface TelegramPreviewController {
   resetState: () => void;
   clear: (
     chatId: number,
-    options?: { target?: TelegramTarget },
+    options?: { awaitFlush?: boolean; target?: TelegramTarget },
   ) => Promise<void>;
   flush: (
     chatId: number,
@@ -171,7 +162,8 @@ export interface TelegramPreviewController {
   ) => Promise<boolean>;
 }
 
-export type TelegramPreviewControllerRuntimeDeps = TelegramPreviewControllerDeps;
+export type TelegramPreviewControllerRuntimeDeps =
+  TelegramPreviewControllerDeps;
 
 export function createTelegramPreviewControllerRuntime(
   deps: TelegramPreviewControllerRuntimeDeps,
@@ -181,10 +173,7 @@ export function createTelegramPreviewControllerRuntime(
     maxMessageLength: deps.maxMessageLength,
     initialDraftSupport: deps.initialDraftSupport,
     sendDraft: deps.sendDraft,
-    throttleMs: deps.throttleMs,
     maxDraftId: deps.maxDraftId,
-    setTimer: deps.setTimer,
-    clearTimer: deps.clearTimer,
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
 }
@@ -223,7 +212,7 @@ export function createTelegramNativeMarkdownPreviewFinalizer<
   getState: () => TelegramPreviewRuntimeState | undefined;
   clear: (
     chatId: number,
-    options?: { target?: TelegramTarget },
+    options?: { awaitFlush?: boolean; target?: TelegramTarget },
   ) => Promise<void>;
   discard?: () => void;
   sendMarkdownReply: (
@@ -283,12 +272,6 @@ export function createTelegramPreviewController(
   deps: TelegramPreviewControllerDeps,
 ): TelegramPreviewController {
   let state: TelegramPreviewRuntimeState | undefined;
-  const clearTimer = deps.clearTimer ?? clearTimeout;
-  const setTimer =
-    deps.setTimer ??
-    ((callback: () => void, ms: number): ReturnType<typeof setTimeout> =>
-      setTimeout(callback, ms));
-  const throttleMs = deps.throttleMs ?? TELEGRAM_PREVIEW_THROTTLE_MS;
   const maxDraftId = deps.maxDraftId ?? TELEGRAM_DRAFT_ID_MAX;
   const maxMessageLength =
     deps.maxMessageLength ?? TELEGRAM_DRAFT_PREVIEW_MAX_CHARS;
@@ -299,11 +282,6 @@ export function createTelegramPreviewController(
     setState: (nextState) => {
       state = nextState;
     },
-    clearScheduledFlush: (nextState) => {
-      if (!nextState.flushTimer) return;
-      clearTimer(nextState.flushTimer);
-      nextState.flushTimer = undefined;
-    },
     maxMessageLength,
     getDraftSupport: () => draftSupport,
     setDraftSupport: (support) => {
@@ -334,15 +312,8 @@ export function createTelegramPreviewController(
     flush: (chatId, options) =>
       flushTelegramPreview(chatId, getRuntimeDeps(), options),
     scheduleFlush: (chatId, options) => {
-      if (!state || state.flushTimer) return;
-      if (throttleMs <= 0) {
-        void flushTelegramPreview(chatId, getRuntimeDeps(), options);
-        return;
-      }
-      state.flushTimer = setTimer(() => {
-        void flushTelegramPreview(chatId, getRuntimeDeps(), options);
-      }, throttleMs);
-      state.flushTimer.unref?.();
+      if (!state) return;
+      void flushTelegramPreview(chatId, getRuntimeDeps(), options);
     },
     finalize: (chatId, _replyToMessageId, options) =>
       finalizeTelegramPreview(chatId, getRuntimeDeps(), options),
@@ -464,7 +435,6 @@ export async function clearTelegramPreview(
 ): Promise<void> {
   const state = deps.getState();
   if (!state) return;
-  deps.clearScheduledFlush(state);
   if (state.flushPromise && options.awaitFlush !== false) {
     state.flushRequested = false;
     await state.flushPromise.catch(() => {});
@@ -699,6 +669,10 @@ function findSafeTelegramRichMarkdownDraftEnd(markdown: string): number {
   return safeEnd;
 }
 
+function hasTelegramPreviewVisibleContent(markdown: string): boolean {
+  return /[\p{L}\p{N}]/u.test(markdown);
+}
+
 export function getSafeTelegramRichMarkdownDraftPrefix(
   markdown: string,
   maxMessageLength: number,
@@ -710,13 +684,21 @@ export function getSafeTelegramRichMarkdownDraftPrefix(
       ? source.slice(0, maxMessageLength)
       : source;
   const safeEnd = findSafeTelegramRichMarkdownDraftEnd(limited);
-  if (safeEnd > 0) return limited.slice(0, safeEnd).trimEnd() || undefined;
+  if (safeEnd > 0) {
+    const safePrefix = limited.slice(0, safeEnd).trimEnd();
+    return hasTelegramPreviewVisibleContent(safePrefix)
+      ? safePrefix
+      : undefined;
+  }
   let candidateEnd = limited.length;
   while (candidateEnd > 0) {
     candidateEnd = limited.lastIndexOf(" ", candidateEnd - 1);
     if (candidateEnd <= 0) return undefined;
     const candidate = limited.slice(0, candidateEnd).trimEnd();
-    if (findSafeTelegramRichMarkdownDraftEnd(candidate) === candidate.length) {
+    if (
+      hasTelegramPreviewVisibleContent(candidate) &&
+      findSafeTelegramRichMarkdownDraftEnd(candidate) === candidate.length
+    ) {
       return candidate || undefined;
     }
   }
@@ -795,7 +777,6 @@ export async function flushTelegramPreview(
     await state.flushPromise;
     return;
   }
-  state.flushTimer = undefined;
   state.flushPromise = (async () => {
     do {
       state.flushRequested = false;

package/lib/queue.ts

@@ -1920,6 +1920,76 @@ export function createTelegramDeferredQueueDispatchRuntime<TContext = unknown>(
   };
 }
 
+// --- Dispatch Watchdog Runtime ---
+
+export interface TelegramQueueDispatchWatchdogRuntime<TContext = unknown> {
+  start: (ctx: TContext) => void;
+  stop: () => void;
+  poke: () => void;
+}
+
+export interface TelegramQueueDispatchWatchdogRuntimeDeps<
+  TContext = unknown,
+> extends TelegramRuntimeEventRecorderPort {
+  hasQueuedItems: () => boolean;
+  dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  intervalMs?: number;
+  setInterval?: (
+    callback: () => void,
+    ms: number,
+  ) => ReturnType<typeof setInterval>;
+  clearInterval?: (timer: ReturnType<typeof setInterval>) => void;
+}
+
+export function createTelegramQueueDispatchWatchdogRuntime<
+  TContext = unknown,
+>(
+  deps: TelegramQueueDispatchWatchdogRuntimeDeps<TContext>,
+): TelegramQueueDispatchWatchdogRuntime<TContext> {
+  const intervalMs = deps.intervalMs ?? 1000;
+  const setIntervalFn: NonNullable<
+    TelegramQueueDispatchWatchdogRuntimeDeps<TContext>["setInterval"]
+  > = deps.setInterval ?? ((callback, ms) => setInterval(callback, ms));
+  const clearIntervalFn: NonNullable<
+    TelegramQueueDispatchWatchdogRuntimeDeps<TContext>["clearInterval"]
+  > = deps.clearInterval ?? ((timer) => clearInterval(timer));
+  let ctx: TContext | undefined;
+  let interval: ReturnType<typeof setInterval> | undefined;
+  let dispatchInFlight = false;
+  const tick = (): void => {
+    if (ctx === undefined || dispatchInFlight || !deps.hasQueuedItems()) return;
+    dispatchInFlight = true;
+    try {
+      deps.dispatchNextQueuedTelegramTurn(ctx);
+    } catch (error) {
+      deps.recordRuntimeEvent?.("dispatch", error, {
+        phase: "queue-watchdog",
+      });
+    } finally {
+      dispatchInFlight = false;
+    }
+  };
+  const stop = (): void => {
+    ctx = undefined;
+    if (!interval) return;
+    clearIntervalFn(interval);
+    interval = undefined;
+  };
+  return {
+    start: (nextCtx) => {
+      ctx = nextCtx;
+      if (!interval) {
+        const nextInterval = setIntervalFn(tick, intervalMs);
+        interval = nextInterval;
+        nextInterval.unref?.();
+      }
+      tick();
+    },
+    stop,
+    poke: tick,
+  };
+}
+
 // --- Dispatch Runtime ---
 
 export interface TelegramPromptDeliveryOptions {

package/lib/runtime-log.ts

@@ -4,7 +4,14 @@
  * Owns session-local append-only runtime evidence for debugging without becoming routing state
  */
 
-import { existsSync, mkdirSync, statSync, writeFileSync, appendFile } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  statSync,
+  writeFileSync,
+  appendFile,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
@@ -17,6 +24,7 @@ export interface TelegramRuntimeJsonlEvent {
 
 export interface TelegramRuntimeJsonlLogOptions {
   path?: string;
+  previousPath?: string;
   maxBytes?: number;
   getNowMs?: () => number;
 }
@@ -57,6 +65,8 @@ export function createTelegramRuntimeJsonlLog(
   options: TelegramRuntimeJsonlLogOptions = {},
 ): TelegramRuntimeJsonlLog {
   const path = options.path ?? getTelegramRuntimeLogPath();
+  const previousPath =
+    options.previousPath ?? path.replace(/\.jsonl$/u, ".previous.jsonl");
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_LOG_BYTES;
   const getNowMs = options.getNowMs ?? Date.now;
   let scopeKey: string | undefined;
@@ -66,8 +76,15 @@ export function createTelegramRuntimeJsonlLog(
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
   };
 
+  const preserveCurrentLog = () => {
+    if (!existsSync(path)) return;
+    mkdirSync(dirname(previousPath), { recursive: true, mode: 0o700 });
+    copyFileSync(path, previousPath);
+  };
+
   const writeReset = (reason: string, scope?: Record<string, unknown>) => {
     ensureParent();
+    preserveCurrentLog();
     writeFileSync(
       path,
       safeJsonLine({
@@ -75,6 +92,7 @@ export function createTelegramRuntimeJsonlLog(
         kind: "reset",
         reason,
         scope,
+        previousPath,
       }) + "\n",
       { mode: 0o600 },
     );

package/lib/status.ts

@@ -113,6 +113,17 @@ export interface TelegramBridgeStatusBusFollower {
   status?: string;
 }
 
+export interface TelegramBridgeStatusLocalBus {
+  leaderSocketPath?: string;
+  leaderTransport?: "pipe" | "socket";
+  followerSocketPath?: string;
+  followerTransport?: "pipe" | "socket";
+  followerRegistered?: boolean;
+  followerTarget?: { chatId: number; threadId?: number };
+  followerSlot?: string;
+  followerThreadName?: string;
+}
+
 export interface TelegramBridgeStatusTopicTarget {
   instanceId?: string;
   status?: string;
@@ -187,6 +198,7 @@ export interface TelegramBridgeStatusLineState {
   pendingModelSwitch: boolean;
   queuedItems: Array<{ queueLane: TelegramStatusQueueLane }>;
   busFollowers?: TelegramBridgeStatusBusFollower[];
+  localBus?: TelegramBridgeStatusLocalBus;
   topicTargets?: TelegramBridgeStatusTopicTarget[];
   threadReservations?: TelegramBridgeStatusThreadReservation[];
   topicSyncObservations?: TelegramBridgeStatusSyncObservation[];
@@ -266,6 +278,7 @@ export interface TelegramBridgeStatusRuntimeDeps<
       }
     | undefined;
   getBusFollowers?: () => TelegramBridgeStatusBusFollower[];
+  getLocalBus?: () => TelegramBridgeStatusLocalBus | undefined;
   getTopicTargets?: () => TelegramBridgeStatusTopicTarget[];
   getThreadReservations?: () => TelegramBridgeStatusThreadReservation[];
   getTopicSyncObservations?: () => TelegramBridgeStatusSyncObservation[];
@@ -626,6 +639,7 @@ export function createTelegramBridgeStatusRuntime<
         pendingModelSwitch: deps.hasPendingModelSwitch(),
         queuedItems: deps.getQueuedItems(),
         busFollowers: deps.getBusFollowers?.(),
+        localBus: deps.getLocalBus?.(),
         topicTargets: deps.getTopicTargets?.(),
         threadReservations: deps.getThreadReservations?.(),
         topicSyncObservations: deps.getTopicSyncObservations?.(),
@@ -682,6 +696,7 @@ export function createTelegramStatusSnapshot(
     },
     liveRoster: {
       busFollowers: state.busFollowers ?? [],
+      ...(state.localBus ? { localBus: state.localBus } : {}),
       topicTargets: state.topicTargets ?? [],
       reservations: state.threadReservations ?? [],
       syncObservations: state.topicSyncObservations ?? [],
@@ -824,6 +839,38 @@ function buildTelegramBusFollowerLines(
   ];
 }
 
+function buildTelegramLocalBusLines(
+  state: Pick<TelegramBridgeStatusLineState, "localBus">,
+  options: { verbose?: boolean } = {},
+): string[] {
+  const localBus = state.localBus;
+  if (!localBus) return [];
+  const target = formatTelegramStatusTarget(localBus.followerTarget);
+  const label = formatTelegramThreadStatusLabel({
+    slot: localBus.followerSlot,
+    threadName: localBus.followerThreadName,
+  });
+  const followerLine = `- follower registered: ${localBus.followerRegistered ? "yes" : "no"}${label ? ` ${label}` : ""}${target}`;
+  const lines = ["", "local bus:", followerLine];
+  if (options.verbose) {
+    if (localBus.leaderSocketPath) {
+      const transport = localBus.leaderTransport
+        ? ` [${localBus.leaderTransport}]`
+        : "";
+      lines.push(`- leader endpoint${transport}: ${localBus.leaderSocketPath}`);
+    }
+    if (localBus.followerSocketPath) {
+      const transport = localBus.followerTransport
+        ? ` [${localBus.followerTransport}]`
+        : "";
+      lines.push(
+        `- follower endpoint${transport}: ${localBus.followerSocketPath}`,
+      );
+    }
+  }
+  return lines;
+}
+
 function buildTelegramSyncSliceLines(
   state: Pick<TelegramBridgeStatusLineState, "syncState">,
 ): string[] {
@@ -1038,6 +1085,8 @@ function buildTelegramBridgeCompactStatusLines(
       : []),
     ...(state.pendingModelSwitch ? ["- pending model switch: yes"] : []),
     ...buildTelegramBridgeCompactThreadLines(state),
+    ...buildTelegramBusFollowerLines(state),
+    ...buildTelegramLocalBusLines(state),
     ...buildTelegramThreadReconciliationLines(state),
     "",
     "diagnostics:",
@@ -1100,6 +1149,7 @@ export function buildTelegramBridgeDiagnosticStatusLines(
     `- queued turns: ${state.queuedItems.length}`,
     `- lanes: control=${controlQueueCount}, priority=${priorityQueueCount}, default=${defaultQueueCount}`,
     ...buildTelegramBusFollowerLines(state),
+    ...buildTelegramLocalBusLines(state, { verbose: true }),
     ...buildTelegramTopicTargetDiagnosticLines(state),
     ...buildTelegramThreadReconciliationLines(state),
     ...buildTelegramSyncSliceLines(state),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "private": false,
   "publishConfig": {
     "access": "public"