@llblab/pi-telegram 0.2.9 → 0.3.0

package/lib/pi.ts

@@ -0,0 +1,80 @@
+/**
+ * pi SDK adapter boundary
+ * Owns direct pi SDK imports and exposes narrow bridge-facing helpers/types for the extension composition layer
+ */
+
+import {
+  type AgentEndEvent,
+  type AgentStartEvent,
+  type BeforeAgentStartEvent,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  type SessionShutdownEvent,
+  type SessionStartEvent,
+  SettingsManager,
+} from "@mariozechner/pi-coding-agent";
+
+export type {
+  AgentEndEvent,
+  AgentStartEvent,
+  BeforeAgentStartEvent,
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+  SessionShutdownEvent,
+  SessionStartEvent,
+};
+
+export interface PiSettingsManager {
+  reload: () => Promise<void>;
+  getEnabledModels: () => string[] | undefined;
+}
+
+export interface PiExtensionApiRuntimePorts {
+  sendUserMessage: ExtensionAPI["sendUserMessage"];
+  getThinkingLevel: ExtensionAPI["getThinkingLevel"];
+  setThinkingLevel: ExtensionAPI["setThinkingLevel"];
+  setModel: ExtensionAPI["setModel"];
+}
+
+export function createExtensionApiRuntimePorts(
+  api: Pick<
+    ExtensionAPI,
+    "sendUserMessage" | "getThinkingLevel" | "setThinkingLevel" | "setModel"
+  >,
+): PiExtensionApiRuntimePorts {
+  return {
+    sendUserMessage: (content) => api.sendUserMessage(content),
+    getThinkingLevel: () => api.getThinkingLevel(),
+    setThinkingLevel: (level) => api.setThinkingLevel(level),
+    setModel: (model) => api.setModel(model),
+  };
+}
+
+export function createSettingsManager(cwd: string): PiSettingsManager {
+  return SettingsManager.create(cwd);
+}
+
+export function getExtensionContextModel(
+  ctx: ExtensionContext,
+): ExtensionContext["model"] {
+  return ctx.model;
+}
+
+export function isExtensionContextIdle(ctx: ExtensionContext): boolean {
+  return ctx.isIdle();
+}
+
+export function hasExtensionContextPendingMessages(
+  ctx: ExtensionContext,
+): boolean {
+  return ctx.hasPendingMessages();
+}
+
+export function compactExtensionContext(
+  ctx: ExtensionContext,
+  callbacks: Parameters<ExtensionContext["compact"]>[0],
+): ReturnType<ExtensionContext["compact"]> {
+  return ctx.compact(callbacks);
+}

package/lib/polling.ts

@@ -3,11 +3,12 @@
  * Owns polling request builders, stop conditions, and the long-poll loop runtime for Telegram updates
  */
 
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-
-import type { TelegramConfig } from "./api.ts";
+export interface TelegramPollingConfig {
+  botToken?: string;
+  lastUpdateId?: number;
+}
 
-export interface TelegramUpdateLike {
+export interface TelegramUpdate {
   update_id: number;
 }
 
@@ -47,7 +48,7 @@ export function buildTelegramLongPollRequest(lastUpdateId?: number): {
 }
 
 export function getLatestTelegramUpdateId(
-  updates: TelegramUpdateLike[],
+  updates: TelegramUpdate[],
 ): number | undefined {
   return updates.at(-1)?.update_id;
 }
@@ -62,25 +63,241 @@ export function shouldStopTelegramPolling(
   );
 }
 
-export interface TelegramPollLoopDeps<TUpdate extends TelegramUpdateLike> {
-  ctx: ExtensionContext;
+export interface TelegramPollingStartState {
+  hasBotToken: boolean;
+  hasPollingPromise: boolean;
+}
+
+export interface TelegramPollingControllerState {
+  pollingPromise?: Promise<void>;
+  pollingController?: AbortController;
+}
+
+export function createTelegramPollingControllerState(): TelegramPollingControllerState {
+  return {};
+}
+
+export function isTelegramPollingControllerActive(
+  state: TelegramPollingControllerState,
+): boolean {
+  return !!state.pollingPromise;
+}
+
+export function createTelegramPollingActivityReader(
+  state: TelegramPollingControllerState,
+): () => boolean {
+  return () => isTelegramPollingControllerActive(state);
+}
+
+export interface TelegramPollingRuntimeDeps<TContext> {
+  hasBotToken: () => boolean;
+  getPollingPromise: () => Promise<void> | undefined;
+  setPollingPromise: (promise: Promise<void> | undefined) => void;
+  getPollingController: () => AbortController | undefined;
+  setPollingController: (controller: AbortController | undefined) => void;
+  stopTypingLoop: () => unknown;
+  runPollLoop: (ctx: TContext, signal: AbortSignal) => Promise<void>;
+  updateStatus: (ctx: TContext) => void;
+  createAbortController?: () => AbortController;
+}
+
+export type TelegramPollingControllerDeps<TContext> = Omit<
+  TelegramPollingRuntimeDeps<TContext>,
+  | "getPollingPromise"
+  | "setPollingPromise"
+  | "getPollingController"
+  | "setPollingController"
+> & { state?: TelegramPollingControllerState };
+
+export interface TelegramPollingController<TContext> {
+  isActive: () => boolean;
+  start: (ctx: TContext) => void;
+  stop: () => Promise<void>;
+}
+
+export interface TelegramPollingControllerRuntimeDeps<
+  TUpdate extends TelegramUpdate,
+  TContext = unknown,
+> extends TelegramPollLoopRunnerDeps<TUpdate, TContext> {
+  state?: TelegramPollingControllerState;
+  hasBotToken: () => boolean;
+  stopTypingLoop: () => unknown;
+  createAbortController?: () => AbortController;
+}
+
+export function createTelegramPollingControllerRuntime<
+  TUpdate extends TelegramUpdate,
+  TContext = unknown,
+>(
+  deps: TelegramPollingControllerRuntimeDeps<TUpdate, TContext>,
+): TelegramPollingController<TContext> {
+  return createTelegramPollingController({
+    state: deps.state,
+    hasBotToken: deps.hasBotToken,
+    stopTypingLoop: deps.stopTypingLoop,
+    runPollLoop: createTelegramPollLoopRunner<TUpdate, TContext>({
+      getConfig: deps.getConfig,
+      deleteWebhook: deps.deleteWebhook,
+      getUpdates: deps.getUpdates,
+      persistConfig: deps.persistConfig,
+      handleUpdate: deps.handleUpdate,
+      updateStatus: deps.updateStatus,
+      sleep: deps.sleep,
+      maxUpdateFailures: deps.maxUpdateFailures,
+      recordRuntimeEvent: deps.recordRuntimeEvent,
+    }),
+    updateStatus: deps.updateStatus,
+    createAbortController: deps.createAbortController,
+  });
+}
+
+export function createTelegramPollingController<TContext>(
+  deps: TelegramPollingControllerDeps<TContext>,
+): TelegramPollingController<TContext> {
+  const state = deps.state ?? createTelegramPollingControllerState();
+  const runtimeDeps: TelegramPollingRuntimeDeps<TContext> = {
+    ...deps,
+    getPollingPromise: () => state.pollingPromise,
+    setPollingPromise: (promise) => {
+      state.pollingPromise = promise;
+    },
+    getPollingController: () => state.pollingController,
+    setPollingController: (controller) => {
+      state.pollingController = controller;
+    },
+  };
+  return {
+    isActive: () => isTelegramPollingControllerActive(state),
+    start: (ctx) => startTelegramPollingRuntime(ctx, runtimeDeps),
+    stop: () => stopTelegramPollingRuntime(runtimeDeps),
+  };
+}
+
+export function shouldStartTelegramPolling(
+  state: TelegramPollingStartState,
+): boolean {
+  return state.hasBotToken && !state.hasPollingPromise;
+}
+
+export async function stopTelegramPollingRuntime<TContext>(
+  deps: TelegramPollingRuntimeDeps<TContext>,
+): Promise<void> {
+  deps.stopTypingLoop();
+  deps.getPollingController()?.abort();
+  deps.setPollingController(undefined);
+  await deps.getPollingPromise()?.catch(() => undefined);
+  deps.setPollingPromise(undefined);
+}
+
+export function startTelegramPollingRuntime<TContext>(
+  ctx: TContext,
+  deps: TelegramPollingRuntimeDeps<TContext>,
+): void {
+  if (
+    !shouldStartTelegramPolling({
+      hasBotToken: deps.hasBotToken(),
+      hasPollingPromise: !!deps.getPollingPromise(),
+    })
+  ) {
+    return;
+  }
+  const controller = deps.createAbortController?.() ?? new AbortController();
+  deps.setPollingController(controller);
+  const promise = deps.runPollLoop(ctx, controller.signal).finally(() => {
+    deps.setPollingPromise(undefined);
+    deps.setPollingController(undefined);
+    deps.updateStatus(ctx);
+  });
+  deps.setPollingPromise(promise);
+  deps.updateStatus(ctx);
+}
+
+export interface TelegramRuntimeEventRecorderPort {
+  recordRuntimeEvent?: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+}
+
+export interface TelegramPollLoopDeps<
+  TUpdate extends TelegramUpdate,
+  TContext = unknown,
+> extends TelegramRuntimeEventRecorderPort {
+  ctx: TContext;
   signal: AbortSignal;
-  config: TelegramConfig;
-  deleteWebhook: (signal: AbortSignal) => Promise<void>;
+  config: TelegramPollingConfig;
+  deleteWebhook: (signal: AbortSignal) => Promise<unknown>;
   getUpdates: (
     body: Record<string, unknown>,
     signal: AbortSignal,
   ) => Promise<TUpdate[]>;
   persistConfig: () => Promise<void>;
-  handleUpdate: (update: TUpdate, ctx: ExtensionContext) => Promise<void>;
+  handleUpdate: (update: TUpdate, ctx: TContext) => Promise<void>;
   onErrorStatus: (message: string) => void;
   onStatusReset: () => void;
   sleep: (ms: number) => Promise<void>;
+  maxUpdateFailures?: number;
 }
 
-export async function runTelegramPollLoop<TUpdate extends TelegramUpdateLike>(
-  deps: TelegramPollLoopDeps<TUpdate>,
-): Promise<void> {
+export interface TelegramPollLoopRunnerDeps<
+  TUpdate extends TelegramUpdate,
+  TContext = unknown,
+> extends TelegramRuntimeEventRecorderPort {
+  getConfig: () => TelegramPollingConfig;
+  deleteWebhook: (signal: AbortSignal) => Promise<unknown>;
+  getUpdates: (
+    body: Record<string, unknown>,
+    signal: AbortSignal,
+  ) => Promise<TUpdate[]>;
+  persistConfig: () => Promise<void>;
+  handleUpdate: (update: TUpdate, ctx: TContext) => Promise<void>;
+  updateStatus: (ctx: TContext, message?: string) => void;
+  sleep?: (ms: number) => Promise<void>;
+  maxUpdateFailures?: number;
+}
+
+export function createTelegramPollLoopRunner<
+  TUpdate extends TelegramUpdate,
+  TContext = unknown,
+>(
+  deps: TelegramPollLoopRunnerDeps<TUpdate, TContext>,
+): (ctx: TContext, signal: AbortSignal) => Promise<void> {
+  const sleep =
+    deps.sleep ??
+    ((ms: number) =>
+      new Promise<void>((resolve) => {
+        setTimeout(resolve, ms);
+      }));
+  return (ctx, signal) =>
+    runTelegramPollLoop({
+      ctx,
+      signal,
+      config: deps.getConfig(),
+      deleteWebhook: deps.deleteWebhook,
+      getUpdates: deps.getUpdates,
+      persistConfig: deps.persistConfig,
+      handleUpdate: deps.handleUpdate,
+      onErrorStatus: (message) => {
+        deps.updateStatus(ctx, message);
+      },
+      onStatusReset: () => {
+        deps.updateStatus(ctx);
+      },
+      sleep,
+      maxUpdateFailures: deps.maxUpdateFailures,
+      recordRuntimeEvent: deps.recordRuntimeEvent,
+    });
+}
+
+function getTelegramPollingErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function runTelegramPollLoop<
+  TUpdate extends TelegramUpdate,
+  TContext = unknown,
+>(deps: TelegramPollLoopDeps<TUpdate, TContext>): Promise<void> {
   if (!deps.config.botToken) return;
   try {
     await deps.deleteWebhook(deps.signal);
@@ -102,6 +319,9 @@ export async function runTelegramPollLoop<TUpdate extends TelegramUpdateLike>(
       // ignore
     }
   }
+  const maxUpdateFailures = Math.max(1, deps.maxUpdateFailures ?? 3);
+  const updateFailures = new Map<number, number>();
+  let handledUpdateFailureRethrown = false;
   while (!deps.signal.aborted) {
     try {
       const updates = await deps.getUpdates(
@@ -109,14 +329,40 @@ export async function runTelegramPollLoop<TUpdate extends TelegramUpdateLike>(
         deps.signal,
       );
       for (const update of updates) {
-        deps.config.lastUpdateId = update.update_id;
-        await deps.persistConfig();
-        await deps.handleUpdate(update, deps.ctx);
+        try {
+          await deps.handleUpdate(update, deps.ctx);
+          deps.config.lastUpdateId = update.update_id;
+          updateFailures.delete(update.update_id);
+          await deps.persistConfig();
+        } catch (error) {
+          const failureCount = (updateFailures.get(update.update_id) ?? 0) + 1;
+          updateFailures.set(update.update_id, failureCount);
+          deps.recordRuntimeEvent?.("polling", error, {
+            phase: "handleUpdate",
+            updateId: update.update_id,
+            failureCount,
+          });
+          if (failureCount < maxUpdateFailures) {
+            handledUpdateFailureRethrown = true;
+            throw error;
+          }
+          const message = getTelegramPollingErrorMessage(error);
+          deps.onErrorStatus(
+            `skipping Telegram update ${update.update_id} after ${failureCount} failures: ${message}`,
+          );
+          deps.config.lastUpdateId = update.update_id;
+          updateFailures.delete(update.update_id);
+          await deps.persistConfig();
+        }
       }
     } catch (error) {
       if (shouldStopTelegramPolling(deps.signal.aborted, error)) return;
-      const message = error instanceof Error ? error.message : String(error);
-      deps.onErrorStatus(message);
+      if (handledUpdateFailureRethrown) {
+        handledUpdateFailureRethrown = false;
+      } else {
+        deps.recordRuntimeEvent?.("polling", error, { phase: "loop" });
+      }
+      deps.onErrorStatus(getTelegramPollingErrorMessage(error));
       await deps.sleep(3000);
       deps.onStatusReset();
     }