@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -3,6 +3,7 @@ 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 gateway_socket_service_1 = require("./gateway-socket.service");
 const http_1 = require("./src/app/http");
 exports.TELEGRAM_MCP_HTTP_SERVICE_NAME = "telegramMcp.http";
 const TelegramMcpHttpService = {
@@ -25,6 +26,12 @@ const TelegramMcpHttpService = {
             });
             await this.httpHandler.handleRequest(req, res, pathname);
         },
+        async routeUpgrade(req, socket, head, pathname) {
+            if (!this.httpHandler) {
+                throw new Error("telegram_mcp HTTP handler is not initialized yet");
+            }
+            return await this.httpHandler.handleUpgrade(req, socket, head, pathname);
+        },
     },
     actions: {
         async route(ctx) {
@@ -56,6 +63,7 @@ const TelegramMcpHttpService = {
         this.logger.info("Starting telegram_mcp HTTP service");
         this.httpHandler = (0, http_1.createMcpHttpHandler)(runtime, {
             createMcpServer: () => mcpServerService.createServer(),
+            getGatewaySocketService: () => this.broker.getLocalService(gateway_socket_service_1.TELEGRAM_MCP_GATEWAY_SOCKET_SERVICE_NAME),
         });
         this.logger.info("telegram_mcp HTTP service is ready", {
             path: runtime.config.mcp.httpPath,

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

@@ -5,11 +5,10 @@ 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 xchange_service_1 = require("./xchange.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");
@@ -27,66 +26,55 @@ const browserScreenshotTool_1 = require("./src/features/browser/model/browserScr
 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 listGatewaySessionsTool_1 = require("./src/features/collaboration/model/listGatewaySessionsTool");
 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 sendFileToTelegramTool_1 = require("./src/features/notify/model/sendFileToTelegramTool");
 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");
+const getXchangeRecordTool_1 = require("./src/features/xchange/model/getXchangeRecordTool");
+const listXchangeRecordsTool_1 = require("./src/features/xchange/model/listXchangeRecordsTool");
+const markXchangeRecordReadTool_1 = require("./src/features/xchange/model/markXchangeRecordReadTool");
 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,
+        xchange_service_1.TELEGRAM_MCP_XCHANGE_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 ||
+            const xchangeService = this.broker.getLocalService(xchange_service_1.TELEGRAM_MCP_XCHANGE_SERVICE_NAME);
+            if (!sessionContextService ||
                 !notifyService ||
-                !inboxService ||
                 !approvalService ||
                 !browserService ||
                 !collaborationService ||
-                !toolsSyncService) {
+                !toolsSyncService ||
+                !xchangeService) {
                 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 sendFileToTelegramTool_1.SendFileToTelegramTool(notifyService.getNotifyService()),
                 new askUserTelegram_1.AskUserTelegramTool(approvalService.getApprovalOrchestrator()),
                 new browserOpenTool_1.BrowserOpenTool(browserService.getBrowserService()),
                 new browserReloadTool_1.BrowserReloadTool(browserService.getBrowserService()),
@@ -104,7 +92,11 @@ const TelegramMcpMcpServerService = {
                 new browserScreenshotTool_1.BrowserScreenshotTool(browserService.getBrowserService()),
                 new browserCloseTool_1.BrowserCloseTool(browserService.getBrowserService()),
                 new sendPartnerNoteTool_1.SendPartnerNoteTool(collaborationService.getCollaborationService()),
+                new listGatewaySessionsTool_1.ListGatewaySessionsTool(collaborationService.getGatewaySessionsService()),
                 new sendPartnerFileTool_1.SendPartnerFileTool(collaborationService.getSendPartnerFileService()),
+                new listXchangeRecordsTool_1.ListXchangeRecordsTool(xchangeService.getXchangeService()),
+                new getXchangeRecordTool_1.GetXchangeRecordTool(xchangeService.getXchangeService()),
+                new markXchangeRecordReadTool_1.MarkXchangeRecordReadTool(xchangeService.getXchangeService()),
                 new refreshToolsMarkdownTool_1.RefreshToolsMarkdownTool(toolsSyncService.getRefreshToolsMarkdownService()),
             ];
             return (0, server_1.createMcpServer)(tools);
@@ -112,14 +104,13 @@ const TelegramMcpMcpServerService = {
     },
     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,
+            xchange_service_1.TELEGRAM_MCP_XCHANGE_SERVICE_NAME,
         ]);
         this.logger.info("telegram_mcp MCP server service is ready");
     },

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

@@ -2,11 +2,137 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TELEGRAM_MCP_NOTIFY_SERVICE_NAME = void 0;
 const runtime_service_1 = require("./runtime.service");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
 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],
+    actions: {
+        sendForGatewaySession: {
+            params: {
+                client_uuid: "string",
+                local_session_id: "string",
+                message: "string",
+                session_label: { type: "string", optional: true },
+                task: { type: "string", optional: true },
+                context: { type: "string", optional: true },
+                risk_level: { type: "string", optional: true },
+            },
+            async handler(ctx) {
+                const service = this.getNotifyService();
+                return service.sendForGatewayBoundSession({
+                    clientUuid: String(ctx.params.client_uuid),
+                    localSessionId: String(ctx.params.local_session_id),
+                    message: String(ctx.params.message),
+                    ...(typeof ctx.params.session_label === "string"
+                        ? { sessionLabel: ctx.params.session_label }
+                        : {}),
+                    ...(typeof ctx.params.task === "string" ? { task: ctx.params.task } : {}),
+                    ...(typeof ctx.params.context === "string"
+                        ? { context: ctx.params.context }
+                        : {}),
+                    ...(typeof ctx.params.risk_level === "string"
+                        ? { riskLevel: ctx.params.risk_level }
+                        : {}),
+                });
+            },
+        },
+        sendRequestForGatewaySession: {
+            params: {
+                client_uuid: "string",
+                local_session_id: "string",
+                request_id: "string",
+                telegram_chat_id: "number",
+                telegram_user_id: "number",
+                question: "string",
+                session_label: { type: "string", optional: true },
+                task: { type: "string", optional: true },
+                context: { type: "string", optional: true },
+                affected_files: { type: "array", optional: true, items: "string" },
+                options: { type: "array", optional: true, items: "string" },
+                recommended_option: { type: "string", optional: true },
+                risk_level: { type: "string", optional: true },
+                fallback_if_timeout: { type: "string", optional: true },
+            },
+            async handler(ctx) {
+                const service = this.getNotifyService();
+                return service.sendRequestForGatewayBoundSession({
+                    clientUuid: String(ctx.params.client_uuid),
+                    localSessionId: String(ctx.params.local_session_id),
+                    requestId: String(ctx.params.request_id),
+                    telegramChatId: Number(ctx.params.telegram_chat_id),
+                    telegramUserId: Number(ctx.params.telegram_user_id),
+                    question: String(ctx.params.question),
+                    ...(typeof ctx.params.session_label === "string"
+                        ? { sessionLabel: ctx.params.session_label }
+                        : {}),
+                    ...(typeof ctx.params.task === "string" ? { task: ctx.params.task } : {}),
+                    ...(typeof ctx.params.context === "string"
+                        ? { context: ctx.params.context }
+                        : {}),
+                    ...(Array.isArray(ctx.params.affected_files)
+                        ? { affectedFiles: ctx.params.affected_files }
+                        : {}),
+                    ...(Array.isArray(ctx.params.options)
+                        ? { options: ctx.params.options }
+                        : {}),
+                    ...(typeof ctx.params.recommended_option === "string"
+                        ? { recommendedOption: ctx.params.recommended_option }
+                        : {}),
+                    ...(typeof ctx.params.risk_level === "string"
+                        ? { riskLevel: ctx.params.risk_level }
+                        : {}),
+                    ...(typeof ctx.params.fallback_if_timeout === "string"
+                        ? { fallbackIfTimeout: ctx.params.fallback_if_timeout }
+                        : {}),
+                });
+            },
+        },
+        sendDocumentForGatewaySession: {
+            params: {
+                client_uuid: "string",
+                local_session_id: "string",
+                file_name: "string",
+                content_base64: "string",
+                caption: { type: "string", optional: true },
+            },
+            async handler(ctx) {
+                const service = this.getNotifyService();
+                return service.sendDocumentForGatewayBoundSession({
+                    clientUuid: String(ctx.params.client_uuid),
+                    localSessionId: String(ctx.params.local_session_id),
+                    fileName: String(ctx.params.file_name),
+                    contentBase64: String(ctx.params.content_base64),
+                    ...(typeof ctx.params.caption === "string"
+                        ? { caption: ctx.params.caption }
+                        : {}),
+                });
+            },
+        },
+        sendDocumentRemote: {
+            params: {
+                $$strict: false,
+                session_id: { type: "string", optional: true },
+                cwd: { type: "string", optional: true },
+                file_path: "string",
+                caption: { type: "string", optional: true },
+            },
+            async handler(ctx) {
+                const service = this.getNotifyService();
+                return service.sendDocument({
+                    ...(typeof ctx.params.session_id === "string"
+                        ? { session_id: ctx.params.session_id }
+                        : {}),
+                    ...(typeof ctx.params.cwd === "string" ? { cwd: ctx.params.cwd } : {}),
+                    file_path: String(ctx.params.file_path),
+                    ...(typeof ctx.params.caption === "string"
+                        ? { caption: ctx.params.caption }
+                        : {}),
+                });
+            },
+        },
+    },
     created() {
         this.notifyService = null;
     },
@@ -26,7 +152,7 @@ const TelegramMcpNotifyService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         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.notifyService = new notifyService_1.NotifyService(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })), async (sessionId) => (await this.broker.call("telegramMcp.gatewaySocket.resolveConnectedSessionTarget", { sessionId }, { meta: { internal_call: true } })));
         this.logger.info("telegram_mcp notify service is ready");
     },
 };

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

@@ -2,11 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME = void 0;
 const runtime_service_1 = require("./runtime.service");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
 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],
+    actions: {
+        getContextRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getSessionContextService().getContext(ctx.params);
+            },
+        },
+        setContextRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getSessionContextService().setContext(ctx.params);
+            },
+        },
+        renameSessionRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getSessionContextService().renameSession(ctx.params);
+            },
+        },
+        clearContextRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getSessionContextService().clearContext(ctx.params);
+            },
+        },
+    },
     created() {
         this.sessionContextService = null;
     },
@@ -26,7 +53,7 @@ const TelegramMcpSessionContextService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp session-context service");
-        this.sessionContextService = new sessionContextService_1.SessionContextService(runtime.stateStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver);
+        this.sessionContextService = new sessionContextService_1.SessionContextService(runtime.sessionStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })));
         this.logger.info("telegram_mcp session-context service is ready");
     },
 };

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

@@ -7,9 +7,13 @@ 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 processLocalSessionStore_1 = require("../../shared/integrations/memory/processLocalSessionStore");
 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");
+const gatewayClientAccess_1 = require("../../features/distributed-client/model/gatewayClientAccess");
+const client_2 = require("../../shared/integrations/terminal/client");
+const ptyRegistry_1 = require("../../shared/integrations/terminal/ptyRegistry");
 async function createAppRuntime(input) {
     const config = (0, env_1.loadConfig)();
     const logger = (0, logger_1.createLogger)(config);
@@ -54,10 +58,16 @@ async function createAppRuntime(input) {
             pollIntervalMs: config.webapp.pollIntervalMs,
             actionCooldownMs: config.webapp.actionCooldownMs,
         },
-        tmux: {
-            nudgeEnabled: config.tmux.nudgeEnabled,
-            nudgeDebounceSeconds: config.tmux.nudgeDebounceSeconds,
-            nudgeCooldownSeconds: config.tmux.nudgeCooldownSeconds,
+        terminal: {
+            nudgeEnabled: config.terminal.nudgeEnabled,
+            nudgeDebounceSeconds: config.terminal.nudgeDebounceSeconds,
+            nudgeCooldownSeconds: config.terminal.nudgeCooldownSeconds,
+        },
+        telegram: {
+            webhookEnabled: config.telegram.webhook.enabled,
+            webhookPath: config.telegram.webhook.path,
+            webhookPublicUrlConfigured: Boolean(config.telegram.webhook.publicUrl),
+            webhookTrace: config.telegram.webhook.trace,
         },
         project: projectIdentityResolver.getIdentity(),
     });
@@ -68,27 +78,138 @@ async function createAppRuntime(input) {
         db: config.redis.db,
     });
     const stateStore = new stateStore_1.RedisStateStore(redis);
+    let sessionStore = stateStore;
     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);
+    const objectStore = new minioExchangeStore_1.MinioExchangeStore(input.callBroker, stateStore, config.terminal, config.exchange.dir, config.mcp.vfsScope, logger, config.distributed.mode, config.distributed.gatewayPublicUrl, config.distributed.gatewayAuthToken);
+    if (config.distributed.mode === "client") {
+        const resolvedSession = projectIdentityResolver.resolveSessionDefaults({
+            cwd: process.cwd(),
+        });
+        const existingSession = await stateStore.getSession(resolvedSession.sessionId);
+        const persistedToolsState = (0, projectIdentity_1.readSessionMarkerState)(resolvedSession.cwd, logger);
+        const terminalTarget = (0, client_2.ensureTerminalTargetForSession)(config.terminal, {
+            sessionId: resolvedSession.sessionId,
+            cwd: resolvedSession.cwd,
+            ...(typeof existingSession?.terminalTarget === "string"
+                ? { target: existingSession.terminalTarget }
+                : {}),
+        });
+        if (!terminalTarget) {
+            throw new Error("PTY terminal target could not be created during runtime bootstrap");
+        }
+        const initialSession = {
+            sessionId: resolvedSession.sessionId,
+            ...(typeof existingSession?.label === "string"
+                ? { label: existingSession.label }
+                : { label: resolvedSession.sessionLabel }),
+            ...(typeof existingSession?.cwd === "string"
+                ? { cwd: existingSession.cwd }
+                : { cwd: resolvedSession.cwd }),
+            ...(typeof existingSession?.activeProjectUuid === "string"
+                ? { activeProjectUuid: existingSession.activeProjectUuid }
+                : {}),
+            ...(typeof existingSession?.activeProjectName === "string"
+                ? { activeProjectName: existingSession.activeProjectName }
+                : {}),
+            ...(typeof existingSession?.task === "string"
+                ? { task: existingSession.task }
+                : {}),
+            ...(typeof existingSession?.summary === "string"
+                ? { summary: existingSession.summary }
+                : {}),
+            ...(Array.isArray(existingSession?.files)
+                ? { files: existingSession.files }
+                : {}),
+            ...(Array.isArray(existingSession?.decisions)
+                ? { decisions: existingSession.decisions }
+                : {}),
+            ...(Array.isArray(existingSession?.risks)
+                ? { risks: existingSession.risks }
+                : {}),
+            terminalTarget: terminalTarget,
+            ...(typeof existingSession?.lastTerminalNudgeAt === "string"
+                ? { lastTerminalNudgeAt: existingSession.lastTerminalNudgeAt }
+                : {}),
+            ...(typeof existingSession?.lastSeenToolsHash === "string"
+                ? { lastSeenToolsHash: existingSession.lastSeenToolsHash }
+                : typeof persistedToolsState?.lastSeenToolsHash === "string"
+                    ? { lastSeenToolsHash: persistedToolsState.lastSeenToolsHash }
+                    : {}),
+            ...(typeof existingSession?.lastNotifiedToolsHash === "string"
+                ? { lastNotifiedToolsHash: existingSession.lastNotifiedToolsHash }
+                : typeof persistedToolsState?.lastNotifiedToolsHash === "string"
+                    ? { lastNotifiedToolsHash: persistedToolsState.lastNotifiedToolsHash }
+                    : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        sessionStore = new processLocalSessionStore_1.ProcessLocalSessionStore({
+            initialSessions: [initialSession],
+            onClearSession: async (sessionId) => {
+                await stateStore.clearSession(sessionId);
+            },
+        });
+        logger.info("Client PTY process-local session store initialized", {
+            sessionId: resolvedSession.sessionId,
+            terminalTarget,
+        });
+    }
     await stateStore.resetRuntimeState();
     logger.info("Runtime pending state reset");
-    const telegramTransport = new transport_1.TelegramTransport(config, stateStore, stateStore, stateStore, stateStore, stateStore, stateStore, stateStore, objectStore, webAppLaunchRegistry, logger);
+    if (config.distributed.mode === "client" && config.distributed.gatewayPublicUrl) {
+        const clientUuid = await (0, gatewayClientAccess_1.ensureGatewayClientUuid)({
+            maintenanceStore: stateStore,
+            gatewayPublicUrl: config.distributed.gatewayPublicUrl,
+            ...(config.distributed.gatewayAuthToken
+                ? { gatewayAuthToken: config.distributed.gatewayAuthToken }
+                : {}),
+            ...(config.project.name ? { projectName: config.project.name } : {}),
+            ...(config.telegram.botUsername ? { botUsername: config.telegram.botUsername } : {}),
+            ...(config.distributed.gatewayToken
+                ? { gatewayToken: config.distributed.gatewayToken }
+                : {}),
+            ...(config.distributed.gatewayUserUuid
+                ? { gatewayUserUuid: config.distributed.gatewayUserUuid }
+                : {}),
+            ...(process.env.NAMESPACE?.trim()
+                ? { namespace: process.env.NAMESPACE.trim() }
+                : {}),
+            ...(process.env.NODE_ID?.trim() ? { nodeId: process.env.NODE_ID.trim() } : {}),
+        });
+        logger.info("Gateway client identity ensured", {
+            clientUuid,
+            gatewayPublicUrl: config.distributed.gatewayPublicUrl,
+        });
+    }
+    const sessions = await sessionStore.listSessions();
+    let recoveredCount = 0;
+    for (const session of sessions) {
+        if (!session.terminalTarget?.startsWith("pty:")) {
+            continue;
+        }
+        (0, client_2.ensureTerminalTargetForSession)(config.terminal, {
+            sessionId: session.sessionId,
+            ...(session.cwd ? { cwd: session.cwd } : {}),
+            target: session.terminalTarget,
+        });
+        recoveredCount += 1;
+    }
+    logger.info("PTY terminal sessions recovered", { recoveredCount });
+    const telegramTransport = new transport_1.TelegramTransport(config, sessionStore, 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");
     await telegramTransport.sendStartupNotifications();
     logger.info("Startup Telegram notifications completed");
     const gatewayHttpService = new gatewayHttpService_1.GatewayHttpService(config, input.callBroker);
     return {
+        callBroker: input.callBroker,
         config,
         logger,
         redis,
         stateStore,
         telegramTransport,
-        sessionStore: stateStore,
+        sessionStore,
         bindingStore: stateStore,
-        inboxStore: stateStore,
+        adminAuthStore: stateStore,
         localeStore: stateStore,
         xchangeFileMetaStore: stateStore,
         maintenanceStore: stateStore,
@@ -99,6 +220,7 @@ async function createAppRuntime(input) {
         shutdown: async () => {
             logger.info("Shutdown started");
             await telegramTransport.stop();
+            (0, ptyRegistry_1.stopAllPtyTargets)();
             redis.disconnect();
             logger.info("Shutdown completed");
         },