@llblab/pi-telegram 0.52.2 → 0.53.1

package/lib/config.ts

@@ -15,20 +15,20 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
+
+import type { CommandTemplateObjectConfig } from "./command-templates.ts";
+import type { TelegramInboundHandlerConfig } from "./inbound.ts";
+import { withTelegramFileTransaction } from "./locks.ts";
 import {
   resolveAgentDir,
   resolveTelegramConfigPath,
   TELEGRAM_DEFAULT_PROFILE_NAME,
 } from "./paths.ts";
-export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.ts";
-
-import type { CommandTemplateObjectConfig } from "./command-templates.ts";
+import { isPiStaleContextError } from "./pi.ts";
 import { isWireRecord as isPlainConfigRecord } from "./wire.ts";
-import type { TelegramInboundHandlerConfig } from "./inbound.ts";
-import { withTelegramFileTransaction } from "./locks.ts";
 
-const CONFIG_RUNTIME_KEY = "__piTelegramConfigRuntime__";
+export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.ts";
+
 const CONFIG_REPLACE_RETRY_ATTEMPTS = 5;
 const CONFIG_REPLACE_RETRY_DELAY_MS = 25;
 
@@ -136,21 +136,22 @@ export interface ResolvedTelegramTimeConfig {
 }
 
 export type TelegramThreadDisplayMode =
-  | "letters"
-  | "names"
-  | "directories"
-  | "directory-snake"
-  | "directory-title";
+  "letters" | "names" | "directories" | "directory-snake" | "directory-title";
 
 const TELEGRAM_THREAD_DISPLAY_MODES: readonly TelegramThreadDisplayMode[] = [
-  "letters", "names", "directory-snake", "directory-title",
+  "letters",
+  "names",
+  "directory-snake",
+  "directory-title",
 ];
 
 export function resolveTelegramThreadDisplayMode(
   config: Pick<TelegramConfig, "threadDisplayMode">,
 ): TelegramThreadDisplayMode {
-  return TELEGRAM_THREAD_DISPLAY_MODES.includes(config.threadDisplayMode as TelegramThreadDisplayMode)
-    ? config.threadDisplayMode as TelegramThreadDisplayMode
+  return TELEGRAM_THREAD_DISPLAY_MODES.includes(
+    config.threadDisplayMode as TelegramThreadDisplayMode,
+  )
+    ? (config.threadDisplayMode as TelegramThreadDisplayMode)
     : "letters";
 }
 
@@ -164,21 +165,27 @@ export async function setTelegramThreadDisplayMode(
   }
   const profile = store.getActiveProfileName();
   const current = () => isCurrent() && store.getActiveProfileName() === profile;
-  if (!current()) throw new Error("Telegram Thread display setting lost authority.");
+  if (!current())
+    throw new Error("Telegram Thread display setting lost authority.");
   await store.load();
   if (!current() || !store.hasBotToken()) {
-    throw new Error("Telegram Thread display setting lost its configured profile.");
+    throw new Error(
+      "Telegram Thread display setting lost its configured profile.",
+    );
   }
-  await store.persist({ ...store.get(), threadDisplayMode: mode }, { isCurrent: current });
-  if (!current()) throw new Error("Telegram Thread display setting changed during persistence.");
+  await store.persist(
+    { ...store.get(), threadDisplayMode: mode },
+    { isCurrent: current },
+  );
+  if (!current())
+    throw new Error(
+      "Telegram Thread display setting changed during persistence.",
+    );
 }
 
 export type TelegramAssistantRenderingMode = "rich" | "html";
 export type TelegramActivityVerbosity =
-  | "quiet"
-  | "thinking"
-  | "tools"
-  | "verbose";
+  "quiet" | "thinking" | "tools" | "verbose";
 
 export interface TelegramConfig {
   /** @deprecated persisted identity belongs in profiles.default; retained for effective/legacy views */
@@ -304,7 +311,10 @@ export interface TelegramConfigStore {
   ) => { admitted: false } | { admitted: true; value: T };
   load: () => Promise<void>;
   didLastLoadRecoverInvalidConfig: () => boolean;
-  persist: (config?: TelegramConfig, options?: { isCurrent?: () => boolean }) => Promise<void>;
+  persist: (
+    config?: TelegramConfig,
+    options?: { isCurrent?: () => boolean },
+  ) => Promise<void>;
 }
 
 export function createTelegramConfigBotIdGetter(
@@ -338,29 +348,6 @@ export interface TelegramInvalidConfigRecovery {
   error: unknown;
 }
 
-export interface TelegramConfigRuntime {
-  updateVoiceConfig: (voice: NonNullable<TelegramConfig["voice"]>) => void;
-}
-
-export function setGlobalTelegramConfigRuntime(
-  runtime: TelegramConfigRuntime | undefined,
-): void {
-  const globals = globalThis as Record<string, unknown>;
-  if (runtime) globals[CONFIG_RUNTIME_KEY] = runtime;
-  else delete globals[CONFIG_RUNTIME_KEY];
-}
-
-export function updateTelegramVoiceConfig(
-  voice: NonNullable<TelegramConfig["voice"]>,
-): boolean {
-  const runtime = (globalThis as Record<string, unknown>)[
-    CONFIG_RUNTIME_KEY
-  ] as TelegramConfigRuntime | undefined;
-  if (!runtime || typeof runtime.updateVoiceConfig !== "function") return false;
-  runtime.updateVoiceConfig(voice);
-  return true;
-}
-
 type TelegramMutableConfigStore = Pick<
   TelegramConfigStore,
   "get" | "set" | "persist"
@@ -387,22 +374,6 @@ async function loadLatestTelegramConfig(
   }
 }
 
-export function bindGlobalTelegramConfigRuntime(
-  configStore: TelegramMutableConfigStore,
-): void {
-  setGlobalTelegramConfigRuntime({
-    updateVoiceConfig(voice) {
-      const current = configStore.get();
-      const next = {
-        ...current,
-        voice: { ...(current.voice ?? {}), ...voice },
-      };
-      configStore.set(next);
-      void configStore.persist(next);
-    },
-  });
-}
-
 function getInvalidTelegramConfigRecoveryPath(configPath: string): string {
   return `${configPath}.invalid-${process.pid}-${Date.now()}`;
 }
@@ -448,22 +419,6 @@ export async function readTelegramConfig(
   }
 }
 
-export async function writeTelegramConfig(
-  agentDir: string,
-  configPath: string,
-  config: TelegramConfig,
-): Promise<void> {
-  await mkdir(agentDir, { recursive: true });
-  const tempConfigPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile(tempConfigPath, JSON.stringify(config, null, "\t") + "\n", {
-    encoding: "utf8",
-    mode: 0o600,
-  });
-  await chmod(tempConfigPath, 0o600);
-  await rename(tempConfigPath, configPath);
-  await chmod(configPath, 0o600);
-}
-
 function cloneTelegramConfig<T>(value: T): T {
   return structuredClone(value);
 }
@@ -544,10 +499,16 @@ export function getTelegramProfileFields(
 ): TelegramBotProfile | undefined {
   const token = config.botToken?.trim();
   if (!token) return undefined;
+  return { botToken: token, ...pickTelegramRootProfileFields(config) };
+}
+
+/** Root-level profile fields other than the token, including the retired legacy cursor. */
+function pickTelegramRootProfileFields(
+  config: TelegramConfig,
+): Omit<TelegramBotProfile, "botToken"> & TelegramLegacyCursorCarrier {
   const legacyCursor = (config as TelegramConfig & TelegramLegacyCursorCarrier)
     .lastUpdateId;
   return {
-    botToken: token,
     ...(config.botUsername !== undefined
       ? { botUsername: config.botUsername }
       : {}),
@@ -620,23 +581,7 @@ export function normalizeTelegramDefaultProfileConfig(config: TelegramConfig): {
   const legacyProfile: Partial<TelegramBotProfile> &
     TelegramLegacyCursorCarrier = {
     ...(legacyToken ? { botToken: legacyToken } : {}),
-    ...(config.botUsername !== undefined
-      ? { botUsername: config.botUsername }
-      : {}),
-    ...(config.botId !== undefined ? { botId: config.botId } : {}),
-    ...(config.allowedUserId !== undefined
-      ? { allowedUserId: config.allowedUserId }
-      : {}),
-    ...(config.threadDisplayMode !== undefined
-      ? { threadDisplayMode: config.threadDisplayMode }
-      : {}),
-    ...((config as TelegramConfig & TelegramLegacyCursorCarrier)
-      .lastUpdateId !== undefined
-      ? {
-          lastUpdateId: (config as TelegramConfig & TelegramLegacyCursorCarrier)
-            .lastUpdateId,
-        }
-      : {}),
+    ...pickTelegramRootProfileFields(config),
   };
   if (!canonicalProfile && !legacyToken) {
     throw new Error("Legacy Telegram default profile has no bot token");
@@ -724,21 +669,31 @@ export function createTelegramConfigStore(
     );
     mutationVersion += 1;
   };
-  const adoptPersistedConfig = (merged: TelegramConfig, preserveLocalChanges: boolean) => {
+  const adoptPersistedConfig = (
+    merged: TelegramConfig,
+    preserveLocalChanges: boolean,
+  ) => {
     // Local edits are relative to the latest observation, not a queued write's older request baseline.
     const nextConfig = preserveLocalChanges
-      ? mergeTelegramConfigDelta(persistedConfig as Record<string, unknown>, config as Record<string, unknown>,
-          merged as Record<string, unknown>) as TelegramConfig
+      ? (mergeTelegramConfigDelta(
+          persistedConfig as Record<string, unknown>,
+          config as Record<string, unknown>,
+          merged as Record<string, unknown>,
+        ) as TelegramConfig)
       : cloneTelegramConfig(merged);
     persistedConfig = cloneTelegramConfig(merged);
     config = nextConfig;
   };
   const withPersistedPairingProfile = <T>(
-    profileName: string, tokenSha256: string,
+    profileName: string,
+    tokenSha256: string,
     observe: (latest: TelegramConfig, profile: TelegramBotProfile) => T,
   ): T => {
-    if ((profileName !== TELEGRAM_DEFAULT_PROFILE_NAME && !isValidTelegramProfileName(profileName)) ||
-        !/^[a-f0-9]{64}$/u.test(tokenSha256)) {
+    if (
+      (profileName !== TELEGRAM_DEFAULT_PROFILE_NAME &&
+        !isValidTelegramProfileName(profileName)) ||
+      !/^[a-f0-9]{64}$/u.test(tokenSha256)
+    ) {
       throw new Error("Invalid Telegram pairing admission identity.");
     }
     return withTelegramFileTransaction(`${configPath}.transaction`, () => {
@@ -748,11 +703,18 @@ export function createTelegramConfigStore(
         typeof profile?.botToken === "string"
           ? resolveTelegramBotToken(profile.botToken, env)
           : undefined;
-      if (!profile || !resolvedToken ||
-          createHash("sha256").update(resolvedToken).digest("hex") !== tokenSha256 ||
-          (profile.allowedUserId !== undefined &&
-            (!Number.isSafeInteger(profile.allowedUserId) || profile.allowedUserId <= 0))) {
-        throw new Error("Telegram pairing admission authority is unavailable or changed.");
+      if (
+        !profile ||
+        !resolvedToken ||
+        createHash("sha256").update(resolvedToken).digest("hex") !==
+          tokenSha256 ||
+        (profile.allowedUserId !== undefined &&
+          (!Number.isSafeInteger(profile.allowedUserId) ||
+            profile.allowedUserId <= 0))
+      ) {
+        throw new Error(
+          "Telegram pairing admission authority is unavailable or changed.",
+        );
       }
       return observe(latest, profile);
     });
@@ -788,17 +750,20 @@ export function createTelegramConfigStore(
       return true;
     },
     getActiveProfileName: () => activeProfileName,
-    getBotToken: () => resolveTelegramBotToken(getEffectiveConfig().botToken, env),
+    getBotToken: () =>
+      resolveTelegramBotToken(getEffectiveConfig().botToken, env),
     getBotTokenDiagnostic: () =>
       getTelegramBotTokenDiagnostic(getEffectiveConfig().botToken, env),
-    hasBotToken: () => !!resolveTelegramBotToken(getEffectiveConfig().botToken, env),
+    hasBotToken: () =>
+      !!resolveTelegramBotToken(getEffectiveConfig().botToken, env),
     getAllowedUserId: () => getEffectiveConfig().allowedUserId,
     getLegacyPollingCursor: () =>
       (getEffectiveConfig() as TelegramConfig & TelegramLegacyCursorCarrier)
         .lastUpdateId,
     removeLegacyPollingCursor: () => {
       const next = {
-        ...(getEffectiveConfig() as TelegramConfig & TelegramLegacyCursorCarrier),
+        ...(getEffectiveConfig() as TelegramConfig &
+          TelegramLegacyCursorCarrier),
       };
       delete next.lastUpdateId;
       setEffectiveConfig(next);
@@ -817,26 +782,47 @@ export function createTelegramConfigStore(
     withSourceSerialization: (operation) =>
       withTelegramFileTransaction(`${configPath}.transaction`, operation),
     withPairingAdmission: (profileName, tokenSha256, publish) =>
-      withPersistedPairingProfile(profileName, tokenSha256, (_latest, profile) =>
-        publish(profile.allowedUserId === undefined)),
-    withPairedUserAdmission: (profileName, tokenSha256, userId, publish, assertExecutionCurrent) => {
-      if (!Number.isSafeInteger(userId) || userId <= 0) return { admitted: false };
+      withPersistedPairingProfile(
+        profileName,
+        tokenSha256,
+        (_latest, profile) => publish(profile.allowedUserId === undefined),
+      ),
+    withPairedUserAdmission: (
+      profileName,
+      tokenSha256,
+      userId,
+      publish,
+      assertExecutionCurrent,
+    ) => {
+      if (!Number.isSafeInteger(userId) || userId <= 0)
+        return { admitted: false };
       assertExecutionCurrent?.();
-      return withPersistedPairingProfile(profileName, tokenSha256, (latest, profile) => {
-        if (profile.allowedUserId !== userId) return { admitted: false };
-        assertExecutionCurrent?.();
-        const current = getEffectiveConfig();
-        const previousOwner = persistedConfig.profiles?.[profileName]?.allowedUserId;
-        if ((activeProfileName ?? TELEGRAM_DEFAULT_PROFILE_NAME) !== profileName ||
+      return withPersistedPairingProfile(
+        profileName,
+        tokenSha256,
+        (latest, profile) => {
+          if (profile.allowedUserId !== userId) return { admitted: false };
+          assertExecutionCurrent?.();
+          const current = getEffectiveConfig();
+          const previousOwner =
+            persistedConfig.profiles?.[profileName]?.allowedUserId;
+          if (
+            (activeProfileName ?? TELEGRAM_DEFAULT_PROFILE_NAME) !==
+              profileName ||
             current.botToken !== profile.botToken ||
-            (current.allowedUserId !== undefined && current.allowedUserId !== userId) ||
-            (current.allowedUserId === undefined && previousOwner !== undefined)) {
-          throw new Error("Telegram paired admission lost local profile authority.");
-        }
-        // Observation is not a local edit; queued persistence still adopts its own fresh disk result.
-        adoptPersistedConfig(latest, true);
-        return { admitted: true, value: publish() };
-      });
+            (current.allowedUserId !== undefined &&
+              current.allowedUserId !== userId) ||
+            (current.allowedUserId === undefined && previousOwner !== undefined)
+          ) {
+            throw new Error(
+              "Telegram paired admission lost local profile authority.",
+            );
+          }
+          // Observation is not a local edit; queued persistence still adopts its own fresh disk result.
+          adoptPersistedConfig(latest, true);
+          return { admitted: true, value: publish() };
+        },
+      );
     },
     persistAllowedUserId: (userId, assertExecutionCurrent, commitIfOwned) => {
       const profileName = activeProfileName;
@@ -845,40 +831,63 @@ export function createTelegramConfigStore(
       const previousOwner = getEffectiveConfig().allowedUserId;
       const assertCurrent = () => {
         assertExecutionCurrent?.();
-        if (activeProfileName !== profileName || getEffectiveConfig().botToken !== botToken ||
-            getEffectiveConfig().allowedUserId !== previousOwner) {
-          throw new Error("Telegram pairing lost its originating profile authority.");
+        if (
+          activeProfileName !== profileName ||
+          getEffectiveConfig().botToken !== botToken ||
+          getEffectiveConfig().allowedUserId !== previousOwner
+        ) {
+          throw new Error(
+            "Telegram pairing lost its originating profile authority.",
+          );
         }
       };
       const pairing = persistQueue.then(() => {
         assertCurrent();
-        if (!Number.isSafeInteger(userId) || userId <= 0) throw new Error("Invalid Telegram pairing user ID.");
+        if (!Number.isSafeInteger(userId) || userId <= 0)
+          throw new Error("Invalid Telegram pairing user ID.");
         let merged: TelegramConfig | undefined;
         const publish = () => {
-          merged = withTelegramFileTransaction(`${configPath}.transaction`, () => {
-            const latest = readTelegramConfigForTransaction(configPath);
-            const profile = latest.profiles?.[profileKey];
-            if (!botToken || profile?.botToken !== botToken) {
-              throw new Error("Telegram pairing profile is unavailable or changed.");
-            }
-            assertCurrent();
-            if (profile.allowedUserId !== undefined) return latest;
-            const next = { ...latest, profiles: { ...latest.profiles,
-              [profileKey]: { ...profile, allowedUserId: userId } } };
-            writeTelegramConfigInTransaction(agentDir, configPath, next);
-            return next;
-          });
+          merged = withTelegramFileTransaction(
+            `${configPath}.transaction`,
+            () => {
+              const latest = readTelegramConfigForTransaction(configPath);
+              const profile = latest.profiles?.[profileKey];
+              if (!botToken || profile?.botToken !== botToken) {
+                throw new Error(
+                  "Telegram pairing profile is unavailable or changed.",
+                );
+              }
+              assertCurrent();
+              if (profile.allowedUserId !== undefined) return latest;
+              const next = {
+                ...latest,
+                profiles: {
+                  ...latest.profiles,
+                  [profileKey]: { ...profile, allowedUserId: userId },
+                },
+              };
+              writeTelegramConfigInTransaction(agentDir, configPath, next);
+              return next;
+            },
+          );
         };
         if (commitIfOwned) {
-          if (!commitIfOwned(publish)) throw new Error("Telegram pairing lost transport ownership before publication.");
+          if (!commitIfOwned(publish))
+            throw new Error(
+              "Telegram pairing lost transport ownership before publication.",
+            );
         } else {
           publish();
         }
-        if (!merged) throw new Error("Telegram pairing publication did not execute.");
+        if (!merged)
+          throw new Error("Telegram pairing publication did not execute.");
         adoptPersistedConfig(merged, true);
         return merged.profiles?.[profileKey]?.allowedUserId === userId;
       });
-      persistQueue = pairing.then(() => undefined, () => undefined);
+      persistQueue = pairing.then(
+        () => undefined,
+        () => undefined,
+      );
       return pairing;
     },
     load: async () => {
@@ -936,7 +945,9 @@ export function createTelegramConfigStore(
           `${configPath}.transaction`,
           () => {
             if (options?.isCurrent && !options.isCurrent()) {
-              throw new Error("Telegram config update lost its originating authority.");
+              throw new Error(
+                "Telegram config update lost its originating authority.",
+              );
             }
             const latestConfig = readTelegramConfigForTransaction(configPath);
             const merged = mergeTelegramConfigDelta(
@@ -950,7 +961,10 @@ export function createTelegramConfigStore(
             return merged;
           },
         );
-        adoptPersistedConfig(mergedConfig, mutationVersion !== capturedMutationVersion);
+        adoptPersistedConfig(
+          mergedConfig,
+          mutationVersion !== capturedMutationVersion,
+        );
       });
       persistQueue = persist.catch(() => undefined);
       return persist;
@@ -1051,10 +1065,8 @@ function createTelegramActivityVerbositySetter(
   return async (verbosity) => {
     await loadLatestTelegramConfig(configStore);
     const current = configStore.get();
-    const {
-      activityVerbosity: _legacyActivityVerbosity,
-      ...assistant
-    } = current.assistant ?? {};
+    const { activityVerbosity: _legacyActivityVerbosity, ...assistant } =
+      current.assistant ?? {};
     const config = {
       ...current,
       assistant: {
@@ -1087,7 +1099,9 @@ export function createTelegramVoiceReplyModeConfiguredChecker(
 
 export function createTelegramVoiceReplyModeSetter(
   configStore: TelegramMutableConfigStore,
-): (replyMode: "manual" | "hidden" | "mirror" | "always" | undefined) => Promise<void> {
+): (
+  replyMode: "manual" | "hidden" | "mirror" | "always" | undefined,
+) => Promise<void> {
   return async (replyMode) => {
     await loadLatestTelegramConfig(configStore);
     const current = configStore.get();
@@ -1250,12 +1264,10 @@ export function createTelegramConfigControls(
       createTelegramAssistantRenderingModeGetter(configStore),
     setAssistantRenderingMode:
       createTelegramAssistantRenderingModeSetter(configStore),
-    getActivityVerbosity:
-      createTelegramActivityVerbosityGetter(configStore),
+    getActivityVerbosity: createTelegramActivityVerbosityGetter(configStore),
     refreshActivityVerbosity:
       createTelegramActivityVerbosityRefresher(configStore),
-    setActivityVerbosity:
-      createTelegramActivityVerbositySetter(configStore),
+    setActivityVerbosity: createTelegramActivityVerbositySetter(configStore),
     getVoiceReplyMode: createTelegramVoiceReplyModeGetter(configStore),
     isVoiceReplyModeConfigured:
       createTelegramVoiceReplyModeConfiguredChecker(configStore),
@@ -1310,14 +1322,6 @@ export function getTelegramAuthorizationState(
   return { kind: "deny" };
 }
 
-function isTelegramStaleContextError(error: unknown): boolean {
-  return (
-    error instanceof Error &&
-    (error.message.includes("stale after session") ||
-      error.message.includes("stale ctx"))
-  );
-}
-
 export async function pairTelegramUserIfNeeded<TContext>(
   userId: number,
   deps: TelegramUserPairingDeps<TContext>,
@@ -1328,13 +1332,16 @@ export async function pairTelegramUserIfNeeded<TContext>(
   );
   if (authorization.kind !== "pair") return authorization.kind === "allow";
   deps.assertExecutionCurrent?.();
-  const allowed = await deps.persistAllowedUserId(authorization.userId, deps.assertExecutionCurrent);
+  const allowed = await deps.persistAllowedUserId(
+    authorization.userId,
+    deps.assertExecutionCurrent,
+  );
   deps.assertExecutionCurrent?.();
   if (!allowed) return false;
   try {
     deps.updateStatus(deps.ctx);
   } catch (error) {
-    if (!isTelegramStaleContextError(error)) throw error;
+    if (!isPiStaleContextError(error)) throw error;
   }
   return true;
 }