@deadragdoll/tellymcp 0.0.6 → 0.0.8

package/.env.example.client

@@ -90,4 +90,6 @@ SOCKS5_PROXY=
 
 # Логирование.
 LOG_LEVEL=info
+LOG_FILE_ENABLED=false
+LOG_FILE_PATH=.tellymcp/log.jsonl
 ENABLE_LOGFEED=0

package/.env.example.gateway

@@ -112,8 +112,9 @@ SOCKS5_PROXY=
 
 # Логирование.
 LOG_LEVEL=info
-ENABLE_LOGFEED=0
 LOG_FILE_ENABLED=false
+LOG_FILE_PATH=.tellymcp/log.jsonl
+ENABLE_LOGFEED=0
 
 # Секреты шлюза.
 SESSION_SECRET=change_me_session_secret

package/README-ru.md

@@ -73,6 +73,12 @@ Telegram HITL здесь тоже есть, но он не исчерпывае
 - partner notes и partner files
 - tools sync и version checks
 
+Важно для `Share`:
+
+- текущая сессия должна выполнить работу сама
+- target-сессии отправляется только результат
+- исходное поручение не должно пересылаться дальше как новая задача
+
 Полный список MCP tools лучше держать ниже по README и в самом MCP server, а не на первом экране.
 
 ## Prerequisites
@@ -121,6 +127,10 @@ tmux attach -t backend
 
 Если агентов несколько, лучше запускать каждого в своей tmux-сессии или pane и привязывать отдельно.
 
+Если tmux pane пересоздан и его `pane_id` изменился, TellyMCP теперь пытается автоматически восстановить актуальный target по сохранённым tmux session/window/pane hints.
+
+Если авто-восстановление не удалось, в Telegram придёт operational warning, а не только запись в backend log.
+
 ## Быстрый старт
 
 ### 1. Standalone client без шлюза
@@ -229,6 +239,99 @@ tellymcp run --env .env
 
 - `https://your-host.example/api/mcp`
 
+## Docker: только для инфраструктуры или для `gateway`-only
+
+Docker больше не является основным способом запуска TellyMCP, но один container path поддерживается:
+
+- запуск только `gateway`-ноды в контейнере
+
+Это вариант именно для чистого control-plane узла:
+
+- без локальных agent sessions
+- без локального `tmux`
+- не для `client`
+- не для `both`
+
+Плюс `docker-compose.yml` по-прежнему может поднимать локальную инфраструктуру:
+
+- `redis` для всех режимов
+- `postgres` для `gateway` / `both`
+- `rabbitmq` только если нужен durable fanout на шлюзе
+
+Только Redis, для `standalone` или `client`:
+
+```bash
+docker compose up -d redis
+```
+
+Redis + Postgres, для `gateway` или `both`:
+
+```bash
+docker compose --profile gateway up -d
+```
+
+Добавить RabbitMQ при необходимости:
+
+```bash
+docker compose --profile gateway --profile rmq up -d
+```
+
+Полный gateway stack в Docker:
+
+1. Скопировать пример:
+
+```bash
+cp .env.example.gateway .env-gateway
+```
+
+2. Отредактировать `.env-gateway` и задать минимум:
+
+- `TELEGRAM_BOT_TOKEN`
+- `TELEGRAM_BOT_USERNAME`
+- `WEBAPP_PUBLIC_URL`
+- `GATEWAY_PUBLIC_URL`
+- `GATEWAY_WS_URL`
+- `MCP_HTTP_BEARER_TOKEN`
+
+3. Запустить:
+
+```bash
+docker compose up -d
+```
+
+Это поднимет:
+
+- `redis`
+- `postgres`
+- `tellymcp-gateway`
+
+Внутри Docker compose сам переопределяет:
+
+- `MCP_HTTP_HOST=0.0.0.0`
+- `REDIS_HOST=redis`
+- `DB_HOST=postgres`
+
+Ожидаемые endpoint'ы:
+
+- `http://127.0.0.1:8080/api/healthz`
+- `http://127.0.0.1:8080/api/mcp`
+- `http://127.0.0.1:8080/api/webapp`
+- `http://127.0.0.1:8080/api/gateway`
+
+Остановить всё:
+
+```bash
+docker compose down
+```
+
+Сам TellyMCP при этом запускается напрямую на хосте:
+
+```bash
+tellymcp run --env .env
+```
+
+Для `client` и `both` по-прежнему рекомендуется именно хостовый запуск.
+
 ## Как начать работу с ботом изнутри агента
 
 После подключения MCP можно просто написать агенту обычной фразой, что нужно привязаться к Telegram.
@@ -332,6 +435,9 @@ tellymcp mcp --help
 - `PROXY_USE=http|socks5`
 - `HTTP_PROXY`
 - `SOCKS5_PROXY`
+- `LOG_LEVEL`
+- `LOG_FILE_ENABLED`
+- `LOG_FILE_PATH`
 
 Только client:
 

package/README.md

@@ -122,6 +122,10 @@ Use short, meaningful names such as:
 
 If you run multiple agents, put each one in its own tmux session or pane and pair them separately.
 
+If a tmux pane is recreated and its pane id changes, TellyMCP now tries to recover the live pane target automatically from saved tmux session, window, and pane hints.
+
+If auto-recovery fails, Telegram sends an operational warning so the problem is visible to the human user, not only in backend logs.
+
 ## Quick start
 
 ### Standalone client node
@@ -412,10 +416,11 @@ Canonical instructions:
   - the `TOOLS.md` version marker
   - the file content itself
 
-Logs are written in two places at the same time:
+Logs use one runtime model:
 
-- pretty console output to `stderr`
-- JSONL file at `.telegram-human-mcp/log.jsonl`
+- `pino-pretty` console output to `stderr`
+- optional JSONL file sink via `LOG_FILE_ENABLED=true` and `LOG_FILE_PATH=...`
+- optional in-app `LogFeed` buffer for Telegram/UI diagnostics when `ENABLE_LOGFEED=1`
 
 If Telegram access requires a proxy, the bot transport can use:
 
@@ -489,6 +494,8 @@ Current file model:
 - `vfs/minio` are no longer part of the active Telegram file exchange path
 - if an agent must send a real local file to a partner, prefer `send_partner_file`
   over plain `send_partner_note`
+- for `Share`, the current session must do the work itself and send only the result
+- `Share` must not forward the original task into the target session as a new assignment
 
 Current presence model:
 
@@ -552,10 +559,10 @@ Recommended local dev settings:
 - install browser binaries once with `npx playwright install chromium`
 - install browser binaries once with `tellymcp browser install`
 
-Recommended Docker settings:
+Recommended headless server settings:
 
 - `BROWSER_HEADLESS=true`
-- target the host dev server through `http://host.docker.internal:3000`
+- target the app through a reachable host or LAN address, for example `http://127.0.0.1:3000` or `http://192.168.x.x:3000`
 
 Current browser tools:
 
@@ -829,75 +836,111 @@ If `MCP_HTTP_BEARER_TOKEN` is configured:
 `yarn dev:gw:telegram` is still available, but it only starts the `telegram_mcp` feature node.
 It does not expose HTTP by itself anymore. `/mcp`, `/webapp`, and `/healthz` are now served only through the Moleculer API gateway aliases in the full `dev:gw` / `start:gw` runtime, or through a separate gateway node in the same namespace.
 
-## Optional Docker deployment
+## Optional Docker infrastructure
+
+Docker is no longer the default way to run TellyMCP, but there is one supported container path:
 
-Docker is no longer required for the default product install flow.
+- `gateway`-only container deployment
 
-This repository still includes a single-container deployment path without an internal nginx layer for ops/self-hosted scenarios.
+This is intended for a pure control-plane node:
 
-Inside the container:
+- no local agent sessions
+- no local `tmux`
+- no `client` mode
+- no `both` mode
 
-- `node` runs the MCP HTTP service on `0.0.0.0:8787`
-- `redis-server` runs on `127.0.0.1:6379`
-- the application itself serves:
-  - `/mcp`
-  - `/webapp`
-  - `/healthz`
-  - `/sessions`
-  - `/prune`
+The repository also keeps Docker for local infrastructure:
 
-This means an external reverse proxy can forward directly to container port `8787`, while all app routing stays inside the Node service.
+- `redis` for all modes
+- `postgres` for `gateway` / `both`
+- `rabbitmq` only if you want durable fanout on the gateway
 
-Build the image fully inside Docker:
+Start Redis only, for `standalone` or `client` mode:
 
 ```bash
-docker compose build
+docker compose up -d redis
 ```
 
-Run it:
+Start Redis + Postgres, for `gateway` or `both` mode:
 
 ```bash
-docker compose up -d
+docker compose --profile gateway up -d
 ```
 
-Stop it:
+Add RabbitMQ only when you need it:
 
 ```bash
-docker compose down
+docker compose --profile gateway --profile rmq up -d
 ```
 
-The compose file:
+Run a full gateway container stack with Redis and Postgres:
 
-- builds the image from this repository
-- injects `.env`
-- overrides runtime networking so the app talks to local in-container Redis and listens on `0.0.0.0:8787`
-- publishes only `8787:8787`
-- keeps `host.docker.internal` available for optional host-side development integrations
-- persists Redis state in `./data/redis`
+1. Copy the example:
 
-After startup:
+```bash
+cp .env.example.gateway .env-gateway
+```
 
-- MCP is reachable at `http://<host>:8787/mcp`
-- Mini App static/API routes are reachable under `http://<host>:8787/webapp/`
-- health check is at `http://<host>:8787/healthz`
+2. Edit `.env-gateway` and set at minimum:
+
+- `TELEGRAM_BOT_TOKEN`
+- `TELEGRAM_BOT_USERNAME`
+- `WEBAPP_PUBLIC_URL`
+- `GATEWAY_PUBLIC_URL`
+- `GATEWAY_WS_URL`
+- `MCP_HTTP_BEARER_TOKEN`
 
-Recommended external reverse proxy pattern:
+3. Start the stack:
 
-- external proxy forwards `/mcp` to `http://<container-host>:8787/mcp`
-- external proxy forwards `/webapp/` to `http://<container-host>:8787/webapp/`
-- or, if you prefer, the external proxy can forward a wider prefix directly to `http://<container-host>:8787`
-- no direct external access is needed to in-container Redis
-- `tmux` access is expected to be direct from the running `tellymcp` process
+```bash
+docker compose up -d
+```
 
-Important:
+This starts:
+
+- `redis`
+- `postgres`
+- `tellymcp-gateway`
+
+Inside Docker, compose overrides:
+
+- `MCP_HTTP_HOST=0.0.0.0`
+- `REDIS_HOST=redis`
+- `DB_HOST=postgres`
+
+Public endpoint expectations stay the same:
+
+- `http://127.0.0.1:8080/api/healthz`
+- `http://127.0.0.1:8080/api/mcp`
+- `http://127.0.0.1:8080/api/webapp`
+- `http://127.0.0.1:8080/api/gateway`
+
+Stop everything:
+
+```bash
+docker compose down
+```
+
+Default published ports:
+
+- Redis: `6379`
+- Postgres: `5432`
+- RabbitMQ AMQP: `5672`
+- RabbitMQ UI: `15672`
+
+The TellyMCP process itself should run directly on the host:
+
+```bash
+tellymcp run --env .env
+```
+
+This keeps:
 
-- pairing state
-- active session bindings
-- inbox messages
-- menu payload buffers
-- WebApp launch/session state
+- direct `tmux` access
+- simpler debugging
+- the same runtime model for `standalone`, `client`, `gateway`, and `both`
 
-are all stored in Redis. In the Docker deployment they survive restarts because `./data/redis` is mounted into the container and Redis AOF is enabled.
+For `client` and `both`, host execution is still the recommended model.
 
 Optional if the local tmux server uses a non-default socket:
 

package/VERSION.md

@@ -4,6 +4,35 @@ 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.8
+
+### Added
+- Unified logging model based on `pino`:
+  - pretty console output by default
+  - optional JSONL file sink for Alloy or other collectors
+  - `LOG_FILE_ENABLED=true`
+  - `LOG_FILE_PATH=.tellymcp/log.jsonl`
+- Better tmux recovery behavior:
+  - when a saved pane target becomes stale after tmux recreation, TellyMCP now tries to recover the live pane automatically from stored tmux session/window/pane hints
+  - if auto-recovery fails, Telegram sends a clear operational warning instead of leaving the problem only in logs
+- Stronger `Share` execution guidance:
+  - the current session must do the work itself
+  - it must send only the result
+  - it must not forward the original task to the target session as a new assignment
+
+### Changed
+- Runtime identity and service labels now use `tellymcp` naming consistently instead of older `telegram-human-mcp` tags.
+- MCP server metadata now reports the current package version and `tellymcp` service name.
+- Logging config is now simpler:
+  - one console logging model
+  - one optional JSON file sink
+  - optional `LogFeed` buffer for UI diagnostics
+
+### Fixed
+- 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.
+
 ## 0.0.3
 
 ### Added

package/dist/cli.js

@@ -82,7 +82,7 @@ async function getPlaywrightBrowserStatus(browserEnabled) {
 }
 function printHelp() {
     const tmux = getTmuxStatus();
-    printBanner("CLI", "Telegram Human-in-the-Loop MCP server");
+    printBanner("CLI", "Telegram control plane for MCP-connected coding agents");
     printSection("Usage", [
         "  tellymcp init <client|gateway|both> [directory]",
         "  tellymcp run [--env <file>]",

package/dist/lib/mixins/session.errors.js

@@ -1,19 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlaygroundDisabledError = exports.SessionIdleTimeoutExceededError = exports.TokenInvalidError = exports.TokenNotFoundError = exports.SessionTokenSignatureInvalidError = exports.SessionTokenInvalidFormatError = exports.SessionTokenMismatchError = exports.SessionTokenNotFoundError = exports.SessionTokenRevokedError = exports.SessionTokenNotActiveError = exports.SessionTokenExpiredError = exports.SessionTokenInvalidError = exports.SessionValidationError = exports.SessionRefreshError = exports.SessionMaxLifetimeExceededError = exports.SessionStealedError = exports.SessionInvalidError = exports.SessionExpiredError = exports.SessionNotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BackendError = void 0;
-const graphql_1 = require("graphql");
-class BackendError extends graphql_1.GraphQLError {
-    constructor(message, code, type, data) {
-        super(message, {
-            extensions: {
-                code: code,
-                type: type || code,
-                data,
-            },
-        });
+exports.PlaygroundDisabledError = exports.SessionIdleTimeoutExceededError = exports.TokenInvalidError = exports.TokenNotFoundError = exports.SessionTokenSignatureInvalidError = exports.SessionTokenInvalidFormatError = exports.SessionTokenMismatchError = exports.SessionTokenNotFoundError = exports.SessionTokenRevokedError = exports.SessionTokenNotActiveError = exports.SessionTokenExpiredError = exports.SessionTokenInvalidError = exports.SessionValidationError = exports.SessionRefreshError = exports.SessionMaxLifetimeExceededError = exports.SessionStealedError = exports.SessionInvalidError = exports.SessionExpiredError = exports.SessionNotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.wrapUnhandledBackendError = exports.buildUnhandledBackendErrorCode = exports.BackendError = void 0;
+class BackendError extends Error {
+    statusCode;
+    code;
+    data;
+    constructor(message, statusCode = 500, code, data) {
+        super(message);
+        this.name = "BackendError";
+        this.statusCode = statusCode;
+        this.code = code || String(statusCode);
+        this.data = data;
     }
 }
 exports.BackendError = BackendError;
+const buildUnhandledBackendErrorCode = (rawName) => `XC_${rawName.toUpperCase()}`;
+exports.buildUnhandledBackendErrorCode = buildUnhandledBackendErrorCode;
+const wrapUnhandledBackendError = (err, rawName) => new BackendError(err.message, 502, (0, exports.buildUnhandledBackendErrorCode)(rawName));
+exports.wrapUnhandledBackendError = wrapUnhandledBackendError;
 class UnauthorizedError extends BackendError {
     constructor(message = "Unauthorized", data) {
         super(message, 401, "UNAUTHORIZED", data);

package/dist/lib/pinoTargets.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPinoTargets = createPinoTargets;
+function createPinoTargets(config) {
+    const targets = [
+        {
+            target: "pino-pretty",
+            level: config.level,
+            options: {
+                destination: 2,
+                colorize: true,
+                translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
+                ignore: "pid,hostname",
+                singleLine: false,
+            },
+        },
+    ];
+    if (config.fileEnabled) {
+        targets.unshift({
+            target: "pino/file",
+            level: config.level,
+            options: {
+                destination: config.filePath,
+                mkdir: true,
+            },
+        });
+    }
+    return targets;
+}

package/dist/moleculer.config.js

@@ -8,11 +8,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const moleculer_1 = require("moleculer");
 const dotenv_1 = __importDefault(require("dotenv"));
 require("module-alias/register");
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
+const pino_1 = __importDefault(require("pino"));
 const logfeed_1 = require("./lib/mixins/logfeed");
 const session_errors_1 = require("./lib/mixins/session.errors");
-const tracer_1 = require("./lib/middlewares/tracer");
+const pinoTargets_1 = require("./lib/pinoTargets");
 dotenv_1.default.config({ path: process.env.ENV_FILE ?? ".env" });
 /**
  * Moleculer ServiceBroker configuration file 1
@@ -40,72 +39,34 @@ dotenv_1.default.config({ path: process.env.ENV_FILE ?? ".env" });
  *  }
  */
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+const pinoTransport = pino_1.default.transport({
+    targets: (0, pinoTargets_1.createPinoTargets)({
+        level: process.env.LOG_LEVEL || "info",
+        fileEnabled: process.env.LOG_FILE_ENABLED === "true",
+        filePath: process.env.LOG_FILE_PATH || ".tellymcp/log.jsonl",
+    }),
+});
 const logger = [
     {
-        type: "Console",
+        type: "Pino",
         options: {
-            colors: true,
-            moduleColors: true,
-            formatter: process.env.LOGFORMATTER ?? "short",
-            objectPrinter: null,
-            autoPadding: false,
+            pino: {
+                options: {
+                    name: "tellymcp-broker",
+                    level: process.env.LOG_LEVEL || "info",
+                    timestamp: pino_1.default.stdTimeFunctions.isoTime,
+                },
+                destination: pinoTransport,
+            },
         },
     },
 ];
 const metricsEnabled = process.env.MOLECULER_METRICS === "true";
 const metricsPort = +(process.env.METRICS_PORT || 3030);
 const metricsPath = process.env.METRICS_PATH || "/metrics";
-const logFileEnabled = process.env.LOG_FILE_ENABLED === "true";
 const logFeedEnabled = process.env.ENABLE_LOGFEED != null
     ? !["0", "false", "no", "off"].includes(process.env.ENABLE_LOGFEED.toLowerCase())
     : process.env.LOGFEED_ENABLED !== "false";
-const logFileFolder = process.env.LOG_FILE_FOLDER || "./logs";
-const logFileName = process.env.LOG_FILE_NAME || "moleculer-{date}.log";
-const logFileRetentionDays = +(process.env.LOG_FILE_RETENTION_DAYS || 14);
-const cleanupLogFiles = async () => {
-    if (!logFileEnabled || !Number.isFinite(logFileRetentionDays) || logFileRetentionDays <= 0) {
-        return;
-    }
-    const logFolder = node_path_1.default.resolve(logFileFolder);
-    const now = Date.now();
-    const maxAgeMs = logFileRetentionDays * 24 * 60 * 60 * 1000;
-    const filenamePattern = new RegExp(`^${logFileName
-        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-        .replace(/\\\{date\\\}/g, "\\d{4}-\\d{2}-\\d{2}")
-        .replace(/\\\{nodeID\\\}/g, "[^/]+")
-        .replace(/\\\{namespace\\\}/g, "[^/]+")}$`);
-    try {
-        const entries = await promises_1.default.readdir(logFolder, { withFileTypes: true });
-        await Promise.all(entries
-            .filter(entry => entry.isFile() && filenamePattern.test(entry.name))
-            .map(async (entry) => {
-            const filePath = node_path_1.default.join(logFolder, entry.name);
-            const stats = await promises_1.default.stat(filePath);
-            if (now - stats.mtimeMs > maxAgeMs) {
-                await promises_1.default.unlink(filePath);
-            }
-        }));
-    }
-    catch (error) {
-        if (error.code !== "ENOENT") {
-            console.warn("LOG_FILE cleanup failed:", error);
-        }
-    }
-};
-if (logFileEnabled) {
-    void cleanupLogFiles();
-    logger.push({
-        type: "File",
-        options: {
-            level: process.env.LOG_FILE_LEVEL || process.env.LOG_LEVEL || "info",
-            folder: logFileFolder,
-            filename: logFileName,
-            formatter: process.env.LOG_FILE_FORMATTER || "json",
-            eol: "\n",
-            interval: +(process.env.LOG_FILE_INTERVAL_MS || 1000),
-        },
-    });
-}
 if (logFeedEnabled) {
     logger.push(new logfeed_1.LogFeedLogger({
         level: process.env.LOGFEED_LEVEL || process.env.LOG_LEVEL || "info",
@@ -206,18 +167,15 @@ const brokerConfig = {
     // Enable action & event parameter validation. More info: https://moleculer.services/docs/0.14/validating.html
     validator: true,
     errorHandler: (err, { ctx, service }) => {
-        // ctx.service.logger.error("errorHandler", err);
         if (err instanceof session_errors_1.BackendError) {
-            // ctx.meta.$statusCode = err.extensions.code;
             return err;
         }
         else if (err instanceof Error) {
-            // ctx.meta.$statusCode = 502;
             const rawName = ctx?.action?.rawName ||
                 ctx?.action?.name ||
                 service?.name ||
                 "UNKNOWN";
-            return new session_errors_1.BackendError(err.message, 502, `XC_${String(rawName).toUpperCase()}`);
+            return (0, session_errors_1.wrapUnhandledBackendError)(err, String(rawName));
         }
         return err;
     },
@@ -259,15 +217,11 @@ const brokerConfig = {
         },
     },
     // Register custom middlewares
-    middlewares: [(0, tracer_1.createTracerMiddleware)()],
+    middlewares: [],
     // Register custom REPL commands.
     replCommands: null,
     // Called after broker created.
     // created(broker: ServiceBroker): void {},
-    // Called after broker started.
-    started() {
-        console.log("ALLOWED ORIGINS", (process.env.ORIGINS ?? "").split(","));
-    },
     // Called after broker stopped.
     // async stopped(broker: ServiceBroker): Promise<void> {},
 };

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

@@ -165,9 +165,18 @@ const envSchema = z.object({
     LOG_LEVEL: z
         .enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"])
         .default("info"),
+    LOG_FILE_ENABLED: z
+        .string()
+        .optional()
+        .transform((value) => value === "true"),
+    LOG_FILE_PATH: z.string().min(1).default(".tellymcp/log.jsonl"),
 });
 function loadConfig() {
-    if ((0, node_fs_1.existsSync)(".env")) {
+    const explicitEnvFile = process.env.ENV_FILE?.trim();
+    if (explicitEnvFile) {
+        process.loadEnvFile(explicitEnvFile);
+    }
+    else if ((0, node_fs_1.existsSync)(".env")) {
         process.loadEnvFile(".env");
     }
     const parsed = envSchema.parse(process.env);
@@ -312,6 +321,8 @@ function loadConfig() {
         },
         logging: {
             level: parsed.LOG_LEVEL,
+            fileEnabled: parsed.LOG_FILE_ENABLED,
+            filePath: parsed.LOG_FILE_PATH,
         },
     };
 }

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

@@ -136,7 +136,7 @@ function createMcpHttpHandler(runtime, input) {
         if (requestUrl.pathname === "/healthz") {
             writeJson(res, 200, {
                 ok: true,
-                service: "telegram-human-mcp",
+                service: "tellymcp",
                 transport: "streamable-http",
             });
             return;

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

@@ -5,8 +5,8 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const registry_1 = require("../../../shared/api/tool-registry/registry");
 function createMcpServer(tools) {
     const server = new mcp_js_1.McpServer({
-        name: "telegram-human-mcp",
-        version: "1.0.0",
+        name: "tellymcp",
+        version: "0.0.6",
     });
     (0, registry_1.registerTools)(server, tools);
     return server;

package/dist/services/features/telegram-mcp/src/features/distributed-gateway/model/gatewayHttpService.js

@@ -241,7 +241,7 @@ class GatewayHttpService {
         if (pathname === "/gateway/healthz") {
             writeJson(res, 200, {
                 ok: true,
-                service: "telegram-human-mcp-gateway",
+                service: "tellymcp-gateway",
                 mode: this.config.distributed.mode,
                 databaseConfigured: Boolean(process.env.DB_HOST && process.env.DB_NAME),
                 s3Configured: Boolean(this.config.distributed.gatewayS3Bucket),