@llblab/pi-telegram 0.51.5 → 0.52.0

package/lib/keyboard.ts

@@ -21,9 +21,9 @@ export interface TelegramInlineKeyboardMarkup {
   inline_keyboard: TelegramInlineKeyboardButton[][];
 }
 
-export const TELEGRAM_CALLBACK_DATA_MAX_BYTES = 64;
+const TELEGRAM_CALLBACK_DATA_MAX_BYTES = 64;
 
-export function getTelegramCallbackDataByteLength(value: string): number {
+function getTelegramCallbackDataByteLength(value: string): number {
   return new TextEncoder().encode(value).byteLength;
 }
 

package/lib/lifecycle.ts

@@ -1,9 +1,12 @@
 /**
- * Telegram lifecycle hook registration helpers
+ * Telegram session lifecycle coordination and hook registration
  * Zones: pi agent lifecycle, telegram session
- * Binds prepared Telegram lifecycle runtimes to pi extension lifecycle events
+ * Owns context generations, bounded connect intent across resume, and session sequencing.
+ * Transport authority, durable bindings, and queue custody remain with their owners.
  */
 
+import { randomUUID } from "node:crypto";
+import { formatTelegramConnectionFailure } from "./status.ts";
 import * as BusFollower from "./bus-follower.ts";
 import * as Queue from "./queue.ts";
 import * as TextGroups from "./text-groups.ts";
@@ -157,6 +160,130 @@ export interface TelegramSessionLifecycleHooks {
   ) => Promise<void>;
 }
 
+export interface TelegramConnectionIntent {
+  id: string;
+  cwd: string;
+  profileName?: string;
+}
+interface TelegramConnectionHandoff extends TelegramConnectionIntent {
+  pid: number;
+  targetSessionFile: string;
+  expiresAtMs: number;
+}
+export interface TelegramConnectionHandoffStore {
+  pending?: TelegramConnectionHandoff;
+}
+const HANDOFF_KEY = Symbol.for("pi-telegram.connection-resume.v1");
+function processHandoffStore(): TelegramConnectionHandoffStore {
+  const globals = globalThis as unknown as Record<symbol, TelegramConnectionHandoffStore>;
+  return globals[HANDOFF_KEY] ??= {};
+}
+
+export interface TelegramConnectionLifecycle {
+  prepare(event: SessionStartEvent, ctx: ExtensionContext): (() => void) | undefined;
+  onSessionShutdown(event: SessionShutdownEvent, ctx: ExtensionContext): void;
+}
+
+export function createTelegramConnectionLifecycle(deps: {
+  intent: ReturnType<typeof createTelegramConnectionIntentRuntime>;
+  getGeneration(): number;
+  isCurrent(ctx: ExtensionContext): boolean;
+  getProfileName(): string | undefined;
+  isConnected(): boolean;
+  activateProfile(profileName: string | undefined, isCurrent: () => boolean): Promise<boolean>;
+  start(ctx: ExtensionContext): Promise<{ ok: boolean; message?: string }>;
+  recordError(error: unknown): void;
+}): TelegramConnectionLifecycle {
+  return {
+    onSessionShutdown(event, ctx) {
+      deps.intent.suspend({ reason: event.reason, cwd: ctx.cwd,
+        targetSessionFile: event.targetSessionFile, connected: deps.isConnected(),
+        profileName: deps.getProfileName() });
+    },
+    prepare(event, ctx) {
+      const intent = deps.intent.resume({ reason: event.reason, cwd: ctx.cwd,
+        sessionFile: event.reason === "resume" ? ctx.sessionManager.getSessionFile() : undefined });
+      if (!intent) return undefined;
+      const generation = deps.getGeneration();
+      const isCurrent = () => deps.intent.isActive(intent.id) &&
+        generation === deps.getGeneration() && deps.isCurrent(ctx);
+      return () => {
+        // Startup remains extension-owned background work; no captured command ctx crosses resume.
+        void (async () => {
+          if (!isCurrent()) return;
+          if (!await deps.activateProfile(intent.profileName, isCurrent)) {
+            if (isCurrent()) ctx.ui.notify("Telegram profile unavailable. Run /telegram-setup.", "warning");
+            return;
+          }
+          if (!isCurrent()) return;
+          const result = await deps.start(ctx);
+          if (!isCurrent()) return;
+          if (!result.ok) {
+            deps.recordError(new Error(result.message ?? "Telegram resume connection failed."));
+            ctx.ui.notify(formatTelegramConnectionFailure(result.message), "warning");
+          }
+        })().catch((error) => {
+          deps.recordError(error);
+          if (isCurrent()) ctx.ui.notify(formatTelegramConnectionFailure(error), "warning");
+        }).finally(() => deps.intent.finish(intent.id));
+      };
+    },
+  };
+}
+
+export function createTelegramConnectionIntentRuntime(options: {
+  store?: TelegramConnectionHandoffStore;
+  now?: () => number;
+  pid?: number;
+} = {}) {
+  const store = options.store ?? processHandoffStore();
+  const now = options.now ?? Date.now;
+  const pid = options.pid ?? process.pid;
+  let active: TelegramConnectionIntent | undefined;
+  return {
+    begin(cwd: string, profileName?: string): string {
+      store.pending = undefined;
+      active = { id: randomUUID(), cwd, profileName };
+      return active.id;
+    },
+    isActive(id: string): boolean {
+      return active?.id === id;
+    },
+    finish(id: string): void {
+      if (active?.id === id) active = undefined;
+    },
+    cancel(): void {
+      active = undefined;
+      store.pending = undefined;
+    },
+    suspend(input: {
+      reason: string;
+      cwd: string;
+      targetSessionFile?: string;
+      connected: boolean;
+      profileName?: string;
+    }): void {
+      const intent = active ?? (input.connected
+        ? { id: randomUUID(), cwd: input.cwd, profileName: input.profileName }
+        : undefined);
+      active = undefined;
+      store.pending = input.reason === "resume" && input.targetSessionFile &&
+          intent?.cwd === input.cwd
+        ? { ...intent, pid, targetSessionFile: input.targetSessionFile, expiresAtMs: now() + 30_000 }
+        : undefined;
+    },
+    resume(input: { reason: string; cwd: string; sessionFile?: string }): TelegramConnectionIntent | undefined {
+      const handoff = store.pending;
+      store.pending = undefined;
+      if (!handoff || handoff.pid !== pid || now() >= handoff.expiresAtMs ||
+          input.reason !== "resume" || input.cwd !== handoff.cwd ||
+          input.sessionFile !== handoff.targetSessionFile) return undefined;
+      active = { id: randomUUID(), cwd: handoff.cwd, profileName: handoff.profileName };
+      return { ...active };
+    },
+  };
+}
+
 export interface TelegramSessionContextStore<TContext> {
   get: () => TContext | undefined;
   getGeneration: () => number;
@@ -250,6 +377,7 @@ export function createTelegramSessionGenerationFence(
 }
 
 export interface TelegramBridgeSessionServiceRuntime {
+  connection?: TelegramConnectionLifecycle;
   resumeGroupedInput(ctx: ExtensionContext): void;
   suspendGroupedInput(): void;
   delivery: {
@@ -319,6 +447,7 @@ export interface TelegramBridgeSessionLifecyclePorts<
     };
     delivery: TelegramBridgeSessionServiceRuntime["delivery"];
     polling: TelegramBridgeSessionServiceRuntime["polling"];
+    connection?: TelegramBridgeSessionServiceRuntime["connection"];
     inboundWorker: TelegramBridgeSessionServiceRuntime["inboundWorker"];
     capabilityMonitor: TelegramBridgeSessionServiceRuntime["capabilityMonitor"];
     queueWatchdog: TelegramBridgeSessionServiceRuntime["queueWatchdog"];
@@ -348,6 +477,7 @@ export function createTelegramBridgeSessionLifecycleDeps<
       }),
       delivery: ports.services.delivery,
       polling: ports.services.polling,
+      connection: ports.services.connection,
       inboundWorker: ports.services.inboundWorker,
       capabilityMonitor: ports.services.capabilityMonitor,
       queueWatchdog: ports.services.queueWatchdog,
@@ -371,19 +501,23 @@ export function createTelegramBridgeSessionLifecycleAssembly<
       suspendPolling: deps.follower.suspendPolling,
       recordRuntimeEvent: deps.follower.recordRuntimeEvent,
     });
+  let preserveTarget = true;
   const queueLifecycle = Queue.createTelegramSessionLifecycleRuntime({
     ...deps.queue,
     isSessionActive,
-    stopPolling: suspendForReplacement,
+    stopPolling: () => suspendForReplacement(preserveTarget),
     clearPendingMediaGroups: deps.services.suspendGroupedInput,
   });
   const servicesLifecycle: TelegramSessionLifecycleHooks = {
     async onSessionStart(event, ctx) {
+      const resumeConnection = deps.services.connection?.prepare(event, ctx);
       await queueLifecycle.onSessionStart(event, ctx);
       if (!isSessionActive(ctx)) return;
       deps.services.resumeGroupedInput(ctx);
       await deps.services.delivery.onSessionStart();
-      await deps.services.polling.onSessionStart(event, ctx);
+      if (!isSessionActive(ctx)) return;
+      if (resumeConnection) resumeConnection();
+      else await deps.services.polling.onSessionStart(event, ctx);
       deps.services.capabilityMonitor.start(ctx);
       deps.services.queueWatchdog.start(ctx);
     },
@@ -391,6 +525,8 @@ export function createTelegramBridgeSessionLifecycleAssembly<
       const generation = deps.contextStore.getGeneration();
       const isCurrent = () => deps.contextStore.isCurrent(ctx, generation);
       if (!isCurrent()) return;
+      deps.services.connection?.onSessionShutdown(event, ctx);
+      preserveTarget = event.reason !== "resume";
       let preserveThread: (() => Promise<void>) | undefined;
       if (event.reason === "quit") {
         try {
@@ -515,7 +651,7 @@ export function createTelegramCompactionObserverRuntime<TContext>(
           "compact",
           new Error("Compaction observer timed out"),
         );
-        deps.onCompactionAbandoned?.();
+        // Observer expiry releases local presence, not Pi's eventual terminal result.
         requestDispatch();
       }, timeoutMs);
       unrefTelegramLifecycleTimer(fallbackTimer);