@llblab/pi-telegram 0.19.3 → 0.20.0

package/lib/bindings.ts

@@ -73,8 +73,8 @@ export function registerTelegramCommandsAndTools({
   getDefaultChatId,
   getDefaultTarget,
   canSendDirect,
-  updateStatus,
   recordRuntimeEvent,
+  updateStatus,
 }: TelegramCommandsAndToolsBindingDeps): void {
   OutboundAttachments.registerTelegramOutboundAttachmentTool(pi, {
     getActiveTurn: activeTurnRuntime.get,
@@ -96,22 +96,72 @@ export function registerTelegramCommandsAndTools({
   });
   Prompts.registerTelegramHelpTool(pi);
   Commands.registerTelegramBridgeCommands(pi, {
-    promptForConfig: Setup.createTelegramSetupPromptRuntime({
-      getConfig: configStore.get,
-      setConfig: configStore.set,
-      setupGuard: setup,
-      getMe: TelegramApi.fetchTelegramBotIdentity,
-      persistConfig,
-      startPolling: lockedPollingRuntime.start,
-      updateStatus,
-      recordRuntimeEvent,
-    }),
+    promptForConfig: async (ctx, profileName) => {
+      const nextProfileName = profileName ?? undefined;
+      if (profileName && !Config.isValidTelegramProfileName(profileName)) {
+        ctx.ui.notify(`Invalid Telegram profile name: ${profileName}`, "error");
+        return;
+      }
+      const previousProfileName = configStore.getActiveProfileName();
+      if (previousProfileName !== nextProfileName) {
+        await (stopPolling ?? lockedPollingRuntime.stop)();
+      }
+      if (!profileName) {
+        configStore.activateProfile(undefined);
+      } else {
+        const storedConfig = configStore.getStoredConfig();
+        if (!storedConfig.profiles?.[profileName]) {
+          configStore.set({
+            ...storedConfig,
+            profiles: {
+              ...(storedConfig.profiles ?? {}),
+              [profileName]: { botToken: "" },
+            },
+          });
+        }
+        configStore.activateProfile(profileName);
+      }
+      const runSetup = Setup.createTelegramSetupPromptRuntime({
+        getConfig: configStore.get,
+        setConfig: configStore.set,
+        setupGuard: setup,
+        getMe: TelegramApi.fetchTelegramBotIdentity,
+        persistConfig,
+        startPolling: lockedPollingRuntime.start,
+        updateStatus,
+        recordRuntimeEvent,
+      });
+      await runSetup(ctx);
+      if (profileName) {
+        ctx.ui.notify(`Profile "${profileName}" saved and connected.`, "info");
+      }
+    },
     getStatusLines,
     reloadConfig: configStore.load,
     hasBotToken: configStore.hasBotToken,
     startPolling: lockedPollingRuntime.start,
     stopPolling: stopPolling ?? lockedPollingRuntime.stop,
     updateStatus,
+    getProfileNames: () =>
+      Config.getTelegramProfileNames(configStore.getStoredConfig()),
+    activateDefaultProfileConfig: async () => {
+      await configStore.load();
+      const previousProfileName = configStore.getActiveProfileName();
+      if (previousProfileName) {
+        await (stopPolling ?? lockedPollingRuntime.stop)();
+      }
+      configStore.activateProfile(undefined);
+    },
+    activateProfileConfig: async (_ctx, profileName) => {
+      await configStore.load();
+      if (!Config.isValidTelegramProfileName(profileName)) return false;
+      const previousProfileName = configStore.getActiveProfileName();
+      if (previousProfileName !== profileName) {
+        await (stopPolling ?? lockedPollingRuntime.stop)();
+      }
+      if (!configStore.activateProfile(profileName)) return false;
+      return true;
+    },
   });
 }
 

package/lib/bus-follower.ts

@@ -90,6 +90,7 @@ export interface TelegramBusFollowerSessionReplacementSuspenderDeps {
   registrationState: Pick<TelegramBusFollowerRegistrationState, "isRegistered">;
   instanceId: string;
   suspendPolling: () => Promise<void>;
+  onFollowerSessionDisconnect?: () => Promise<void> | void;
   recordRuntimeEvent: (
     category: string,
     error: unknown,
@@ -387,24 +388,42 @@ function isTelegramStaleContextError(error: unknown): boolean {
   );
 }
 
+export async function markTelegramFollowerThreadStaleForSessionDisconnect(input: {
+  topicTargetStore: Threads.TelegramTopicTargetStore;
+  target: TelegramTarget;
+}): Promise<void> {
+  await input.topicTargetStore.load();
+  const record = input.topicTargetStore.list().find(
+    (candidate) =>
+      candidate.target.chatId === input.target.chatId &&
+      candidate.target.threadId === input.target.threadId,
+  );
+  const marked = input.topicTargetStore.markStaleByTarget(
+    input.target,
+    "unknown",
+    "Follower session reloaded before reconnect.",
+  );
+  const forgotIdentity = record?.profileKey
+    ? input.topicTargetStore.forgetIdentityByProfileKey(record.profileKey)
+    : false;
+  if (marked || forgotIdentity) await input.topicTargetStore.persist();
+}
+
 export function createTelegramBusFollowerSessionReplacementSuspender(
   deps: TelegramBusFollowerSessionReplacementSuspenderDeps,
 ): () => Promise<void> {
   return async () => {
     if (deps.registrationState.isRegistered()) {
-      setTelegramFollowerSessionHandoff({
-        pid: (deps.getPid ?? (() => process.pid))(),
-        instanceId: deps.instanceId,
-        createdAtMs: (deps.getNowMs ?? Date.now)(),
-      });
+      setTelegramFollowerSessionHandoff(undefined);
+      await deps.onFollowerSessionDisconnect?.();
       deps.recordRuntimeEvent(
         "bus",
-        "Telegram follower registration preserved",
+        "Telegram follower registration stopped for session replacement",
         {
-          phase: "follower-session-preserve",
+          phase: "follower-session-disconnect",
+          instanceId: deps.instanceId,
         },
       );
-      return;
     }
     await deps.suspendPolling();
   };

package/lib/bus-leader.ts

@@ -54,6 +54,7 @@ export interface TelegramBusLeaderTargetProvisionerDeps<TContext> {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
   getCwd?: (ctx: TContext) => string | undefined;
+  getTelegramProfile?: () => string | undefined;
   shouldForceFreshUnnamed?: () => boolean;
   topicTargetStore: Threads.TelegramTopicTargetStore;
   callApi: <TResponse>(
@@ -315,6 +316,10 @@ export function createTelegramBusFollowerTargetProvisioner(
   (TelegramTarget & { slot?: string; threadName?: string }) | undefined
 > {
   const getNowMs = deps.getNowMs ?? Date.now;
+  const pendingRegistrations = new Map<
+    string,
+    Promise<(TelegramTarget & { slot?: string; threadName?: string }) | undefined>
+  >();
   return async (registration) => {
     const registrationStartedAtMs = Date.now();
     const chatId = deps.getAllowedUserId();
@@ -337,6 +342,9 @@ export function createTelegramBusFollowerTargetProvisioner(
       registration.profileKey ?? `manual:${registration.instanceId}`;
     const followerOwner =
       Threads.getTelegramThreadOwnerFromProfileKey(followerProfileKey);
+    const registrationKey = followerProfileKey || registration.instanceId;
+    const pendingRegistration = pendingRegistrations.get(registrationKey);
+    if (pendingRegistration) return pendingRegistration;
     const provisionTarget = async () => {
       deps.onProvisioningStart?.();
       try {
@@ -356,6 +364,9 @@ export function createTelegramBusFollowerTargetProvisioner(
         deps.onProvisioningEnd?.();
       }
     };
+    const runRegistration = async (): Promise<
+      (TelegramTarget & { slot?: string; threadName?: string }) | undefined
+    > => {
     let result = await provisionTarget();
     deps.setSyncState(
       Sync.markTelegramSyncSliceFresh(deps.getSyncState(), "target-bindings", {
@@ -363,48 +374,14 @@ export function createTelegramBusFollowerTargetProvisioner(
         action: "follower-register",
       }),
     );
-    let connectedAnnouncement =
-      createTelegramBusInstanceLifecycleAnnouncement({
-        target: result.target,
-        threadName: result.record.threadName,
-        slot: result.record.slot,
-        state: "connected",
-      });
-    let connectedAnnouncementSent = false;
-    if (result.reused && connectedAnnouncement) {
-      try {
-        await deps.callApi("sendMessage", {
-          chat_id: connectedAnnouncement.target.chatId,
-          message_thread_id: connectedAnnouncement.target.threadId,
-          text: connectedAnnouncement.text,
-          parse_mode: connectedAnnouncement.parseMode,
-        });
-        connectedAnnouncementSent = true;
-      } catch (error) {
-        deps.recordRuntimeEvent("telegram", error, {
-          phase: "follower-topic-reuse-probe",
-          instanceId: registration.instanceId,
-          chatId: result.target.chatId,
-          threadId: result.target.threadId,
+    const connectedAnnouncement = result.reused
+      ? undefined
+      : createTelegramBusInstanceLifecycleAnnouncement({
+          target: result.target,
+          threadName: result.record.threadName,
+          slot: result.record.slot,
+          state: "connected",
         });
-        if (Threads.isTelegramTopicTargetStaleError(error)) {
-          deps.topicTargetStore.markStaleByTarget(
-            result.target,
-            "deleted",
-            "Follower registration found the reusable thread target stale.",
-          );
-          await deps.topicTargetStore.persist();
-          result = await provisionTarget();
-          connectedAnnouncement = createTelegramBusInstanceLifecycleAnnouncement({
-            target: result.target,
-            threadName: result.record.threadName,
-            slot: result.record.slot,
-            state: "connected",
-          });
-          connectedAnnouncementSent = false;
-        }
-      }
-    }
     recordSlowTelegramBusFollowerRegistrationStep(deps, {
       phase: "follower-register-critical",
       elapsedMs: Date.now() - registrationStartedAtMs,
@@ -414,7 +391,7 @@ export function createTelegramBusFollowerTargetProvisioner(
     });
     scheduleTelegramBusLeaderBackgroundTask(async () => {
       const backgroundStartedAtMs = Date.now();
-      if (connectedAnnouncement && !connectedAnnouncementSent) {
+      if (connectedAnnouncement) {
         try {
           await deps.callApi("sendMessage", {
             chat_id: connectedAnnouncement.target.chatId,
@@ -486,6 +463,12 @@ export function createTelegramBusFollowerTargetProvisioner(
       slot: result.record.slot,
       threadName: result.record.threadName,
     };
+    };
+    const registrationPromise = runRegistration().finally(() => {
+      pendingRegistrations.delete(registrationKey);
+    });
+    pendingRegistrations.set(registrationKey, registrationPromise);
+    return registrationPromise;
   };
 }
 
@@ -516,6 +499,7 @@ export function createTelegramBusLeaderTargetProvisioner<TContext>(
         getAllowedUserId: deps.getAllowedUserId,
         instanceId: deps.instanceId,
         cwd: deps.getCwd?.(ctx),
+        telegramProfile: deps.getTelegramProfile?.(),
         forceFreshUnnamed: deps.shouldForceFreshUnnamed?.(),
         getNowMs,
         getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,

package/lib/bus.ts

@@ -13,8 +13,8 @@ import {
   type Server,
   type Socket,
 } from "node:net";
-import { homedir, platform as getPlatform } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { platform as getPlatform } from "node:os";
+import { dirname } from "node:path";
 
 import {
   classifyTelegramBusTransportError,
@@ -30,21 +30,16 @@ import {
   type TelegramBusTransportRetryPolicy,
 } from "./bus-transport.ts";
 import type { TelegramTarget } from "./target.ts";
+import { resolveAgentDir } from "./paths.ts";
 
 export type TelegramBusRole = "leader" | "follower";
 
-function getAgentDir(): string {
-  return process.env.PI_CODING_AGENT_DIR
-    ? resolve(process.env.PI_CODING_AGENT_DIR)
-    : join(homedir(), ".pi", "agent");
-}
-
 export function createTelegramBusAuthSecret(): string {
   return randomBytes(32).toString("base64url");
 }
 
 export function getTelegramBusSocketPath(
-  agentDir = getAgentDir(),
+  agentDir = resolveAgentDir(),
   platform = getPlatform(),
 ): string {
   return getTelegramBusLeaderEndpoint({ agentDir, platform });
@@ -52,7 +47,7 @@ export function getTelegramBusSocketPath(
 
 export function getTelegramBusFollowerSocketPath(
   instanceId: string,
-  agentDir = getAgentDir(),
+  agentDir = resolveAgentDir(),
   platform = getPlatform(),
 ): string {
   return getTelegramBusFollowerEndpoint({ agentDir, platform, instanceId });
@@ -155,7 +150,9 @@ export function isTelegramFollowerApiCallAllowed(input: {
     const messageId = (body as Record<string, unknown>).message_id;
     const parsedMessageId =
       typeof messageId === "number" ? messageId : Number(messageId);
-    return Number.isInteger(parsedMessageId) && matchesId(messageId, parsedMessageId);
+    return (
+      Number.isInteger(parsedMessageId) && matchesId(messageId, parsedMessageId)
+    );
   };
   const isBotCommandRegistration = (body: unknown): boolean => {
     if (!body || typeof body !== "object" || Array.isArray(body)) return false;
@@ -185,7 +182,8 @@ export function isTelegramFollowerApiCallAllowed(input: {
     if (apiMethod === "getMe") return true;
     if (apiMethod === "setMyCommands")
       return isBotCommandRegistration(input.args[1]);
-    if (apiMethod === "sendChatAction") return isTargetChatScoped(input.args[1]);
+    if (apiMethod === "sendChatAction")
+      return isTargetChatScoped(input.args[1]);
     if (apiMethod === "deleteMessage" || apiMethod === "editMessageText") {
       return isTargetMessageScoped(input.args[1]);
     }
@@ -351,9 +349,7 @@ export interface TelegramBusLocalServerDeps {
   handleEnvelope: (
     envelope: TelegramBusEnvelope,
   ) =>
-    | Promise<TelegramBusEnvelope | undefined>
-    | TelegramBusEnvelope
-    | undefined;
+    Promise<TelegramBusEnvelope | undefined> | TelegramBusEnvelope | undefined;
   recordTransportEvent?: TelegramBusTransportEventRecorder;
 }
 
@@ -454,7 +450,9 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
 
 export interface TelegramBusFollowerThreadRestoreHandlerDeps {
   followerRegistry: Pick<TelegramBusFollowerRegistry, "get" | "register">;
-  followerTargetController: ReturnType<typeof createTelegramBusFollowerTargetController>;
+  followerTargetController: ReturnType<
+    typeof createTelegramBusFollowerTargetController
+  >;
   onRestored?: () => void;
 }
 
@@ -517,11 +515,7 @@ export function createTelegramBusFollowerThreadRestoreHandler(
   target: TelegramTarget & { threadId: number };
   oldTarget?: TelegramTarget & { threadId: number };
 }) => Promise<boolean> {
-  return async ({
-    record,
-    target,
-    oldTarget,
-  }) => {
+  return async ({ record, target, oldTarget }) => {
     if (!record.instanceId) return false;
     const follower = deps.followerRegistry.get(record.instanceId);
     if (!follower) return false;
@@ -637,7 +631,10 @@ export function createTelegramBusLocalServer(
           activeServer.close(() => resolve()),
         );
       }
-      if (!isTelegramBusPipePath(deps.socketPath) && existsSync(deps.socketPath)) {
+      if (
+        !isTelegramBusPipePath(deps.socketPath) &&
+        existsSync(deps.socketPath)
+      ) {
         unlinkSync(deps.socketPath);
       }
       deps.recordTransportEvent?.(

package/lib/commands.ts

@@ -295,7 +295,7 @@ export interface TelegramBridgeCommandStartPollingResult {
 }
 
 export interface TelegramBridgeCommandRegistrationDeps {
-  promptForConfig: (ctx: ExtensionCommandContext) => Promise<void>;
+  promptForConfig: (ctx: ExtensionCommandContext, profileName?: string) => Promise<void>;
   getStatusLines: (options?: TelegramBridgeStatusLineOptions) => string[];
   reloadConfig: () => Promise<void>;
   hasBotToken: () => boolean;
@@ -308,6 +308,19 @@ export interface TelegramBridgeCommandRegistrationDeps {
     | TelegramBridgeCommandStartPollingResult;
   stopPolling: () => Promise<void | string>;
   updateStatus: (ctx: ExtensionCommandContext) => void;
+  getProfileNames?: () => string[];
+  activateDefaultProfileConfig?: (ctx: ExtensionCommandContext) => Promise<void>;
+  activateProfileConfig?: (
+    ctx: ExtensionCommandContext,
+    profileName: string,
+  ) => Promise<boolean>;
+}
+
+function parseTelegramProfileArg(args: string): string | undefined {
+  const word = args.trim().split(/\s+/)[0];
+  if (!word || word.length === 0) return undefined;
+  if (word.startsWith("-")) return undefined;
+  return word;
 }
 
 function formatTelegramTakeoverTitle(ctx: ExtensionCommandContext): string {
@@ -331,9 +344,9 @@ export function registerTelegramBridgeCommands(
   deps: TelegramBridgeCommandRegistrationDeps,
 ): void {
   pi.registerCommand("telegram-setup", {
-    description: "Configure Telegram bot token",
-    handler: async (_args, ctx) => {
-      await deps.promptForConfig(ctx);
+    description: "Configure Telegram bot token. Use /telegram-setup <name> for named profiles.",
+    handler: async (args, ctx) => {
+      await deps.promptForConfig(ctx, parseTelegramProfileArg(args));
     },
   });
   pi.registerCommand("telegram-status", {
@@ -346,11 +359,31 @@ export function registerTelegramBridgeCommands(
     },
   });
   pi.registerCommand("telegram-connect", {
-    description: "Start the Telegram bridge in this Pi session",
-    handler: async (_args, ctx) => {
-      await deps.reloadConfig();
+    description: "Start the Telegram bridge. Use /telegram-connect <name> for named profiles.",
+    handler: async (args, ctx) => {
+      const profileName = parseTelegramProfileArg(args);
+      if (profileName && deps.activateProfileConfig) {
+        const ok = await deps.activateProfileConfig(ctx, profileName);
+        if (!ok) {
+          ctx.ui.notify(`Profile "${profileName}" not found.`, "error");
+          deps.updateStatus(ctx);
+          return;
+        }
+        ctx.ui.notify(`Activated profile "${profileName}".`, "info");
+      } else {
+        await (deps.activateDefaultProfileConfig?.(ctx) ?? deps.reloadConfig());
+      }
       if (!deps.hasBotToken()) {
-        await deps.promptForConfig(ctx);
+        const profileNames = deps.getProfileNames?.() ?? [];
+        if (!profileName && profileNames.length > 0) {
+          ctx.ui.notify(
+            `No default Telegram profile configured. Available profiles: ${profileNames.join(", ")}. Use /telegram-connect <profileName> or /telegram-setup to create a default profile.`,
+            "info",
+          );
+          deps.updateStatus(ctx);
+          return;
+        }
+        await deps.promptForConfig(ctx, profileName);
         return;
       }
       let result = await deps.startPolling(ctx, {