@deadragdoll/tellymcp 0.0.8 → 0.0.9

package/README-ru.md

@@ -1,6 +1,6 @@
 # TellyMCP
 
-[English](README.md) | [Русский](README-ru.md) | [Standalone Guide](STANDALONE.md) | [Standalone RU](STANDALONE-ru.md) | [Release Notes](VERSION.md)
+[English](README.md) | [Русский](README-ru.md) | [Standalone Guide](STANDALONE.md) | [Standalone RU](STANDALONE-ru.md) | [Screenshots](screenshots/README.md) | [Gallery](screenshots/GALLERY.md) | [Release Notes](VERSION.md)
 
 [![npm version](https://img.shields.io/npm/v/%40deadragdoll%2Ftellymcp)](https://www.npmjs.com/package/@deadragdoll/tellymcp)
 [![npm downloads](https://img.shields.io/npm/dm/%40deadragdoll%2Ftellymcp)](https://www.npmjs.com/package/@deadragdoll/tellymcp)
@@ -239,6 +239,26 @@ tellymcp run --env .env
 
 - `https://your-host.example/api/mcp`
 
+## Mini App / Live
+
+Если `WEBAPP_ENABLED=true`, в меню сессии появляется `🖥 Live`.
+
+Mini App:
+
+- обслуживается этим же Node service по `WEBAPP_BASE_PATH`
+- в `client`-режиме тоже может открываться через общий gateway domain
+- показывает видимую область tmux pane и отправляет ограниченный набор control actions
+- валидирует Telegram `initData` на сервере
+- умеет открываться в режимах:
+  - `default`
+  - `expand`
+  - `fullscreen` с fallback на `expand`
+- после успешного bootstrap удаляет временное launcher-сообщение
+- автоматически восстанавливается после короткого рестарта шлюза:
+  - краткий `502/503` переживается обычным polling
+  - если in-process WebApp session на шлюзе была потеряна и приходит `401/403`, Mini App сама делает повторный bootstrap
+  - в типовом restart-case переоткрывать `Live` не нужно
+
 ## Docker: только для инфраструктуры или для `gateway`-only
 
 Docker больше не является основным способом запуска TellyMCP, но один container path поддерживается:

package/README.md

@@ -1,6 +1,6 @@
 # TellyMCP
 
-[English](README.md) | [Русский](README-ru.md) | [Standalone Guide](STANDALONE.md) | [Standalone RU](STANDALONE-ru.md) | [Release Notes](VERSION.md)
+[English](README.md) | [Русский](README-ru.md) | [Standalone Guide](STANDALONE.md) | [Standalone RU](STANDALONE-ru.md) | [Screenshots](screenshots/README.md) | [Gallery](screenshots/GALLERY.md) | [Release Notes](VERSION.md)
 
 [![npm version](https://img.shields.io/npm/v/%40deadragdoll%2Ftellymcp)](https://www.npmjs.com/package/@deadragdoll/tellymcp)
 [![npm downloads](https://img.shields.io/npm/dm/%40deadragdoll%2Ftellymcp)](https://www.npmjs.com/package/@deadragdoll/tellymcp)
@@ -521,6 +521,10 @@ The Mini App:
 - requires the Telegram user from `initData` to match the bound session user
 - resolves the active session from the bound Telegram user, so a session id in the URL is not required for normal use
 - deletes the temporary `Open Live View` launcher message after successful Mini App bootstrap
+- auto-recovers after a short gateway restart:
+  - short `502/503` periods are tolerated by polling
+  - expired in-process WebApp sessions (`401/403`) trigger an automatic re-bootstrap
+  - in normal restart cases the user does not need to reopen `Live`
 - allows only a fixed control set:
   - `Esc`
   - `Tab`

package/TOOLS.md

@@ -1,10 +1,12 @@
 # Tools
 
-Version: `2026-05-17.1`
+Version: `2026-05-18.1`
 
 Gateway/client runtime compatibility:
 
 - `TOOLS.md` hash sync and runtime version handshake are separate checks.
+- The authoritative freshness check for `TOOLS.md` is the content hash, not this human-readable `Version:` line.
+- Treat this `Version:` line only as a quick visual marker for humans and logs.
 - `TOOLS.md` sync tells the agent to refresh instructions.
 - `ws hello/hello_ack` checks `package_version`, `protocol_version`, and `capabilities`.
 - If protocol major versions differ, gateway transport is blocked until the older side is upgraded.

package/VERSION.md

@@ -4,6 +4,34 @@ Public, user-facing release notes for published versions of `@deadragdoll/tellym
 
 For detailed engineering history, refactors, and internal development notes, see [CHANGELOG.md](CHANGELOG.md).
 
+## 0.0.9
+
+### Added
+- Public screenshot docs:
+  - full screenshot index in `screenshots/README.md`
+  - shorter public gallery in `screenshots/GALLERY.md`
+- More explicit Live launch modes from Telegram:
+  - `Fullscreen`
+  - `Expand`
+  - `Default`
+
+### Changed
+- README and README-RU now surface screenshot links directly in the top navigation.
+- The `Live` Mini App UI is more practical on phones:
+  - wrap/unwrap toggle moved into the status bar
+  - session name is shown as a compact state badge
+  - update timestamp is shorter and less noisy
+  - local `Live` screenshots are documented in a clearer flow near the launcher step
+
+### Fixed
+- `Live` now reconnects more gracefully after a gateway restart:
+  - short `502/503` gaps recover through polling
+  - expired in-process WebApp sessions (`401/403`) trigger automatic re-bootstrap
+  - reopening the Mini App is no longer required in the normal restart case
+- Runtime MCP metadata now reports the actual package version instead of stale hardcoded version data.
+- Successful tmux nudges no longer overwrite `tmuxPaneId` with non-pane targets such as `backend:0.0`.
+- If tmux itself is unavailable for a paired session with a saved tmux target, Telegram now receives an operational warning instead of leaving the signal only in backend logs.
+
 ## 0.0.8
 
 ### Added
@@ -32,6 +60,10 @@ For detailed engineering history, refactors, and internal development notes, see
 - Stale tmux pane ids like `%1 -> %2` no longer require manual user understanding before the service can try to wake the session again.
 - Broken tmux nudge targets are now visible to the user in Telegram, not only in backend logs.
 - `Share` inbox instructions are now explicit enough to reduce the chance that one agent re-delegates the task back into the collaboration graph.
+- `Live` Mini App now survives a normal gateway restart much better:
+  - short `502/503` periods recover through polling
+  - lost in-process WebApp sessions (`401/403`) trigger automatic re-bootstrap
+  - reopening the Mini App is no longer required in the normal restart case
 
 ## 0.0.3
 

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

@@ -105,6 +105,11 @@ function normalizePrefixedPathname(pathname) {
     const stripped = pathname.slice(normalizedRootPrefix.length);
     return stripped.startsWith("/") ? stripped : `/${stripped || ""}`;
 }
+function resolveLaunchModeOverride(value) {
+    return value === "default" || value === "expand" || value === "fullscreen"
+        ? value
+        : null;
+}
 function normalizeBasePath(value) {
     const trimmed = value.trim().replace(/\/+$/u, "");
     if (!trimmed) {
@@ -152,9 +157,11 @@ function createMcpHttpHandler(runtime, input) {
                     writeText(res, 405, "Method not allowed");
                     return;
                 }
+                const launchMode = resolveLaunchModeOverride(requestUrl.searchParams.get("launchMode")) ??
+                    runtime.config.webapp.launchMode;
                 writeHtml(res, 200, (0, assets_1.renderWebAppHtml)({
                     basePath: publicWebAppBasePath,
-                    launchMode: runtime.config.webapp.launchMode,
+                    launchMode,
                 }));
                 return;
             }

package/dist/services/features/telegram-mcp/src/app/providers/mcp/server.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMcpServer = createMcpServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const registry_1 = require("../../../shared/api/tool-registry/registry");
+const versionHandshake_1 = require("../../../shared/lib/version/versionHandshake");
 function createMcpServer(tools) {
     const server = new mcp_js_1.McpServer({
         name: "tellymcp",
-        version: "0.0.6",
+        version: (0, versionHandshake_1.getTellyMcpPackageVersion)(__dirname),
     });
     (0, registry_1.registerTools)(server, tools);
     return server;

package/dist/services/features/telegram-mcp/src/app/webapp/assets.js

@@ -100,6 +100,21 @@ body {
   border-color: rgba(87, 193, 255, 0.8);
 }
 
+.btn.active {
+  border-color: rgba(87, 193, 255, 0.85);
+  background: linear-gradient(180deg, rgba(20, 54, 77, 0.98) 0%, rgba(14, 39, 57, 1) 100%);
+  color: #d9f3ff;
+  box-shadow: inset 0 0 0 1px rgba(87, 193, 255, 0.16);
+}
+
+.btn.toggle {
+  border-color: rgba(87, 193, 255, 0.42);
+  background: linear-gradient(180deg, rgba(31, 38, 52, 0.98) 0%, rgba(21, 27, 38, 1) 100%);
+  color: #cfe9ff;
+  box-shadow: inset 0 0 0 1px rgba(87, 193, 255, 0.08);
+  font-weight: 600;
+}
+
 .statusbar {
   position: fixed;
   left: 0;
@@ -127,11 +142,32 @@ body {
   gap: 8px 16px;
 }
 
+.status-toggle {
+  min-width: 72px;
+  padding: 4px 8px;
+  border-radius: 9px;
+  font-size: 12px;
+  line-height: 1.1;
+}
+
 .session-label {
-  color: var(--text);
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 3px 8px;
+  border-radius: 999px;
+  border: 1px solid rgba(76, 217, 100, 0.42);
+  background: rgba(26, 42, 31, 0.92);
+  color: #d6ffe0;
   font-weight: 600;
 }
 
+.session-label.error {
+  border-color: rgba(255, 116, 116, 0.5);
+  background: rgba(57, 23, 26, 0.94);
+  color: #ffd8d8;
+}
+
 .ok {
   color: var(--success);
 }
@@ -146,6 +182,13 @@ body {
   font: 13px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
 }
 
+.terminal.unwrap {
+  white-space: pre;
+  word-break: normal;
+  overflow-x: auto;
+  overflow-y: auto;
+}
+
 .ansi-bold {
   font-weight: 700;
 }
@@ -194,6 +237,8 @@ const state = {
   timer: null,
   actionBusy: false,
   pollIntervalMs: 2000,
+  wrapEnabled: true,
+  recoverPromise: null,
 };
 
 const elements = {
@@ -201,6 +246,7 @@ const elements = {
   status: document.querySelector("[data-role=status]"),
   updated: document.querySelector("[data-role=updated]"),
   interrupt: document.querySelector("[data-role=interrupt]"),
+  wrap: document.querySelector("[data-role=wrap]"),
   type: document.querySelector("[data-role=type]"),
   esc: document.querySelector("[data-role=escape]"),
   tab: document.querySelector("[data-role=tab]"),
@@ -213,16 +259,80 @@ const elements = {
 };
 
 function setStatus(text, isError = false) {
-  const sessionName = elements.session.textContent || "Live View";
-  elements.status.textContent = text + " - " + sessionName;
+  elements.status.textContent = text;
   elements.status.classList.toggle("error", isError);
   elements.status.classList.toggle("ok", !isError);
+  elements.session.classList.toggle("error", isError);
+  elements.session.classList.toggle("ok", !isError);
 }
 
 function setUpdated(text) {
   elements.updated.textContent = text;
 }
 
+function createHttpError(message, status) {
+  const error = new Error(message);
+  error.status = status;
+  return error;
+}
+
+function shouldRecoverWebAppSession(error) {
+  return (
+    error &&
+    typeof error === "object" &&
+    (error.status === 401 || error.status === 403)
+  );
+}
+
+function applyTmuxAvailability(hasTarget) {
+  elements.interrupt.disabled = !hasTarget;
+  elements.type.disabled = !hasTarget;
+  elements.esc.disabled = !hasTarget;
+  elements.tab.disabled = !hasTarget;
+  elements.slash.disabled = !hasTarget;
+  elements.del.disabled = !hasTarget;
+  elements.up.disabled = !hasTarget;
+  elements.down.disabled = !hasTarget;
+  elements.enter.disabled = !hasTarget;
+}
+
+function getWrapPreferenceKey() {
+  return "telegram-mcp-live-wrap";
+}
+
+function applyWrapMode(enabled) {
+  state.wrapEnabled = enabled;
+  elements.terminal.classList.toggle("unwrap", !enabled);
+  elements.wrap.classList.toggle("active", enabled);
+  elements.wrap.setAttribute("aria-pressed", enabled ? "true" : "false");
+  elements.wrap.textContent = enabled ? "Unwrap" : "Wrap";
+  elements.wrap.title = enabled
+    ? "Wrapping enabled. Tap to switch to horizontal scroll."
+    : "Horizontal scroll enabled. Tap to wrap lines.";
+}
+
+function loadWrapPreference() {
+  try {
+    const stored = window.localStorage.getItem(getWrapPreferenceKey());
+    if (stored === "off") {
+      applyWrapMode(false);
+      return;
+    }
+  } catch (_error) {
+  }
+
+  applyWrapMode(true);
+}
+
+function toggleWrapMode() {
+  const next = !state.wrapEnabled;
+  applyWrapMode(next);
+  try {
+    window.localStorage.setItem(getWrapPreferenceKey(), next ? "on" : "off");
+  } catch (_error) {
+  }
+}
+
 function formatCapturedAt(value) {
   if (!value) {
     return "never";
@@ -234,12 +344,10 @@ function formatCapturedAt(value) {
   }
 
   return new Intl.DateTimeFormat(undefined, {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
     hour: "2-digit",
     minute: "2-digit",
     second: "2-digit",
+    hour12: false,
   }).format(date);
 }
 
@@ -561,6 +669,49 @@ async function bootstrap() {
   return response.json();
 }
 
+function applyBootstrapPayload(bootstrapPayload) {
+  state.token = bootstrapPayload.token;
+  state.sessionId = bootstrapPayload.session_id;
+  state.pollIntervalMs = bootstrapPayload.poll_interval_ms || state.pollIntervalMs;
+  elements.session.textContent =
+    bootstrapPayload.session_label || bootstrapPayload.session_id;
+  elements.session.hidden = false;
+
+  const hasTmuxTarget = Boolean(bootstrapPayload.tmux_target);
+  applyTmuxAvailability(hasTmuxTarget);
+  setStatus(hasTmuxTarget ? "Live" : "No tmux target", !hasTmuxTarget);
+}
+
+async function recoverWebAppSession() {
+  if (state.recoverPromise) {
+    return state.recoverPromise;
+  }
+
+  state.recoverPromise = (async () => {
+    setStatus("Reconnecting...", true);
+    const bootstrapPayload = await bootstrap();
+    applyBootstrapPayload(bootstrapPayload);
+    return bootstrapPayload;
+  })().finally(() => {
+    state.recoverPromise = null;
+  });
+
+  return state.recoverPromise;
+}
+
+async function withRecoveredSession(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (!shouldRecoverWebAppSession(error)) {
+      throw error;
+    }
+
+    await recoverWebAppSession();
+    return operation();
+  }
+}
+
 async function fetchVisibleBuffer() {
   const response = await fetch(config.basePath + "/api/view", {
     method: "GET",
@@ -571,7 +722,7 @@ async function fetchVisibleBuffer() {
 
   if (!response.ok) {
     const text = await response.text();
-    throw new Error(text || "Failed to fetch visible buffer.");
+    throw createHttpError(text || "Failed to fetch visible buffer.", response.status);
   }
 
   return response.json();
@@ -584,21 +735,22 @@ async function sendAction(action) {
 
   state.actionBusy = true;
   try {
-    const response = await fetch(config.basePath + "/api/action", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: "Bearer " + state.token,
-      },
-      body: JSON.stringify({ action }),
-    });
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(text || "Failed to send action.");
-    }
+    await withRecoveredSession(async () => {
+      const response = await fetch(config.basePath + "/api/action", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: "Bearer " + state.token,
+        },
+        body: JSON.stringify({ action }),
+      });
 
-    await refreshVisibleBuffer();
+      if (!response.ok) {
+        const text = await response.text();
+        throw createHttpError(text || "Failed to send action.", response.status);
+      }
+    });
+    await withRecoveredSession(refreshVisibleBuffer);
   } finally {
     state.actionBusy = false;
   }
@@ -611,22 +763,26 @@ async function sendTextInput(text) {
 
   state.actionBusy = true;
   try {
-    const response = await fetch(config.basePath + "/api/action", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: "Bearer " + state.token,
-      },
-      body: JSON.stringify({ action: "text", text }),
-    });
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(text || "Failed to send text.");
-    }
+    await withRecoveredSession(async () => {
+      const response = await fetch(config.basePath + "/api/action", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: "Bearer " + state.token,
+        },
+        body: JSON.stringify({ action: "text", text }),
+      });
 
+      if (!response.ok) {
+        const textResponse = await response.text();
+        throw createHttpError(
+          textResponse || "Failed to send text.",
+          response.status,
+        );
+      }
+    });
     setStatus("Text sent");
-    await refreshVisibleBuffer();
+    await withRecoveredSession(refreshVisibleBuffer);
   } finally {
     state.actionBusy = false;
   }
@@ -646,9 +802,9 @@ function confirmInterrupt() {
 }
 
 async function refreshVisibleBuffer() {
-  const payload = await fetchVisibleBuffer();
+  const payload = await withRecoveredSession(fetchVisibleBuffer);
   elements.terminal.innerHTML = renderAnsiToHtml(payload.content || "");
-  setUpdated("Updated: " + formatCapturedAt(payload.captured_at));
+  setUpdated(formatCapturedAt(payload.captured_at));
 }
 
 function stopPolling() {
@@ -672,6 +828,10 @@ function startPolling() {
 }
 
 function bindUi() {
+  elements.wrap.addEventListener("click", () => {
+    toggleWrapMode();
+  });
+
   elements.interrupt.addEventListener("click", () => {
     confirmInterrupt()
       .then((ok) => {
@@ -748,32 +908,12 @@ async function applyLaunchMode() {
 async function main() {
   try {
     await applyLaunchMode();
+    loadWrapPreference();
     bindUi();
     setStatus("Authorizing Mini App...");
     const bootstrapPayload = await bootstrap();
-    state.token = bootstrapPayload.token;
-    state.sessionId = bootstrapPayload.session_id;
-    state.pollIntervalMs = bootstrapPayload.poll_interval_ms || state.pollIntervalMs;
-    elements.session.textContent =
-      bootstrapPayload.session_label || bootstrapPayload.session_id;
-
-    if (!bootstrapPayload.tmux_target) {
-      elements.interrupt.disabled = true;
-      elements.type.disabled = true;
-      elements.esc.disabled = true;
-      elements.tab.disabled = true;
-      elements.slash.disabled = true;
-      elements.del.disabled = true;
-      elements.up.disabled = true;
-      elements.down.disabled = true;
-      elements.enter.disabled = true;
-      setStatus("No tmux target", true);
-    }
-
+    applyBootstrapPayload(bootstrapPayload);
     await refreshVisibleBuffer();
-    if (bootstrapPayload.tmux_target) {
-      setStatus("Connected");
-    }
     startPolling();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -818,7 +958,8 @@ function renderWebAppHtml(input) {
           <span class="session-label" data-role="session" hidden>Live View</span>
         </div>
         <div class="status-right">
-          <span data-role="updated">Updated: never</span>
+          <button class="btn toggle status-toggle active" data-role="wrap" type="button" aria-pressed="true">Wrap</button>
+          <span data-role="updated">never</span>
         </div>
       </div>
     </div>

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

@@ -1236,9 +1236,15 @@ class TelegramTransport {
             ...(input.project_name ? [`Проект: ${input.project_name}`] : []),
             `Сессия: ${input.source_session_label} -> ${input.target_session_label}`,
             "",
-            "Открой Live по кнопке ниже.",
+            "Открой Live в нужном режиме по кнопкам ниже.",
         ].join("\n"), {
-            reply_markup: new grammy_1.InlineKeyboard().webApp("Open Live View", liveViewUrl),
+            reply_markup: this.buildLiveViewLaunchKeyboard((mode) => this.buildLiveViewUrlForSessionTarget({
+                targetSessionId: input.target_session_id,
+                targetClientUuid: input.target_client_uuid,
+                targetLocalSessionId: input.target_local_session_id,
+                sourceClientUuid: input.source_client_uuid,
+                launchMode: mode,
+            })),
         }, {
             kind: "notification",
             sessionId: sourceSession.sessionId,
@@ -2533,6 +2539,12 @@ class TelegramTransport {
                         : String(error),
                 };
                 if ((0, client_1.isTmuxUnavailableError)(error)) {
+                    void this.sessionStore.getSession(sessionId).then((session) => {
+                        if (!session?.tmuxTarget) {
+                            return;
+                        }
+                        return this.notifyTmuxUnavailable(sessionId, session, error);
+                    });
                     this.logger.warn("tmux nudge skipped because tmux is unavailable", payload);
                     return;
                 }
@@ -2611,7 +2623,11 @@ class TelegramTransport {
         await this.sessionStore.setSession({
             ...session,
             tmuxTarget,
-            ...(tmuxTarget ? { tmuxPaneId: tmuxTarget } : {}),
+            ...(tmuxTarget.startsWith("%")
+                ? { tmuxPaneId: tmuxTarget }
+                : session.tmuxPaneId
+                    ? { tmuxPaneId: session.tmuxPaneId }
+                    : {}),
             lastTmuxNudgeAt,
         });
         this.tmuxNudgeFailureNoticeAt.delete(sessionId);
@@ -2698,6 +2714,51 @@ class TelegramTransport {
             });
         }
     }
+    async notifyTmuxUnavailable(sessionId, session, error) {
+        const binding = await this.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            return;
+        }
+        const nowMs = Date.now();
+        const lastNoticeAt = this.tmuxNudgeFailureNoticeAt.get(sessionId);
+        if (lastNoticeAt &&
+            nowMs - lastNoticeAt < TMUX_NUDGE_FAILURE_NOTICE_COOLDOWN_MS) {
+            return;
+        }
+        this.tmuxNudgeFailureNoticeAt.set(sessionId, nowMs);
+        const sessionLabel = session.label ?? sessionId;
+        const tmuxTarget = session.tmuxTarget ?? "unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        try {
+            await this.sendNotification({
+                sessionId,
+                sessionLabel: "TellyMCP",
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: [
+                    `⚠️ Автоматический tmux nudge для сессии ${sessionLabel} пропущен.`,
+                    "tmux сейчас недоступен на этой машине.",
+                    `tmux target: ${tmuxTarget}`,
+                    `Ошибка: ${errorMessage}`,
+                    "Обычно это значит, что tmux session/server не запущен или недоступен по текущему socket path.",
+                    "Запусти tmux и агента внутри него, либо обнови/сними tmux target для этой сессии.",
+                ].join("\n"),
+            });
+        }
+        catch (notifyError) {
+            this.logger.warn("Failed to deliver tmux unavailable notification", {
+                sessionId,
+                tmuxTarget,
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+                notifyError: notifyError instanceof Error
+                    ? (notifyError.stack ?? notifyError.message)
+                    : String(notifyError),
+            });
+        }
+    }
     async sendTypingForSession(sessionId) {
         const binding = await this.bindingStore.getBinding(sessionId);
         if (!binding) {
@@ -4084,9 +4145,14 @@ class TelegramTransport {
             ? (0, relay_1.buildLiveRelaySessionId)(clientUuid, activeSessionId)
             : activeSessionId;
         const url = new URL(`${baseUrl}/live/${encodeURIComponent(liveSessionId)}`);
+        url.searchParams.set("launchMode", this.config.webapp.launchMode);
         await ctx.answerCallbackQuery({ text: "Открываю Live View." });
-        const sent = await this.replyText(ctx, `🖥 Live: ${session?.label ?? activeSessionId}`, { kind: "menu", sessionId: activeSessionId }, {
-            reply_markup: new grammy_1.InlineKeyboard().webApp("Open Live View", url.toString()),
+        const sent = await this.replyText(ctx, [`🖥 Live: ${session?.label ?? activeSessionId}`, "", "Выбери режим открытия:"].join("\n"), { kind: "menu", sessionId: activeSessionId }, {
+            reply_markup: this.buildLiveViewLaunchKeyboard((mode) => {
+                const modeUrl = new URL(url.toString());
+                modeUrl.searchParams.set("launchMode", mode);
+                return modeUrl.toString();
+            }),
         });
         this.webAppLaunchRegistry.set(principal.telegramUserId, activeSessionId, this.config.webapp.initDataTtlSeconds, {
             telegramChatId: principal.telegramChatId,
@@ -4113,7 +4179,28 @@ class TelegramTransport {
         const liveSessionId = canUseRelay
             ? (0, relay_1.buildLiveRelaySessionId)(input.targetClientUuid, input.targetLocalSessionId, input.sourceClientUuid)
             : (input.targetLocalSessionId ?? input.targetSessionId);
-        return new URL(`${baseUrl}/live/${encodeURIComponent(liveSessionId)}`).toString();
+        const url = new URL(`${baseUrl}/live/${encodeURIComponent(liveSessionId)}`);
+        url.searchParams.set("launchMode", input.launchMode ?? this.config.webapp.launchMode);
+        return url.toString();
+    }
+    buildLiveViewLaunchKeyboard(getUrl) {
+        const keyboard = new grammy_1.InlineKeyboard();
+        const modes = [
+            { mode: "fullscreen", label: "Fullscreen" },
+            { mode: "expand", label: "Expand" },
+            { mode: "default", label: "Default" },
+        ];
+        for (const [index, { mode, label }] of modes.entries()) {
+            const url = getUrl(mode);
+            if (!url) {
+                continue;
+            }
+            keyboard.webApp(label, url);
+            if (index === 1) {
+                keyboard.row();
+            }
+        }
+        return keyboard;
     }
     clearPendingInteractionsForContext(ctx) {
         const principal = this.getPrincipalFromContext(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deadragdoll/tellymcp",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "TellyMCP - Telegram control plane for MCP-connected coding agents",
   "main": "dist/services/features/telegram-mcp/runtime.service.js",
   "bin": {