@deadragdoll/tellymcp 0.0.14 → 0.0.16

package/dist/envMigration.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateEnvironmentContent = migrateEnvironmentContent;
+const dotenv_1 = require("dotenv");
+const environmentContract_1 = require("./services/features/telegram-mcp/src/app/config/environmentContract");
+const allRoles = ["client", "gateway", "both"];
+const gatewayRoles = ["gateway", "both"];
+const clientRoles = ["client", "both"];
+const environmentSections = [
+    {
+        title: "Runtime role and request policy",
+        roles: allRoles,
+        keys: ["DISTRIBUTED_MODE", "TELEGRAM_REQUEST_MODE"],
+    },
+    {
+        title: "Workspace identity",
+        roles: clientRoles,
+        keys: [
+            "PROJECT_NAME",
+            "TELLYMCP_SESSION_ID",
+            "TELLYMCP_SESSION_LABEL",
+            "GATEWAY_USER_UUID",
+        ],
+    },
+    {
+        title: "Gateway connection and scope",
+        roles: allRoles,
+        keys: [
+            "GATEWAY_PUBLIC_URL",
+            "GATEWAY_WS_URL",
+            "GATEWAY_WS_PATH",
+            "GATEWAY_SCOPE_TOKEN",
+            "GATEWAY_AUTH_TOKEN",
+        ],
+    },
+    {
+        title: "Telegram gateway",
+        roles: gatewayRoles,
+        keys: [
+            "TELEGRAM_BOT_TOKEN",
+            "TELEGRAM_BOT_USERNAME",
+            "ADMIN_TOKEN",
+            "DEBUG_LANGUAGE",
+            "TELEGRAM_POLL_INTERVAL_MS",
+            "TELEGRAM_DEFAULT_TIMEOUT_SECONDS",
+            "TELEGRAM_MAX_CONTEXT_CHARS",
+            "TELEGRAM_MAX_QUESTION_CHARS",
+            "TELEGRAM_MAX_MESSAGE_CHARS",
+            "TELEGRAM_MENU_PAYLOAD_TTL_SECONDS",
+            "TELEGRAM_WEBHOOK_ENABLED",
+            "TELEGRAM_WEBHOOK_PATH",
+            "TELEGRAM_WEBHOOK_PUBLIC_URL",
+            "TELEGRAM_WEBHOOK_SECRET",
+            "TELEGRAM_WEBHOOK_TRACE",
+            "TELEGRAM_WEBHOOK_DROP_PENDING_UPDATES",
+        ],
+    },
+    {
+        title: "Redis",
+        roles: gatewayRoles,
+        keys: [
+            "REDIS_HOST",
+            "REDIS_PORT",
+            "REDIS_DB",
+            "REDIS_USERNAME",
+            "REDIS_PASSWORD",
+        ],
+    },
+    {
+        title: "PostgreSQL gateway metadata",
+        roles: gatewayRoles,
+        keys: [
+            "DB_HOST",
+            "DB_PORT",
+            "DB_USER",
+            "DB_PASSWORD",
+            "DB_NAME",
+            "DB_SCHEMA",
+        ],
+    },
+    {
+        title: "Standalone HTTP and MCP",
+        roles: allRoles,
+        keys: [
+            "ROOT_PREFIX",
+            "PORT",
+            "MCP_HTTP_HOST",
+            "MCP_HTTP_PORT",
+            "MCP_HTTP_PATH",
+            "MCP_HTTP_BEARER_TOKEN",
+            "MCP_HTTP_ENABLE_DEBUG_ROUTES",
+            "MCP_HTTP_ENABLE_PRUNE_ROUTE",
+            "MCP_XCHANGE_DIR",
+        ],
+    },
+    {
+        title: "Chat connector OAuth",
+        roles: gatewayRoles,
+        keys: [
+            "TELLYMCP_PUBLIC_URL",
+            "TELLYMCP_OAUTH_ISSUER",
+            "TELLYMCP_OAUTH_AUDIENCE",
+            "TELLYMCP_MAGIC_TOKEN",
+            "TELLYMCP_MAGIC_TOKEN_HASH",
+            "TELLYMCP_OAUTH_CLIENT_ID",
+            "TELLYMCP_OAUTH_CLIENT_SECRET",
+            "TELLYMCP_ALLOWED_REDIRECT_URIS",
+            "TELLYMCP_OAUTH_PRIVATE_KEY_PEM",
+            "TELLYMCP_AUTH_CODE_TTL_SECONDS",
+            "TELLYMCP_OAUTH_SCOPES",
+            "TELLYMCP_OAUTH_KEY_ID",
+        ],
+    },
+    {
+        title: "RabbitMQ fanout",
+        roles: gatewayRoles,
+        keys: [
+            "RMQ_HOST",
+            "RMQ_PORT",
+            "RMQ_USER",
+            "RMQ_PASSWORD",
+            "RMQ_VHOST",
+            "RMQ_EXCHANGE",
+        ],
+    },
+    {
+        title: "Telegram Mini App",
+        roles: gatewayRoles,
+        keys: [
+            "WEBAPP_ENABLED",
+            "WEBAPP_BASE_PATH",
+            "WEBAPP_PUBLIC_URL",
+            "WEBAPP_INITDATA_TTL_SECONDS",
+            "WEBAPP_SESSION_TTL_SECONDS",
+            "WEBAPP_LAUNCH_MODE",
+            "WEBAPP_VISIBLE_SCREENS",
+            "WEBAPP_ACTION_COOLDOWN_MS",
+        ],
+    },
+    {
+        title: "Built-in PTY terminal",
+        roles: clientRoles,
+        keys: [
+            "TERMINAL_SHELL",
+            "TERMINAL_COLS",
+            "TERMINAL_ROWS",
+            "TERMINAL_SCROLLBACK_LINES",
+            "TERMINAL_NUDGE_ENABLED",
+            "TERMINAL_NUDGE_DEBOUNCE_SECONDS",
+            "TERMINAL_NUDGE_COOLDOWN_SECONDS",
+            "TERMINAL_NUDGE_MESSAGE",
+            "TERMINAL_PARTNER_NUDGE_MESSAGE",
+            "TERMINAL_PARTNER_REPLY_NUDGE_MESSAGE",
+            "TERMINAL_CAPTURE_MODE",
+            "TERMINAL_CAPTURE_LINES",
+            "TERMINAL_PROMPT_SCAN_ENABLED",
+            "TERMINAL_PROMPT_SCAN_INTERVAL_SECONDS",
+            "TERMINAL_PROMPT_SCAN_COOLDOWN_SECONDS",
+            "TERMINAL_PROMPT_SCAN_STRATEGY",
+            "TERMINAL_PROMPT_SCAN_MIN_SCORE",
+        ],
+    },
+    {
+        title: "Gateway-side prompt detection",
+        roles: ["gateway"],
+        keys: [
+            "TERMINAL_PROMPT_SCAN_ENABLED",
+            "TERMINAL_PROMPT_SCAN_INTERVAL_SECONDS",
+            "TERMINAL_PROMPT_SCAN_COOLDOWN_SECONDS",
+            "TERMINAL_PROMPT_SCAN_STRATEGY",
+            "TERMINAL_PROMPT_SCAN_MIN_SCORE",
+        ],
+    },
+    {
+        title: "Browser automation",
+        roles: clientRoles,
+        keys: [
+            "BROWSER_ENABLED",
+            "BROWSER_HEADLESS",
+            "BROWSER_DEVTOOLS",
+            "BROWSER_ADDRESS",
+            "BROWSER_TIMEOUT_MS",
+            "BROWSER_MAX_EVENTS",
+            "BROWSER_WAIT_UNTIL",
+            "BROWSER_EXECUTABLE_PATH",
+            "BROWSER_CHANNEL",
+            "BROWSER_SLOW_MO_MS",
+            "BROWSER_ATTACH_ENABLED",
+            "BROWSER_ATTACH_WS_HOST",
+            "BROWSER_ATTACH_WS_PORT",
+            "BROWSER_ATTACH_WS_PATH",
+        ],
+    },
+    {
+        title: "Outbound proxy",
+        roles: allRoles,
+        keys: ["PROXY_USE", "HTTP_PROXY", "SOCKS5_PROXY", "NO_PROXY"],
+    },
+    {
+        title: "Moleculer identity and diagnostics",
+        roles: allRoles,
+        keys: [
+            "NAMESPACE",
+            "NODE_ID",
+            "TRANSPORT",
+            "MOLECULER_TRACE",
+            "MOLECULER_METRICS",
+            "METRICS_PORT",
+            "METRICS_PATH",
+        ],
+    },
+    {
+        title: "Logging",
+        roles: allRoles,
+        keys: [
+            "LOG_LEVEL",
+            "LOG_STDERR_LEVEL",
+            "LOG_FILE_ENABLED",
+            "LOG_FILE_LEVEL",
+            "LOG_FILE_PATH",
+            "LOGFEED_ENABLED",
+            "LOGFEED_LEVEL",
+            "LOGFEED_BUFFER_SIZE",
+        ],
+    },
+];
+function inferRole(environment) {
+    const configuredMode = environment.DISTRIBUTED_MODE?.trim();
+    if (configuredMode === "client" ||
+        configuredMode === "gateway" ||
+        configuredMode === "both") {
+        return configuredMode;
+    }
+    if (configuredMode) {
+        throw new Error(`DISTRIBUTED_MODE must be client, gateway, or both; received ${configuredMode}.`);
+    }
+    return environment.TELEGRAM_BOT_TOKEN ||
+        environment.DB_HOST ||
+        environment.ROOT_PREFIX ||
+        environment.PORT
+        ? "gateway"
+        : "client";
+}
+function formatEnvironmentValue(value) {
+    if (/^[A-Za-z0-9_./:@%+,?&=-]*$/u.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function migrateEnvironmentContent(source) {
+    const parsed = (0, dotenv_1.parse)(source);
+    const normalized = { ...parsed };
+    const renamedKeys = [];
+    const handledLegacyKeys = new Set();
+    for (const [from, to] of Object.entries(environmentContract_1.LEGACY_ENV_RENAMES)) {
+        if (!(from in parsed)) {
+            continue;
+        }
+        if (!(to in parsed)) {
+            normalized[to] = parsed[from] ?? "";
+        }
+        delete normalized[from];
+        handledLegacyKeys.add(from);
+        renamedKeys.push({ from, to });
+    }
+    for (const [name, value] of Object.entries(parsed)) {
+        if (!name.startsWith("TMUX_")) {
+            continue;
+        }
+        const replacement = (0, environmentContract_1.getTmuxReplacement)(name);
+        if (replacement && !(replacement in parsed)) {
+            normalized[replacement] = value;
+            renamedKeys.push({ from: name, to: replacement });
+        }
+        delete normalized[name];
+        handledLegacyKeys.add(name);
+    }
+    for (const name of environmentContract_1.REMOVED_ENV_KEYS) {
+        delete normalized[name];
+    }
+    const role = inferRole(normalized);
+    normalized.DISTRIBUTED_MODE = role;
+    const emitted = new Set();
+    const keptKeys = [];
+    const output = [
+        "# Generated by tellymcp migrate-env.",
+        `# Role: ${role}`,
+        "",
+    ];
+    for (const section of environmentSections) {
+        if (!section.roles.includes(role)) {
+            continue;
+        }
+        const sectionKeys = section.keys.filter((key) => key in normalized && !emitted.has(key));
+        if (sectionKeys.length === 0) {
+            continue;
+        }
+        output.push(`# ${section.title}`);
+        for (const key of sectionKeys) {
+            output.push(`${key}=${formatEnvironmentValue(normalized[key] ?? "")}`);
+            emitted.add(key);
+            keptKeys.push(key);
+        }
+        output.push("");
+    }
+    const droppedKeys = Object.keys(parsed)
+        .filter((key) => !emitted.has(key) && !handledLegacyKeys.has(key))
+        .sort();
+    return {
+        role,
+        content: `${output.join("\n").trimEnd()}\n`,
+        keptKeys,
+        renamedKeys,
+        droppedKeys,
+    };
+}

package/dist/moleculer.config.js

@@ -67,9 +67,7 @@ const logger = [
 const metricsEnabled = process.env.MOLECULER_METRICS === "true";
 const metricsPort = +(process.env.METRICS_PORT || 3030);
 const metricsPath = process.env.METRICS_PATH || "/metrics";
-const logFeedEnabled = process.env.ENABLE_LOGFEED != null
-    ? !["0", "false", "no", "off"].includes(process.env.ENABLE_LOGFEED.toLowerCase())
-    : process.env.LOGFEED_ENABLED !== "false";
+const logFeedEnabled = !["0", "false", "no", "off"].includes((process.env.LOGFEED_ENABLED ?? "true").toLowerCase());
 if (logFeedEnabled) {
     logger.push(new logfeed_1.LogFeedLogger({
         level: process.env.LOGFEED_LEVEL || process.env.LOG_LEVEL || "info",

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

@@ -26,7 +26,7 @@ const TelegramMcpApprovalService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp approval service");
-        this.approvalOrchestrator = new orchestrator_1.HumanApprovalOrchestrator(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
+        this.approvalOrchestrator = new orchestrator_1.HumanApprovalOrchestrator(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
         this.logger.info("telegram_mcp approval service is ready");
     },
 };

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

@@ -78,11 +78,11 @@ const TelegramMcpCollaborationService = {
             return localBackend.sendPartnerNote(input, resolved);
         });
         const backend = runtime.config.distributed.gatewayPublicUrl
-            ? new gatewayCollaborationBackend_1.GatewayCollaborationBackend(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername)
+            ? new gatewayCollaborationBackend_1.GatewayCollaborationBackend(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayScopeToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername)
             : localBackend;
         this.collaborationService = new collaborationService_1.CollaborationService(backend, runtime.logger, runtime.projectIdentityResolver);
         this.sendPartnerFileService = new sendPartnerFileService_1.SendPartnerFileService(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver, this.collaborationService, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })));
-        this.gatewaySessionsService = new gatewaySessionsService_1.GatewaySessionsService(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername);
+        this.gatewaySessionsService = new gatewaySessionsService_1.GatewaySessionsService(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayScopeToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername);
         runtime.telegramTransport.setCollaborationService(this.collaborationService);
         this.logger.info("telegram_mcp collaboration service is ready");
     },

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

@@ -5,7 +5,7 @@ const db_1 = require("../../../lib/mixins/db");
 exports.TELEGRAM_MCP_ENSUREDB_SERVICE_NAME = "telegramMcp.ensuredb";
 const DISTRIBUTED_MODE = process.env.DISTRIBUTED_MODE || "client";
 const GATEWAY_ENABLED = DISTRIBUTED_MODE === "gateway" || DISTRIBUTED_MODE === "both";
-const MCP_SCHEMA = process.env.DB_SCHEME || "mcp";
+const MCP_SCHEMA = process.env.DB_SCHEMA || "mcp";
 const TelegramMcpEnsureDbService = {
     name: exports.TELEGRAM_MCP_ENSUREDB_SERVICE_NAME,
     mixins: [db_1.DBMixin],

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

@@ -11,7 +11,7 @@ const gatewayReplyResolution_1 = require("./src/features/distributed-gateway/mod
 const gatewayScope_1 = require("./src/shared/lib/gatewayScope");
 const ensuredb_service_1 = require("./ensuredb.service");
 exports.TELEGRAM_MCP_GATEWAY_SERVICE_NAME = "telegramMcp.gateway";
-const MCP_SCHEMA = process.env.DB_SCHEME || "mcp";
+const MCP_SCHEMA = process.env.DB_SCHEMA || "mcp";
 const DISTRIBUTED_MODE = process.env.DISTRIBUTED_MODE || "client";
 const GATEWAY_ENABLED = DISTRIBUTED_MODE === "gateway" || DISTRIBUTED_MODE === "both";
 function trimOptionalText(value) {

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

@@ -43,6 +43,7 @@ const getFileListTool_1 = require("./src/features/file-content/model/getFileList
 const sendFileToTelegramTool_1 = require("./src/features/notify/model/sendFileToTelegramTool");
 const notifyTelegramTool_1 = require("./src/features/notify/model/notifyTelegramTool");
 const clearSessionContextTool_1 = require("./src/features/session-context/model/clearSessionContextTool");
+const getRuntimeDiagnosticsTool_1 = require("./src/features/session-context/model/getRuntimeDiagnosticsTool");
 const getSessionContextTool_1 = require("./src/features/session-context/model/getSessionContextTool");
 const renameSessionTool_1 = require("./src/features/session-context/model/renameSessionTool");
 const setSessionContextTool_1 = require("./src/features/session-context/model/setSessionContextTool");
@@ -87,6 +88,7 @@ const TelegramMcpMcpServerService = {
                 new setSessionContextTool_1.SetSessionContextTool(sessionContextService.getSessionContextService()),
                 new renameSessionTool_1.RenameSessionTool(sessionContextService.getSessionContextService()),
                 new getSessionContextTool_1.GetSessionContextTool(sessionContextService.getSessionContextService()),
+                new getRuntimeDiagnosticsTool_1.GetRuntimeDiagnosticsTool(sessionContextService.getSessionContextService()),
                 new clearSessionContextTool_1.ClearSessionContextTool(sessionContextService.getSessionContextService()),
                 new notifyTelegramTool_1.NotifyTelegramTool(notifyService.getNotifyService()),
                 new sendFileToTelegramTool_1.SendFileToTelegramTool(notifyService.getNotifyService()),

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

@@ -4,6 +4,7 @@ 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");
+const versionHandshake_1 = require("./src/shared/lib/version/versionHandshake");
 exports.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME = "telegramMcp.sessionContext";
 const TelegramMcpSessionContextService = {
     name: exports.TELEGRAM_MCP_SESSION_CONTEXT_SERVICE_NAME,
@@ -15,6 +16,12 @@ const TelegramMcpSessionContextService = {
                 return this.getSessionContextService().getContext(ctx.params);
             },
         },
+        getRuntimeDiagnosticsRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getSessionContextService().getRuntimeDiagnostics(ctx.params);
+            },
+        },
         setContextRemote: {
             params: { $$strict: false },
             async handler(ctx) {
@@ -53,7 +60,24 @@ const TelegramMcpSessionContextService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp session-context service");
-        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.sessionContextService = new sessionContextService_1.SessionContextService(runtime.sessionStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver, runtime.config.distributed.mode === "client"
+            ? undefined
+            : new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, {
+                meta: { internal_call: true },
+            })), {
+            mode: runtime.config.distributed.mode,
+            packageVersion: (0, versionHandshake_1.getTellyMcpPackageVersion)(__dirname),
+            protocolVersion: versionHandshake_1.TELLYMCP_PROTOCOL_VERSION,
+            ...(process.env.NODE_ID?.trim()
+                ? { nodeId: process.env.NODE_ID.trim() }
+                : {}),
+            gatewayWsUrlConfigured: Boolean(runtime.config.distributed.gatewayWsUrl),
+            gatewayAuthConfigured: Boolean(runtime.config.distributed.gatewayAuthToken ||
+                runtime.config.distributed.gatewayScopeToken),
+            ...(runtime.redis
+                ? { pingRedis: async () => await runtime.redis.ping() }
+                : {}),
+        });
         this.logger.info("telegram_mcp session-context service is ready");
     },
 };

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

@@ -8,6 +8,7 @@ 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 processLocalStateStore_1 = require("../../shared/integrations/memory/processLocalStateStore");
 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");
@@ -22,11 +23,14 @@ async function createAppRuntime(input) {
     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,
-        },
+        state: config.distributed.mode === "client"
+            ? { backend: "process-local" }
+            : {
+                backend: "redis",
+                host: config.redis.host,
+                port: config.redis.port,
+                db: config.redis.db,
+            },
         logging: {
             level: config.logging.level,
         },
@@ -42,13 +46,9 @@ async function createAppRuntime(input) {
         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: {
@@ -82,81 +82,85 @@ async function createAppRuntime(input) {
         },
         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);
-    let sessionStore = stateStore;
+    let redis = null;
+    let stateStore;
+    let sessionStore;
+    if (config.distributed.mode === "client") {
+        const resolvedSession = projectIdentityResolver.resolveSessionDefaults({ cwd: process.cwd() });
+        const marker = (0, projectIdentity_1.readSessionMarkerState)(resolvedSession.cwd, logger);
+        stateStore = new processLocalStateStore_1.ProcessLocalStateStore({
+            ...(marker?.gatewayClientUuid
+                ? { gatewayClientUuid: marker.gatewayClientUuid }
+                : {}),
+            onGatewayClientUuidChange: (gatewayClientUuid) => {
+                (0, projectIdentity_1.writeSessionMarkerState)({
+                    cwd: resolvedSession.cwd,
+                    localSessionId: resolvedSession.sessionId,
+                    sessionLabel: resolvedSession.sessionLabel,
+                    ...(marker?.envFile ? { envFile: marker.envFile } : {}),
+                    ...(marker?.lastSeenToolsHash
+                        ? { lastSeenToolsHash: marker.lastSeenToolsHash }
+                        : {}),
+                    ...(marker?.lastNotifiedToolsHash
+                        ? { lastNotifiedToolsHash: marker.lastNotifiedToolsHash }
+                        : {}),
+                    gatewayClientUuid,
+                    logger,
+                });
+            },
+        });
+        sessionStore = new processLocalSessionStore_1.ProcessLocalSessionStore();
+        logger.info("Client process-local state store initialized", {
+            gatewayClientUuidRestored: Boolean(marker?.gatewayClientUuid),
+        });
+    }
+    else {
+        redis = await (0, client_1.createRedisClient)(config);
+        logger.info("Redis connected", {
+            host: config.redis.host,
+            port: config.redis.port,
+            db: config.redis.db,
+        });
+        const redisStateStore = new stateStore_1.RedisStateStore(redis);
+        stateStore = redisStateStore;
+        sessionStore = redisStateStore;
+    }
     const webAppLaunchRegistry = new auth_1.WebAppLaunchRegistry();
-    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);
+    const objectStore = new minioExchangeStore_1.MinioExchangeStore(config.terminal, config.exchange.dir, logger);
     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 }
-                : {}),
+            label: resolvedSession.sessionLabel,
+            cwd: resolvedSession.cwd,
             terminalTarget: terminalTarget,
-            ...(typeof existingSession?.lastTerminalNudgeAt === "string"
-                ? { lastTerminalNudgeAt: existingSession.lastTerminalNudgeAt }
+            ...(typeof persistedToolsState?.lastSeenToolsHash === "string"
+                ? { lastSeenToolsHash: persistedToolsState.lastSeenToolsHash }
+                : {}),
+            ...(typeof persistedToolsState?.lastNotifiedToolsHash === "string"
+                ? { lastNotifiedToolsHash: persistedToolsState.lastNotifiedToolsHash }
                 : {}),
-            ...(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);
+                await stateStore.clearBinding(sessionId);
+                await stateStore.clearBrowserAttachment(sessionId);
+                await stateStore.clearBrowserRecording(sessionId);
+                for (const meta of await stateStore.listXchangeFileMetas(sessionId)) {
+                    await stateStore.deleteXchangeFileMeta(sessionId, meta.filePath);
+                }
             },
         });
         logger.info("Client PTY process-local session store initialized", {
@@ -175,8 +179,8 @@ async function createAppRuntime(input) {
                 : {}),
             ...(config.project.name ? { projectName: config.project.name } : {}),
             ...(config.telegram.botUsername ? { botUsername: config.telegram.botUsername } : {}),
-            ...(config.distributed.gatewayToken
-                ? { gatewayToken: config.distributed.gatewayToken }
+            ...(config.distributed.gatewayScopeToken
+                ? { gatewayScopeToken: config.distributed.gatewayScopeToken }
                 : {}),
             ...(config.distributed.gatewayUserUuid
                 ? { gatewayUserUuid: config.distributed.gatewayUserUuid }
@@ -216,7 +220,7 @@ async function createAppRuntime(input) {
         ? new temporaryFileLinkStore_1.TemporaryFileLinkStore(config.distributed.gatewayPublicUrl, logger)
         : null;
     await temporaryFileLinkStore?.start();
-    const firefoxAttachServer = new firefoxAttachServer_1.FirefoxAttachServer(config, logger, stateStore, stateStore);
+    const firefoxAttachServer = new firefoxAttachServer_1.FirefoxAttachServer(config, logger, sessionStore, stateStore);
     await firefoxAttachServer.start();
     return {
         callBroker: input.callBroker,
@@ -243,7 +247,7 @@ async function createAppRuntime(input) {
             await firefoxAttachServer.stop();
             await telegramTransport.stop();
             (0, ptyRegistry_1.stopAllPtyTargets)();
-            redis.disconnect();
+            redis?.disconnect();
             logger.info("Shutdown completed");
         },
     };