@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteConsoleActionClient = void 0;
+const relay_1 = require("../../../app/webapp/relay");
+function isBackendErrorLike(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        typeof value.statusCode === "number" &&
+        typeof value.code === "string");
+}
+function formatBackendErrorLike(value) {
+    const details = [];
+    if (typeof value.code === "string" && value.code.trim()) {
+        details.push(`code=${value.code.trim()}`);
+    }
+    if (typeof value.statusCode === "number") {
+        details.push(`statusCode=${value.statusCode}`);
+    }
+    if (value.data !== undefined) {
+        try {
+            details.push(`data=${JSON.stringify(value.data)}`);
+        }
+        catch {
+            details.push(`data=${String(value.data)}`);
+        }
+    }
+    const base = typeof value.message === "string" && value.message.trim()
+        ? value.message.trim()
+        : `${value.name ?? "BackendError"} (${value.code})`;
+    return details.length > 0 ? `${base}\n${details.join("\n")}` : base;
+}
+class RemoteConsoleActionClient {
+    callBroker;
+    constructor(callBroker) {
+        this.callBroker = callBroker;
+    }
+    async resolveTarget(sessionId, _params) {
+        const relayTarget = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+        if (relayTarget) {
+            return {
+                clientUuid: relayTarget.clientUuid,
+                localSessionId: relayTarget.localSessionId,
+            };
+        }
+        const trimmedSessionId = sessionId.trim();
+        if (!trimmedSessionId) {
+            throw new Error("Gateway-routed action requires a non-empty canonical session_id in the format client_uuid:local_session_id.");
+        }
+        const resolved = await this.callBroker("telegramMcp.gatewaySocket.resolveConnectedSessionTarget", {
+            sessionId: trimmedSessionId,
+        });
+        if (!resolved) {
+            throw new Error(`Could not resolve live console target for session_id '${trimmedSessionId}'.`);
+        }
+        return {
+            clientUuid: resolved.client_uuid,
+            localSessionId: resolved.local_session_id,
+        };
+    }
+    async invokeForRelaySession(sessionId, actionName, params) {
+        const target = await this.resolveTarget(sessionId, params);
+        const result = await this.callBroker("telegramMcp.gatewaySocket.requestClientAction", {
+            clientUuid: target.clientUuid,
+            actionName,
+            params: {
+                ...params,
+                session_id: target.localSessionId,
+            },
+        });
+        if (isBackendErrorLike(result)) {
+            throw new Error(formatBackendErrorLike(result));
+        }
+        return result;
+    }
+}
+exports.RemoteConsoleActionClient = RemoteConsoleActionClient;

package/dist/services/features/telegram-mcp/src/features/embedded-runtime/model/embeddedRuntimeBroker.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmbeddedRuntimeBroker = createEmbeddedRuntimeBroker;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+function isSourceRuntimeMode() {
+    return process.env.TELLYMCP_SOURCE_RUNTIME === "true";
+}
+function collectServiceSchemaFiles(rootDir, extension) {
+    const files = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir) {
+            continue;
+        }
+        for (const entry of (0, node_fs_1.readdirSync)(currentDir)) {
+            const fullPath = node_path_1.default.join(currentDir, entry);
+            const stat = (0, node_fs_1.statSync)(fullPath);
+            if (stat.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (stat.isFile() && entry.endsWith(extension)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+function unwrapCjsDefault(value) {
+    let current = value;
+    while (current &&
+        typeof current === "object" &&
+        "default" in current &&
+        Object.keys(current).length <= 3) {
+        const next = current.default;
+        if (next === current || next == null) {
+            break;
+        }
+        current = next;
+    }
+    return current;
+}
+function resolveServiceSchemaExport(moduleNamespace) {
+    const unwrappedModule = unwrapCjsDefault(moduleNamespace);
+    if (unwrappedModule &&
+        typeof unwrappedModule === "object" &&
+        "name" in unwrappedModule) {
+        return unwrappedModule;
+    }
+    if (unwrappedModule &&
+        typeof unwrappedModule === "object" &&
+        "default" in unwrappedModule) {
+        return unwrapCjsDefault(unwrappedModule.default);
+    }
+    return unwrappedModule;
+}
+async function createEmbeddedRuntimeBroker(input) {
+    process.env.ENV_FILE = input.envPath;
+    process.env.TELLYMCP_STANDALONE_HTTP = input.standaloneHttp ? "true" : "false";
+    const sourceRuntime = isSourceRuntimeMode();
+    const brokerConfigPath = sourceRuntime
+        ? node_path_1.default.join(input.packageRoot, "src", "moleculer.config.ts")
+        : node_path_1.default.join(input.packageRoot, "dist", "moleculer.config.js");
+    const servicesRoot = sourceRuntime
+        ? node_path_1.default.join(input.packageRoot, "src", "services", "features", "telegram-mcp")
+        : node_path_1.default.join(input.packageRoot, "dist", "services", "features", "telegram-mcp");
+    const serviceExtension = sourceRuntime ? ".service.ts" : ".service.js";
+    const { ServiceBroker } = (await import("moleculer"));
+    const brokerConfigModule = (await import((0, node_url_1.pathToFileURL)(brokerConfigPath).href));
+    const brokerConfig = unwrapCjsDefault(brokerConfigModule);
+    const broker = new ServiceBroker(brokerConfig);
+    const serviceFiles = collectServiceSchemaFiles(servicesRoot, serviceExtension);
+    for (const serviceFile of serviceFiles) {
+        const serviceModule = (await import((0, node_url_1.pathToFileURL)(serviceFile).href));
+        const schema = resolveServiceSchemaExport(serviceModule);
+        broker.createService(schema);
+    }
+    await broker.start();
+    const runtimeService = broker.getLocalService("telegramMcp.runtime");
+    if (!runtimeService?.waitUntilReady) {
+        await broker.stop();
+        throw new Error("Embedded runtime service is unavailable");
+    }
+    const runtime = await runtimeService.waitUntilReady();
+    return { broker, runtime };
+}

package/dist/services/features/telegram-mcp/src/features/foreground-terminal/model/foregroundTerminalRuntime.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isForegroundPtyClientMode = isForegroundPtyClientMode;
+exports.runForegroundPtyRuntime = runForegroundPtyRuntime;
+const client_1 = require("../../../shared/integrations/terminal/client");
+const embeddedRuntimeBroker_1 = require("../../embedded-runtime/model/embeddedRuntimeBroker");
+function isForegroundPtyClientMode(parsed) {
+    return (parsed.DISTRIBUTED_MODE || "client").trim() === "client";
+}
+async function createForegroundBroker(envPath, packageRoot) {
+    if (!process.env.LOG_STDERR_LEVEL?.trim()) {
+        process.env.LOG_STDERR_LEVEL = "error";
+    }
+    if (!process.env.LOG_FILE_ENABLED?.trim()) {
+        process.env.LOG_FILE_ENABLED = "true";
+    }
+    if (!process.env.LOG_FILE_LEVEL?.trim()) {
+        process.env.LOG_FILE_LEVEL = process.env.LOG_LEVEL?.trim() || "info";
+    }
+    return (0, embeddedRuntimeBroker_1.createEmbeddedRuntimeBroker)({
+        envPath,
+        packageRoot,
+        standaloneHttp: false,
+    });
+}
+async function ensureForegroundPtySession(runtime) {
+    const resolved = runtime.projectIdentityResolver.resolveSessionDefaults({
+        cwd: process.cwd(),
+    });
+    const existing = await runtime.sessionStore.getSession(resolved.sessionId);
+    const target = (0, client_1.ensureTerminalTargetForSession)(runtime.config.terminal, {
+        sessionId: resolved.sessionId,
+        cwd: resolved.cwd,
+        ...(typeof existing?.terminalTarget === "string"
+            ? { target: existing.terminalTarget }
+            : {}),
+    });
+    if (!target) {
+        throw new Error("PTY terminal target could not be created");
+    }
+    const updatedAt = new Date().toISOString();
+    await runtime.sessionStore.setSession({
+        sessionId: resolved.sessionId,
+        ...(typeof existing?.label === "string"
+            ? { label: existing.label }
+            : { label: resolved.sessionLabel }),
+        ...(typeof existing?.cwd === "string" ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
+        ...(typeof existing?.activeProjectUuid === "string"
+            ? { activeProjectUuid: existing.activeProjectUuid }
+            : {}),
+        ...(typeof existing?.activeProjectName === "string"
+            ? { activeProjectName: existing.activeProjectName }
+            : {}),
+        ...(typeof existing?.task === "string" ? { task: existing.task } : {}),
+        ...(typeof existing?.summary === "string" ? { summary: existing.summary } : {}),
+        ...(Array.isArray(existing?.files) ? { files: existing.files } : {}),
+        ...(Array.isArray(existing?.decisions)
+            ? { decisions: existing.decisions }
+            : {}),
+        ...(Array.isArray(existing?.risks) ? { risks: existing.risks } : {}),
+        terminalTarget: target,
+        ...(typeof existing?.lastTerminalNudgeAt === "string"
+            ? { lastTerminalNudgeAt: existing.lastTerminalNudgeAt }
+            : {}),
+        ...(typeof existing?.lastSeenToolsHash === "string"
+            ? { lastSeenToolsHash: existing.lastSeenToolsHash }
+            : {}),
+        ...(typeof existing?.lastNotifiedToolsHash === "string"
+            ? { lastNotifiedToolsHash: existing.lastNotifiedToolsHash }
+            : {}),
+        updatedAt,
+    });
+    return {
+        sessionId: resolved.sessionId,
+        sessionLabel: typeof existing?.label === "string" && existing.label.trim()
+            ? existing.label
+            : resolved.sessionLabel,
+        target,
+    };
+}
+async function attachCurrentTerminalToPty(runtime, target) {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const resize = () => {
+        if (stdout.isTTY) {
+            (0, client_1.resizeForegroundTerminal)(target, stdout.columns || 120, stdout.rows || 40);
+        }
+    };
+    resize();
+    const snapshot = await (0, client_1.captureVisibleTerminal)(runtime.config.terminal, target, 80, 1);
+    if (snapshot.trim().length > 0) {
+        stdout.write(`${snapshot}${snapshot.endsWith("\n") ? "" : "\n"}`);
+    }
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const finish = async (code) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            detach();
+            try {
+                await Promise.resolve();
+            }
+            finally {
+                resolve(code);
+            }
+        };
+        if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+            stdin.setRawMode(true);
+        }
+        stdin.resume();
+        const onStdinData = (chunk) => {
+            (0, client_1.sendForegroundTerminalInput)(target, typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+        };
+        const detachPty = (0, client_1.subscribeForegroundTerminal)(target, {
+            onData: (data) => {
+                stdout.write(data);
+            },
+            onExit: ({ exitCode }) => {
+                void finish(exitCode);
+            },
+        });
+        const onSigwinch = () => {
+            resize();
+        };
+        const onSignal = (signal) => {
+            void runtime.logger.warn("Foreground PTY runtime interrupted", { signal });
+            void finish(signal === "SIGTERM" ? 143 : 130);
+        };
+        const detach = () => {
+            detachPty();
+            stdin.off("data", onStdinData);
+            process.off("SIGINT", sigintHandler);
+            process.off("SIGTERM", sigtermHandler);
+            stdout.off("resize", onSigwinch);
+            if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+                stdin.setRawMode(false);
+            }
+            stdin.pause();
+        };
+        const sigintHandler = () => {
+            onSignal("SIGINT");
+        };
+        const sigtermHandler = () => {
+            onSignal("SIGTERM");
+        };
+        stdin.on("data", onStdinData);
+        stdout.on("resize", onSigwinch);
+        process.on("SIGINT", sigintHandler);
+        process.on("SIGTERM", sigtermHandler);
+        process.nextTick(() => {
+            try {
+                (0, client_1.sendForegroundTerminalInput)(target, "");
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+async function runForegroundPtyRuntime(input) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Foreground PTY mode requires an interactive TTY. Run this command in a real terminal.");
+    }
+    input.printBanner("run", "Starting foreground PTY runtime");
+    process.stdout.write(`Using env: ${input.envPath}\n`);
+    process.stdout.write("Mode: client + built-in PTY\n\n");
+    const handle = await createForegroundBroker(input.envPath, input.packageRoot);
+    try {
+        const session = await ensureForegroundPtySession(handle.runtime);
+        await handle.broker
+            .call("telegramMcp.gatewaySocket.refreshClientHello")
+            .catch((error) => {
+            handle.runtime.logger.warn("Foreground PTY hello refresh failed", {
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                sessionId: session.sessionId,
+            });
+        });
+        process.stdout.write(`Attached session: ${session.sessionLabel} (${session.sessionId})\n`);
+        process.stdout.write(`Terminal target: ${session.target}\n\n`);
+        const exitCode = await attachCurrentTerminalToPty(handle.runtime, session.target);
+        await handle.broker.stop();
+        (0, client_1.stopAllForegroundTerminals)();
+        process.exit(exitCode);
+    }
+    catch (error) {
+        (0, client_1.stopAllForegroundTerminals)();
+        await handle.broker.stop().catch(() => undefined);
+        throw error;
+    }
+}