@deadragdoll/tellymcp 0.0.1

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

@@ -0,0 +1,124 @@
+"use strict";
+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.parseProtocolVersion = parseProtocolVersion;
+exports.evaluateVersionCompatibility = evaluateVersionCompatibility;
+exports.findPackageRoot = findPackageRoot;
+exports.getTellyMcpPackageVersion = getTellyMcpPackageVersion;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+exports.TELLYMCP_PROTOCOL_VERSION = "1.0";
+exports.TELLYMCP_CAPABILITIES = [
+    "collab_projects",
+    "delivery_status_push",
+    "live_approval",
+    "live_relay",
+    "send_partner_file",
+    "tools_sync",
+    "version_handshake",
+];
+function parseProtocolVersion(value) {
+    if (!value?.trim()) {
+        return null;
+    }
+    const match = value.trim().match(/^(\d+)\.(\d+)$/u);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+    };
+}
+function mergeCompatibility(current, next) {
+    if (current === "reject" || next === "reject") {
+        return "reject";
+    }
+    if (current === "warn" || next === "warn") {
+        return "warn";
+    }
+    return "ok";
+}
+function evaluateVersionCompatibility(input) {
+    const reasons = [];
+    let compatibility = "ok";
+    const clientProtocol = parseProtocolVersion(input.clientProtocolVersion);
+    const gatewayProtocol = parseProtocolVersion(input.gatewayProtocolVersion);
+    if (!gatewayProtocol) {
+        return {
+            compatibility: "reject",
+            reasons: ["Gateway protocol version is invalid."],
+        };
+    }
+    if (!clientProtocol) {
+        return {
+            compatibility: "reject",
+            reasons: ["Client protocol version is missing or invalid."],
+        };
+    }
+    if (clientProtocol.major !== gatewayProtocol.major) {
+        return {
+            compatibility: "reject",
+            reasons: [
+                `Protocol major mismatch: client ${input.clientProtocolVersion} vs gateway ${input.gatewayProtocolVersion}.`,
+            ],
+        };
+    }
+    if (clientProtocol.minor !== gatewayProtocol.minor) {
+        compatibility = mergeCompatibility(compatibility, "warn");
+        reasons.push(`Protocol minor mismatch: client ${input.clientProtocolVersion} vs gateway ${input.gatewayProtocolVersion}.`);
+    }
+    if (!input.clientPackageVersion?.trim()) {
+        compatibility = mergeCompatibility(compatibility, "warn");
+        reasons.push("Client package version is missing.");
+    }
+    else if (input.clientPackageVersion.trim() !== input.gatewayPackageVersion.trim()) {
+        compatibility = mergeCompatibility(compatibility, "warn");
+        reasons.push(`Package version mismatch: client ${input.clientPackageVersion.trim()} vs gateway ${input.gatewayPackageVersion.trim()}.`);
+    }
+    return { compatibility, reasons };
+}
+function findPackageRoot(startDir) {
+    let currentDir = node_path_1.default.resolve(startDir);
+    while (true) {
+        const packageJsonPath = node_path_1.default.join(currentDir, "package.json");
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+                if (parsed.name === "@deadragdoll/tellymcp") {
+                    return currentDir;
+                }
+            }
+            catch {
+                // ignore malformed package.json while walking upward
+            }
+        }
+        const parentDir = node_path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+let cachedPackageVersion = null;
+function getTellyMcpPackageVersion(startDir) {
+    if (cachedPackageVersion) {
+        return cachedPackageVersion;
+    }
+    const packageRoot = findPackageRoot(startDir);
+    if (!packageRoot) {
+        return "0.0.0-unknown";
+    }
+    try {
+        const packageJsonPath = node_path_1.default.join(packageRoot, "package.json");
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+        cachedPackageVersion = parsed.version?.trim() || "0.0.0-unknown";
+        return cachedPackageVersion;
+    }
+    catch {
+        return "0.0.0-unknown";
+    }
+}

package/dist/services/features/telegram-mcp/src/shared/types/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_STANDALONE_HTTP_SERVICE_NAME = void 0;
+const node_http_1 = require("node:http");
+const mcp_http_service_1 = require("./mcp-http.service");
+const runtime_service_1 = require("./runtime.service");
+exports.TELEGRAM_MCP_STANDALONE_HTTP_SERVICE_NAME = "telegramMcp.standaloneHttp";
+function resolveStandaloneBind(runtime) {
+    const mode = runtime.config.distributed.mode;
+    const publicRootPrefix = process.env.ROOT_PREFIX || "/api";
+    if (mode === "gateway" || mode === "both") {
+        const port = Number(process.env.PORT ?? runtime.config.mcp.httpPort);
+        return {
+            host: runtime.config.mcp.httpHost,
+            port,
+            publicRootPrefix,
+        };
+    }
+    return {
+        host: runtime.config.mcp.httpHost,
+        port: runtime.config.mcp.httpPort,
+        publicRootPrefix: "/",
+    };
+}
+const TelegramMcpStandaloneHttpService = {
+    name: exports.TELEGRAM_MCP_STANDALONE_HTTP_SERVICE_NAME,
+    dependencies: [
+        runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME,
+        mcp_http_service_1.TELEGRAM_MCP_HTTP_SERVICE_NAME,
+    ],
+    created() {
+        this.httpServer = null;
+    },
+    async started() {
+        if (process.env.TELLYMCP_STANDALONE_HTTP === "false") {
+            return;
+        }
+        await this.broker.waitForServices([
+            runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME,
+            mcp_http_service_1.TELEGRAM_MCP_HTTP_SERVICE_NAME,
+        ]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        const httpService = this.broker.getLocalService(mcp_http_service_1.TELEGRAM_MCP_HTTP_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        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 { host, port, publicRootPrefix } = resolveStandaloneBind(runtime);
+        this.httpServer = (0, node_http_1.createServer)(async (req, res) => {
+            try {
+                const requestUrl = new URL(req.url ?? "/", "http://standalone.local");
+                await httpService.routeRequest?.(req, res, requestUrl.pathname);
+            }
+            catch (error) {
+                this.logger.error("Standalone HTTP request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                    res.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                if (!res.writableEnded) {
+                    res.end("Internal Server Error");
+                }
+            }
+        });
+        await new Promise((resolve, reject) => {
+            const server = this.httpServer;
+            if (!server) {
+                reject(new Error("Standalone HTTP server was not created"));
+                return;
+            }
+            server.once("error", reject);
+            server.listen(port, host, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+        this.logger.info("telegram_mcp standalone HTTP server is ready", {
+            host,
+            port,
+            mode: runtime.config.distributed.mode,
+            rootPrefix: publicRootPrefix,
+            mcpPath: publicRootPrefix === "/"
+                ? runtime.config.mcp.httpPath
+                : `${publicRootPrefix}${runtime.config.mcp.httpPath}`,
+            webappBasePath: publicRootPrefix === "/"
+                ? runtime.config.webapp.basePath
+                : `${publicRootPrefix}${runtime.config.webapp.basePath}`,
+            gatewayPath: publicRootPrefix === "/" ? "/gateway" : `${publicRootPrefix}/gateway`,
+        });
+    },
+    async stopped() {
+        const server = this.httpServer;
+        this.httpServer = null;
+        if (!server) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    },
+};
+exports.default = TelegramMcpStandaloneHttpService;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+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],
+    created() {
+        this.refreshToolsMarkdownService = null;
+    },
+    methods: {
+        getRefreshToolsMarkdownService() {
+            if (!this.refreshToolsMarkdownService) {
+                throw new Error("telegram_mcp tools sync service is not initialized yet");
+            }
+            return this.refreshToolsMarkdownService;
+        },
+    },
+    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 = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp tools sync service");
+        this.refreshToolsMarkdownService = new refreshToolsMarkdownService_1.RefreshToolsMarkdownService(runtime.config, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp tools sync service is ready");
+    },
+};
+exports.default = TelegramMcpToolsSyncService;

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@deadragdoll/tellymcp",
+  "version": "0.0.1",
+  "description": "TellyMCP - Telegram Human-in-the-Loop MCP Server",
+  "main": "dist/services/features/telegram-mcp/runtime.service.js",
+  "bin": {
+    "tellymcp": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "config/templates",
+    "README.md",
+    "README-ru.md",
+    "STANDALONE.md",
+    "STANDALONE-ru.md",
+    "CHANGELOG.md",
+    "TOOLS.md",
+    ".env.example.client",
+    ".env.example.gateway"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "telegram",
+    "mcp",
+    "human-in-the-loop",
+    "bot",
+    "agent"
+  ],
+  "_moduleAliases": {
+    "@src": "src"
+  },
+  "scripts": {
+    "postinstall": "node ./scripts/postinstall.js",
+    "mcp:local": "codex mcp add telegramHuman --url http://127.0.0.1:8787/mcp",
+    "dev:gw": "TS_NODE_TRANSPILE_ONLY=1 TS_NODE_EXPERIMENTAL_RESOLVER=1 NODE_OPTIONS=--openssl-legacy-provider ts-node ./node_modules/moleculer/bin/moleculer-runner.js src/services --config src/moleculer.config.ts --envfile ./.env-dev --hot --mask \"**/*.service.ts\"",
+    "dev:builder": "TS_NODE_TRANSPILE_ONLY=1 TS_NODE_EXPERIMENTAL_RESOLVER=1 NODE_OPTIONS=--openssl-legacy-provider ts-node ./node_modules/moleculer/bin/moleculer-runner.js src/services --config src/moleculer.config.ts --envfile ./.env-builder --hot --mask \"**/*.service.ts\"",
+    "dev:gw:telegram": "TS_NODE_TRANSPILE_ONLY=1 TS_NODE_EXPERIMENTAL_RESOLVER=1 NODE_OPTIONS=--openssl-legacy-provider ts-node ./node_modules/moleculer/bin/moleculer-runner.js src/services/features/telegram-mcp --config src/moleculer.config.ts --envfile ./.env-dev --hot --mask \"**/*.service.ts\"",
+    "dev:client": "TS_NODE_TRANSPILE_ONLY=1 TS_NODE_EXPERIMENTAL_RESOLVER=1 NODE_OPTIONS=--openssl-legacy-provider ts-node ./node_modules/moleculer/bin/moleculer-runner.js src/services --config src/moleculer.config.ts --envfile ./.env-client --hot --mask \"**/*.service.ts\"",
+    "dev": "yarn dev:gw",
+    "dev:watch": "yarn dev:gw",
+    "dev:service": "yarn dev:gw",
+    "build": "rm -rf dist && tsc -p tsconfig.json && tsc-alias -p tsconfig.json",
+    "start": "yarn start:gw",
+    "start:gw": "node ./node_modules/moleculer/bin/moleculer-runner.js dist/services --config dist/moleculer.config.js --mask \"**/*.service.js\"",
+    "start:gw:telegram": "node ./node_modules/moleculer/bin/moleculer-runner.js dist/services/features/telegram-mcp --config dist/moleculer.config.js --mask \"**/*.service.js\"",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/code4bones/tellymcp.git"
+  },
+  "homepage": "https://www.npmjs.com/package/@deadragdoll/tellymcp",
+  "bugs": {
+    "url": "https://github.com/code4bones/tellymcp/issues"
+  },
+  "author": "code4bones <code4bones@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@grammyjs/menu": "^1.3.1",
+    "@grammyjs/storage-redis": "^2.5.1",
+    "@modelcontextprotocol/sdk": "^1.18.1",
+    "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",
+    "mime-types": "^3.0.2",
+    "module-alias": "^2.3.4",
+    "moleculer": "0.15.0",
+    "node-fetch": "^3.3.2",
+    "pg": "^8.20.0",
+    "picocolors": "^1.1.1",
+    "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"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.34.0",
+    "@types/amqplib": "^0.10.8",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "24.12.4",
+    "eslint": "^9.34.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "globals": "^16.3.0",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.17",
+    "tsx": "4.22.1",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "8.59.3",
+    "vitest": "^4.1.6"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const pc = require("picocolors");
+
+function getTmuxStatus() {
+  const result = spawnSync("tmux", ["-V"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+
+  if (result.status === 0) {
+    return {
+      found: true,
+      version: (result.stdout || "tmux").trim(),
+    };
+  }
+
+  return { found: false };
+}
+
+function getInstallHints() {
+  if (process.platform === "darwin") {
+    return ["brew install tmux"];
+  }
+
+  return [
+    "Ubuntu/Debian: sudo apt install tmux",
+    "Fedora/RHEL:   sudo dnf install tmux",
+    "Arch:          sudo pacman -S tmux",
+  ];
+}
+
+function line(value = "") {
+  process.stdout.write(`${value}\n`);
+}
+
+const tmux = getTmuxStatus();
+
+line();
+line(`${pc.bold(pc.cyan("TellyMCP"))} ${pc.dim("installed")}`);
+line();
+
+if (tmux.found) {
+  line(`${pc.green("OK")} tmux detected: ${tmux.version}`);
+  line("Live view and session nudges should work on this machine.");
+} else {
+  line(`${pc.yellow("WARN")} tmux was not found on this system.`);
+  line("TellyMCP can still run, but Live view and nudges will be limited.");
+  line("Install tmux, for example:");
+  for (const hint of getInstallHints()) {
+    line(`  ${hint}`);
+  }
+}
+
+line();
+line(`Check your local setup: ${pc.bold("tellymcp doctor")}`);
+line(`General help: ${pc.bold("tellymcp help")}`);
+line(`MCP setup examples: ${pc.bold("tellymcp mcp --help")}`);
+line();