@llblab/pi-telegram 0.19.3 → 0.20.1

package/lib/bus-transport.ts

@@ -99,31 +99,55 @@ export function getTelegramBusTransportRetryPolicy(input: {
   };
 }
 
+function normalizeTelegramBusEndpointScope(value: string): string {
+  return value.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 80);
+}
+
 export function getTelegramBusLeaderEndpoint(input: {
   agentDir: string;
   platform: NodeJS.Platform | string;
+  profileName?: string;
 }): string {
+  const profileScope = input.profileName
+    ? normalizeTelegramBusEndpointScope(input.profileName)
+    : undefined;
   return input.platform === "win32"
-    ? getTelegramBusPipePath({ agentDir: input.agentDir, scope: "bus" })
-    : join(input.agentDir, "tmp", "telegram", "bus.sock");
+    ? getTelegramBusPipePath({
+        agentDir: input.agentDir,
+        scope: profileScope ? `bus-${profileScope}` : "bus",
+      })
+    : join(
+        input.agentDir,
+        "tmp",
+        "telegram",
+        profileScope ? `bus.${profileScope}.sock` : "bus.sock",
+      );
 }
 
 export function getTelegramBusFollowerEndpoint(input: {
   agentDir: string;
   platform: NodeJS.Platform | string;
   instanceId: string;
+  profileName?: string;
 }): string {
+  const instanceScope = normalizeTelegramBusEndpointScope(input.instanceId);
+  const profileScope = input.profileName
+    ? normalizeTelegramBusEndpointScope(input.profileName)
+    : undefined;
   return input.platform === "win32"
     ? getTelegramBusPipePath({
         agentDir: input.agentDir,
-        scope: `follower-${input.instanceId}`,
+        scope: profileScope
+          ? `follower-${profileScope}-${instanceScope}`
+          : `follower-${instanceScope}`,
       })
     : join(
         input.agentDir,
         "tmp",
         "telegram",
         "followers",
-        `${input.instanceId.replace(/[^a-zA-Z0-9_.-]/g, "_")}.sock`,
+        ...(profileScope ? [profileScope] : []),
+        `${instanceScope}.sock`,
       );
 }
 

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,32 +30,34 @@ 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(),
+  profileName?: string,
 ): string {
-  return getTelegramBusLeaderEndpoint({ agentDir, platform });
+  return getTelegramBusLeaderEndpoint({ agentDir, platform, profileName });
 }
 
 export function getTelegramBusFollowerSocketPath(
   instanceId: string,
-  agentDir = getAgentDir(),
+  agentDir = resolveAgentDir(),
   platform = getPlatform(),
+  profileName?: string,
 ): string {
-  return getTelegramBusFollowerEndpoint({ agentDir, platform, instanceId });
+  return getTelegramBusFollowerEndpoint({
+    agentDir,
+    platform,
+    instanceId,
+    profileName,
+  });
 }
 
 export interface TelegramBusInstanceRegistration {
@@ -155,7 +157,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 +189,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]);
     }
@@ -346,14 +351,20 @@ export interface TelegramBusLocalServer {
   stop: () => Promise<void>;
 }
 
+export type TelegramBusSocketPathSource = string | (() => string);
+
+export function resolveTelegramBusSocketPath(
+  source: TelegramBusSocketPathSource,
+): string {
+  return typeof source === "function" ? source() : source;
+}
+
 export interface TelegramBusLocalServerDeps {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   handleEnvelope: (
     envelope: TelegramBusEnvelope,
   ) =>
-    | Promise<TelegramBusEnvelope | undefined>
-    | TelegramBusEnvelope
-    | undefined;
+    Promise<TelegramBusEnvelope | undefined> | TelegramBusEnvelope | undefined;
   recordTransportEvent?: TelegramBusTransportEventRecorder;
 }
 
@@ -366,7 +377,7 @@ export interface TelegramBusLocalClientOptions {
 }
 
 export interface TelegramBusForeignOwnedForwarderDeps {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   createRequestId: () => string;
   getNowMs?: () => number;
   timeoutMs?: number;
@@ -405,12 +416,13 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
   const getNowMs = deps.getNowMs ?? Date.now;
   const send = async (envelope: TelegramBusEnvelope): Promise<boolean> => {
     if (deps.getAuthSecret) envelope.auth = deps.getAuthSecret();
+    const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
     const response = await sendTelegramBusLocalEnvelope({
-      socketPath: deps.socketPath,
+      socketPath,
       envelope,
       timeoutMs: deps.timeoutMs,
       retry: getTelegramBusTransportRetryPolicy({
-        endpoint: deps.socketPath,
+        endpoint: socketPath,
         operation: "operation",
       }),
     });
@@ -454,7 +466,9 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
 
 export interface TelegramBusFollowerThreadRestoreHandlerDeps {
   followerRegistry: Pick<TelegramBusFollowerRegistry, "get" | "register">;
-  followerTargetController: ReturnType<typeof createTelegramBusFollowerTargetController>;
+  followerTargetController: ReturnType<
+    typeof createTelegramBusFollowerTargetController
+  >;
   onRestored?: () => void;
 }
 
@@ -517,11 +531,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;
@@ -564,6 +574,7 @@ export function createTelegramBusLocalServer(
   deps: TelegramBusLocalServerDeps,
 ): TelegramBusLocalServer {
   let server: Server | undefined;
+  let activeSocketPath: string | undefined;
   const sockets = new Set<Socket>();
   const closeSocket = (socket: Socket) => {
     sockets.delete(socket);
@@ -572,16 +583,18 @@ export function createTelegramBusLocalServer(
   return {
     start: async () => {
       if (server) return;
-      const usesWindowsPipe = isTelegramBusPipePath(deps.socketPath);
+      const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
+      activeSocketPath = socketPath;
+      const usesWindowsPipe = isTelegramBusPipePath(socketPath);
       deps.recordTransportEvent?.(
         "server-start",
-        getTelegramBusEndpointDiagnostics(deps.socketPath),
+        getTelegramBusEndpointDiagnostics(socketPath),
       );
       if (!usesWindowsPipe) {
-        const socketDir = dirname(deps.socketPath);
+        const socketDir = dirname(socketPath);
         mkdirSync(socketDir, { recursive: true, mode: 0o700 });
         chmodSync(socketDir, 0o700);
-        if (existsSync(deps.socketPath)) unlinkSync(deps.socketPath);
+        if (existsSync(socketPath)) unlinkSync(socketPath);
       }
       server = createServer((socket) => {
         sockets.add(socket);
@@ -597,14 +610,14 @@ export function createTelegramBusLocalServer(
               socket,
               deps.handleEnvelope,
               deps.recordTransportEvent,
-              deps.socketPath,
+              socketPath,
             );
           }
         });
         socket.on("close", () => sockets.delete(socket));
         socket.on("error", (error) => {
           deps.recordTransportEvent?.("server-socket-error", {
-            ...getTelegramBusEndpointDiagnostics(deps.socketPath),
+            ...getTelegramBusEndpointDiagnostics(socketPath),
             ...classifyTelegramBusTransportError(error),
           });
           closeSocket(socket);
@@ -613,37 +626,47 @@ export function createTelegramBusLocalServer(
       try {
         await new Promise<void>((resolve, reject) => {
           server?.once("error", reject);
-          server?.listen(deps.socketPath, resolve);
+          server?.listen(socketPath, resolve);
         });
         deps.recordTransportEvent?.(
           "server-started",
-          getTelegramBusEndpointDiagnostics(deps.socketPath),
+          getTelegramBusEndpointDiagnostics(socketPath),
         );
       } catch (error) {
+        server = undefined;
+        activeSocketPath = undefined;
         deps.recordTransportEvent?.("server-start-failed", {
-          ...getTelegramBusEndpointDiagnostics(deps.socketPath),
+          ...getTelegramBusEndpointDiagnostics(socketPath),
           ...classifyTelegramBusTransportError(error),
         });
         throw error;
       }
-      if (!usesWindowsPipe) chmodSync(deps.socketPath, 0o600);
+      if (!usesWindowsPipe) chmodSync(socketPath, 0o600);
     },
     stop: async () => {
       const activeServer = server;
+      const socketPath = activeSocketPath;
       server = undefined;
+      activeSocketPath = undefined;
       for (const socket of sockets) closeSocket(socket);
       if (activeServer) {
         await new Promise<void>((resolve) =>
           activeServer.close(() => resolve()),
         );
       }
-      if (!isTelegramBusPipePath(deps.socketPath) && existsSync(deps.socketPath)) {
-        unlinkSync(deps.socketPath);
+      if (
+        socketPath &&
+        !isTelegramBusPipePath(socketPath) &&
+        existsSync(socketPath)
+      ) {
+        unlinkSync(socketPath);
+      }
+      if (socketPath) {
+        deps.recordTransportEvent?.(
+          "server-stopped",
+          getTelegramBusEndpointDiagnostics(socketPath),
+        );
       }
-      deps.recordTransportEvent?.(
-        "server-stopped",
-        getTelegramBusEndpointDiagnostics(deps.socketPath),
-      );
     },
   };
 }

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, {

package/lib/config.ts

@@ -6,27 +6,19 @@
 
 import { existsSync } from "node:fs";
 import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { resolveAgentDir, resolveTelegramConfigPath } from "./paths.ts";
 
 import type { TelegramInboundHandlerConfig } from "./inbound.ts";
 import type { CommandTemplateObjectConfig } from "./command-templates.ts";
 
 const CONFIG_RUNTIME_KEY = "__piTelegramConfigRuntime__";
 
-function getAgentDir(): string {
-  return process.env.PI_CODING_AGENT_DIR
-    ? resolve(process.env.PI_CODING_AGENT_DIR)
-    : join(homedir(), ".pi", "agent");
-}
-
 function getConfigPath(): string {
-  return join(getAgentDir(), "telegram.json");
+  return resolveTelegramConfigPath();
 }
 
 export type TelegramOutboundCommandTemplateConfig =
-  | string
-  | CommandTemplateObjectConfig;
+  string | CommandTemplateObjectConfig;
 export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConfig {
   type?: string;
   match?: string | string[];
@@ -75,12 +67,88 @@ export interface TelegramConfig {
     sendTranscript?: boolean;
   };
   time?: TelegramTimeConfig;
+  /** Named bot/session profiles (e.g. "work", "omp"). */
+  profiles?: Record<string, TelegramBotProfile>;
+}
+
+/**
+ * Per-profile bot/session identity fields.
+ * Stored under `profiles.<name>` in telegram.json.
+ * Shared bridge settings (inboundHandlers, outboundHandlers, voice, time,
+ * assistant, proactivePush) stay at the top level.
+ */
+export interface TelegramBotProfile {
+  botToken: string;
+  botUsername?: string;
+  botId?: number;
+  allowedUserId?: number;
+  lastUpdateId?: number;
+}
+
+/** Profile names must be lowercase letters, digits, hyphens, underscores; max 32 chars. */
+const TELEGRAM_PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,31}$/;
+const TELEGRAM_RESERVED_PROFILE_NAMES: ReadonlySet<string> = new Set([
+  "default",
+  "main",
+  "active",
+]);
+
+export function isValidTelegramProfileName(name: string): boolean {
+  return (
+    TELEGRAM_PROFILE_NAME_PATTERN.test(name) &&
+    !TELEGRAM_RESERVED_PROFILE_NAMES.has(name)
+  );
+}
+
+/**
+ * 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();
 }
 
 export interface TelegramConfigStore {
   get: () => TelegramConfig;
+  getStoredConfig: () => TelegramConfig;
   set: (config: TelegramConfig) => void;
   update: (mutate: (config: TelegramConfig) => void) => void;
+  activateProfile: (profileName: string | undefined) => boolean;
+  getActiveProfileName: () => string | undefined;
   getBotToken: () => string | undefined;
   hasBotToken: () => boolean;
   getAllowedUserId: () => number | undefined;
@@ -211,23 +279,85 @@ export async function writeTelegramConfig(
   await chmod(configPath, 0o600);
 }
 
+function getTelegramProfileFields(config: TelegramConfig): TelegramBotProfile | undefined {
+  const token = config.botToken?.trim();
+  if (!token) return undefined;
+  return {
+    botToken: token,
+    botUsername: config.botUsername,
+    botId: config.botId,
+    allowedUserId: config.allowedUserId,
+    lastUpdateId: config.lastUpdateId,
+  };
+}
+
+function applyTelegramProfile(
+  config: TelegramConfig,
+  profileName: string | undefined,
+): TelegramConfig {
+  if (!profileName) return config;
+  const profile = config.profiles?.[profileName];
+  if (!profile) return config;
+  return {
+    ...config,
+    botToken: profile.botToken,
+    botUsername: profile.botUsername,
+    botId: profile.botId,
+    allowedUserId: profile.allowedUserId,
+    lastUpdateId: profile.lastUpdateId,
+  };
+}
+
+function storeTelegramEffectiveConfig(
+  baseConfig: TelegramConfig,
+  nextConfig: TelegramConfig,
+  profileName: string | undefined,
+): TelegramConfig {
+  if (!profileName) return nextConfig;
+  const profile = getTelegramProfileFields(nextConfig);
+  const profiles = { ...(baseConfig.profiles ?? {}) };
+  if (profile) profiles[profileName] = profile;
+  else delete profiles[profileName];
+  return {
+    ...nextConfig,
+    botToken: baseConfig.botToken,
+    botUsername: baseConfig.botUsername,
+    botId: baseConfig.botId,
+    allowedUserId: baseConfig.allowedUserId,
+    lastUpdateId: baseConfig.lastUpdateId,
+    profiles: Object.keys(profiles).length > 0 ? profiles : undefined,
+  };
+}
+
 export function createTelegramConfigStore(
   options: TelegramConfigStoreOptions = {},
 ): TelegramConfigStore {
   let config: TelegramConfig = options.initialConfig ?? {};
-  const agentDir = options.agentDir ?? getAgentDir();
+  let activeProfileName: string | undefined;
+  const agentDir = options.agentDir ?? resolveAgentDir();
   const configPath = options.configPath ?? getConfigPath();
+  const getEffectiveConfig = () => applyTelegramProfile(config, activeProfileName);
+  const setEffectiveConfig = (nextConfig: TelegramConfig) => {
+    config = storeTelegramEffectiveConfig(config, nextConfig, activeProfileName);
+  };
   return {
-    get: () => config,
-    set: (nextConfig) => {
-      config = nextConfig;
-    },
+    get: getEffectiveConfig,
+    getStoredConfig: () => config,
+    set: setEffectiveConfig,
     update: (mutate) => {
-      mutate(config);
+      const nextConfig = getEffectiveConfig();
+      mutate(nextConfig);
+      setEffectiveConfig(nextConfig);
+    },
+    activateProfile: (profileName) => {
+      if (profileName && !config.profiles?.[profileName]) return false;
+      activeProfileName = profileName;
+      return true;
     },
-    getBotToken: () => config.botToken,
-    hasBotToken: () => !!config.botToken,
-    getAllowedUserId: () => config.allowedUserId,
+    getActiveProfileName: () => activeProfileName,
+    getBotToken: () => getEffectiveConfig().botToken,
+    hasBotToken: () => !!getEffectiveConfig().botToken,
+    getAllowedUserId: () => getEffectiveConfig().allowedUserId,
     getInboundHandlers: () => [
       ...(config.inboundHandlers ?? []),
       ...(config.attachmentHandlers ?? []),
@@ -235,7 +365,9 @@ export function createTelegramConfigStore(
     getAttachmentHandlers: () => config.attachmentHandlers,
     getOutboundHandlers: () => config.outboundHandlers,
     setAllowedUserId: (userId) => {
-      config.allowedUserId = userId;
+      const nextConfig = getEffectiveConfig();
+      nextConfig.allowedUserId = userId;
+      setEffectiveConfig(nextConfig);
     },
     load: async () => {
       config = await readTelegramConfig(configPath, {
@@ -247,9 +379,18 @@ export function createTelegramConfigStore(
           });
         },
       });
+      if (activeProfileName && !config.profiles?.[activeProfileName]) {
+        activeProfileName = undefined;
+      }
     },
-    persist: async (nextConfig = config) => {
-      await writeTelegramConfig(agentDir, configPath, nextConfig);
+    persist: async (nextConfig = getEffectiveConfig()) => {
+      const storedConfig = storeTelegramEffectiveConfig(
+        config,
+        nextConfig,
+        activeProfileName,
+      );
+      config = storedConfig;
+      await writeTelegramConfig(agentDir, configPath, storedConfig);
     },
   };
 }
@@ -481,9 +622,7 @@ export function createTelegramConfigControls(
 }
 
 export type TelegramAuthorizationState =
-  | { kind: "pair"; userId: number }
-  | { kind: "allow" }
-  | { kind: "deny" };
+  { kind: "pair"; userId: number } | { kind: "allow" } | { kind: "deny" };
 
 export interface TelegramUserPairingDeps<TContext> {
   allowedUserId?: number;