@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportConstructorWiring.js

@@ -0,0 +1,642 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTransportConstructorWiring = buildTransportConstructorWiring;
+const grammy_1 = require("grammy");
+const proxyFetch_1 = require("./proxyFetch");
+const transportFormatting_1 = require("./transportFormatting");
+const transportContent_1 = require("./transportContent");
+const transportAttachmentStore_1 = require("./transportAttachmentStore");
+const transportBroadcastActions_1 = require("./transportBroadcastActions");
+const transportContext_1 = require("./transportContext");
+const transportConsoleRegistry_1 = require("./transportConsoleRegistry");
+const transportDocumentActions_1 = require("./transportDocumentActions");
+const transportEventActions_1 = require("./transportEventActions");
+const transportFileHandoffActions_1 = require("./transportFileHandoffActions");
+const transportGatewayActions_1 = require("./transportGatewayActions");
+const transportLifecycleActions_1 = require("./transportLifecycleActions");
+const transportLiveActions_1 = require("./transportLiveActions");
+const transportMenuCallbacks_1 = require("./transportMenuCallbacks");
+const transportMenuFactories_1 = require("./transportMenuFactories");
+const transportMenuFingerprints_1 = require("./transportMenuFingerprints");
+const transportMenuFlow_1 = require("./transportMenuFlow");
+const transportMenuShell_1 = require("./transportMenuShell");
+const transportMenuState_1 = require("./transportMenuState");
+const transportMessageFlow_1 = require("./transportMessageFlow");
+const transportOutputActions_1 = require("./transportOutputActions");
+const transportPartnerActions_1 = require("./transportPartnerActions");
+const transportPayloadState_1 = require("./transportPayloadState");
+const transportProjectActions_1 = require("./transportProjectActions");
+const transportProjectEntryActions_1 = require("./transportProjectEntryActions");
+const transportProjectEvents_1 = require("./transportProjectEvents");
+const transportProjectMenus_1 = require("./transportProjectMenus");
+const transportProjectState_1 = require("./transportProjectState");
+const transportProjectView_1 = require("./transportProjectView");
+const transportRequestFlow_1 = require("./transportRequestFlow");
+const transportSessionActions_1 = require("./transportSessionActions");
+const transportTerminalActions_1 = require("./transportTerminalActions");
+const transportTerminalRuntime_1 = require("./transportTerminalRuntime");
+const transportXchangeState_1 = require("./transportXchangeState");
+const transportUtils_1 = require("./transportUtils");
+function buildTransportConstructorWiring(host) {
+    const telegramBaseFetchConfig = (0, proxyFetch_1.createTelegramBaseFetchConfig)(host.config, host.logger);
+    const telegramFetch = (0, proxyFetch_1.createTelegramFetch)(host.config, host.logger);
+    const bot = Object.keys(telegramBaseFetchConfig).length > 0
+        ? new grammy_1.Bot(host.config.telegram.botToken ?? "0:disabled", {
+            client: {
+                baseFetchConfig: telegramBaseFetchConfig,
+            },
+        })
+        : new grammy_1.Bot(host.config.telegram.botToken ?? "0:disabled");
+    const context = new transportContext_1.TransportContext({
+        config: host.config,
+        localeStore: host.localeStore,
+    });
+    const payloadState = new transportPayloadState_1.TransportPayloadState({
+        menuPayloadStore: host.menuPayloadStore,
+        menuPayloadTtlSeconds: host.config.telegram.menuPayloadTtlSeconds,
+    });
+    const xchangeState = new transportXchangeState_1.TransportXchangeState({
+        config: host.config,
+        sessionStore: host.sessionStore,
+        xchangeFileMetaStore: host.xchangeFileMetaStore,
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const outputActions = new transportOutputActions_1.TransportOutputActions({
+        config: host.config,
+        logger: host.logger,
+        bot,
+    });
+    const consoleRegistry = new transportConsoleRegistry_1.TransportConsoleRegistry({
+        config: host.config,
+        logger: host.logger,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const liveActions = new transportLiveActions_1.TransportLiveActions({
+        config: host.config,
+        webAppLaunchRegistry: host.webAppLaunchRegistry,
+        logger: host.logger,
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        ensureGatewayClientUuid: (principal, actor) => gatewayActions.ensureGatewayClientUuid(principal, actor),
+        sendChatMessage: (telegramChatId, text, options, meta) => outputActions.sendChatMessage(telegramChatId, text, options, meta),
+    });
+    const terminalActions = new transportTerminalActions_1.TransportTerminalActions({
+        config: host.config,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        logger: host.logger,
+        terminalNudgeFailureNoticeAt: host.terminalNudgeFailureNoticeAt,
+        terminalPromptNoticeState: host.terminalPromptNoticeState,
+        sendTypingForSession: (sessionId) => terminalRuntime.sendTypingForSession(sessionId),
+        resolveLocaleForTelegramUserId: (userId) => context.resolveLocaleForTelegramUserId(userId),
+        sendNotification: (input) => requestFlow.sendNotification(input),
+        sendLiveViewLauncherMessage: (input) => liveActions.sendLauncherMessage(input),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+        createTerminalPromptActionPayload: (sessionId, actions) => payloadState.createTerminalPromptActionPayload(sessionId, actions),
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        sendChatMessage: (telegramChatId, text, options, meta) => outputActions.sendChatMessage(telegramChatId, text, options, meta),
+        t: (locale, key, vars) => context.t(locale, key, vars),
+    });
+    const terminalRuntime = new transportTerminalRuntime_1.TransportTerminalRuntime({
+        config: host.config,
+        logger: host.logger,
+        bot,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        isTelegramEnabled: () => host.config.distributed.mode !== "client" && Boolean(host.config.telegram.botToken?.trim()),
+        terminalActions,
+        terminalNudgeDebounceTimers: host.terminalNudgeDebounceTimers,
+        ensureGatewayScopedConsolesBoundForPrincipal: async (principal) => {
+            await consoleRegistry.ensureScopedConsolesBound({ principal });
+        },
+    });
+    const menuFingerprints = new transportMenuFingerprints_1.TransportMenuFingerprints({
+        logger: host.logger,
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        listActiveSessionStorageEntries: (sessionId) => xchangeState.listActiveSessionStorageEntries(sessionId),
+        listActiveSessionScreenshots: (sessionId) => xchangeState.listActiveSessionScreenshots(sessionId),
+    });
+    const documentActions = new transportDocumentActions_1.TransportDocumentActions({
+        logger: host.logger,
+    });
+    const projectMenus = new transportProjectMenus_1.TransportProjectMenus({
+        createMenuOptions: (onMenuOutdated) => host.createMenuOptions(onMenuOutdated),
+        buildProjectsFingerprint: (ctx) => gatewayActions.buildProjectsFingerprint(ctx),
+        loadProjectsContext: (ctx) => gatewayActions.loadProjectsContext(ctx),
+        tForContext: (ctx, key, vars) => context.tForContext(ctx, key, vars),
+        createProjectMenuPayload: (sessionId, projectUuid, title) => payloadState.createProjectMenuPayload(sessionId, projectUuid, title),
+        createProjectDeleteMenuPayload: (sessionId, projectUuid, title) => payloadState.createProjectDeleteMenuPayload(sessionId, projectUuid, title),
+        handleProjectSelect: (ctx) => projectEntryActions.handleProjectSelect(ctx),
+        handleProjectDeleteSelect: (ctx) => projectEntryActions.handleProjectDeleteSelect(ctx),
+        beginProjectMode: (ctx, mode) => projectEntryActions.beginProjectMode(ctx, mode),
+        beginProjectBroadcast: (ctx) => broadcastActions.beginProjectBroadcast(ctx),
+        handleCollabHistoryExport: (ctx) => menuFlow.handleCollabHistoryExport(ctx),
+        showCollabToolsMenu: (ctx) => menuFlow.showCollabToolsMenu(ctx),
+        showCollabDeleteMenu: (ctx) => menuFlow.showCollabDeleteMenu(ctx),
+        showProjectsMenu: (ctx) => menuFlow.showProjectsMenu(ctx),
+        showMainMenu: (ctx) => menuState.showMainMenu(ctx),
+    });
+    const menuFactories = new transportMenuFactories_1.TransportMenuFactories({
+        logger: host.logger,
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        createMenuOptions: (onMenuOutdated) => host.createMenuOptions(onMenuOutdated),
+        tForContext: (ctx, key, vars) => context.tForContext(ctx, key, vars),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        buildMainMenuFingerprint: (ctx) => menuFingerprints.buildMainMenuFingerprint(ctx),
+        buildStorageFingerprint: (ctx) => menuFingerprints.buildStorageFingerprint(ctx),
+        buildScreenshotsFingerprint: (ctx) => menuFingerprints.buildScreenshotsFingerprint(ctx),
+        buildSessionsFingerprint: (ctx) => menuFingerprints.buildSessionsFingerprint(ctx),
+        buildScreenshotsButtonLabel: (ctx) => menuFingerprints.buildScreenshotsButtonLabel(ctx),
+        showLiveViewLauncher: (ctx) => menuFlow.showLiveViewLauncher(ctx),
+        showBufferMenu: (ctx) => menuFlow.showBufferMenu(ctx),
+        showBrowserMenu: (ctx) => menuFlow.showBrowserMenu(ctx),
+        showMainMenu: (ctx) => menuState.showMainMenu(ctx),
+        showProjectsEntryPoint: (ctx) => menuFlow.showProjectsMenu(ctx),
+        showStorageMenu: (ctx) => menuFlow.showStorageMenu(ctx),
+        showSettingsMenu: (ctx) => menuFlow.showSettingsMenu(ctx),
+        showSessionsMenu: (ctx) => menuFlow.showSessionsMenu(ctx),
+        showScreenshotsMenu: (ctx) => menuFlow.showScreenshotsMenu(ctx),
+        sendActiveSessionBuffer: (ctx, input) => menuFlow.sendActiveSessionBuffer(ctx, input),
+        showUnpairConfirmMenu: (ctx) => menuFlow.showUnpairConfirmMenu(ctx),
+        showDeveloperMenu: (ctx) => menuFlow.showDeveloperMenu(ctx),
+        showDeveloperInfo: (ctx) => menuFlow.showDeveloperInfo(ctx),
+        showPruneConfirmMenu: (ctx) => menuFlow.showPruneConfirmMenu(ctx),
+        showActiveSessionInfo: (ctx) => menuFlow.showActiveSessionInfo(ctx),
+        beginRenameActiveSession: (ctx) => sessionActions.beginRenameActiveSession(ctx),
+        beginBroadcast: (ctx) => broadcastActions.beginBroadcast(ctx),
+        pruneAllSessions: (ctx) => sessionActions.pruneAllSessions(ctx),
+        unpairActiveSession: (ctx) => sessionActions.unpairActiveSession(ctx),
+        handleStorageOpen: (ctx) => menuCallbacks.handleStorageOpen(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleStorageGet: (ctx) => menuCallbacks.handleStorageGet(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleStorageDelete: (ctx) => menuCallbacks.handleStorageDelete(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleScreenshotOpen: (ctx) => menuCallbacks.handleScreenshotOpen(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleScreenshotGet: (ctx) => menuCallbacks.handleScreenshotGet(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleScreenshotDelete: (ctx) => menuCallbacks.handleScreenshotDelete(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleSessionSelection: (ctx) => menuCallbacks.handleSessionSelection(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        handleSessionGroupSelection: (ctx) => menuCallbacks.handleSessionGroupSelection(ctx, (0, transportUtils_1.readMenuPayloadKey)(ctx)),
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        createFileMenuPayload: (sessionId, filePath) => payloadState.createFileMenuPayload(sessionId, filePath),
+        createSessionMenuPayload: (sessionId, ownerLabel, ownerKey) => payloadState.createSessionMenuPayload(sessionId, ownerLabel, ownerKey),
+        createSessionGroupMenuPayload: (ownerLabel, ownerKey) => payloadState.createSessionGroupMenuPayload(ownerLabel, ownerKey),
+        formatStoragePreviewLabel: (filePath, meta) => (0, transportFormatting_1.formatStoragePreviewLabel)(filePath, meta),
+        formatFilePreviewLabel: (filePath) => (0, transportFormatting_1.formatFilePreviewLabel)(filePath),
+        formatSessionMenuLabel: (input) => (0, transportFormatting_1.formatSessionMenuLabel)(input),
+        listActiveSessionStorageEntries: (sessionId) => xchangeState.listActiveSessionStorageEntries(sessionId),
+        listActiveSessionScreenshots: (sessionId) => xchangeState.listActiveSessionScreenshots(sessionId),
+    });
+    const mainMenu = menuFactories.createMainMenu();
+    const storageMenu = menuFactories.createStorageMenu();
+    const browserMenu = menuFactories.createBrowserMenu();
+    const screenshotsMenu = menuFactories.createScreenshotsMenu();
+    const sessionsMenu = menuFactories.createSessionsMenu();
+    const bufferMenu = menuFactories.createBufferMenu();
+    const settingsMenu = menuFactories.createSettingsMenu();
+    const developerMenu = menuFactories.createDeveloperMenu();
+    const unpairConfirmMenu = menuFactories.createUnpairConfirmMenu();
+    const pruneConfirmMenu = menuFactories.createPruneConfirmMenu();
+    const storageMessageMenu = menuFactories.createStorageMessageMenu();
+    const screenshotMessageMenu = menuFactories.createScreenshotMessageMenu();
+    const projectsMenu = projectMenus.createProjectsMenu();
+    const collabToolsMenu = projectMenus.createCollabToolsMenu();
+    const collabDeleteMenu = projectMenus.createCollabDeleteMenu();
+    const menuState = new transportMenuState_1.TransportMenuState({
+        logger: host.logger,
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        getTerminalStatusLine: async (locale) => context.t(locale, "menu:main.screen.terminal_mode_direct"),
+        setCurrentAttachmentTargetForContext: (ctx, target) => menuFlow.setCurrentAttachmentTargetForContext(ctx, target),
+        renderMenuHtmlScreen: (ctx, text, meta, menu) => menuFlow.renderMenuHtmlScreen(ctx, text, meta, menu),
+        renderMenuScreen: (ctx, text, meta, menu) => menuFlow.renderMenuScreen(ctx, text, meta, menu),
+        renderMenuMarkdownScreen: (ctx, text, meta, menu) => menuFlow.renderMenuMarkdownScreen(ctx, text, meta, menu),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        getMainMenu: () => mainMenu,
+        getSessionsMenu: () => sessionsMenu,
+        getStorageMenu: () => storageMenu,
+        getBrowserMenu: () => browserMenu,
+        getScreenshotsMenu: () => screenshotsMenu,
+        getSettingsMenu: () => settingsMenu,
+        getBufferMenu: () => bufferMenu,
+        getDeveloperMenu: () => developerMenu,
+        getUnpairConfirmMenu: () => unpairConfirmMenu,
+        getPruneConfirmMenu: () => pruneConfirmMenu,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        listActiveSessionScreenshots: (sessionId) => xchangeState.listActiveSessionScreenshots(sessionId),
+        listActiveSessionStorageEntries: (sessionId) => xchangeState.listActiveSessionStorageEntries(sessionId),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const projectState = new transportProjectState_1.TransportProjectState({
+        config: host.config,
+        getGatewayActorFromContext: (ctx) => context.getGatewayActorFromContext(ctx),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        maintenanceStore: host.maintenanceStore,
+        menuPayloadStore: host.menuPayloadStore,
+    });
+    const gatewayActions = new transportGatewayActions_1.TransportGatewayActions({
+        getCollaborationService: () => host.getCollaborationService(),
+        projectState,
+    });
+    const attachmentStore = new transportAttachmentStore_1.TransportAttachmentStore({
+        sessionStore: host.sessionStore,
+        xchangeFileMetaStore: host.xchangeFileMetaStore,
+        objectStore: host.objectStore,
+        telegramFetch: (input, init) => telegramFetch(input, init),
+        getRequiredBotToken: (action) => host.getRequiredBotToken(action),
+        getTelegramFile: (fileId) => bot.api.getFile(fileId),
+    });
+    const lifecycleActions = new transportLifecycleActions_1.TransportLifecycleActions({
+        logger: host.logger,
+        config: host.config,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        isTelegramEnabled: () => host.config.distributed.mode !== "client" &&
+            Boolean(host.config.telegram.botToken?.trim()),
+        resolveLocaleForTelegramUserId: (telegramUserId, telegramLanguageCode) => context.resolveLocaleForTelegramUserId(telegramUserId, telegramLanguageCode),
+        t: (locale, key, options) => context.t(locale, key, options),
+        sendNotification: (input) => host.sendNotification(input),
+    });
+    const projectView = new transportProjectView_1.TransportProjectView({
+        config: host.config,
+        projectsMenu,
+        collabToolsMenu,
+        collabDeleteMenu,
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        resolveLocaleForTelegramUserId: (telegramUserId, telegramLanguageCode) => context.resolveLocaleForTelegramUserId(telegramUserId, telegramLanguageCode),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        getGatewayActorFromContext: (ctx) => context.getGatewayActorFromContext(ctx),
+        ensureGatewayClientUuid: (principal, actor) => gatewayActions.ensureGatewayClientUuid(principal, actor),
+        loadProjectsContext: (ctx) => gatewayActions.loadProjectsContext(ctx),
+        listGatewayProjects: (principal, actor) => gatewayActions.listGatewayProjects(principal, actor),
+        listGatewayProjectSessions: (principal, projectUuid) => gatewayActions.listGatewayProjectSessions(principal, projectUuid),
+        listGatewaySessionHistory: (principal, localSessionId) => gatewayActions.listGatewaySessionHistory(principal, localSessionId),
+        collectCollabBroadcastTargets: (principal, _sessionId) => broadcastActions.listCollabBroadcastTargets(principal),
+        ensureOpenedProjectIsActive: (input) => gatewayActions.ensureOpenedProjectIsActive(input),
+        setCurrentAttachmentTargetForContext: (ctx, target) => menuFlow.setCurrentAttachmentTargetForContext(ctx, target),
+        renderMenuScreen: (ctx, text, meta, menu) => menuFlow.renderMenuScreen(ctx, text, meta, menu),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        editText: (ctx, text, meta, options) => outputActions.editText(ctx, text, meta, options),
+        replyDocumentWithRetry: (ctx, document, options, meta) => documentActions.replyDocumentWithRetry(ctx, document, options, meta),
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        maintenanceStore: host.maintenanceStore,
+        xchangeFileMetaStore: host.xchangeFileMetaStore,
+        webAppLaunchRegistry: host.webAppLaunchRegistry,
+        createProjectMemberMenuPayload: (sessionId, projectUuid, targetSessionId, title, extra) => payloadState.createProjectMemberMenuPayload(sessionId, projectUuid, targetSessionId, title, extra),
+        listActiveSessionFiles: (sessionId) => xchangeState.listActiveSessionFiles(sessionId),
+        formatFilePreviewLabel: (filePath, meta) => (0, transportFormatting_1.formatFilePreviewLabel)(filePath, meta),
+    });
+    const menuFlow = new transportMenuFlow_1.TransportMenuFlow({
+        config: host.config,
+        logger: host.logger,
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        menuState,
+        projectView,
+        liveActions,
+        terminalActions,
+        pendingRenames: host.pendingRenames,
+        pendingBroadcasts: host.pendingBroadcasts,
+        pendingPartnerNotes: host.pendingPartnerNotes,
+        pendingFileHandoffs: host.pendingFileHandoffs,
+        pendingProjects: host.pendingProjects,
+        currentAttachmentTargets: host.currentAttachmentTargets,
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        ensureGatewayScopeConsolesBound: ({ principal, ctx }) => consoleRegistry.ensureScopedConsolesBound({ principal, ctx }),
+        getGatewayActorFromContext: (ctx) => context.getGatewayActorFromContext(ctx),
+        t: (locale, key, options) => context.t(locale, key, options),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        editText: (ctx, text, meta, options) => outputActions.editText(ctx, text, meta, options),
+        replyDocumentWithRetry: (ctx, document, options, meta) => documentActions.replyDocumentWithRetry(ctx, document, options, meta),
+        captureRelaySessionBuffer: (sessionId, scope) => host.callGatewayJson("/live/capture-buffer", {
+            session_id: sessionId,
+            scope,
+        }),
+    });
+    const broadcastActions = new transportBroadcastActions_1.TransportBroadcastActions({
+        config: host.config,
+        logger: host.logger,
+        pendingBroadcasts: host.pendingBroadcasts,
+        pendingRenames: host.pendingRenames,
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        tForContext: (ctx, key, vars) => context.tForContext(ctx, key, vars),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        deleteMessage: (chatId, messageId) => host.deleteMessage(chatId, messageId),
+        showCollabToolsMenu: (ctx) => menuFlow.showCollabToolsMenu(ctx),
+        showDeveloperMenu: (ctx) => menuFlow.showDeveloperMenu(ctx),
+        ensureGatewayClientUuid: (principal) => gatewayActions.ensureGatewayClientUuid(principal),
+        listGatewayProjects: (principal) => gatewayActions.listGatewayProjects(principal),
+        listGatewayProjectSessions: (principal, projectUuid) => gatewayActions.listGatewayProjectSessions(principal, projectUuid),
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        routeTelegramInboxToRelaySession: (input) => messageFlow.routeTelegramInboxToRelaySession(input),
+        scheduleTerminalNudgeForInboxMessage: (sessionId, session) => terminalRuntime.scheduleTerminalNudgeForInboxMessage(sessionId, session),
+        sendPartnerNote: (input) => gatewayActions.sendPartnerNote(input),
+    });
+    const partnerActions = new transportPartnerActions_1.TransportPartnerActions({
+        config: host.config,
+        logger: host.logger,
+        pendingPartnerNotes: host.pendingPartnerNotes,
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        deleteMessage: (chatId, messageId) => host.deleteMessage(chatId, messageId),
+        showProjectsMenu: (ctx, introText) => menuFlow.showProjectsMenu(ctx, introText),
+        showMainMenu: (ctx, introText) => menuState.showMainMenu(ctx, introText),
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        maintenanceStore: host.maintenanceStore,
+        ensureProjectSessionRegistered: (input) => gatewayActions.ensureProjectSessionRegistered(input),
+        sendPartnerNote: (input) => gatewayActions.sendPartnerNote(input),
+        nudgeSessionInbox: (sessionId) => host.nudgeSessionInbox(sessionId),
+    });
+    const fileHandoffActions = new transportFileHandoffActions_1.TransportFileHandoffActions({
+        logger: host.logger,
+        config: host.config,
+        pendingFileHandoffs: host.pendingFileHandoffs,
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        deleteMessage: (chatId, messageId) => host.deleteMessage(chatId, messageId),
+        showProjectsMenu: (ctx) => menuFlow.showProjectsMenu(ctx),
+        showMainMenu: (ctx) => menuState.showMainMenu(ctx),
+        showProjectMemberDetail: (ctx, input) => projectView.showProjectMemberDetail(ctx, {
+            ...input,
+            inviteToken: input.inviteToken ?? "",
+        }),
+        getProjectPayloadByUuid: (sessionId, projectUuid) => projectState.getProjectPayloadByUuid(sessionId, projectUuid),
+        ensureProjectSessionRegistered: (input) => gatewayActions.ensureProjectSessionRegistered(input),
+        sendPartnerNote: (input) => gatewayActions.sendPartnerNote(input),
+        xchangeFileMetaStore: host.xchangeFileMetaStore,
+        sessionStore: host.sessionStore,
+        maintenanceStore: host.maintenanceStore,
+        objectStore: host.objectStore,
+        nudgeSessionInbox: (sessionId) => host.nudgeSessionInbox(sessionId),
+    });
+    const menuCallbacks = new transportMenuCallbacks_1.TransportMenuCallbacks({
+        logger: host.logger,
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        tForContext: (ctx, key, vars) => context.tForContext(ctx, key, vars),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        editText: (ctx, text, meta, options) => outputActions.editText(ctx, text, meta, options),
+        showMainMenu: (ctx, introText) => menuState.showMainMenu(ctx, introText),
+        showSessionsMenu: (ctx, introText) => menuFlow.showSessionsMenu(ctx, introText),
+        showScreenshotsMenu: (ctx, introText) => menuFlow.showScreenshotsMenu(ctx, introText),
+        showStorageMenu: (ctx, introText) => menuFlow.showStorageMenu(ctx, introText),
+        storageMessageMenu,
+        screenshotMessageMenu,
+        xchangeFileMetaStore: host.xchangeFileMetaStore,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        objectStore: host.objectStore,
+        formatScreenshotDetail: (sessionId, filePath, meta) => (0, transportContent_1.formatScreenshotDetail)(sessionId, filePath, meta),
+        formatStorageDetail: (sessionId, filePath, meta) => (0, transportContent_1.formatStorageDetail)(sessionId, filePath, meta),
+        formatFilePreviewLabel: (filePath, meta) => (0, transportFormatting_1.formatFilePreviewLabel)(filePath, meta),
+        listActiveSessionFiles: (sessionId) => xchangeState.listActiveSessionFiles(sessionId),
+        createPartnerFileTargetPayload: (sessionId, targetSessionId, title, filePath) => payloadState.createPartnerFileTargetPayload(sessionId, targetSessionId, title, filePath),
+        ensureStoredXchangeFile: (sessionId, filePath, source) => attachmentStore.ensureStoredXchangeFile(sessionId, filePath, source),
+        sendDocumentToChat: (chatId, filePath, caption) => host.sendDocumentToChat(chatId, filePath, caption),
+        maybeNotifyToolsMismatchForSession: (sessionId) => host.maybeNotifyToolsMismatchForSession(sessionId),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const requestFlow = new transportRequestFlow_1.TransportRequestFlow({
+        logger: host.logger,
+        config: host.config,
+        adminAuthStore: host.adminAuthStore,
+        maintenanceStore: host.maintenanceStore,
+        waiters: host.waiters,
+        isTelegramEnabled: () => host.config.distributed.mode !== "client" &&
+            Boolean(host.config.telegram.botToken?.trim()),
+        isAdminAuthEnabled: () => host.isAdminAuthEnabled(),
+        resolveLocaleForTelegramUserId: (telegramUserId, telegramLanguageCode) => context.resolveLocaleForTelegramUserId(telegramUserId, telegramLanguageCode),
+        t: (locale, key, options) => context.t(locale, key, options),
+        sendTextChunks: (chatId, body, meta) => outputActions.sendTextChunks(chatId, body, meta),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const projectEvents = new transportProjectEvents_1.TransportProjectEvents({
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        resolveLocaleForTelegramUserId: (telegramUserId, telegramLanguageCode) => context.resolveLocaleForTelegramUserId(telegramUserId, telegramLanguageCode),
+        t: (locale, key, options) => context.t(locale, key, options),
+        sendNotification: (input) => host.sendNotification(input),
+    });
+    const sessionActions = new transportSessionActions_1.TransportSessionActions({
+        logger: host.logger,
+        config: host.config,
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        maintenanceStore: host.maintenanceStore,
+        pendingRenames: host.pendingRenames,
+        pendingBroadcasts: host.pendingBroadcasts,
+        getMainMenu: () => mainMenu,
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        t: (locale, key, options) => context.t(locale, key, options),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        showSessionsMenu: (ctx, introText) => menuFlow.showSessionsMenu(ctx, introText),
+        clearPendingInteractionsForContext: (ctx) => menuFlow.clearPendingInteractionsForContext(ctx),
+        clearTerminalNudgeDebounceTimers: () => terminalRuntime.clearTerminalNudgeDebounceTimers(),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const projectActions = new transportProjectActions_1.TransportProjectActions({
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        t: (locale, key, vars) => context.t(locale, key, vars),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        extractCallbackSuffix: (ctx, prefix) => (0, transportUtils_1.extractCallbackSuffix)(ctx, prefix),
+        getGatewayActorFromContext: (ctx) => context.getGatewayActorFromContext(ctx),
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        pendingProjects: host.pendingProjects,
+        ensureGatewayClientUuid: (principal, actor) => gatewayActions.ensureGatewayClientUuid(principal, actor),
+        listGatewayProjects: (principal) => gatewayActions.listGatewayProjects(principal),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+        activateProjectForSession: (input) => gatewayActions.activateProjectForSession(input),
+        ensureProjectSessionRegistered: (input) => gatewayActions.ensureProjectSessionRegistered(input),
+        ensureOpenedProjectIsActive: (input) => gatewayActions.ensureOpenedProjectIsActive(input),
+        getProjectPayloadByUuid: (sessionId, projectUuid) => projectState.getProjectPayloadByUuid(sessionId, projectUuid),
+        getProjectMemberPayloadByKey: (payloadKey) => projectState.getProjectMemberPayloadByKey(payloadKey),
+        getPartnerFileTargetPayloadByKey: (payloadKey) => projectState.getPartnerFileTargetPayloadByKey(payloadKey),
+        getLiveApprovalPayloadByKey: (payloadKey) => projectState.getLiveApprovalPayloadByKey(payloadKey),
+        beginFileHandoffModeForTarget: (ctx, input) => fileHandoffActions.beginModeForTarget(ctx, input),
+        beginPartnerNoteMode: (ctx, kind, target) => partnerActions.beginPartnerNoteMode(ctx, kind, target),
+        showProjectMembers: (ctx, input) => projectView.showProjectMembers(ctx, input),
+        showProjectMemberDetail: (ctx, input) => projectView.showProjectMemberDetail(ctx, input),
+        showProjectMemberFiles: (ctx, input) => projectView.showProjectMemberFiles(ctx, input),
+        showProjectsMenu: (ctx, introText) => menuFlow.showProjectsMenu(ctx, introText),
+        showCollabDeleteMenu: (ctx, introText) => menuFlow.showCollabDeleteMenu(ctx, introText),
+        replyText: (ctx, text, meta) => outputActions.replyText(ctx, text, meta),
+        editText: (ctx, text, meta) => outputActions.editText(ctx, text, meta),
+    });
+    const projectEntryActions = new transportProjectEntryActions_1.TransportProjectEntryActions({
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        menuPayloadStore: host.menuPayloadStore,
+        pendingProjects: host.pendingProjects,
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        t: (locale, key, options) => context.t(locale, key, options),
+        replyText: (ctx, text, meta) => outputActions.replyText(ctx, text, meta),
+        showProjectsMenu: (ctx, introText) => menuFlow.showProjectsMenu(ctx, introText),
+        listGatewayProjects: (principal) => gatewayActions.listGatewayProjects(principal),
+        getProjectPayloadByUuid: (sessionId, projectUuid) => projectState.getProjectPayloadByUuid(sessionId, projectUuid),
+        ensureOpenedProjectIsActive: (input) => gatewayActions.ensureOpenedProjectIsActive(input),
+        showProjectMembers: (ctx, input) => projectView.showProjectMembers(ctx, input),
+        ensureGatewayClientUuid: (principal) => gatewayActions.ensureGatewayClientUuid(principal),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+    });
+    const messageFlow = new transportMessageFlow_1.TransportMessageFlow({
+        logger: host.logger,
+        config: host.config,
+        bindingStore: host.bindingStore,
+        sessionStore: host.sessionStore,
+        isAdminAuthEnabled: () => host.isAdminAuthEnabled(),
+        isPrincipalAdminAuthorized: (principal) => host.isPrincipalAdminAuthorized(principal),
+        setPrincipalAdminAuthorized: (principal) => host.setPrincipalAdminAuthorized(principal),
+        waiters: host.waiters,
+        currentAttachmentTargets: host.currentAttachmentTargets,
+        isAdminBotProfile: () => host.isAdminBotProfile(),
+        getPrincipalFromContext: (ctx) => context.getPrincipalFromContext(ctx),
+        ensureGatewayUserForPrincipal: ({ principal, ctx }) => host.ensureGatewayUserForPrincipal({ principal, ctx }),
+        extractIncomingText: (message) => (0, transportContent_1.extractIncomingText)(message),
+        collectIncomingAttachments: (message) => (0, transportContent_1.collectIncomingAttachments)(message),
+        buildInboxText: (text, attachments) => (0, transportFormatting_1.buildInboxText)(text, attachments),
+        clearPendingInteractionsForContext: (ctx) => menuFlow.clearPendingInteractionsForContext(ctx),
+        handlePendingRename: (ctx, text) => sessionActions.handlePendingRename(ctx, text),
+        handlePendingBroadcast: (ctx, text) => broadcastActions.handlePendingBroadcast(ctx, text),
+        handlePendingPartnerNote: (ctx, text) => partnerActions.handlePendingPartnerNote(ctx, text),
+        handlePendingFileHandoff: (ctx, text) => fileHandoffActions.handlePending(ctx, text),
+        handlePendingProject: (ctx, text) => projectActions.handlePendingProject(ctx, text),
+        replyText: (ctx, text, meta, options) => outputActions.replyText(ctx, text, meta, options),
+        tForContext: (ctx, key, options) => context.tForContext(ctx, key, options),
+        showSessionsMenu: (ctx, introText) => menuFlow.showSessionsMenu(ctx, introText),
+        showHelp: (ctx) => menuFlow.showHelp(ctx),
+        ensureGatewayScopeConsolesBound: ({ principal, ctx }) => consoleRegistry.ensureScopedConsolesBound({ principal, ctx }),
+        getMainMenu: () => mainMenu,
+        clearWaiter: (requestId) => requestFlow.clearWaiter(requestId),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+        scheduleTerminalNudgeForInboxMessage: (sessionId, session) => terminalRuntime.scheduleTerminalNudgeForInboxMessage(sessionId, session),
+        downloadIncomingAttachments: (session, sessionId, sourceTelegramMessageId, attachments) => attachmentStore.downloadIncomingAttachments(session, sessionId, sourceTelegramMessageId, attachments),
+        storeTelegramUploadMetas: (input) => attachmentStore.storeTelegramUploadMetas(input),
+        deliverAttachmentToPartner: (input) => fileHandoffActions.deliverToPartnerPublic(input).then(() => { }),
+    });
+    const eventActions = new transportEventActions_1.TransportEventActions({
+        logger: host.logger,
+        config: host.config,
+        sessionStore: host.sessionStore,
+        bindingStore: host.bindingStore,
+        webAppLaunchRegistry: host.webAppLaunchRegistry,
+        createLiveApprovalMenuPayload: (input) => payloadState.createLiveApprovalMenuPayload(input),
+        nudgeSessionInbox: (sessionId) => host.nudgeSessionInbox(sessionId),
+        sendNotification: (input) => host.sendNotification(input),
+        resolveLocaleForTelegramUserId: (telegramUserId, telegramLanguageCode) => context.resolveLocaleForTelegramUserId(telegramUserId, telegramLanguageCode),
+        t: (locale, key, options) => context.t(locale, key, options),
+        tForTelegramUserId: (telegramUserId, key, options) => context.tForTelegramUserId(telegramUserId, key, options),
+        sendChatMessage: (telegramChatId, text, options, meta) => outputActions.sendChatMessage(telegramChatId, text, options, meta),
+        buildLiveViewUrl: (input) => liveActions.buildUrl(input),
+        buildLiveViewKeyboard: (buildUrlForMode, locale) => liveActions.buildKeyboard(buildUrlForMode, locale),
+    });
+    const menuShell = new transportMenuShell_1.TransportMenuShell({
+        logger: host.logger,
+        tForContext: (ctx, key) => context.tForContext(ctx, key),
+        showProjectsMenu: (ctx) => menuFlow.showProjectsMenu(ctx),
+        handleMessage: (ctx) => messageFlow.handleMessage(ctx),
+        cancelPendingBroadcast: (ctx) => broadcastActions.cancelPendingBroadcast(ctx),
+        cancelPendingPartnerNote: (ctx) => partnerActions.cancelPendingPartnerNote(ctx),
+        cancelPendingFileHandoff: (ctx) => fileHandoffActions.cancelPending(ctx),
+        handleProjectSetCallback: (ctx) => projectActions.handleProjectSetCallback(ctx),
+        handleProjectMembersCallback: (ctx) => projectActions.handleProjectMembersCallback(ctx),
+        handleProjectMemberOpenCallback: (ctx) => projectActions.handleProjectMemberOpenCallback(ctx),
+        handleProjectMemberNoteCallback: (ctx) => projectActions.handleProjectMemberNoteCallback(ctx),
+        handleProjectMemberLiveCallback: (ctx) => projectActions.handleProjectMemberLiveCallback(ctx),
+        handleLiveApprovalCallback: (ctx) => projectActions.handleLiveApprovalCallback(ctx),
+        handleTerminalPromptActionCallback: (ctx) => terminalActions.handlePromptActionCallback(ctx),
+        handleProjectDetailCallback: (ctx) => projectActions.handleProjectDetailCallback(ctx),
+        handleProjectDeleteCallback: (ctx) => projectActions.handleProjectDeleteCallback(ctx),
+        handleProjectLeaveCallback: (ctx) => projectActions.handleProjectLeaveCallback(ctx),
+    });
+    mainMenu.register([
+        storageMenu,
+        browserMenu,
+        projectsMenu,
+        collabToolsMenu,
+        collabDeleteMenu,
+        screenshotsMenu,
+        sessionsMenu,
+        bufferMenu,
+        settingsMenu,
+        developerMenu,
+        unpairConfirmMenu,
+        pruneConfirmMenu,
+        storageMessageMenu,
+        screenshotMessageMenu,
+    ]);
+    return {
+        telegramFetch,
+        bot,
+        mainMenu,
+        storageMenu,
+        browserMenu,
+        projectsMenu,
+        collabToolsMenu,
+        collabDeleteMenu,
+        screenshotsMenu,
+        sessionsMenu,
+        bufferMenu,
+        settingsMenu,
+        developerMenu,
+        unpairConfirmMenu,
+        pruneConfirmMenu,
+        storageMessageMenu,
+        screenshotMessageMenu,
+        terminalActions,
+        liveActions,
+        lifecycleActions,
+        attachmentStore,
+        broadcastActions,
+        context,
+        documentActions,
+        eventActions,
+        partnerActions,
+        fileHandoffActions,
+        menuFactories,
+        menuFingerprints,
+        menuFlow,
+        menuShell,
+        consoleRegistry,
+        gatewayActions,
+        messageFlow,
+        menuCallbacks,
+        menuState,
+        payloadState,
+        projectMenus,
+        projectEvents,
+        projectState,
+        projectView,
+        projectActions,
+        projectEntryActions,
+        requestFlow,
+        sessionActions,
+        outputActions,
+        terminalRuntime,
+        xchangeState,
+    };
+}