@llblab/pi-telegram 0.23.3 → 0.24.1

package/lib/command-templates.ts

@@ -36,9 +36,7 @@ export interface CommandTemplateObjectConfig {
 }
 
 export type CommandTemplateValue =
-  | string
-  | CommandTemplateConfig[]
-  | CommandTemplateObjectConfig;
+  string | CommandTemplateConfig[] | CommandTemplateObjectConfig;
 
 export type CommandTemplateConfig = string | CommandTemplateObjectConfig;
 
@@ -90,12 +88,6 @@ const COMMAND_TEMPLATE_RISK_LABEL_ORDER: CommandTemplateRiskLabel[] = [
   "risk.platform_specific",
 ];
 
-export type CommandTemplateExecCommand = (
-  command: string,
-  args: string[],
-  options?: CommandTemplateExecOptions,
-) => Promise<CommandTemplateExecResult>;
-
 function normalizeCommandTemplateArgs(value: string[] | undefined): string[] {
   if (!Array.isArray(value)) return [];
   return value.map(String).map((item) => item.trim());
@@ -257,9 +249,18 @@ function getLeafCommandTemplateRiskLabels(
     labels.add("risk.broad_fs_write");
   }
   if (
-    ["curl", "wget", "ssh", "scp", "sftp", "rsync", "nc", "ncat", "telnet", "ftp"].includes(
-      command,
-    ) ||
+    [
+      "curl",
+      "wget",
+      "ssh",
+      "scp",
+      "sftp",
+      "rsync",
+      "nc",
+      "ncat",
+      "telnet",
+      "ftp",
+    ].includes(command) ||
     (command === "git" &&
       hasAnyArg(args, ["clone", "fetch", "pull", "push", "ls-remote"])) ||
     ["npm", "pnpm", "yarn", "pip", "cargo"].includes(command)
@@ -283,13 +284,32 @@ function getLeafCommandTemplateRiskLabels(
     labels.add("risk.long_running");
   }
   if (
-    ["systemctl", "launchctl", "osascript", "open", "xdg-open", "powershell", "pwsh", "cmd.exe", "apt", "apt-get", "dnf", "yum", "brew", "pacman", "apk", "xclip", "wl-copy"].includes(
-      command,
-    )
+    [
+      "systemctl",
+      "launchctl",
+      "osascript",
+      "open",
+      "xdg-open",
+      "powershell",
+      "pwsh",
+      "cmd.exe",
+      "apt",
+      "apt-get",
+      "dnf",
+      "yum",
+      "brew",
+      "pacman",
+      "apk",
+      "xclip",
+      "wl-copy",
+    ].includes(command)
   ) {
     labels.add("risk.platform_specific");
   }
-  if (["pass", "gpg", "ssh-add"].includes(command) || hasSecretTouchingText(parts)) {
+  if (
+    ["pass", "gpg", "ssh-add"].includes(command) ||
+    hasSecretTouchingText(parts)
+  ) {
     labels.add("risk.secret_touching");
   }
   return sortRiskLabels(labels);
@@ -347,10 +367,6 @@ function pad(value: number, width: number): string {
   return String(value).padStart(width, "0");
 }
 
-export function isCommandTemplateRepeatPlaceholder(name: string): boolean {
-  return /^_{0,6}(?:index|prev|next|repeat)$/.test(name);
-}
-
 export function getCommandTemplateRepeatDefaults(
   index: number,
   repeat: number,

package/lib/commands.ts

@@ -4,7 +4,10 @@
  * Owns Telegram slash-command normalization, bot command metadata, and pi-side command registration behind runtime ports
  */
 
-import { pairTelegramUserIfNeeded } from "./config.ts";
+import {
+  pairTelegramUserIfNeeded,
+  TELEGRAM_DEFAULT_PROFILE_NAME,
+} from "./config.ts";
 import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
 import type { TelegramBridgeStatusLineOptions } from "./status.ts";
 import {
@@ -321,7 +324,7 @@ 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;
+  return word === TELEGRAM_DEFAULT_PROFILE_NAME ? undefined : word;
 }
 
 function formatTelegramTakeoverTitle(ctx: ExtensionCommandContext): string {

package/lib/config.ts

@@ -15,7 +15,12 @@ import {
   writeFileSync,
 } from "node:fs";
 import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
-import { resolveAgentDir, resolveTelegramConfigPath } from "./paths.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 type { TelegramInboundHandlerConfig } from "./inbound.ts";
@@ -52,10 +57,15 @@ export interface ResolvedTelegramTimeConfig {
 export type TelegramAssistantRenderingMode = "rich" | "html";
 
 export interface TelegramConfig {
+  /** @deprecated persisted identity belongs in profiles.default; retained for effective/legacy views */
   botToken?: string;
+  /** @deprecated persisted identity belongs in profiles.default; retained for effective/legacy views */
   botUsername?: string;
+  /** @deprecated persisted identity belongs in profiles.default; retained for effective/legacy views */
   botId?: number;
+  /** @deprecated persisted identity belongs in profiles.default; retained for effective/legacy views */
   allowedUserId?: number;
+  /** @deprecated persisted identity belongs in profiles.default; retained for effective/legacy views */
   lastUpdateId?: number;
   inboundHandlers?: TelegramInboundHandlerConfig[];
   attachmentHandlers?: TelegramInboundHandlerConfig[];
@@ -77,7 +87,7 @@ export interface TelegramConfig {
     sendTranscript?: boolean;
   };
   time?: TelegramTimeConfig;
-  /** Named bot/session profiles (e.g. "work", "omp"). */
+  /** Canonical bot/session profiles, including profiles.default. */
   profiles?: Record<string, TelegramBotProfile>;
 }
 
@@ -98,7 +108,6 @@ export interface TelegramBotProfile {
 /** Profile names must contain only lowercase ASCII letters and digits; max 32 chars. */
 const TELEGRAM_PROFILE_NAME_PATTERN = /^[a-z0-9]{1,32}$/;
 const TELEGRAM_RESERVED_PROFILE_NAMES: ReadonlySet<string> = new Set([
-  "default",
   "main",
   "active",
 ]);
@@ -110,41 +119,6 @@ export function isValidTelegramProfileName(name: string): boolean {
   );
 }
 
-/**
- * Resolve the effective config for a named (or default) profile.
- * Returns bot/session fields from the named profile, falling back to
- * top-level fields for the default profile. Shared bridge settings
- * always come from the top level.
- */
-export function resolveTelegramActiveProfile(
-  config: TelegramConfig,
-  profileName?: string,
-): {
-  botToken?: string;
-  botUsername?: string;
-  botId?: number;
-  allowedUserId?: number;
-  lastUpdateId?: number;
-} {
-  if (!profileName || !config.profiles?.[profileName]) {
-    return {
-      botToken: config.botToken,
-      botUsername: config.botUsername,
-      botId: config.botId,
-      allowedUserId: config.allowedUserId,
-      lastUpdateId: config.lastUpdateId,
-    };
-  }
-  const profile = config.profiles[profileName];
-  return {
-    botToken: profile.botToken,
-    botUsername: profile.botUsername,
-    botId: profile.botId,
-    allowedUserId: profile.allowedUserId,
-    lastUpdateId: profile.lastUpdateId,
-  };
-}
-
 /** List defined profile names. */
 export function getTelegramProfileNames(config: TelegramConfig): string[] {
   return Object.keys(config.profiles ?? {}).sort();
@@ -154,6 +128,7 @@ export interface TelegramConfigStore {
   get: () => TelegramConfig;
   getStoredConfig: () => TelegramConfig;
   set: (config: TelegramConfig) => void;
+  setProfile: (profileName: string, profile: TelegramBotProfile) => void;
   update: (mutate: (config: TelegramConfig) => void) => void;
   activateProfile: (profileName: string | undefined) => boolean;
   getActiveProfileName: () => string | undefined;
@@ -396,10 +371,91 @@ export function getTelegramProfileFields(
   if (!token) return undefined;
   return {
     botToken: token,
-    botUsername: config.botUsername,
-    botId: config.botId,
-    allowedUserId: config.allowedUserId,
-    lastUpdateId: config.lastUpdateId,
+    ...(config.botUsername !== undefined
+      ? { botUsername: config.botUsername }
+      : {}),
+    ...(config.botId !== undefined ? { botId: config.botId } : {}),
+    ...(config.allowedUserId !== undefined
+      ? { allowedUserId: config.allowedUserId }
+      : {}),
+    ...(config.lastUpdateId !== undefined
+      ? { lastUpdateId: config.lastUpdateId }
+      : {}),
+  };
+}
+
+function omitTelegramRootProfileFields(config: TelegramConfig): TelegramConfig {
+  const {
+    botToken: _botToken,
+    botUsername: _botUsername,
+    botId: _botId,
+    allowedUserId: _allowedUserId,
+    lastUpdateId: _lastUpdateId,
+    ...sharedConfig
+  } = config;
+  return sharedConfig;
+}
+
+export function normalizeTelegramDefaultProfileConfig(config: TelegramConfig): {
+  config: TelegramConfig;
+  changed: boolean;
+} {
+  const hasLegacyRootProfile = [
+    "botToken",
+    "botUsername",
+    "botId",
+    "allowedUserId",
+    "lastUpdateId",
+  ].some((field) => Object.hasOwn(config, field));
+  if (!hasLegacyRootProfile) return { config, changed: false };
+  const canonicalProfile = config.profiles?.[TELEGRAM_DEFAULT_PROFILE_NAME];
+  const legacyToken = config.botToken?.trim();
+  if (Object.hasOwn(config, "botToken") && !legacyToken) {
+    throw new Error("Legacy Telegram default profile has no bot token");
+  }
+  const legacyProfile: Partial<TelegramBotProfile> = {
+    ...(legacyToken ? { botToken: legacyToken } : {}),
+    ...(config.botUsername !== undefined
+      ? { botUsername: config.botUsername }
+      : {}),
+    ...(config.botId !== undefined ? { botId: config.botId } : {}),
+    ...(config.allowedUserId !== undefined
+      ? { allowedUserId: config.allowedUserId }
+      : {}),
+    ...(config.lastUpdateId !== undefined
+      ? { lastUpdateId: config.lastUpdateId }
+      : {}),
+  };
+  if (!canonicalProfile && !legacyToken) {
+    throw new Error("Legacy Telegram default profile has no bot token");
+  }
+  const hasConflict = canonicalProfile
+    ? Object.entries(legacyProfile).some(
+        ([field, value]) =>
+          Object.hasOwn(canonicalProfile, field) &&
+          !configValuesEqual(
+            canonicalProfile[field as keyof TelegramBotProfile],
+            value,
+          ),
+      )
+    : false;
+  if (hasConflict) {
+    throw new Error(
+      "Conflicting Telegram default profile identity at root and profiles.default",
+    );
+  }
+  const normalizedProfile: TelegramBotProfile = canonicalProfile
+    ? { ...legacyProfile, ...canonicalProfile }
+    : (legacyProfile as TelegramBotProfile);
+  return {
+    config: {
+      ...omitTelegramRootProfileFields(config),
+      profiles: {
+        ...(config.profiles ?? {}),
+        [TELEGRAM_DEFAULT_PROFILE_NAME]: normalizedProfile,
+      },
+    },
+    changed: true,
   };
 }
 
@@ -407,16 +463,12 @@ function applyTelegramProfile(
   config: TelegramConfig,
   profileName: string | undefined,
 ): TelegramConfig {
-  if (!profileName) return config;
-  const profile = config.profiles?.[profileName];
-  if (!profile) return config;
+  const effectiveProfileName = profileName ?? TELEGRAM_DEFAULT_PROFILE_NAME;
+  const profile = config.profiles?.[effectiveProfileName];
+  if (!profile) return omitTelegramRootProfileFields(config);
   return {
-    ...config,
-    botToken: profile.botToken,
-    botUsername: profile.botUsername,
-    botId: profile.botId,
-    allowedUserId: profile.allowedUserId,
-    lastUpdateId: profile.lastUpdateId,
+    ...omitTelegramRootProfileFields(config),
+    ...profile,
   };
 }
 
@@ -425,18 +477,13 @@ function storeTelegramEffectiveConfig(
   nextConfig: TelegramConfig,
   profileName: string | undefined,
 ): TelegramConfig {
-  if (!profileName) return nextConfig;
+  const effectiveProfileName = profileName ?? TELEGRAM_DEFAULT_PROFILE_NAME;
   const profile = getTelegramProfileFields(nextConfig);
   const profiles = { ...(baseConfig.profiles ?? {}) };
-  if (profile) profiles[profileName] = profile;
-  else delete profiles[profileName];
+  if (profile) profiles[effectiveProfileName] = profile;
+  else delete profiles[effectiveProfileName];
   return {
-    ...nextConfig,
-    botToken: baseConfig.botToken,
-    botUsername: baseConfig.botUsername,
-    botId: baseConfig.botId,
-    allowedUserId: baseConfig.allowedUserId,
-    lastUpdateId: baseConfig.lastUpdateId,
+    ...omitTelegramRootProfileFields(nextConfig),
     profiles: Object.keys(profiles).length > 0 ? profiles : undefined,
   };
 }
@@ -444,7 +491,9 @@ function storeTelegramEffectiveConfig(
 export function createTelegramConfigStore(
   options: TelegramConfigStoreOptions = {},
 ): TelegramConfigStore {
-  let config: TelegramConfig = cloneTelegramConfig(options.initialConfig ?? {});
+  let config: TelegramConfig = normalizeTelegramDefaultProfileConfig(
+    cloneTelegramConfig(options.initialConfig ?? {}),
+  ).config;
   let persistedConfig: TelegramConfig = {};
   let mutationVersion = 0;
   let persistQueue: Promise<void> = Promise.resolve();
@@ -465,14 +514,30 @@ export function createTelegramConfigStore(
     get: getEffectiveConfig,
     getStoredConfig: () => config,
     set: setEffectiveConfig,
+    setProfile: (profileName, profile) => {
+      config = {
+        ...omitTelegramRootProfileFields(config),
+        profiles: {
+          ...(config.profiles ?? {}),
+          [profileName]: cloneTelegramConfig(profile),
+        },
+      };
+      mutationVersion += 1;
+    },
     update: (mutate) => {
       const nextConfig = getEffectiveConfig();
       mutate(nextConfig);
       setEffectiveConfig(nextConfig);
     },
     activateProfile: (profileName) => {
-      if (profileName && !config.profiles?.[profileName]) return false;
-      activeProfileName = profileName;
+      const normalizedProfileName =
+        !profileName || profileName === TELEGRAM_DEFAULT_PROFILE_NAME
+          ? undefined
+          : profileName;
+      if (normalizedProfileName && !config.profiles?.[normalizedProfileName]) {
+        return false;
+      }
+      activeProfileName = normalizedProfileName;
       return true;
     },
     getActiveProfileName: () => activeProfileName,
@@ -491,7 +556,7 @@ export function createTelegramConfigStore(
       setEffectiveConfig(nextConfig);
     },
     load: async () => {
-      config = await readTelegramConfig(configPath, {
+      const loadedConfig = await readTelegramConfig(configPath, {
         onInvalidConfig: (recovery) => {
           options.recordRuntimeEvent?.("config", recovery.error, {
             phase: "load",
@@ -500,6 +565,31 @@ export function createTelegramConfigStore(
           });
         },
       });
+      let normalized: ReturnType<typeof normalizeTelegramDefaultProfileConfig>;
+      try {
+        normalized = normalizeTelegramDefaultProfileConfig(loadedConfig);
+      } catch (error) {
+        options.recordRuntimeEvent?.("config", error, {
+          phase: "default-profile-normalize",
+          configPath,
+        });
+        throw error;
+      }
+      config = normalized.changed
+        ? withTelegramFileTransaction(`${configPath}.transaction`, () => {
+            const latestConfig = readTelegramConfigForTransaction(configPath);
+            const latestNormalized =
+              normalizeTelegramDefaultProfileConfig(latestConfig);
+            if (latestNormalized.changed) {
+              writeTelegramConfigInTransaction(
+                agentDir,
+                configPath,
+                latestNormalized.config,
+              );
+            }
+            return latestNormalized.config;
+          })
+        : normalized.config;
       persistedConfig = cloneTelegramConfig(config);
       mutationVersion += 1;
     },
@@ -522,7 +612,9 @@ export function createTelegramConfigStore(
               desiredConfig as Record<string, unknown>,
               latestConfig as Record<string, unknown>,
             ) as TelegramConfig;
-            writeTelegramConfigInTransaction(agentDir, configPath, merged);
+            if (!configValuesEqual(latestConfig, merged)) {
+              writeTelegramConfigInTransaction(agentDir, configPath, merged);
+            }
             return merged;
           },
         );

package/lib/inbound.ts

@@ -23,8 +23,7 @@ const MAX_INBOUND_HANDLER_OUTPUT_LENGTH = 12_000;
 const MAX_INBOUND_HANDLER_FAILURE_STREAM_LENGTH = 4_000;
 
 type TelegramInboundCommandTemplateConfig =
-  | string
-  | CommandTemplateObjectConfig;
+  string | CommandTemplateObjectConfig;
 
 export interface TelegramInboundHandlerConfig {
   match?: string | string[];
@@ -74,10 +73,6 @@ export interface TelegramInboundHandlerExecResult {
   killed: boolean;
 }
 
-export interface TelegramInboundHandlerRuntimeContext {
-  cwd: string;
-}
-
 export interface TelegramInboundHandlerRuntimeDeps<TContext> {
   getHandlers: () => TelegramInboundHandlerConfig[] | undefined;
   execCommand: (
@@ -102,9 +97,7 @@ export interface TelegramInboundHandlerRuntime<TContext> {
 }
 
 export type TelegramInboundProgrammaticHandlerResult =
-  | string
-  | { text: string }
-  | undefined;
+  string | { text: string } | undefined;
 
 export interface TelegramInboundProgrammaticHandlerInput {
   kind: string;
@@ -179,12 +172,6 @@ export function getTelegramInboundProgrammaticHandlers(
   ];
 }
 
-export function hasTelegramInboundHandler(kind?: string): boolean {
-  const registry = getOrCreateInboundHandlerRegistry();
-  if (kind !== undefined) return (registry.handlers.get(kind)?.length ?? 0) > 0;
-  return Array.from(registry.handlers.values()).some((list) => list.length > 0);
-}
-
 export function clearTelegramInboundHandlers(): void {
   getOrCreateInboundHandlerRegistry().handlers.clear();
 }
@@ -281,13 +268,6 @@ export function findTelegramInboundHandlers(
   );
 }
 
-export function findTelegramInboundHandler(
-  handlers: TelegramInboundHandlerConfig[] | undefined,
-  file: TelegramInboundHandlerFile,
-): TelegramInboundHandlerConfig | undefined {
-  return findTelegramInboundHandlers(handlers, file)[0];
-}
-
 function hasInboundFilePlaceholder(value: string): boolean {
   return /\{file\}/.test(value);
 }
@@ -420,9 +400,13 @@ function formatTelegramInboundHandlerFailure(
     `Inbound handler exited with code ${result.code}${result.killed ? " (killed)" : ""}`,
   ];
   if (result.stderr.trim())
-    parts.push(`stderr:\n${truncateTelegramInboundFailureStream(result.stderr)}`);
+    parts.push(
+      `stderr:\n${truncateTelegramInboundFailureStream(result.stderr)}`,
+    );
   if (result.stdout.trim())
-    parts.push(`stdout:\n${truncateTelegramInboundFailureStream(result.stdout)}`);
+    parts.push(
+      `stdout:\n${truncateTelegramInboundFailureStream(result.stdout)}`,
+    );
   return parts.join("\n\n");
 }
 
@@ -445,7 +429,13 @@ async function executeTelegramInboundHandlerInvocation(
     cwd,
     timeout,
     ...(typeof handler === "object" && handler.retry !== undefined
-      ? { retry: resolveTelegramInboundNumericControlField(handler.retry, {}, "retry") }
+      ? {
+          retry: resolveTelegramInboundNumericControlField(
+            handler.retry,
+            {},
+            "retry",
+          ),
+        }
       : {}),
     ...(stdin !== undefined ? { stdin } : {}),
   });
@@ -519,7 +509,13 @@ async function executeTelegramTextHandlerInvocation(
     timeout,
     stdin: text,
     ...(typeof handler === "object" && handler.retry !== undefined
-      ? { retry: resolveTelegramInboundNumericControlField(handler.retry, {}, "retry") }
+      ? {
+          retry: resolveTelegramInboundNumericControlField(
+            handler.retry,
+            {},
+            "retry",
+          ),
+        }
       : {}),
   });
   if (result.code !== 0)

package/lib/lifecycle.ts

@@ -196,19 +196,6 @@ export function createTelegramSessionContextStore<TContext>(
   };
 }
 
-export function createTelegramSessionContextTracker(
-  store: Pick<TelegramSessionContextStore<ExtensionContext>, "set" | "clear">,
-): TelegramSessionLifecycleHooks {
-  return {
-    onSessionStart: async (_event, ctx) => {
-      store.set(ctx);
-    },
-    onSessionShutdown: async (_event, ctx) => {
-      store.clear(ctx);
-    },
-  };
-}
-
 export function createTelegramSessionGenerationFence(
   store: TelegramSessionContextStore<ExtensionContext>,
   hooks: TelegramSessionLifecycleHooks,