@deadragdoll/tellymcp 0.0.5 → 0.0.7

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

@@ -7,16 +7,73 @@
 [![node >= 24](https://img.shields.io/badge/node-%3E%3D24-339933)](https://nodejs.org/)
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-TellyMCP — это Telegram Human-in-the-Loop MCP server для coding agents.
+TellyMCP — это self-hosted Telegram control plane для coding agents.
 
-Он позволяет агенту:
+Он привязывает реальные agent-сессии к Telegram, делает их доступными с телефона и даёт им работать вместе между локальными и удалёнными машинами.
+
+Он не завязан на одного вендора или один coding assistant. Если агент умеет работать с MCP server, он может использовать TellyMCP.
+
+## Зачем он нужен
+
+Coding agents полезны ровно до того момента, пока они не остаются одни в терминале:
+
+- им нужно уточнение, пока тебя нет за компьютером
+- им нужен approval перед рискованным действием
+- им нужно передать скриншот, файл или note между сессиями
+- им нужно быстро подключить человека или другого агента, не ломая общий workflow
+
+TellyMCP даёт каждой сессии мобильную панель управления и collaboration layer:
+
+- `Live` tmux view и лёгкое управление из Telegram
+- session-scoped inbox и уведомления
+- workspace-aware handoff для файлов и note
+- локальную и удалённую коллаборацию между сессиями
+- поддержку mixed agent setups, если они умеют говорить по MCP
+
+## Ключевые идеи продукта
+
+- `Live` tmux view и управление внутри Telegram Mini App
+- `Collab`-сценарии для локальных и удалённых agent-сессий
+- `.mcp-xchange` как workspace-level handoff шина для note, файлов и скриншотов
+- MCP-native pairing сессий и session-scoped tools
+- optional gateway mode для multi-machine и multi-bot проектов
+
+## Human-in-the-loop — это только один слой системы
+
+Telegram HITL здесь тоже есть, но он не исчерпывает продукт:
 
 - задавать человеку уточняющие вопросы через Telegram
 - получать несвязанные входящие сообщения позже через inbox
-- привязывать несколько agent-сессий
-- работать с локальными и удалёнными партнёрскими сессиями
-- открывать Live tmux view внутри Telegram Mini App
-- обмениваться note, скриншотами и файлами через `.mcp-xchange`
+- уведомлять человека о прогрессе, blockers и approvals
+
+## Что отличает TellyMCP от простого Telegram bot bridge
+
+- он завязан на сессии, а не только на чат
+- он понимает локальные и удалённые collaboration targets
+- у него есть live terminal surface, а не только обмен сообщениями
+- он передаёт файлы через workspace-aware exchange paths, а не просто через ad hoc upload
+- он может работать как standalone node или как gateway-backed control plane
+
+## Типовые сценарии
+
+- держать долгоживущего агента доступным с телефона
+- запускать рядом разных агентов, если каждый умеет подключаться по MCP
+- подруливать tmux-сессией без ноутбука
+- маршрутизировать работу между `frontend`, `backend`, `review` и другими локальными сессиями
+- работать с удалёнными сессиями через gateway-backed project
+- передавать note, скриншоты и реальные файлы через `.mcp-xchange`
+- проверять локальный веб-интерфейс через `browser_*` tools и отправлять результат обратно в Telegram
+
+## Группы инструментов
+
+- pairing и session context
+- Telegram ask/notify/inbox
+- `Live` tmux control
+- browser inspection и screenshots
+- partner notes и partner files
+- tools sync и version checks
+
+Полный список MCP tools лучше держать ниже по README и в самом MCP server, а не на первом экране.
 
 ## Prerequisites
 
@@ -172,6 +229,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.
@@ -275,6 +425,9 @@ tellymcp mcp --help
 - `PROXY_USE=http|socks5`
 - `HTTP_PROXY`
 - `SOCKS5_PROXY`
+- `LOG_LEVEL`
+- `LOG_FILE_ENABLED`
+- `LOG_FILE_PATH`
 
 Только client:
 

package/README.md

@@ -7,50 +7,73 @@
 [![node >= 24](https://img.shields.io/badge/node-%3E%3D24-339933)](https://nodejs.org/)
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-TellyMCP is a Telegram Human-in-the-Loop MCP server for coding agents.
+TellyMCP is a self-hosted Telegram control plane for coding agents.
 
-It lets an agent:
+It pairs real agent sessions with Telegram, keeps them reachable from mobile, and lets them collaborate across local and remote machines.
+
+It is not tied to one vendor or one coding assistant. If your agent can talk to an MCP server, it can use TellyMCP.
+
+## Why it exists
+
+Coding agents are useful until they leave the terminal:
+
+- they need clarification while you are away from the desk
+- they need approval before doing something risky
+- they need screenshots, files, or notes passed between sessions
+- they need a human or another agent to unblock work without breaking flow
+
+TellyMCP gives each session a mobile control surface and a collaboration layer:
+
+- `Live` tmux view and light control from Telegram
+- session-scoped inbox and notifications
+- workspace-aware file and note handoffs
+- local and remote session collaboration
+- support for mixed agent setups, as long as they speak MCP
+
+## Core ideas
+
+- `Live` tmux view and control inside Telegram Mini App
+- `Collab` flows for local and remote agent sessions
+- `.mcp-xchange` as a workspace-level handoff bus for notes, files, and screenshots
+- MCP-native session pairing and session-scoped tools
+- optional gateway mode for cross-machine and cross-bot projects
+
+## Human-in-the-loop is one layer, not the whole product
+
+Telegram HITL is still supported, but it is not the whole story:
 
 - ask a human for clarification through Telegram
 - receive unsolicited Telegram messages later through an inbox
-- pair multiple agent sessions
-- collaborate across local and remote sessions
-- open a live tmux view inside Telegram Mini App
-- exchange notes, screenshots, and files through `.mcp-xchange`
-
-Current tools:
-
-- `create_session_pair_code`
-- `clear_session_pairing`
-- `set_session_context`
-- `set_tmux_target`
-- `get_tmux_target`
-- `get_session_context`
-- `clear_session_context`
-- `rename_session`
-- `notify_telegram`
-- `get_telegram_inbox_count`
-- `get_telegram_inbox`
-- `delete_telegram_inbox_message`
-- `ask_user_telegram`
-- `browser_open`
-- `browser_reload`
-- `browser_click`
-- `browser_fill`
-- `browser_press`
-- `browser_wait_for`
-- `browser_wait_for_url`
-- `browser_console`
-- `browser_errors`
-- `browser_network_failures`
-- `browser_clear_logs`
-- `browser_dom`
-- `browser_computed_style`
-- `browser_screenshot`
-- `browser_close`
-- `refresh_tools_markdown`
-- `send_partner_note`
-- `send_partner_file`
+- notify a human about progress, blockers, and approvals
+
+## What makes it different from a simple Telegram bot bridge
+
+- it is session-based, not just chat-based
+- it understands local and remote collaboration targets
+- it has a live terminal surface, not only message exchange
+- it moves files through workspace-aware exchange paths, not just ad hoc uploads
+- it can run as a standalone node or as a gateway-backed control plane
+
+## Typical use cases
+
+- keep a long-running agent reachable from your phone
+- run different agents side by side, as long as each one can connect over MCP
+- steer a tmux-based session without opening a laptop
+- route work between `frontend`, `backend`, `review`, or other local sessions
+- collaborate with remote sessions through a gateway-backed project
+- send notes, screenshots, and real files through `.mcp-xchange`
+- inspect or screenshot a local web app with `browser_*` tools and send results back to Telegram
+
+## Tool groups
+
+- session pairing and context
+- Telegram ask/notify/inbox
+- `Live` tmux control
+- browser inspection and screenshots
+- partner notes and partner files
+- tools sync and version checks
+
+The full MCP tool surface is documented later in this README and through the MCP server itself.
 
 ## Prerequisites
 
@@ -389,10 +412,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:
 
@@ -529,10 +553,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:
 
@@ -806,75 +830,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:
 
-Recommended external reverse proxy pattern:
+- `TELEGRAM_BOT_TOKEN`
+- `TELEGRAM_BOT_USERNAME`
+- `WEBAPP_PUBLIC_URL`
+- `GATEWAY_PUBLIC_URL`
+- `GATEWAY_WS_URL`
+- `MCP_HTTP_BEARER_TOKEN`
 
-- 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
+3. Start the stack:
 
-Important:
+```bash
+docker compose up -d
+```
+
+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/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),

package/dist/services/features/telegram-mcp/src/shared/lib/logger/logger.js

@@ -4,10 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLogger = createLogger;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const pino_1 = __importDefault(require("pino"));
-const DEFAULT_LOG_FILE_PATH = ".telegram-human-mcp/log.jsonl";
+const pinoTargets_1 = require("../../../../../../../lib/pinoTargets");
 function write(logger, level, message, meta) {
     if (meta) {
         logger[level](meta, message);
@@ -16,32 +14,15 @@ function write(logger, level, message, meta) {
     logger[level](message);
 }
 function createLogger(config) {
-    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(DEFAULT_LOG_FILE_PATH), { recursive: true });
     const transport = pino_1.default.transport({
-        targets: [
-            {
-                target: "pino/file",
-                level: config.logging.level,
-                options: {
-                    destination: DEFAULT_LOG_FILE_PATH,
-                    mkdir: true,
-                },
-            },
-            {
-                target: "pino-pretty",
-                level: config.logging.level,
-                options: {
-                    destination: 2,
-                    colorize: true,
-                    translateTime: "SYS:standard",
-                    ignore: "pid,hostname",
-                    singleLine: false,
-                },
-            },
-        ],
+        targets: (0, pinoTargets_1.createPinoTargets)({
+            level: config.logging.level,
+            fileEnabled: config.logging.fileEnabled,
+            filePath: config.logging.filePath,
+        }),
     });
     const baseLogger = (0, pino_1.default)({
-        name: "telegram-human-mcp",
+        name: "tellymcp",
         level: config.logging.level,
         timestamp: pino_1.default.stdTimeFunctions.isoTime,
     }, transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deadragdoll/tellymcp",
-  "version": "0.0.5",
-  "description": "TellyMCP - Telegram Human-in-the-Loop MCP Server",
+  "version": "0.0.7",
+  "description": "TellyMCP - Telegram control plane for MCP-connected coding agents",
   "main": "dist/services/features/telegram-mcp/runtime.service.js",
   "bin": {
     "tellymcp": "dist/cli.js"
@@ -75,7 +75,6 @@
     "amqplib": "0.10.9",
     "dotenv": "^17.4.2",
     "grammy": "1.43.0",
-    "graphql": "^16.14.0",
     "https-proxy-agent": "^7.0.6",
     "ioredis": "5.10.1",
     "knex": "^3.2.10",
@@ -88,7 +87,6 @@
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "playwright": "^1.60.0",
-    "redis": "5.12.1",
     "socks-proxy-agent": "^8.0.5",
     "ws": "8.20.1",
     "zod": "4.4.3"

package/dist/lib/middlewares/tracer.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTracerMiddleware = void 0;
-const traceContext_1 = require("../traceContext");
-const trace_1 = require("../trace");
-const shouldSkipTrace = (actionName, ctx) => Boolean(ctx?.meta?.$traceInternal ||
-    !actionName ||
-    actionName === "context" ||
-    actionName === "graphql.publish" ||
-    (actionName === "rest" && ctx?.params?.req?.url === "/api/graphql"));
-const createTracerMiddleware = () => {
-    let broker = null;
-    const resolveTracer = (action) => {
-        const rawName = String(action?.rawName || action?.name || "");
-        if (action?.tracer)
-            return { tracer: action.tracer, source: "action.tracer" };
-        if (action?.schema?.tracer)
-            return { tracer: action.schema.tracer, source: "action.schema.tracer" };
-        if (action?.service?.schema?.actions?.[rawName]?.tracer) {
-            return {
-                tracer: action.service.schema.actions[rawName].tracer,
-                source: "service.schema.actions[rawName].tracer",
-            };
-        }
-        return {};
-    };
-    const callTrace = async (ctx, actionName, params, silent = false) => {
-        if (!broker) {
-            return null;
-        }
-        try {
-            return await broker.call(actionName, params, {
-                requestID: ctx.requestID,
-                meta: {
-                    user: ctx.meta?.user,
-                    $traceInternal: true,
-                },
-            });
-        }
-        catch (error) {
-            if (!silent) {
-                broker.logger.warn("Tracer call failed", {
-                    actionName,
-                    sourceAction: ctx.action?.name || null,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            return null;
-        }
-    };
-    return {
-        created(localBroker) {
-            broker = localBroker;
-        },
-        localAction(next, action) {
-            const actionName = String(action?.rawName || action?.name || "");
-            const serviceName = String(action?.service?.name || "");
-            return async function traceAction(ctx) {
-                if (serviceName === "trace" || shouldSkipTrace(actionName, ctx)) {
-                    return next(ctx);
-                }
-                const resolvedTracer = resolveTracer(ctx?.action || action);
-                const tracer = resolvedTracer.tracer;
-                let traceMeta = null;
-                const startSessionName = tracer?.startSession;
-                const tracerTag = tracer?.tag;
-                const shouldStartRootSession = Boolean(startSessionName);
-                if (!shouldStartRootSession) {
-                    traceMeta = await (0, traceContext_1.loadTraceContext)();
-                }
-                let startedSession = false;
-                if (shouldStartRootSession) {
-                    await (0, traceContext_1.deleteTraceContext)().catch(() => null);
-                    const session = (await callTrace(ctx, "trace.startSession", {
-                        name: startSessionName,
-                        tag: tracerTag || null,
-                        source: actionName,
-                        meta: (0, trace_1.sanitizeTraceValue)({
-                            action: actionName,
-                            params: ctx.params,
-                        }),
-                    }, false));
-                    if (session?.session_id) {
-                        traceMeta = {
-                            sessionId: String(session.session_id),
-                            name: startSessionName ?? null,
-                            tag: tracerTag || null,
-                            rootAction: actionName,
-                            startedBy: actionName,
-                        };
-                        await (0, traceContext_1.saveTraceContext)(traceMeta);
-                        startedSession = true;
-                    }
-                }
-                const sessionId = String(traceMeta?.sessionId || "").trim();
-                const hasSession = Boolean(sessionId);
-                const startedAt = Date.now();
-                if (hasSession) {
-                    await (0, traceContext_1.touchTraceContext)().catch(() => null);
-                    await callTrace(ctx, "trace.log", {
-                        session_id: sessionId,
-                        level: (0, trace_1.normalizeTraceLevel)(tracer?.level || "debug"),
-                        action: actionName,
-                        state: "started",
-                        marker: tracer?.marker || null,
-                        step: tracer?.step || "action",
-                        message: actionName,
-                        data: (0, trace_1.buildTraceStartData)(ctx, actionName, tracer, startedSession),
-                    }, false);
-                }
-                try {
-                    const result = await next(ctx);
-                    const durationMs = Date.now() - startedAt;
-                    if (hasSession) {
-                        await callTrace(ctx, "trace.log", {
-                            session_id: sessionId,
-                            level: (0, trace_1.normalizeTraceLevel)(tracer?.level || "debug"),
-                            action: actionName,
-                            state: "succeeded",
-                            marker: tracer?.marker || null,
-                            step: tracer?.step || "action",
-                            message: actionName,
-                            data: (0, trace_1.buildTraceSuccessData)(ctx, actionName, result, durationMs, tracer),
-                        }, false);
-                        if (tracer?.stopSession) {
-                            await callTrace(ctx, "trace.endSession", {
-                                session_id: sessionId,
-                                status: "succeeded",
-                                summary: `${actionName} completed`,
-                                meta: (0, trace_1.sanitizeTraceValue)({
-                                    action: actionName,
-                                    durationMs,
-                                }),
-                            }, false);
-                            await (0, traceContext_1.deleteTraceContext)();
-                        }
-                    }
-                    return result;
-                }
-                catch (error) {
-                    const durationMs = Date.now() - startedAt;
-                    if (hasSession) {
-                        await callTrace(ctx, "trace.log", {
-                            session_id: sessionId,
-                            level: "error",
-                            action: actionName,
-                            state: "failed",
-                            marker: tracer?.marker || null,
-                            step: tracer?.step || "action",
-                            message: actionName,
-                            data: (0, trace_1.buildTraceErrorData)(ctx, actionName, error, durationMs, tracer),
-                        }, false);
-                        if (tracer?.stopSession || startedSession) {
-                            await callTrace(ctx, "trace.endSession", {
-                                session_id: sessionId,
-                                status: "failed",
-                                summary: error instanceof Error ? error.message : `Action failed: ${actionName}`,
-                                meta: (0, trace_1.sanitizeTraceValue)({
-                                    action: actionName,
-                                    durationMs,
-                                }),
-                            }, false);
-                            await (0, traceContext_1.deleteTraceContext)();
-                        }
-                    }
-                    throw error;
-                }
-            };
-        },
-    };
-};
-exports.createTracerMiddleware = createTracerMiddleware;

package/dist/lib/trace.js

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildTraceErrorData = exports.buildTraceSuccessData = exports.buildTraceStartData = exports.buildTraceMetaSummary = exports.sanitizeTraceValue = exports.normalizeTraceLevel = void 0;
-const TRACE_MAX_DEPTH = 4;
-const TRACE_MAX_ARRAY = 25;
-const TRACE_MAX_KEYS = 40;
-const TRACE_MAX_STRING = 1000;
-const truncateString = (value) => value.length > TRACE_MAX_STRING ? `${value.slice(0, TRACE_MAX_STRING)}...` : value;
-const normalizeTraceLevel = (value) => {
-    const level = String(value || "info").toLowerCase();
-    if (["fatal", "error", "warn", "info", "debug", "trace"].includes(level)) {
-        return level;
-    }
-    return "info";
-};
-exports.normalizeTraceLevel = normalizeTraceLevel;
-const sanitizeError = (error, depth, seen) => {
-    if (!(error instanceof Error)) {
-        return (0, exports.sanitizeTraceValue)(error, depth, seen);
-    }
-    return {
-        name: error.name,
-        message: truncateString(error.message || ""),
-        stack: truncateString(error.stack || ""),
-    };
-};
-const sanitizeTraceValue = (value, depth = 0, seen = new WeakSet()) => {
-    if (value == null || typeof value === "boolean" || typeof value === "number") {
-        return value;
-    }
-    if (typeof value === "string") {
-        return truncateString(value);
-    }
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    if (typeof value === "symbol") {
-        return value.toString();
-    }
-    if (typeof value === "function") {
-        return `[Function ${value.name || "anonymous"}]`;
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (value instanceof Error) {
-        return sanitizeError(value, depth, seen);
-    }
-    if (Buffer.isBuffer(value)) {
-        return `[Buffer ${value.length}]`;
-    }
-    if (value instanceof Set) {
-        return {
-            type: "Set",
-            size: value.size,
-            values: Array.from(value.values())
-                .slice(0, TRACE_MAX_ARRAY)
-                .map(item => (0, exports.sanitizeTraceValue)(item, depth + 1, seen)),
-        };
-    }
-    if (value instanceof Map) {
-        return {
-            type: "Map",
-            size: value.size,
-            entries: Array.from(value.entries())
-                .slice(0, TRACE_MAX_ARRAY)
-                .map(([key, item]) => [
-                (0, exports.sanitizeTraceValue)(key, depth + 1, seen),
-                (0, exports.sanitizeTraceValue)(item, depth + 1, seen),
-            ]),
-        };
-    }
-    if (Array.isArray(value)) {
-        if (depth >= TRACE_MAX_DEPTH) {
-            return `[Array(${value.length})]`;
-        }
-        return value
-            .slice(0, TRACE_MAX_ARRAY)
-            .map(item => (0, exports.sanitizeTraceValue)(item, depth + 1, seen));
-    }
-    if (typeof value === "object") {
-        const objectValue = value;
-        if (seen.has(objectValue)) {
-            return "[Circular]";
-        }
-        seen.add(objectValue);
-        if (depth >= TRACE_MAX_DEPTH) {
-            return `[${objectValue?.constructor?.name || "Object"}]`;
-        }
-        const keys = Object.keys(objectValue).slice(0, TRACE_MAX_KEYS);
-        const result = {};
-        for (const key of keys) {
-            result[key] = (0, exports.sanitizeTraceValue)(objectValue[key], depth + 1, seen);
-        }
-        if (Object.keys(objectValue).length > TRACE_MAX_KEYS) {
-            result.__truncatedKeys = Object.keys(objectValue).length - TRACE_MAX_KEYS;
-        }
-        return result;
-    }
-    return String(value);
-};
-exports.sanitizeTraceValue = sanitizeTraceValue;
-const pickFields = (source, fields) => {
-    if (fields === false) {
-        return undefined;
-    }
-    if (fields === true || fields == null) {
-        return (0, exports.sanitizeTraceValue)(source);
-    }
-    if (!source || typeof source !== "object") {
-        return (0, exports.sanitizeTraceValue)(source);
-    }
-    const result = {};
-    for (const key of fields) {
-        result[key] = (0, exports.sanitizeTraceValue)(source[key]);
-    }
-    return result;
-};
-const buildTraceMetaSummary = (ctx) => (0, exports.sanitizeTraceValue)({
-    requestID: ctx.requestID || null,
-    userSub: ctx.meta?.user?.sub || null,
-});
-exports.buildTraceMetaSummary = buildTraceMetaSummary;
-const buildTraceStartData = (ctx, actionName, tracer, startedSession = false) => (0, exports.sanitizeTraceValue)({
-    action: actionName,
-    startedSession,
-    params: pickFields(ctx.params, tracer?.captureParams),
-    meta: (0, exports.buildTraceMetaSummary)(ctx),
-});
-exports.buildTraceStartData = buildTraceStartData;
-const buildTraceSuccessData = (ctx, actionName, result, durationMs, tracer) => (0, exports.sanitizeTraceValue)({
-    action: actionName,
-    durationMs,
-    result: tracer?.captureResult === undefined
-        ? undefined
-        : pickFields(result, tracer.captureResult),
-});
-exports.buildTraceSuccessData = buildTraceSuccessData;
-const buildTraceErrorData = (ctx, actionName, error, durationMs, tracer) => (0, exports.sanitizeTraceValue)({
-    action: actionName,
-    durationMs,
-    error: tracer?.captureError === undefined
-        ? sanitizeError(error, 0, new WeakSet())
-        : pickFields(error, tracer.captureError),
-    meta: (0, exports.buildTraceMetaSummary)(ctx),
-});
-exports.buildTraceErrorData = buildTraceErrorData;

package/dist/lib/traceContext.js

@@ -1,116 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteTraceContext = exports.touchTraceContext = exports.loadTraceContext = exports.saveTraceContext = void 0;
-const redis = __importStar(require("redis"));
-const trace_1 = require("./trace");
-const TRACE_CONTEXT_TTL_SEC = Math.max(1, Number(process.env.TRACE_CONTEXT_TTL_SEC || 2));
-const TRACE_CONTEXT_KEY = "trace:active";
-let traceRedisClient = null;
-let traceRedisConnectPromise = null;
-const createTraceRedisClient = () => redis.createClient({
-    socket: {
-        host: process.env.REDIS_HOST || "localhost",
-        port: +(process.env.REDIS_PORT || 6379),
-    },
-    database: +(process.env.REDIS_DB || 0),
-    name: `${process.env.APP_NAME || process.env.APPNAME || "app"}:trace`,
-});
-const getTraceRedisClient = async () => {
-    if (traceRedisClient?.isOpen) {
-        return traceRedisClient;
-    }
-    if (!traceRedisClient) {
-        traceRedisClient = createTraceRedisClient();
-    }
-    if (!traceRedisConnectPromise) {
-        traceRedisConnectPromise = traceRedisClient.connect().then(() => traceRedisClient);
-    }
-    try {
-        return await traceRedisConnectPromise;
-    }
-    finally {
-        traceRedisConnectPromise = null;
-    }
-};
-const saveTraceContext = async (trace) => {
-    if (!trace?.sessionId) {
-        return false;
-    }
-    const client = await getTraceRedisClient();
-    await client.setEx(TRACE_CONTEXT_KEY, TRACE_CONTEXT_TTL_SEC, JSON.stringify((0, trace_1.sanitizeTraceValue)(trace)));
-    return true;
-};
-exports.saveTraceContext = saveTraceContext;
-const loadTraceContext = async () => {
-    const client = await getTraceRedisClient();
-    const raw = await client.get(TRACE_CONTEXT_KEY);
-    if (!raw) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(Buffer.isBuffer(raw) ? raw.toString("utf-8") : String(raw));
-        if (!parsed || typeof parsed !== "object") {
-            return null;
-        }
-        return {
-            sessionId: String(parsed.sessionId || ""),
-            name: parsed.name || null,
-            tag: parsed.tag || null,
-            rootAction: parsed.rootAction || null,
-            startedBy: parsed.startedBy || null,
-        };
-    }
-    catch {
-        return null;
-    }
-};
-exports.loadTraceContext = loadTraceContext;
-const touchTraceContext = async () => {
-    const client = await getTraceRedisClient();
-    const exists = await client.exists(TRACE_CONTEXT_KEY);
-    if (!exists) {
-        return false;
-    }
-    await client.expire(TRACE_CONTEXT_KEY, TRACE_CONTEXT_TTL_SEC);
-    return true;
-};
-exports.touchTraceContext = touchTraceContext;
-const deleteTraceContext = async () => {
-    const client = await getTraceRedisClient();
-    await client.del(TRACE_CONTEXT_KEY);
-    return true;
-};
-exports.deleteTraceContext = deleteTraceContext;