@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/inbox.service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_INBOX_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const inboxService_1 = require("./src/features/inbox/model/inboxService");
+exports.TELEGRAM_MCP_INBOX_SERVICE_NAME = "telegramMcp.inbox";
+const TelegramMcpInboxService = {
+    name: exports.TELEGRAM_MCP_INBOX_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.inboxService = null;
+    },
+    methods: {
+        getInboxService() {
+            if (!this.inboxService) {
+                throw new Error("telegram_mcp inbox service is not initialized yet");
+            }
+            return this.inboxService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp inbox service");
+        this.inboxService = new inboxService_1.InboxService(runtime.config, runtime.stateStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp inbox service is ready");
+    },
+};
+exports.default = TelegramMcpInboxService;

package/dist/services/features/telegram-mcp/mcp-http.service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_HTTP_SERVICE_NAME = void 0;
+const mcp_server_service_1 = require("./mcp-server.service");
+const runtime_service_1 = require("./runtime.service");
+const http_1 = require("./src/app/http");
+exports.TELEGRAM_MCP_HTTP_SERVICE_NAME = "telegramMcp.http";
+const TelegramMcpHttpService = {
+    name: exports.TELEGRAM_MCP_HTTP_SERVICE_NAME,
+    dependencies: [
+        runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME,
+        mcp_server_service_1.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME,
+    ],
+    created() {
+        this.httpHandler = null;
+    },
+    methods: {
+        async routeRequest(req, res, pathname) {
+            if (!this.httpHandler) {
+                throw new Error("telegram_mcp HTTP handler is not initialized yet");
+            }
+            this.logger.debug("telegram_mcp HTTP routeRequest received", {
+                method: req.method,
+                pathname,
+            });
+            await this.httpHandler.handleRequest(req, res, pathname);
+        },
+    },
+    actions: {
+        async route(ctx) {
+            const req = ctx.meta?.$request;
+            const res = ctx.meta?.$response;
+            if (!req || !res) {
+                throw new Error("Raw HTTP request/response are not available in context");
+            }
+            const request = req;
+            const requestUrl = new URL(request.originalUrl ?? req.url ?? "/", "http://gateway.local");
+            await this.routeRequest?.(req, res, requestUrl.pathname);
+            return null;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([
+            runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME,
+            mcp_server_service_1.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME,
+        ]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        const mcpServerService = this.broker.getLocalService(mcp_server_service_1.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        if (!mcpServerService) {
+            throw new Error(`Local Moleculer service '${mcp_server_service_1.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp HTTP service");
+        this.httpHandler = (0, http_1.createMcpHttpHandler)(runtime, {
+            createMcpServer: () => mcpServerService.createServer(),
+        });
+        this.logger.info("telegram_mcp HTTP service is ready", {
+            path: runtime.config.mcp.httpPath,
+            webappBasePath: runtime.config.webapp.basePath,
+            bearerAuthEnabled: Boolean(runtime.config.mcp.bearerToken),
+        });
+    },
+    async stopped() {
+        if (!this.httpHandler) {
+            return;
+        }
+        const handle = this.httpHandler;
+        this.httpHandler = null;
+        this.logger.info("Stopping telegram_mcp HTTP service");
+        await handle.close();
+    },
+};
+exports.default = TelegramMcpHttpService;

package/dist/services/features/telegram-mcp/mcp-server.service.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME = void 0;
+const server_1 = require("./src/app/providers/mcp/server");
+const approval_service_1 = require("./approval.service");
+const browser_service_1 = require("./browser.service");
+const collaboration_service_1 = require("./collaboration.service");
+const inbox_service_1 = require("./inbox.service");
+const notify_service_1 = require("./notify.service");
+const pair_service_1 = require("./pair.service");
+const session_context_service_1 = require("./session-context.service");
+const tools_sync_service_1 = require("./tools-sync.service");
+const askUserTelegram_1 = require("./src/features/ask-user/model/askUserTelegram");
+const browserClickTool_1 = require("./src/features/browser/model/browserClickTool");
+const browserClearLogsTool_1 = require("./src/features/browser/model/browserClearLogsTool");
+const browserCloseTool_1 = require("./src/features/browser/model/browserCloseTool");
+const browserComputedStyleTool_1 = require("./src/features/browser/model/browserComputedStyleTool");
+const browserConsoleTool_1 = require("./src/features/browser/model/browserConsoleTool");
+const browserDomTool_1 = require("./src/features/browser/model/browserDomTool");
+const browserErrorsTool_1 = require("./src/features/browser/model/browserErrorsTool");
+const browserFillTool_1 = require("./src/features/browser/model/browserFillTool");
+const browserNetworkFailuresTool_1 = require("./src/features/browser/model/browserNetworkFailuresTool");
+const browserOpenTool_1 = require("./src/features/browser/model/browserOpenTool");
+const browserPressTool_1 = require("./src/features/browser/model/browserPressTool");
+const browserReloadTool_1 = require("./src/features/browser/model/browserReloadTool");
+const browserScreenshotTool_1 = require("./src/features/browser/model/browserScreenshotTool");
+const browserWaitForTool_1 = require("./src/features/browser/model/browserWaitForTool");
+const browserWaitForUrlTool_1 = require("./src/features/browser/model/browserWaitForUrlTool");
+const sendPartnerFileTool_1 = require("./src/features/collaboration/model/sendPartnerFileTool");
+const sendPartnerNoteTool_1 = require("./src/features/collaboration/model/sendPartnerNoteTool");
+const deleteTelegramInboxMessageTool_1 = require("./src/features/inbox/model/deleteTelegramInboxMessageTool");
+const getTelegramInboxCountTool_1 = require("./src/features/inbox/model/getTelegramInboxCountTool");
+const getTelegramInboxTool_1 = require("./src/features/inbox/model/getTelegramInboxTool");
+const notifyTelegramTool_1 = require("./src/features/notify/model/notifyTelegramTool");
+const clearSessionPairingTool_1 = require("./src/features/pair-session/model/clearSessionPairingTool");
+const createSessionPairCodeTool_1 = require("./src/features/pair-session/model/createSessionPairCodeTool");
+const clearSessionContextTool_1 = require("./src/features/session-context/model/clearSessionContextTool");
+const getSessionContextTool_1 = require("./src/features/session-context/model/getSessionContextTool");
+const getTmuxTargetTool_1 = require("./src/features/session-context/model/getTmuxTargetTool");
+const renameSessionTool_1 = require("./src/features/session-context/model/renameSessionTool");
+const setSessionContextTool_1 = require("./src/features/session-context/model/setSessionContextTool");
+const setTmuxTargetTool_1 = require("./src/features/session-context/model/setTmuxTargetTool");
+const refreshToolsMarkdownTool_1 = require("./src/features/tools-sync/model/refreshToolsMarkdownTool");
+exports.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME = "telegramMcp.mcpServer";
+const TelegramMcpMcpServerService = {
+    name: exports.TELEGRAM_MCP_MCP_SERVER_SERVICE_NAME,
+    dependencies: [
+        pair_service_1.TELEGRAM_MCP_PAIR_SERVICE_NAME,
+        session_context_service_1.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME,
+        notify_service_1.TELEGRAM_MCP_NOTIFY_SERVICE_NAME,
+        inbox_service_1.TELEGRAM_MCP_INBOX_SERVICE_NAME,
+        approval_service_1.TELEGRAM_MCP_APPROVAL_SERVICE_NAME,
+        browser_service_1.TELEGRAM_MCP_BROWSER_SERVICE_NAME,
+        collaboration_service_1.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME,
+        tools_sync_service_1.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME,
+    ],
+    methods: {
+        createServer() {
+            const pairService = this.broker.getLocalService(pair_service_1.TELEGRAM_MCP_PAIR_SERVICE_NAME);
+            const sessionContextService = this.broker.getLocalService(session_context_service_1.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME);
+            const notifyService = this.broker.getLocalService(notify_service_1.TELEGRAM_MCP_NOTIFY_SERVICE_NAME);
+            const inboxService = this.broker.getLocalService(inbox_service_1.TELEGRAM_MCP_INBOX_SERVICE_NAME);
+            const approvalService = this.broker.getLocalService(approval_service_1.TELEGRAM_MCP_APPROVAL_SERVICE_NAME);
+            const browserService = this.broker.getLocalService(browser_service_1.TELEGRAM_MCP_BROWSER_SERVICE_NAME);
+            const collaborationService = this.broker.getLocalService(collaboration_service_1.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME);
+            const toolsSyncService = this.broker.getLocalService(tools_sync_service_1.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME);
+            if (!pairService ||
+                !sessionContextService ||
+                !notifyService ||
+                !inboxService ||
+                !approvalService ||
+                !browserService ||
+                !collaborationService ||
+                !toolsSyncService) {
+                throw new Error("telegram_mcp MCP server dependencies are not ready");
+            }
+            const tools = [
+                new createSessionPairCodeTool_1.CreateSessionPairCodeTool(pairService.getPairSessionService()),
+                new clearSessionPairingTool_1.ClearSessionPairingTool(pairService.getPairSessionService()),
+                new setSessionContextTool_1.SetSessionContextTool(sessionContextService.getSessionContextService()),
+                new renameSessionTool_1.RenameSessionTool(sessionContextService.getSessionContextService()),
+                new setTmuxTargetTool_1.SetTmuxTargetTool(sessionContextService.getSessionContextService()),
+                new getTmuxTargetTool_1.GetTmuxTargetTool(sessionContextService.getSessionContextService()),
+                new getSessionContextTool_1.GetSessionContextTool(sessionContextService.getSessionContextService()),
+                new clearSessionContextTool_1.ClearSessionContextTool(sessionContextService.getSessionContextService()),
+                new notifyTelegramTool_1.NotifyTelegramTool(notifyService.getNotifyService()),
+                new getTelegramInboxCountTool_1.GetTelegramInboxCountTool(inboxService.getInboxService()),
+                new getTelegramInboxTool_1.GetTelegramInboxTool(inboxService.getInboxService()),
+                new deleteTelegramInboxMessageTool_1.DeleteTelegramInboxMessageTool(inboxService.getInboxService()),
+                new askUserTelegram_1.AskUserTelegramTool(approvalService.getApprovalOrchestrator()),
+                new browserOpenTool_1.BrowserOpenTool(browserService.getBrowserService()),
+                new browserReloadTool_1.BrowserReloadTool(browserService.getBrowserService()),
+                new browserClickTool_1.BrowserClickTool(browserService.getBrowserService()),
+                new browserFillTool_1.BrowserFillTool(browserService.getBrowserService()),
+                new browserPressTool_1.BrowserPressTool(browserService.getBrowserService()),
+                new browserWaitForTool_1.BrowserWaitForTool(browserService.getBrowserService()),
+                new browserWaitForUrlTool_1.BrowserWaitForUrlTool(browserService.getBrowserService()),
+                new browserConsoleTool_1.BrowserConsoleTool(browserService.getBrowserService()),
+                new browserErrorsTool_1.BrowserErrorsTool(browserService.getBrowserService()),
+                new browserNetworkFailuresTool_1.BrowserNetworkFailuresTool(browserService.getBrowserService()),
+                new browserClearLogsTool_1.BrowserClearLogsTool(browserService.getBrowserService()),
+                new browserDomTool_1.BrowserDomTool(browserService.getBrowserService()),
+                new browserComputedStyleTool_1.BrowserComputedStyleTool(browserService.getBrowserService()),
+                new browserScreenshotTool_1.BrowserScreenshotTool(browserService.getBrowserService()),
+                new browserCloseTool_1.BrowserCloseTool(browserService.getBrowserService()),
+                new sendPartnerNoteTool_1.SendPartnerNoteTool(collaborationService.getCollaborationService()),
+                new sendPartnerFileTool_1.SendPartnerFileTool(collaborationService.getSendPartnerFileService()),
+                new refreshToolsMarkdownTool_1.RefreshToolsMarkdownTool(toolsSyncService.getRefreshToolsMarkdownService()),
+            ];
+            return (0, server_1.createMcpServer)(tools);
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([
+            pair_service_1.TELEGRAM_MCP_PAIR_SERVICE_NAME,
+            session_context_service_1.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME,
+            notify_service_1.TELEGRAM_MCP_NOTIFY_SERVICE_NAME,
+            inbox_service_1.TELEGRAM_MCP_INBOX_SERVICE_NAME,
+            approval_service_1.TELEGRAM_MCP_APPROVAL_SERVICE_NAME,
+            browser_service_1.TELEGRAM_MCP_BROWSER_SERVICE_NAME,
+            collaboration_service_1.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME,
+            tools_sync_service_1.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME,
+        ]);
+        this.logger.info("telegram_mcp MCP server service is ready");
+    },
+};
+exports.default = TelegramMcpMcpServerService;

package/dist/services/features/telegram-mcp/notify.service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_NOTIFY_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const notifyService_1 = require("./src/features/notify/model/notifyService");
+exports.TELEGRAM_MCP_NOTIFY_SERVICE_NAME = "telegramMcp.notify";
+const TelegramMcpNotifyService = {
+    name: exports.TELEGRAM_MCP_NOTIFY_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.notifyService = null;
+    },
+    methods: {
+        getNotifyService() {
+            if (!this.notifyService) {
+                throw new Error("telegram_mcp notify service is not initialized yet");
+            }
+            return this.notifyService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp notify service");
+        this.notifyService = new notifyService_1.NotifyService(runtime.config, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp notify service is ready");
+    },
+};
+exports.default = TelegramMcpNotifyService;

package/dist/services/features/telegram-mcp/pair.service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_PAIR_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const generatePairCode_1 = require("./src/features/pair-session/model/generatePairCode");
+exports.TELEGRAM_MCP_PAIR_SERVICE_NAME = "telegramMcp.pair";
+const TelegramMcpPairService = {
+    name: exports.TELEGRAM_MCP_PAIR_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.pairSessionService = null;
+    },
+    methods: {
+        getPairSessionService() {
+            if (!this.pairSessionService) {
+                throw new Error("telegram_mcp pair service is not initialized yet");
+            }
+            return this.pairSessionService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp pair service");
+        this.pairSessionService = new generatePairCode_1.PairSessionService(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp pair service is ready");
+    },
+};
+exports.default = TelegramMcpPairService;

package/dist/services/features/telegram-mcp/runtime.service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_RUNTIME_SERVICE_NAME = void 0;
+const runtime_1 = require("./src/app/bootstrap/runtime");
+exports.TELEGRAM_MCP_RUNTIME_SERVICE_NAME = "telegramMcp.runtime";
+const TelegramMcpRuntimeService = {
+    name: exports.TELEGRAM_MCP_RUNTIME_SERVICE_NAME,
+    created() {
+        this.runtime = null;
+    },
+    methods: {
+        getRuntime() {
+            if (!this.runtime) {
+                throw new Error("telegram_mcp runtime is not initialized yet");
+            }
+            return this.runtime;
+        },
+    },
+    async started() {
+        this.logger.info("Starting telegram_mcp runtime service");
+        this.runtime = await (0, runtime_1.createAppRuntime)({
+            callBroker: (actionName, params, options) => this.broker.call(actionName, params, options),
+        });
+        this.logger.info("telegram_mcp runtime service is ready");
+    },
+    async stopped() {
+        if (!this.runtime) {
+            return;
+        }
+        const runtime = this.runtime;
+        this.runtime = null;
+        this.logger.info("Stopping telegram_mcp runtime service");
+        await runtime.shutdown();
+    },
+};
+exports.default = TelegramMcpRuntimeService;

package/dist/services/features/telegram-mcp/session-context.service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const sessionContextService_1 = require("./src/features/session-context/model/sessionContextService");
+exports.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME = "telegramMcp.sessionContext";
+const TelegramMcpSessionContextService = {
+    name: exports.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.sessionContextService = null;
+    },
+    methods: {
+        getSessionContextService() {
+            if (!this.sessionContextService) {
+                throw new Error("telegram_mcp session-context service is not initialized yet");
+            }
+            return this.sessionContextService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp session-context service");
+        this.sessionContextService = new sessionContextService_1.SessionContextService(runtime.stateStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp session-context service is ready");
+    },
+};
+exports.default = TelegramMcpSessionContextService;

package/dist/services/features/telegram-mcp/src/app/bootstrap/runtime.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppRuntime = createAppRuntime;
+const env_1 = require("../config/env");
+const auth_1 = require("../webapp/auth");
+const client_1 = require("../providers/redis/client");
+const logger_1 = require("../../shared/lib/logger/logger");
+const projectIdentity_1 = require("../../shared/lib/project-identity/projectIdentity");
+const stateStore_1 = require("../../shared/integrations/redis/stateStore");
+const transport_1 = require("../../shared/integrations/telegram/transport");
+const minioExchangeStore_1 = require("../../shared/integrations/object-storage/minioExchangeStore");
+const gatewayHttpService_1 = require("../../features/distributed-gateway/model/gatewayHttpService");
+async function createAppRuntime(input) {
+    const config = (0, env_1.loadConfig)();
+    const logger = (0, logger_1.createLogger)(config);
+    const projectIdentityResolver = new projectIdentity_1.ProjectIdentityResolver(config, logger);
+    logger.info("Configuration loaded", {
+        mode: config.mode,
+        redis: {
+            host: config.redis.host,
+            port: config.redis.port,
+            db: config.redis.db,
+        },
+        logging: {
+            level: config.logging.level,
+        },
+        mcp: {
+            httpHost: config.mcp.httpHost,
+            httpPort: config.mcp.httpPort,
+            httpPath: config.mcp.httpPath,
+            bearerAuthEnabled: Boolean(config.mcp.bearerToken),
+            enableDebugRoutes: config.mcp.enableDebugRoutes,
+            enablePruneRoute: config.mcp.enablePruneRoute,
+        },
+        distributed: {
+            mode: config.distributed.mode,
+            gatewayPublicUrlConfigured: Boolean(config.distributed.gatewayPublicUrl),
+            gatewayBindHost: config.distributed.gatewayBindHost,
+            gatewayBindPort: config.distributed.gatewayBindPort,
+            gatewayWsUrlConfigured: Boolean(config.distributed.gatewayWsUrl),
+            gatewayWsPath: config.distributed.gatewayWsPath,
+            gatewayAuthEnabled: Boolean(config.distributed.gatewayAuthToken),
+            gatewayDatabaseConfigured: Boolean(config.distributed.gatewayDatabaseUrl),
+            gatewayS3Configured: Boolean(config.distributed.gatewayS3Bucket),
+            gatewayRmqConfigured: Boolean(config.distributed.rmq?.host),
+        },
+        webapp: {
+            enabled: config.webapp.enabled,
+            basePath: config.webapp.basePath,
+            publicUrlConfigured: Boolean(config.webapp.publicUrl),
+            initDataTtlSeconds: config.webapp.initDataTtlSeconds,
+            sessionTtlSeconds: config.webapp.sessionTtlSeconds,
+            launchMode: config.webapp.launchMode,
+            pollIntervalMs: config.webapp.pollIntervalMs,
+            actionCooldownMs: config.webapp.actionCooldownMs,
+        },
+        tmux: {
+            nudgeEnabled: config.tmux.nudgeEnabled,
+            nudgeDebounceSeconds: config.tmux.nudgeDebounceSeconds,
+            nudgeCooldownSeconds: config.tmux.nudgeCooldownSeconds,
+        },
+        project: projectIdentityResolver.getIdentity(),
+    });
+    const redis = await (0, client_1.createRedisClient)(config);
+    logger.info("Redis connected", {
+        host: config.redis.host,
+        port: config.redis.port,
+        db: config.redis.db,
+    });
+    const stateStore = new stateStore_1.RedisStateStore(redis);
+    const webAppLaunchRegistry = new auth_1.WebAppLaunchRegistry();
+    const objectStore = new minioExchangeStore_1.MinioExchangeStore(input.callBroker, stateStore, config.tmux, config.exchange.dir, config.mcp.vfsScope, logger, config.distributed.mode, config.distributed.gatewayPublicUrl, config.distributed.gatewayAuthToken);
+    await stateStore.resetRuntimeState();
+    logger.info("Runtime pending state reset");
+    const telegramTransport = new transport_1.TelegramTransport(config, stateStore, stateStore, stateStore, stateStore, stateStore, stateStore, objectStore, webAppLaunchRegistry, logger);
+    await telegramTransport.start();
+    logger.info("Telegram transport ready");
+    await telegramTransport.recoverPendingInboxNudges();
+    logger.info("Startup inbox nudge recovery completed");
+    const gatewayHttpService = new gatewayHttpService_1.GatewayHttpService(config, input.callBroker);
+    return {
+        config,
+        logger,
+        redis,
+        stateStore,
+        telegramTransport,
+        sessionStore: stateStore,
+        bindingStore: stateStore,
+        inboxStore: stateStore,
+        xchangeFileMetaStore: stateStore,
+        maintenanceStore: stateStore,
+        objectStore,
+        projectIdentityResolver,
+        webAppLaunchRegistry,
+        gatewayHttpService,
+        shutdown: async () => {
+            logger.info("Shutdown started");
+            await telegramTransport.stop();
+            redis.disconnect();
+            logger.info("Shutdown completed");
+        },
+    };
+}