@llblab/pi-telegram 0.20.0 → 0.20.2

package/index.ts

@@ -57,29 +57,31 @@ export default function (pi: Pi.ExtensionAPI) {
     setThinkingLevel,
   } = piRuntime;
   const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
-  const telegramInstanceId = `${process.pid}:${Date.now()}`;
-  // Manual follower identity must survive a Pi process reload in the same
-  // terminal. The process id changes on reload, but the parent shell/terminal id
-  // is stable enough to keep the follower bound to its existing Telegram thread.
-  const telegramManualFollowerOwnerId = String(process.ppid || process.pid);
   const getActiveTelegramThreadProfile = function (): string | undefined {
     return configStore.getActiveProfileName();
   };
-  const getTelegramManualFollowerProfileKey = function (): string {
-    return Threads.getTelegramThreadOwnerKey({
-      kind: "manual-follower",
-      instanceId: telegramManualFollowerOwnerId,
-      telegramProfile: getActiveTelegramThreadProfile(),
+  const busProcessRuntime = Bus.createTelegramBusProcessRuntime({
+    getActiveProfileName: getActiveTelegramThreadProfile,
+    pid: process.pid,
+    parentPid: process.ppid,
+    createdAtMs: Date.now(),
+  });
+  const {
+    instanceId: telegramInstanceId,
+    manualFollowerOwnerId: telegramManualFollowerOwnerId,
+    getLeaderSocketPath: getTelegramBusSocketPath,
+    getFollowerSocketPath: getTelegramBusFollowerSocketPath,
+  } = busProcessRuntime;
+  const getTelegramManualFollowerProfileKey =
+    BusFollower.createTelegramManualFollowerProfileKeyResolver({
+      getActiveProfileName: getActiveTelegramThreadProfile,
+      manualFollowerOwnerId: telegramManualFollowerOwnerId,
     });
-  };
   const telegramBusAuthSecret = Bus.createTelegramBusAuthSecret();
   let telegramActiveBusAuthSecret: string | undefined;
   let telegramBusLifecycleOverridePhase:
     | Status.TelegramBridgeBusLifecyclePhase
     | undefined;
-  const telegramBusSocketPath = Bus.getTelegramBusSocketPath();
-  const telegramBusFollowerSocketPath =
-    Bus.getTelegramBusFollowerSocketPath(telegramInstanceId);
   let telegramBusRequestSequence = 0;
   const telegramBusFollowerRegistry = Bus.createTelegramBusFollowerRegistry();
   const telegramBusFollowerRegistrationState =
@@ -300,12 +302,13 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     getLocalBus() {
       return {
-        leaderSocketPath: telegramBusSocketPath,
-        leaderTransport:
-          BusTransport.getTelegramBusTransportKind(telegramBusSocketPath),
-        followerSocketPath: telegramBusFollowerSocketPath,
+        leaderSocketPath: getTelegramBusSocketPath(),
+        leaderTransport: BusTransport.getTelegramBusTransportKind(
+          getTelegramBusSocketPath(),
+        ),
+        followerSocketPath: getTelegramBusFollowerSocketPath(),
         followerTransport: BusTransport.getTelegramBusTransportKind(
-          telegramBusFollowerSocketPath,
+          getTelegramBusFollowerSocketPath(),
         ),
         followerRegistered: telegramBusFollowerRegistrationState.isRegistered(),
         followerTarget: telegramBusFollowerRegistrationState.getTarget(),
@@ -412,7 +415,7 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     getDefaultTarget: proactivePushTargetGetter,
     callFollowerApi: BusFollower.createTelegramBusFollowerApiCaller({
-      socketPath: telegramBusSocketPath,
+      socketPath: getTelegramBusSocketPath,
       instanceId: telegramInstanceId,
       createRequestId() {
         telegramBusRequestSequence += 1;
@@ -641,7 +644,7 @@ export default function (pi: Pi.ExtensionAPI) {
       Routing.TelegramRoutedCallbackQuery,
       Routing.TelegramRoutedMessage
     >({
-      socketPath: telegramBusSocketPath,
+      socketPath: getTelegramBusSocketPath,
       createRequestId() {
         telegramBusRequestSequence += 1;
         return Bus.createTelegramBusRequestId({
@@ -656,7 +659,7 @@ export default function (pi: Pi.ExtensionAPI) {
     });
   const followerTargetController =
     Bus.createTelegramBusFollowerTargetController({
-      socketPath: telegramBusSocketPath,
+      socketPath: getTelegramBusSocketPath,
       createRequestId() {
         telegramBusRequestSequence += 1;
         return Bus.createTelegramBusRequestId({
@@ -804,68 +807,72 @@ export default function (pi: Pi.ExtensionAPI) {
     compact,
     recordRuntimeEvent,
   });
-  const telegramBusForwardedUpdateReceiver =
-    BusFollower.createTelegramBusForwardedUpdateReceiverRuntime<
+  const promoteTelegramBusFollowerToLeader: BusFollower.TelegramBusFollowerPromotionHandler<Pi.ExtensionContext> =
+    BusFollower.createTelegramBusFollowerPromotionHandler<Pi.ExtensionContext>({
+      topicTargetStore: threadStore,
+      instanceId: telegramInstanceId,
+      getActiveProfileName: getActiveTelegramThreadProfile,
+      async startLeader(ctx): Promise<void> {
+        await lockedPollingRuntime.start(ctx, { force: true });
+      },
+      recordRuntimeEvent,
+    });
+  const telegramBusFollowerAssembly: BusFollower.TelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext> =
+    BusFollower.createTelegramBusFollowerRuntimeAssembly<
       Pi.ExtensionContext,
       Updates.TelegramMessageReactionUpdated,
       Routing.TelegramRoutedCallbackQuery,
       Routing.TelegramRoutedMessage
     >({
-      socketPath: telegramBusFollowerSocketPath,
-      instanceId: telegramInstanceId,
-      getContext() {
-        return telegramSessionContextStore.get();
-      },
-      getAuthSecret() {
-        return telegramActiveBusAuthSecret;
-      },
-      handleForwardedCallback(query, ctx) {
-        return inboundRouteRuntime.handleUpdate({ callback_query: query }, ctx);
-      },
-      handleForwardedReaction(reactionUpdate, ctx) {
-        return inboundRouteRuntime.handleAuthorizedReactionUpdate(
-          reactionUpdate,
-          ctx,
-        );
-      },
-      handleForwardedMessage(message, ctx) {
-        return inboundRouteRuntime.handleUpdate(
-          { message: message as never },
-          ctx,
-        );
-      },
-      async handleForwardedEditedMessage(message, ctx) {
-        return inboundRouteRuntime.handleUpdate(
-          { edited_message: message as never },
-          ctx,
-        );
+      receiver: {
+        socketPath: getTelegramBusFollowerSocketPath,
+        instanceId: telegramInstanceId,
+        getContext() {
+          return telegramSessionContextStore.get();
+        },
+        getAuthSecret() {
+          return telegramActiveBusAuthSecret;
+        },
+        handleForwardedCallback(query, ctx) {
+          return inboundRouteRuntime.handleUpdate({ callback_query: query }, ctx);
+        },
+        handleForwardedReaction(reactionUpdate, ctx) {
+          return inboundRouteRuntime.handleAuthorizedReactionUpdate(
+            reactionUpdate,
+            ctx,
+          );
+        },
+        handleForwardedMessage(message, ctx) {
+          return inboundRouteRuntime.handleUpdate(
+            { message: message as never },
+            ctx,
+          );
+        },
+        async handleForwardedEditedMessage(message, ctx) {
+          return inboundRouteRuntime.handleUpdate(
+            { edited_message: message as never },
+            ctx,
+          );
+        },
+        recordRuntimeEvent,
       },
-      handleReplaceTarget:
-        BusFollower.createTelegramBusFollowerTargetReplacementHandler({
-          topicTargetStore: threadStore,
-          registrationState: telegramBusFollowerRegistrationState,
-          instanceId: telegramInstanceId,
-          manualFollowerProfileKey: getTelegramManualFollowerProfileKey(),
-          manualFollowerOwnerId: telegramManualFollowerOwnerId,
-          getSyncState() {
-            return telegramSyncState;
-          },
-          setSyncState(state) {
-            telegramSyncState = state;
-          },
-          updateStatus,
-          recordRuntimeEvent,
-        }),
-      recordRuntimeEvent,
-    });
-  let telegramBusFollowerRegistration: BusFollower.TelegramBusFollowerRegistrationRuntime<Pi.ExtensionContext>;
-  const telegramFollowerHeartbeatRecovery =
-    BusFollower.createTelegramBusFollowerHeartbeatRecoveryHandler<Pi.ExtensionContext>(
-      {
+      targetReplacement: {
+        topicTargetStore: threadStore,
         registrationState: telegramBusFollowerRegistrationState,
-        getRegistrationRuntime() {
-          return telegramBusFollowerRegistration;
+        instanceId: telegramInstanceId,
+        getManualFollowerProfileKey: getTelegramManualFollowerProfileKey,
+        manualFollowerOwnerId: telegramManualFollowerOwnerId,
+        getSyncState() {
+          return telegramSyncState;
+        },
+        setSyncState(state) {
+          telegramSyncState = state;
         },
+        updateStatus,
+        recordRuntimeEvent,
+      },
+      recovery: {
+        registrationState: telegramBusFollowerRegistrationState,
         getLeaderState() {
           return lockRuntime.getState();
         },
@@ -873,46 +880,17 @@ export default function (pi: Pi.ExtensionAPI) {
           telegramBusLifecycleOverridePhase = phase;
         },
         updateStatus,
-        async promoteToLeader(ctx, binding) {
-          const promotedRecord =
-            await Threads.promoteTelegramFollowerBindingToLeader({
-              store: threadStore,
-              instanceId: telegramInstanceId,
-              cwd: ctx.cwd,
-              telegramProfile: getActiveTelegramThreadProfile(),
-              target: binding.target,
-              slot: binding.slot,
-              threadName: binding.threadName,
-            });
-          if (promotedRecord) {
-            recordRuntimeEvent(
-              "bus",
-              "Follower thread binding promoted to leader",
-              {
-                phase: "follower-promoted-binding",
-                chatId: promotedRecord.target.chatId,
-                threadId: promotedRecord.target.threadId,
-                slot: promotedRecord.slot,
-                threadName: promotedRecord.threadName,
-              },
-            );
-          }
-          await lockedPollingRuntime.start(ctx, { force: true });
-        },
+        promoteToLeader: promoteTelegramBusFollowerToLeader,
         sleep(ms) {
           return Polling.sleepTelegramPollingRetry(ms);
         },
         promotionGraceMs: BusFollower.TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS,
         recordRuntimeEvent,
       },
-    );
-  telegramBusFollowerRegistration =
-    BusFollower.createTelegramBusFollowerRegistrationRuntime<Pi.ExtensionContext>(
-      {
+      registration: {
         instanceId: telegramInstanceId,
-        followerBusSocketPath: telegramBusFollowerSocketPath,
-        startReceiving: telegramBusForwardedUpdateReceiver.start,
-        stopReceiving: telegramBusForwardedUpdateReceiver.stop,
+        getFollowerBusSocketPath: getTelegramBusFollowerSocketPath,
+        getLeaderSocketPath: getTelegramBusSocketPath,
         registrationState: telegramBusFollowerRegistrationState,
         createRequestId() {
           telegramBusRequestSequence += 1;
@@ -933,10 +911,11 @@ export default function (pi: Pi.ExtensionAPI) {
         getProfileKey() {
           return getTelegramManualFollowerProfileKey();
         },
-        onHeartbeatFailure: telegramFollowerHeartbeatRecovery,
         recordRuntimeEvent,
       },
-    );
+    });
+  const telegramBusFollowerRegistration =
+    telegramBusFollowerAssembly.registration;
   const pollingRuntime = Polling.createTelegramPollingControllerRuntime({
     state: pollingControllerState,
     getConfig: configStore.get,
@@ -966,116 +945,67 @@ export default function (pi: Pi.ExtensionAPI) {
       recordEvent: recordRuntimeEvent,
     });
   };
-  const telegramBusLeaderRuntime = BusLeader.createTelegramBusLeaderRuntime({
-    socketPath: telegramBusSocketPath,
-    followerRegistry: telegramBusFollowerRegistry,
-    authSecret: telegramBusAuthSecret,
-    startPolling: pollingRuntime.start,
-    stopPolling: pollingRuntime.stop,
-    authorizeFollowerApiCall: Bus.isTelegramFollowerApiCallAllowed,
-    recordFollowerMessageOwnership(record) {
-      messageOwnershipStore.record({
-        chatId: record.chatId,
-        messageId: record.messageId,
-        target: record.target,
-        instanceId: record.follower.instanceId,
-      });
-    },
-    provisionLeaderTarget:
-      BusLeader.createTelegramBusLeaderTargetProvisioner<Pi.ExtensionContext>({
-        getAllowedUserId: configStore.getAllowedUserId,
-        instanceId: telegramInstanceId,
-        getCwd(ctx) {
-          return typeof ctx.cwd === "string" ? ctx.cwd : undefined;
-        },
-        getTelegramProfile: getActiveTelegramThreadProfile,
-        shouldForceFreshUnnamed() {
-          return forceFreshLeaderThreadOnNextStart;
-        },
-        topicTargetStore: threadStore,
-        callApi(method, body) {
-          return directTelegramApiRuntime.call(method, body);
-        },
-        getCurrentLeaderEpoch,
-        getThreadReconciliationMachineState() {
-          return threadReconciliationRuntime.getState();
-        },
-        recordThreadReconciliationPlan,
-        getSyncState() {
-          return telegramSyncState;
-        },
-        setSyncState(state) {
-          telegramSyncState = state;
-        },
-        setLeaderTarget(input) {
-          telegramBusLeaderTarget = input.target;
-          telegramBusLeaderSlot = input.slot;
-          telegramBusLeaderThreadName = input.threadName;
-        },
-        onProvisioningStart() {
-          telegramTopicProvisioningCount += 1;
-        },
-        onProvisioningEnd() {
-          telegramTopicProvisioningCount = Math.max(
-            0,
-            telegramTopicProvisioningCount - 1,
-          );
+  const telegramBusLeaderRuntime =
+    BusLeader.createTelegramBusLeaderRuntimeAssembly<Pi.ExtensionContext>({
+      runtime: {
+        socketPath: getTelegramBusSocketPath,
+        followerRegistry: telegramBusFollowerRegistry,
+        authSecret: telegramBusAuthSecret,
+        startPolling: pollingRuntime.start,
+        stopPolling: pollingRuntime.stop,
+        authorizeFollowerApiCall: Bus.isTelegramFollowerApiCallAllowed,
+        recordFollowerMessageOwnership(record) {
+          messageOwnershipStore.record({
+            chatId: record.chatId,
+            messageId: record.messageId,
+            target: record.target,
+            instanceId: record.follower.instanceId,
+          });
         },
-        recordRuntimeEvent,
-      }),
-    onFollowerPruned: BusLeader.createTelegramBusFollowerPruneHandler({
+      },
+      getAllowedUserId: configStore.getAllowedUserId,
+      instanceId: telegramInstanceId,
+      getCwd(ctx) {
+        return typeof ctx.cwd === "string" ? ctx.cwd : undefined;
+      },
+      getTelegramProfile: getActiveTelegramThreadProfile,
+      shouldForceFreshUnnamed() {
+        return forceFreshLeaderThreadOnNextStart;
+      },
       topicTargetStore: threadStore,
       callApi(method, body) {
         return directTelegramApiRuntime.call(method, body);
       },
+      callMultipart: directTelegramApiRuntime.callMultipart,
+      downloadFile: directTelegramApiRuntime.downloadFile,
+      recoverStaleTargetError: recoverStaleTelegramTopicApiError,
       getCurrentLeaderEpoch,
+      getThreadReconciliationMachineState() {
+        return threadReconciliationRuntime.getState();
+      },
+      recordThreadReconciliationPlan,
       getSyncState() {
         return telegramSyncState;
       },
       setSyncState(state) {
         telegramSyncState = state;
       },
+      setLeaderTarget(input) {
+        telegramBusLeaderTarget = input.target;
+        telegramBusLeaderSlot = input.slot;
+        telegramBusLeaderThreadName = input.threadName;
+      },
+      onProvisioningStart() {
+        telegramTopicProvisioningCount += 1;
+      },
+      onProvisioningEnd() {
+        telegramTopicProvisioningCount = Math.max(
+          0,
+          telegramTopicProvisioningCount - 1,
+        );
+      },
       recordRuntimeEvent,
-    }),
-    provisionFollowerTarget:
-      BusLeader.createTelegramBusFollowerTargetProvisioner({
-        getAllowedUserId: configStore.getAllowedUserId,
-        topicTargetStore: threadStore,
-        callApi(method, body) {
-          return directTelegramApiRuntime.call(method, body);
-        },
-        getCurrentLeaderEpoch,
-        getSyncState() {
-          return telegramSyncState;
-        },
-        setSyncState(state) {
-          telegramSyncState = state;
-        },
-        onProvisioningStart() {
-          telegramTopicProvisioningCount += 1;
-        },
-        onProvisioningEnd() {
-          telegramTopicProvisioningCount = Math.max(
-            0,
-            telegramTopicProvisioningCount - 1,
-          );
-        },
-        recordRuntimeEvent,
-      }),
-    restoreFollowerRegistry:
-      BusLeader.createTelegramBusFollowerRegistryRestoreHandler({
-        topicTargetStore: threadStore,
-        followerRegistry: telegramBusFollowerRegistry,
-        recordRuntimeEvent,
-      }),
-    callApi: BusLeader.createTelegramBusLeaderApiProxy({
-      call: directTelegramApiRuntime.call,
-      callMultipart: directTelegramApiRuntime.callMultipart,
-      downloadFile: directTelegramApiRuntime.downloadFile,
-      recoverStaleTargetError: recoverStaleTelegramTopicApiError,
-    }),
-    recordRuntimeEvent,
-  });
+    });
   let pollingStartedWithTelegramBus = false;
   let forceFreshLeaderThreadOnNextStart = false;
   const telegramLeaderHealthRuntime = Sync.createTelegramLeaderHealthRuntime({

package/lib/bindings.ts

@@ -94,7 +94,9 @@ export function registerTelegramCommandsAndTools({
       sendMarkdownReply(chatId, undefined, markdown, options),
     recordRuntimeEvent,
   });
-  Prompts.registerTelegramHelpTool(pi);
+  Prompts.registerTelegramHelpTool(pi, {
+    getActiveProfileName: configStore.getActiveProfileName,
+  });
   Commands.registerTelegramBridgeCommands(pi, {
     promptForConfig: async (ctx, profileName) => {
       const nextProfileName = profileName ?? undefined;
@@ -103,36 +105,58 @@ export function registerTelegramCommandsAndTools({
         return;
       }
       const previousProfileName = configStore.getActiveProfileName();
-      if (previousProfileName !== nextProfileName) {
-        await (stopPolling ?? lockedPollingRuntime.stop)();
-      }
+      let setupConfigStore = configStore;
+      let persistSetupConfig = persistConfig;
       if (!profileName) {
+        if (previousProfileName !== nextProfileName) {
+          await (stopPolling ?? lockedPollingRuntime.stop)();
+        }
         configStore.activateProfile(undefined);
       } else {
         const storedConfig = configStore.getStoredConfig();
-        if (!storedConfig.profiles?.[profileName]) {
+        setupConfigStore = Config.createTelegramConfigStore({
+          initialConfig: {
+            ...storedConfig,
+            profiles: {
+              ...(storedConfig.profiles ?? {}),
+              [profileName]: storedConfig.profiles?.[profileName] ?? {
+                botToken: "",
+              },
+            },
+          },
+        });
+        setupConfigStore.activateProfile(profileName);
+        persistSetupConfig = async () => {
+          if (previousProfileName !== profileName) {
+            await (stopPolling ?? lockedPollingRuntime.stop)();
+          }
+          configStore.activateProfile(undefined);
           configStore.set({
             ...storedConfig,
             profiles: {
               ...(storedConfig.profiles ?? {}),
-              [profileName]: { botToken: "" },
+              [profileName]: storedConfig.profiles?.[profileName] ?? {
+                botToken: "",
+              },
             },
           });
-        }
-        configStore.activateProfile(profileName);
+          configStore.activateProfile(profileName);
+          configStore.set(setupConfigStore.get());
+          await persistConfig();
+        };
       }
       const runSetup = Setup.createTelegramSetupPromptRuntime({
-        getConfig: configStore.get,
-        setConfig: configStore.set,
+        getConfig: setupConfigStore.get,
+        setConfig: setupConfigStore.set,
         setupGuard: setup,
         getMe: TelegramApi.fetchTelegramBotIdentity,
-        persistConfig,
+        persistConfig: persistSetupConfig,
         startPolling: lockedPollingRuntime.start,
         updateStatus,
         recordRuntimeEvent,
       });
-      await runSetup(ctx);
-      if (profileName) {
+      const completion = await runSetup(ctx);
+      if (profileName && completion.status === "success") {
         ctx.ui.notify(`Profile "${profileName}" saved and connected.`, "info");
       }
     },
@@ -155,6 +179,8 @@ export function registerTelegramCommandsAndTools({
     activateProfileConfig: async (_ctx, profileName) => {
       await configStore.load();
       if (!Config.isValidTelegramProfileName(profileName)) return false;
+      const storedConfig = configStore.getStoredConfig();
+      if (!storedConfig.profiles?.[profileName]) return false;
       const previousProfileName = configStore.getActiveProfileName();
       if (previousProfileName !== profileName) {
         await (stopPolling ?? lockedPollingRuntime.stop)();