@llblab/pi-telegram 0.52.2 → 0.53.0

package/dist/lib/config.d.ts

@@ -3,9 +3,9 @@
  * Zones: telegram config, pairing, filesystem
  * Owns persisted bot/session pairing state, local config storage, live config controls, authorization policy, and first-user pairing side effects
  */
-export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.ts";
 import type { CommandTemplateObjectConfig } from "./command-templates.ts";
 import type { TelegramInboundHandlerConfig } from "./inbound.ts";
+export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.ts";
 /** Parsed stored bot-token form: a literal secret or one environment-variable reference. */
 export type TelegramBotTokenReference = {
     kind: "literal";
@@ -152,20 +152,13 @@ export interface TelegramInvalidConfigRecovery {
     recoveryPath: string;
     error: unknown;
 }
-export interface TelegramConfigRuntime {
-    updateVoiceConfig: (voice: NonNullable<TelegramConfig["voice"]>) => void;
-}
-export declare function setGlobalTelegramConfigRuntime(runtime: TelegramConfigRuntime | undefined): void;
-export declare function updateTelegramVoiceConfig(voice: NonNullable<TelegramConfig["voice"]>): boolean;
 type TelegramMutableConfigStore = Pick<TelegramConfigStore, "get" | "set" | "persist"> & {
     load?: () => Promise<void>;
     didLastLoadRecoverInvalidConfig?: () => boolean;
 };
-export declare function bindGlobalTelegramConfigRuntime(configStore: TelegramMutableConfigStore): void;
 export declare function readTelegramConfig(configPath: string, options?: {
     onInvalidConfig?: (recovery: TelegramInvalidConfigRecovery) => void;
 }): Promise<TelegramConfig>;
-export declare function writeTelegramConfig(agentDir: string, configPath: string, config: TelegramConfig): Promise<void>;
 export declare function getTelegramProfileFields(config: TelegramConfig): TelegramBotProfile | undefined;
 export declare function normalizeTelegramDefaultProfileConfig(config: TelegramConfig): {
     config: TelegramConfig;

package/dist/lib/config.js

@@ -5,12 +5,11 @@
  */
 import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
-import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
+import { withTelegramFileTransaction } from "./locks.js";
 import { resolveAgentDir, resolveTelegramConfigPath, TELEGRAM_DEFAULT_PROFILE_NAME, } from "./paths.js";
-export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.js";
+import { isPiStaleContextError } from "./pi.js";
 import { isWireRecord as isPlainConfigRecord } from "./wire.js";
-import { withTelegramFileTransaction } from "./locks.js";
-const CONFIG_RUNTIME_KEY = "__piTelegramConfigRuntime__";
+export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.js";
 const CONFIG_REPLACE_RETRY_ATTEMPTS = 5;
 const CONFIG_REPLACE_RETRY_DELAY_MS = 25;
 function isRetryableConfigReplaceError(error) {
@@ -81,7 +80,10 @@ export function getTelegramBotTokenDiagnostic(value, env = process.env) {
     return `Telegram bot token environment variable ${reference.variable} is not set.`;
 }
 const TELEGRAM_THREAD_DISPLAY_MODES = [
-    "letters", "names", "directory-snake", "directory-title",
+    "letters",
+    "names",
+    "directory-snake",
+    "directory-title",
 ];
 export function resolveTelegramThreadDisplayMode(config) {
     return TELEGRAM_THREAD_DISPLAY_MODES.includes(config.threadDisplayMode)
@@ -124,20 +126,6 @@ export function createTelegramConfigBotIdGetter(store) {
 export function createTelegramActiveProfileKeyGetter(store) {
     return () => store.getActiveProfileName() ?? TELEGRAM_DEFAULT_PROFILE_NAME;
 }
-export function setGlobalTelegramConfigRuntime(runtime) {
-    const globals = globalThis;
-    if (runtime)
-        globals[CONFIG_RUNTIME_KEY] = runtime;
-    else
-        delete globals[CONFIG_RUNTIME_KEY];
-}
-export function updateTelegramVoiceConfig(voice) {
-    const runtime = globalThis[CONFIG_RUNTIME_KEY];
-    if (!runtime || typeof runtime.updateVoiceConfig !== "function")
-        return false;
-    runtime.updateVoiceConfig(voice);
-    return true;
-}
 function isEmptyTelegramConfig(config) {
     return Object.keys(config).length === 0;
 }
@@ -151,19 +139,6 @@ async function loadLatestTelegramConfig(configStore) {
         configStore.set(before);
     }
 }
-export function bindGlobalTelegramConfigRuntime(configStore) {
-    setGlobalTelegramConfigRuntime({
-        updateVoiceConfig(voice) {
-            const current = configStore.get();
-            const next = {
-                ...current,
-                voice: { ...(current.voice ?? {}), ...voice },
-            };
-            configStore.set(next);
-            void configStore.persist(next);
-        },
-    });
-}
 function getInvalidTelegramConfigRecoveryPath(configPath) {
     return `${configPath}.invalid-${process.pid}-${Date.now()}`;
 }
@@ -201,17 +176,6 @@ export async function readTelegramConfig(configPath, options = {}) {
         });
     }
 }
-export async function writeTelegramConfig(agentDir, configPath, config) {
-    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(value) {
     return structuredClone(value);
 }
@@ -275,10 +239,13 @@ export function getTelegramProfileFields(config) {
     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) {
     const legacyCursor = config
         .lastUpdateId;
     return {
-        botToken: token,
         ...(config.botUsername !== undefined
             ? { botUsername: config.botUsername }
             : {}),
@@ -332,23 +299,7 @@ export function normalizeTelegramDefaultProfileConfig(config) {
     }
     const legacyProfile = {
         ...(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
-            .lastUpdateId !== undefined
-            ? {
-                lastUpdateId: config
-                    .lastUpdateId,
-            }
-            : {}),
+        ...pickTelegramRootProfileFields(config),
     };
     if (!canonicalProfile && !legacyToken) {
         throw new Error("Legacy Telegram default profile has no bot token");
@@ -421,7 +372,8 @@ export function createTelegramConfigStore(options = {}) {
         config = nextConfig;
     };
     const withPersistedPairingProfile = (profileName, tokenSha256, observe) => {
-        if ((profileName !== TELEGRAM_DEFAULT_PROFILE_NAME && !isValidTelegramProfileName(profileName)) ||
+        if ((profileName !== TELEGRAM_DEFAULT_PROFILE_NAME &&
+            !isValidTelegramProfileName(profileName)) ||
             !/^[a-f0-9]{64}$/u.test(tokenSha256)) {
             throw new Error("Invalid Telegram pairing admission identity.");
         }
@@ -431,10 +383,13 @@ export function createTelegramConfigStore(options = {}) {
             const resolvedToken = typeof profile?.botToken === "string"
                 ? resolveTelegramBotToken(profile.botToken, env)
                 : undefined;
-            if (!profile || !resolvedToken ||
-                createHash("sha256").update(resolvedToken).digest("hex") !== tokenSha256 ||
+            if (!profile ||
+                !resolvedToken ||
+                createHash("sha256").update(resolvedToken).digest("hex") !==
+                    tokenSha256 ||
                 (profile.allowedUserId !== undefined &&
-                    (!Number.isSafeInteger(profile.allowedUserId) || profile.allowedUserId <= 0))) {
+                    (!Number.isSafeInteger(profile.allowedUserId) ||
+                        profile.allowedUserId <= 0))) {
                 throw new Error("Telegram pairing admission authority is unavailable or changed.");
             }
             return observe(latest, profile);
@@ -506,9 +461,11 @@ export function createTelegramConfigStore(options = {}) {
                 assertExecutionCurrent?.();
                 const current = getEffectiveConfig();
                 const previousOwner = persistedConfig.profiles?.[profileName]?.allowedUserId;
-                if ((activeProfileName ?? TELEGRAM_DEFAULT_PROFILE_NAME) !== profileName ||
+                if ((activeProfileName ?? TELEGRAM_DEFAULT_PROFILE_NAME) !==
+                    profileName ||
                     current.botToken !== profile.botToken ||
-                    (current.allowedUserId !== undefined && current.allowedUserId !== userId) ||
+                    (current.allowedUserId !== undefined &&
+                        current.allowedUserId !== userId) ||
                     (current.allowedUserId === undefined && previousOwner !== undefined)) {
                     throw new Error("Telegram paired admission lost local profile authority.");
                 }
@@ -524,7 +481,8 @@ export function createTelegramConfigStore(options = {}) {
             const previousOwner = getEffectiveConfig().allowedUserId;
             const assertCurrent = () => {
                 assertExecutionCurrent?.();
-                if (activeProfileName !== profileName || getEffectiveConfig().botToken !== botToken ||
+                if (activeProfileName !== profileName ||
+                    getEffectiveConfig().botToken !== botToken ||
                     getEffectiveConfig().allowedUserId !== previousOwner) {
                     throw new Error("Telegram pairing lost its originating profile authority.");
                 }
@@ -544,8 +502,13 @@ export function createTelegramConfigStore(options = {}) {
                         assertCurrent();
                         if (profile.allowedUserId !== undefined)
                             return latest;
-                        const next = { ...latest, profiles: { ...latest.profiles,
-                                [profileKey]: { ...profile, allowedUserId: userId } } };
+                        const next = {
+                            ...latest,
+                            profiles: {
+                                ...latest.profiles,
+                                [profileKey]: { ...profile, allowedUserId: userId },
+                            },
+                        };
                         writeTelegramConfigInTransaction(agentDir, configPath, next);
                         return next;
                     });
@@ -851,11 +814,6 @@ export function getTelegramAuthorizationState(userId, allowedUserId) {
     }
     return { kind: "deny" };
 }
-function isTelegramStaleContextError(error) {
-    return (error instanceof Error &&
-        (error.message.includes("stale after session") ||
-            error.message.includes("stale ctx")));
-}
 export async function pairTelegramUserIfNeeded(userId, deps) {
     const authorization = getTelegramAuthorizationState(userId, deps.allowedUserId);
     if (authorization.kind !== "pair")
@@ -869,7 +827,7 @@ export async function pairTelegramUserIfNeeded(userId, deps) {
         deps.updateStatus(deps.ctx);
     }
     catch (error) {
-        if (!isTelegramStaleContextError(error))
+        if (!isPiStaleContextError(error))
             throw error;
     }
     return true;

package/dist/lib/delivery.d.ts

@@ -49,6 +49,7 @@ export type TelegramDeliveryChatAction = "typing" | "upload_document" | "upload_
 /** @internal */
 export interface TelegramDeliveryRuntime {
     readonly generation: string;
+    hasPendingTarget?: (target: TelegramDeliveryTarget) => boolean;
     shutdown: () => void;
     sendView: (view: TelegramDeliveryView, options: SendTelegramViewOptions) => Promise<TelegramDeliveryResult<TelegramDeliveryHandle>>;
     editView: (handle: TelegramDeliveryHandle, view: TelegramDeliveryView) => Promise<TelegramDeliveryResult<TelegramDeliveryHandle>>;
@@ -100,6 +101,7 @@ export interface TelegramBridgeDeliveryRuntimeDeps {
 export declare function createTelegramDeliveryLifecycleHooks(createRuntime: () => TelegramDeliveryRuntime): {
     onSessionStart: () => Promise<void>;
     onSessionShutdown: () => Promise<void>;
+    hasPendingTarget: (target: TelegramDeliveryTarget) => boolean | undefined;
 };
 export declare function createTelegramDeliveryGenerationSeed(instanceId: string): string;
 /** @internal */
@@ -152,8 +154,6 @@ export declare function clearTelegramDeliveryRuntime(): void;
 /** @internal */
 export declare function isTelegramDeliveryHandleCurrent(handle: TelegramDeliveryHandle): boolean;
 export declare function sendTelegramView(view: TelegramDeliveryView, options: SendTelegramViewOptions): Promise<TelegramDeliveryResult<TelegramDeliveryHandle>>;
-/** @internal Edit an exact Telegram message through the currently bound runtime generation. */
-export declare function editTelegramTargetView(target: TelegramDeliveryTarget, messageId: number, view: TelegramDeliveryView): Promise<TelegramDeliveryResult<TelegramDeliveryHandle>>;
 export declare function editTelegramView(handle: TelegramDeliveryHandle, view: TelegramDeliveryView): Promise<TelegramDeliveryResult<TelegramDeliveryHandle>>;
 export declare function deleteTelegramView(handle: TelegramDeliveryHandle): Promise<TelegramDeliveryResult<void>>;
 export declare function sendTelegramChatAction(action: TelegramDeliveryChatAction, options: {

package/dist/lib/delivery.js

@@ -5,7 +5,7 @@
  */
 import { markTelegramBusAggregateDelivery } from "./bus.js";
 import { assertTelegramInlineKeyboardCallbackData, } from "./keyboard.js";
-import { withTelegramReplyParameters, renderTelegramMessage, } from "./replies.js";
+import { renderTelegramMessage, withTelegramReplyParameters, } from "./replies.js";
 import { areTelegramTargetsEqual as areDeliveryTargetsEqual, getTelegramTargetThreadParams, } from "./target.js";
 import { getTelegramApiRetryAfterMs, isRetryableTelegramApiError, isTelegramApiCommitUnknownError, isTelegramMessageUnavailableError, } from "./telegram-api.js";
 const TELEGRAM_DELIVERY_RUNTIME_KEY = "__piTelegramDeliveryRuntime__";
@@ -26,6 +26,7 @@ export function createTelegramDeliveryLifecycleHooks(createRuntime) {
         runtime = undefined;
     };
     return {
+        hasPendingTarget: (target) => runtime?.hasPendingTarget?.(target),
         onSessionStart: async () => {
             stopCurrentRuntime();
             runtime = createRuntime();
@@ -167,7 +168,7 @@ function resolveTelegramDeliveryTarget(scope, deps) {
 }
 function createTelegramDeliveryTargetQueue() {
     const queues = new Map();
-    return async function run(target, operation) {
+    async function run(target, operation) {
         const key = targetKey(target);
         const previous = queues.get(key) ?? Promise.resolve();
         const current = previous.then(operation, operation);
@@ -180,6 +181,10 @@ function createTelegramDeliveryTargetQueue() {
             if (queues.get(key) === settled)
                 queues.delete(key);
         }
+    }
+    return {
+        run,
+        hasPendingTarget: (target) => queues.has(targetKey(target)),
     };
 }
 function getChunkTransportOptions(view, index, chunkCount, replyToMessageId, editing = false) {
@@ -198,7 +203,8 @@ function getChunkTransportOptions(view, index, chunkCount, replyToMessageId, edi
 export function createTelegramDeliveryRuntime(deps) {
     let active = true;
     const handleBindings = new WeakMap();
-    const runForTarget = createTelegramDeliveryTargetQueue();
+    const targetQueue = createTelegramDeliveryTargetQueue();
+    const runForTarget = targetQueue.run;
     const render = (view) => {
         const chunks = deps.renderView(view);
         if (chunks.length === 0 ||
@@ -247,6 +253,7 @@ export function createTelegramDeliveryRuntime(deps) {
     };
     return {
         generation: deps.generation,
+        hasPendingTarget: targetQueue.hasPendingTarget,
         shutdown() {
             active = false;
         },
@@ -420,10 +427,14 @@ export function createTelegramBridgeDeliveryRuntime(deps) {
                 const body = {
                     chat_id: target.chatId,
                     text: chunk.text,
-                    ...(chunk.parseMode === "html" ? { parse_mode: "HTML" } : {}),
+                    ...(chunk.parseMode === "html"
+                        ? { parse_mode: "HTML" }
+                        : {}),
                     ...getTelegramTargetThreadParams(target),
                     ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-                    ...(options.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
+                    ...(options.replyMarkup
+                        ? { reply_markup: options.replyMarkup }
+                        : {}),
                 };
                 return deps.api.sendMessage(target.threadId === undefined
                     ? markTelegramBusAggregateDelivery(body)
@@ -515,17 +526,6 @@ export async function sendTelegramView(view, options) {
         return invalid;
     return runDeliveryOperation((runtime) => runtime.sendView(view, options));
 }
-/** @internal Edit an exact Telegram message through the currently bound runtime generation. */
-export async function editTelegramTargetView(target, messageId, view) {
-    const invalid = validateView(view);
-    if (invalid)
-        return invalid;
-    return runDeliveryOperation((runtime) => runtime.editView({
-        target: { ...target },
-        messageIds: [messageId],
-        generation: runtime.generation,
-    }, view));
-}
 export async function editTelegramView(handle, view) {
     const invalid = validateView(view);
     if (invalid)