@deadragdoll/tellymcp 0.0.9 → 0.0.11

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

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTerminalInteractivePrompt = detectTerminalInteractivePrompt;
+const node_crypto_1 = require("node:crypto");
+const ANSI_ESCAPE_SEQUENCE_PATTERN = 
+// eslint-disable-next-line no-control-regex
+/\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/gu;
+const STRONG_PATTERNS = [
+    {
+        pattern: /\[(?:[Yy]\/[Nn]|[Nn]\/[Yy])\]|\((?:[Yy]\/[Nn]|[Nn]\/[Yy])\)/u,
+        score: 5,
+        reason: "yes_no_prompt",
+    },
+    {
+        pattern: /press\s+enter\s+to\s+continue|hit\s+enter\s+to\s+continue/iu,
+        score: 5,
+        reason: "press_enter_prompt",
+    },
+    {
+        pattern: /waiting\s+for\s+(?:user\s+)?input|awaiting\s+(?:user\s+)?(?:input|confirmation)|requires?\s+approval|need\s+your\s+(?:input|permission|approval)|cannot\s+continue\s+without/iu,
+        score: 4,
+        reason: "waiting_for_input",
+    },
+    {
+        pattern: /\b(do\s+you\s+want|are\s+you\s+sure|would\s+you\s+like|should\s+i|can\s+i\s+go\s+ahead|may\s+i\s+proceed)\b/iu,
+        score: 4,
+        reason: "direct_question_phrase",
+    },
+    {
+        pattern: /\[\s*!\s*\]\s*action\s+required\b/iu,
+        score: 5,
+        reason: "action_required_banner",
+    },
+    {
+        pattern: /\bfield\s+\d+\/\d+\s+\(\d+\s+required\s+unanswered\)/iu,
+        score: 5,
+        reason: "required_unanswered_field",
+    },
+    {
+        pattern: /\ballow\s+the\s+.+\?\s*$/iu,
+        score: 4,
+        reason: "allow_question",
+    },
+    {
+        pattern: /\brun\s+the\s+tool\s+and\s+continue\b/iu,
+        score: 4,
+        reason: "tool_continue_prompt",
+    },
+];
+const MEDIUM_PATTERNS = [
+    {
+        pattern: /\b(confirm|approve|allow|continue|proceed|select|choose)\b/iu,
+        score: 1,
+        reason: "action_keyword",
+    },
+    {
+        pattern: /\?\s*$/u,
+        score: 1,
+        reason: "question_mark",
+    },
+    {
+        pattern: /\b(?:always\s+allow|allow\s+for\s+this\s+session|cancel\s+this\s+tool\s+call)\b/iu,
+        score: 1,
+        reason: "tool_choice_keyword",
+    },
+];
+function normalizeLine(line) {
+    return line
+        .replaceAll("\r", "")
+        .replace(ANSI_ESCAPE_SEQUENCE_PATTERN, "")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+function isNoiseLine(line) {
+    if (!line) {
+        return true;
+    }
+    if (line.length > 260) {
+        return true;
+    }
+    return (/^\[[0-9]{4}-[0-9]{2}-[0-9]{2}\b/u.test(line) ||
+        /^at\s+.+\(.+\)$/u.test(line) ||
+        /^diff --git\b/u.test(line) ||
+        /^(---|\+\+\+|@@)\b/u.test(line) ||
+        /^[~/.\w-]+:\d+:\d+/u.test(line) ||
+        /^https?:\/\/\S+$/u.test(line));
+}
+function scoreStrongLine(line) {
+    const contributions = [];
+    for (const candidate of STRONG_PATTERNS) {
+        if (candidate.pattern.test(line)) {
+            contributions.push({
+                score: candidate.score,
+                reason: candidate.reason,
+            });
+        }
+    }
+    return contributions;
+}
+function scoreMediumLine(line, strategy) {
+    const contributions = [];
+    for (const candidate of MEDIUM_PATTERNS) {
+        if (candidate.pattern.test(line)) {
+            contributions.push({
+                score: candidate.score,
+                reason: candidate.reason,
+            });
+        }
+    }
+    if (strategy === "balanced" &&
+        /\b(input|reply|answer|decision|permission|approval)\b/iu.test(line)) {
+        contributions.push({
+            score: 1,
+            reason: "balanced_context_keyword",
+        });
+    }
+    return contributions;
+}
+function isStrongReason(reason) {
+    return STRONG_PATTERNS.some((candidate) => candidate.reason === reason);
+}
+function detectGroupedSignals(candidateLines, strategy) {
+    const signals = [];
+    const hasPrimaryAllowChoice = candidateLines.some((line) => /^>?[\s\d.]*allow\b/iu.test(line));
+    const hasSecondaryApprovalChoice = candidateLines.some((line) => /\b(?:allow\s+once|allow\s+for\s+this\s+session|always\s+allow|cancel)\b/iu.test(line));
+    const hasSubmitCancelHint = candidateLines.some((line) => /\benter\s+to\s+submit\b.*\besc\s+to\s+cancel\b/iu.test(line));
+    if (hasPrimaryAllowChoice && hasSecondaryApprovalChoice) {
+        signals.push({
+            score: 5,
+            reason: "approval_choice_group",
+        });
+    }
+    if (hasSubmitCancelHint) {
+        signals.push({
+            score: strategy === "balanced" ? 2 : 3,
+            reason: "submit_cancel_hint",
+        });
+    }
+    return signals;
+}
+function collectCandidateLines(rawText, maxLines) {
+    const normalized = rawText
+        .split("\n")
+        .map(normalizeLine)
+        .filter((line) => line.length > 0);
+    return normalized.slice(-Math.max(1, maxLines));
+}
+function detectTerminalInteractivePrompt(rawText, options = {}) {
+    const strategy = options.strategy ?? "strict";
+    const minScore = options.minScore ?? (strategy === "balanced" ? 4 : 5);
+    const candidateLines = collectCandidateLines(rawText, options.maxLines ?? 40);
+    if (candidateLines.length === 0) {
+        return null;
+    }
+    const scoredLines = [];
+    let score = 0;
+    const reasons = new Set();
+    for (const line of candidateLines) {
+        if (isNoiseLine(line)) {
+            continue;
+        }
+        const contributions = scoreStrongLine(line);
+        if (contributions.length === 0) {
+            continue;
+        }
+        scoredLines.push({ line, contributions });
+        for (const contribution of contributions) {
+            score += contribution.score;
+            reasons.add(contribution.reason);
+        }
+    }
+    const optionLineCount = candidateLines.filter((line) => /^(\d+\.\s+|[-*]\s+|\[[ xX]\]\s+)/u.test(line)).length;
+    if (scoredLines.length > 0 && optionLineCount >= 2) {
+        score += 3;
+        reasons.add("multiple_options");
+    }
+    for (const signal of detectGroupedSignals(candidateLines, strategy)) {
+        score += signal.score;
+        reasons.add(signal.reason);
+    }
+    const hasStrongReason = Array.from(reasons).some(isStrongReason);
+    const hasGroupedReason = reasons.has("approval_choice_group") || reasons.has("submit_cancel_hint");
+    const hasOnlyQuestionMarkReason = reasons.size === 1 && reasons.has("question_mark");
+    if (strategy === "strict") {
+        if (hasOnlyQuestionMarkReason) {
+            return null;
+        }
+        if (!hasStrongReason) {
+            if (!hasGroupedReason) {
+                return null;
+            }
+        }
+    }
+    const canUseMediumSignals = strategy === "balanced" ||
+        hasStrongReason ||
+        hasGroupedReason ||
+        reasons.has("multiple_options");
+    if (canUseMediumSignals) {
+        for (const line of candidateLines) {
+            if (isNoiseLine(line)) {
+                continue;
+            }
+            const contributions = scoreMediumLine(line, strategy);
+            if (contributions.length === 0) {
+                continue;
+            }
+            const existing = scoredLines.find((entry) => entry.line === line);
+            if (existing) {
+                existing.contributions.push(...contributions);
+            }
+            else {
+                scoredLines.push({ line, contributions: [...contributions] });
+            }
+            for (const contribution of contributions) {
+                score += contribution.score;
+                reasons.add(contribution.reason);
+            }
+        }
+    }
+    if (score < minScore || scoredLines.length === 0) {
+        return null;
+    }
+    const matchedLines = scoredLines
+        .map((entry) => entry.line)
+        .slice(-6);
+    const excerpt = matchedLines.join("\n");
+    const fingerprint = (0, node_crypto_1.createHash)("sha1")
+        .update(`${strategy}\n${excerpt}`)
+        .digest("hex");
+    return {
+        score,
+        fingerprint,
+        excerpt,
+        matchedLines,
+        reasons: Array.from(reasons),
+    };
+}

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

@@ -3,14 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TELLYMCP_CAPABILITIES = exports.TELLYMCP_PROTOCOL_VERSION = void 0;
+exports.TELLYMCP_CAPABILITIES = exports.TELLYMCP_PACKAGE_NAME = exports.TELLYMCP_PROTOCOL_VERSION = void 0;
 exports.parseProtocolVersion = parseProtocolVersion;
 exports.evaluateVersionCompatibility = evaluateVersionCompatibility;
 exports.findPackageRoot = findPackageRoot;
+exports.getTellyMcpPackageRoot = getTellyMcpPackageRoot;
 exports.getTellyMcpPackageVersion = getTellyMcpPackageVersion;
+exports.comparePackageVersions = comparePackageVersions;
+exports.fetchLatestPublishedPackageVersion = fetchLatestPublishedPackageVersion;
+exports.detectAvailablePackageUpdate = detectAvailablePackageUpdate;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 exports.TELLYMCP_PROTOCOL_VERSION = "1.0";
+exports.TELLYMCP_PACKAGE_NAME = "@deadragdoll/tellymcp";
 exports.TELLYMCP_CAPABILITIES = [
     "collab_projects",
     "delivery_status_push",
@@ -103,7 +108,11 @@ function findPackageRoot(startDir) {
         currentDir = parentDir;
     }
 }
+function getTellyMcpPackageRoot(startDir) {
+    return findPackageRoot(startDir);
+}
 let cachedPackageVersion = null;
+let latestPublishedVersionPromise = null;
 function getTellyMcpPackageVersion(startDir) {
     if (cachedPackageVersion) {
         return cachedPackageVersion;
@@ -122,3 +131,122 @@ function getTellyMcpPackageVersion(startDir) {
         return "0.0.0-unknown";
     }
 }
+function parseSemver(value) {
+    const match = value
+        .trim()
+        .match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4]?.split(".").filter(Boolean) ?? [],
+    };
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 && right.length === 0) {
+        return 0;
+    }
+    if (left.length === 0) {
+        return 1;
+    }
+    if (right.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        const leftNumber = /^\d+$/u.test(leftPart) ? Number(leftPart) : null;
+        const rightNumber = /^\d+$/u.test(rightPart) ? Number(rightPart) : null;
+        if (leftNumber !== null && rightNumber !== null) {
+            if (leftNumber !== rightNumber) {
+                return leftNumber > rightNumber ? 1 : -1;
+            }
+            continue;
+        }
+        if (leftNumber !== null) {
+            return -1;
+        }
+        if (rightNumber !== null) {
+            return 1;
+        }
+        if (leftPart !== rightPart) {
+            return leftPart > rightPart ? 1 : -1;
+        }
+    }
+    return 0;
+}
+function comparePackageVersions(leftVersion, rightVersion) {
+    const left = parseSemver(leftVersion);
+    const right = parseSemver(rightVersion);
+    if (!left || !right) {
+        return null;
+    }
+    if (left.major !== right.major) {
+        return left.major > right.major ? 1 : -1;
+    }
+    if (left.minor !== right.minor) {
+        return left.minor > right.minor ? 1 : -1;
+    }
+    if (left.patch !== right.patch) {
+        return left.patch > right.patch ? 1 : -1;
+    }
+    return comparePrerelease(left.prerelease, right.prerelease);
+}
+async function fetchLatestPublishedPackageVersion(timeoutMs = 1500) {
+    if (!latestPublishedVersionPromise) {
+        latestPublishedVersionPromise = (async () => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(exports.TELLYMCP_PACKAGE_NAME)}/latest`, {
+                    method: "GET",
+                    headers: {
+                        accept: "application/json",
+                    },
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    return null;
+                }
+                const parsed = (await response.json());
+                return typeof parsed.version === "string" && parsed.version.trim()
+                    ? parsed.version.trim()
+                    : null;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        })();
+    }
+    return latestPublishedVersionPromise;
+}
+async function detectAvailablePackageUpdate(input) {
+    if (!input.currentVersion.trim() || input.currentVersion === "0.0.0-unknown") {
+        return null;
+    }
+    const latestVersion = await fetchLatestPublishedPackageVersion(input.timeoutMs);
+    if (!latestVersion) {
+        return null;
+    }
+    const comparison = comparePackageVersions(latestVersion, input.currentVersion);
+    if (comparison === null || comparison <= 0) {
+        return null;
+    }
+    return {
+        currentVersion: input.currentVersion,
+        latestVersion,
+    };
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIncomingPartnerActionDesc = buildIncomingPartnerActionDesc;
+exports.buildIncomingPartnerTools = buildIncomingPartnerTools;
+exports.buildOutgoingPartnerActionDesc = buildOutgoingPartnerActionDesc;
+exports.buildOutgoingPartnerTools = buildOutgoingPartnerTools;
+exports.buildLocalHandoffActionDesc = buildLocalHandoffActionDesc;
+exports.buildLocalHandoffTools = buildLocalHandoffTools;
+exports.buildIncomingTelegramMessageActionDesc = buildIncomingTelegramMessageActionDesc;
+exports.buildIncomingTelegramMessageTools = buildIncomingTelegramMessageTools;
+exports.detectIncomingTelegramBrowserScreenshotRequest = detectIncomingTelegramBrowserScreenshotRequest;
+function looksLikeBrowserScreenshotRequest(text) {
+    const haystack = text.toLowerCase();
+    return (/\b(browser_open|browser_screenshot|playwright)\b/u.test(haystack) ||
+        /\b(скриншот|screenshot|скрин)\b/u.test(haystack) ||
+        /\bhttps?:\/\/[^\s]+/u.test(haystack));
+}
+function buildIncomingPartnerActionDesc(kind, requiresReply, prefersFileDelivery = false, prefersBrowserScreenshot = false) {
+    if (requiresReply || kind === "question" || kind === "request") {
+        if (prefersBrowserScreenshot) {
+            return "Start with get_xchange_record for the newest partner_note. For a webpage screenshot request, use browser_open and browser_screenshot in this console to create the screenshot artifact, then send that real file back with send_partner_file. Do not stop at analysis, do not just summarize the request, and do not replace the browser workflow with a shell fallback unless the browser tools actually fail. The task is not complete until send_partner_file succeeds. Only after that may you call mark_xchange_record_read.";
+        }
+        if (prefersFileDelivery) {
+            return "Start with get_xchange_record for the newest partner_note, then carry out the requested work in this session and send the result back as a real file with send_partner_file. Do not stop at analysis, do not just summarize the request, and do not paste file contents into send_partner_note. The task is not complete until send_partner_file succeeds. Only after that may you call mark_xchange_record_read.";
+        }
+        return "Start with get_xchange_record for the newest partner_note, then carry out the requested work in this session and send the result back with send_partner_note. Do not stop at analysis and do not just restate the request. The task is not complete until send_partner_note succeeds. Only after that may you call mark_xchange_record_read.";
+    }
+    if (kind === "reply") {
+        return "Read the reply and inspect any returned artifacts. If this reply completes a task that originally came from a human telegram_message in this session, you must forward the final result to the human now. Use notify_telegram for text-only results. If the reply returned a real local artifact or file, use send_file_to_telegram to deliver that file to the human Telegram chat. Do not leave the result only in local xchange records. Only after the human-facing delivery succeeds, or after you have incorporated the reply into a non-human internal task, may you call mark_xchange_record_read.";
+    }
+    if (kind === "handoff") {
+        return "Inspect the attached artifacts and body_text, then continue the task in this session. Reply only if the sender requested confirmation or more work.";
+    }
+    return "Read the shared update and attached artifacts, then continue the task in this session.";
+}
+function buildIncomingPartnerTools(kind, requiresReply, prefersFileDelivery = false, prefersBrowserScreenshot = false) {
+    const tools = ["get_xchange_record"];
+    if (prefersBrowserScreenshot) {
+        tools.push("browser_open", "browser_screenshot");
+    }
+    if (prefersFileDelivery) {
+        tools.push("send_partner_file");
+    }
+    if (requiresReply || kind === "question" || kind === "request") {
+        tools.push("send_partner_note");
+    }
+    if (kind === "handoff" && !tools.includes("send_partner_file")) {
+        tools.push("send_partner_file");
+    }
+    if (kind === "reply") {
+        tools.push("notify_telegram", "send_file_to_telegram");
+    }
+    tools.push("mark_xchange_record_read");
+    return tools;
+}
+function buildOutgoingPartnerActionDesc(kind, requiresReply) {
+    if (requiresReply || kind === "question" || kind === "request") {
+        return "Outgoing collaboration note was sent to the target session. Do not block on sleep, polling, or repeated list_xchange_records calls in the same turn. The target console will be nudged separately and can reply later through the normal xchange path.";
+    }
+    return "Outgoing collaboration note was sent to the target session.";
+}
+function buildOutgoingPartnerTools(kind, requiresReply) {
+    void kind;
+    void requiresReply;
+    return ["get_xchange_record"];
+}
+function buildLocalHandoffActionDesc() {
+    return "Read body_text, inspect the attached local artifacts, and continue the task in this same session.";
+}
+function buildLocalHandoffTools() {
+    return ["get_xchange_record", "mark_xchange_record_read"];
+}
+function buildIncomingTelegramMessageActionDesc(kind, prefersBrowserScreenshot = false) {
+    if (kind === "question" || kind === "request") {
+        if (prefersBrowserScreenshot) {
+            return "Start with get_xchange_record for the newest telegram_message. For a webpage screenshot request, use browser_open and browser_screenshot in this console, and set send_to_telegram=true on browser_screenshot so the PNG goes directly back to the human Telegram chat. Do not stop at analysis, do not just restate the request, do not save the screenshot locally and then search for route metadata, and do not call get_session_context just to deliver the screenshot. The task is not complete until browser_screenshot succeeds with send_to_telegram=true. Only after that may you call mark_xchange_record_read.";
+        }
+        return "Start with get_xchange_record for the newest telegram_message, then carry out the requested work in this session and reply to the human through notify_telegram. Do not stop at analysis and do not just restate the request. The task is not complete until notify_telegram succeeds. Only after that may you call mark_xchange_record_read.";
+    }
+    return "Read the Telegram message and attachments, continue the task in this session, and use notify_telegram only if a human-facing reply is needed.";
+}
+function buildIncomingTelegramMessageTools(kind, prefersBrowserScreenshot = false) {
+    const tools = ["get_xchange_record"];
+    if (prefersBrowserScreenshot && (kind === "question" || kind === "request")) {
+        tools.push("browser_open", "browser_screenshot");
+    }
+    else if (kind === "question" || kind === "request") {
+        tools.push("notify_telegram");
+    }
+    tools.push("mark_xchange_record_read");
+    return tools;
+}
+function detectIncomingTelegramBrowserScreenshotRequest(input) {
+    if (input.kind !== "question" && input.kind !== "request") {
+        return false;
+    }
+    return looksLikeBrowserScreenshotRequest([input.summary ?? "", input.text].join("\n"));
+}

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

@@ -30,6 +30,7 @@ const TelegramMcpStandaloneHttpService = {
     ],
     created() {
         this.httpServer = null;
+        this.upgradeHandler = null;
     },
     async started() {
         if (process.env.TELLYMCP_STANDALONE_HTTP === "false") {
@@ -47,7 +48,7 @@ const TelegramMcpStandaloneHttpService = {
         if (!httpService?.routeRequest) {
             throw new Error(`Local Moleculer service '${mcp_http_service_1.TELEGRAM_MCP_HTTP_SERVICE_NAME}' is unavailable`);
         }
-        const runtime = runtimeService.getRuntime();
+        const runtime = await runtimeService.waitUntilReady();
         const { host, port, publicRootPrefix } = resolveStandaloneBind(runtime);
         this.httpServer = (0, node_http_1.createServer)(async (req, res) => {
             try {
@@ -67,6 +68,16 @@ const TelegramMcpStandaloneHttpService = {
                 }
             }
         });
+        this.upgradeHandler = (req, socket, head) => {
+            const requestUrl = new URL(req.url ?? "/", "http://standalone.local");
+            void httpService.routeUpgrade?.(req, socket, head, requestUrl.pathname).catch((error) => {
+                this.logger.error("Standalone HTTP upgrade failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                socket.destroy();
+            });
+        };
+        this.httpServer.on("upgrade", this.upgradeHandler);
         await new Promise((resolve, reject) => {
             const server = this.httpServer;
             if (!server) {
@@ -96,6 +107,7 @@ const TelegramMcpStandaloneHttpService = {
     async stopped() {
         const server = this.httpServer;
         this.httpServer = null;
+        this.upgradeHandler = null;
         if (!server) {
             return;
         }

package/dist/services/features/telegram-mcp/terminal-buffer.service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_TERMINAL_BUFFER_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
+const terminalBufferService_1 = require("./src/features/terminal-buffer/model/terminalBufferService");
+exports.TELEGRAM_MCP_TERMINAL_BUFFER_SERVICE_NAME = "telegramMcp.terminalBuffer";
+const TelegramMcpTerminalBufferService = {
+    name: exports.TELEGRAM_MCP_TERMINAL_BUFFER_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        captureBufferRemote: {
+            params: { type: "object" },
+            async handler(ctx) {
+                return this.getTerminalBufferService().captureBuffer(ctx.params);
+            },
+        },
+    },
+    created() {
+        this.terminalBufferService = null;
+    },
+    methods: {
+        getTerminalBufferService() {
+            if (!this.terminalBufferService) {
+                throw new Error("telegram_mcp terminal-buffer service is not initialized yet");
+            }
+            return this.terminalBufferService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = await runtimeService.waitUntilReady();
+        this.logger.info("Starting telegram_mcp terminal-buffer service");
+        this.terminalBufferService = new terminalBufferService_1.TerminalBufferService(runtime.config, runtime.sessionStore, runtime.logger, runtime.projectIdentityResolver, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })));
+        this.logger.info("telegram_mcp terminal-buffer service is ready");
+    },
+};
+exports.default = TelegramMcpTerminalBufferService;

package/dist/services/features/telegram-mcp/terminal-input.service.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_TERMINAL_INPUT_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const terminalInputService_1 = require("./src/features/terminal-input/model/terminalInputService");
+exports.TELEGRAM_MCP_TERMINAL_INPUT_SERVICE_NAME = "telegramMcp.terminalInput";
+const TelegramMcpTerminalInputService = {
+    name: exports.TELEGRAM_MCP_TERMINAL_INPUT_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        submitHumanMessageRemote: {
+            params: { type: "object" },
+            async handler(ctx) {
+                return this.getTerminalInputService().submitHumanMessage(ctx.params);
+            },
+        },
+    },
+    created() {
+        this.terminalInputService = null;
+    },
+    methods: {
+        getTerminalInputService() {
+            if (!this.terminalInputService) {
+                throw new Error("telegram_mcp terminal-input service is not initialized yet");
+            }
+            return this.terminalInputService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = await runtimeService.waitUntilReady();
+        this.logger.info("Starting telegram_mcp terminal-input service");
+        this.terminalInputService = new terminalInputService_1.TerminalInputService(runtime.config, runtime.sessionStore, runtime.logger);
+        this.logger.info("telegram_mcp terminal-input service is ready");
+    },
+};
+exports.default = TelegramMcpTerminalInputService;

package/dist/services/features/telegram-mcp/tools-sync.service.js

@@ -2,11 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME = void 0;
 const runtime_service_1 = require("./runtime.service");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
 const refreshToolsMarkdownService_1 = require("./src/features/tools-sync/model/refreshToolsMarkdownService");
 exports.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME = "telegramMcp.toolsSync";
 const TelegramMcpToolsSyncService = {
     name: exports.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME,
     dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        refreshToolsMarkdownRemote: {
+            params: {
+                $$strict: false,
+                session_id: { type: "string", optional: true, empty: false },
+                cwd: { type: "string", optional: true, empty: false },
+                known_hash: { type: "string", optional: true, empty: false },
+            },
+            async handler(ctx) {
+                return this.getRefreshToolsMarkdownService().refresh(ctx.params);
+            },
+        },
+    },
     created() {
         this.refreshToolsMarkdownService = null;
     },
@@ -24,9 +38,9 @@ const TelegramMcpToolsSyncService = {
         if (!runtimeService) {
             throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
         }
-        const runtime = runtimeService.getRuntime();
+        const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp tools sync service");
-        this.refreshToolsMarkdownService = new refreshToolsMarkdownService_1.RefreshToolsMarkdownService(runtime.config, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver);
+        this.refreshToolsMarkdownService = new refreshToolsMarkdownService_1.RefreshToolsMarkdownService(runtime.config, runtime.sessionStore, runtime.logger, runtime.projectIdentityResolver, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })));
         this.logger.info("telegram_mcp tools sync service is ready");
     },
 };