@deadragdoll/tellymcp 0.0.1

package/dist/cli.js

@@ -0,0 +1,636 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_net_1 = __importDefault(require("node:net"));
+const dotenv_1 = require("dotenv");
+const picocolors_1 = __importDefault(require("picocolors"));
+const ws_1 = __importDefault(require("ws"));
+const distDir = __dirname;
+const packageRoot = node_path_1.default.resolve(distDir, "..");
+function getTmuxStatus() {
+    const result = (0, node_child_process_1.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 printBanner(title, subtitle) {
+    process.stdout.write(`${picocolors_1.default.bold(picocolors_1.default.cyan("TellyMCP"))} ${picocolors_1.default.dim(title)}\n`);
+    if (subtitle) {
+        process.stdout.write(`${picocolors_1.default.dim(subtitle)}\n`);
+    }
+    process.stdout.write("\n");
+}
+function printSection(title, lines) {
+    process.stdout.write(`${picocolors_1.default.bold(title)}\n`);
+    for (const line of lines) {
+        process.stdout.write(`${line}\n`);
+    }
+    process.stdout.write("\n");
+}
+function getTmuxInstallHints() {
+    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 printHelp() {
+    const tmux = getTmuxStatus();
+    printBanner("CLI", "Telegram Human-in-the-Loop MCP server");
+    printSection("Usage", [
+        "  tellymcp init <client|gateway|both> [directory]",
+        "  tellymcp run [--env <file>]",
+        "  tellymcp run --env=<file>",
+        "  tellymcp doctor [--env <file>]",
+        "  tellymcp mcp [--url <url>] [--bearer <token>] [--format claude|legacy]",
+        "  tellymcp help",
+    ]);
+    printSection("Examples", [
+        "  tellymcp init client",
+        "  tellymcp init gateway ./gateway-node",
+        "  tellymcp run",
+        "  tellymcp run --env .env.client",
+        "  tellymcp doctor --env .env.client",
+        "  tellymcp mcp --help",
+    ]);
+    if (tmux.found) {
+        printSection("tmux", [
+            `${picocolors_1.default.green("  OK")} ${tmux.version}`,
+            "  Live view and session nudges are available.",
+        ]);
+    }
+    else {
+        printSection("tmux", [
+            `${picocolors_1.default.yellow("  WARN")} tmux was not found on this system.`,
+            "  TellyMCP will still run, but Live view and nudges will be limited.",
+            "  Install examples:",
+            ...getTmuxInstallHints().map((line) => `    ${line}`),
+        ]);
+    }
+}
+function printMcpHelp() {
+    printBanner("MCP helper", "Prints JSON snippets for Claude, Codex, and other MCP clients");
+    printSection("Usage", [
+        "  tellymcp mcp --help",
+        "  tellymcp mcp --url <url>",
+        "  tellymcp mcp --url <url> --bearer <token>",
+        "  tellymcp mcp --url <url> --format legacy",
+    ]);
+    printSection("What this command does", [
+        "  It prints a config snippet.",
+        "  It does not register MCP in your agent automatically.",
+        "  Copy the printed JSON into your agent's MCP config.",
+    ]);
+    printSection("What you need", [
+        "  1. tmux must be installed on the machine where tellymcp runs.",
+        "  2. Your MCP endpoint depends on mode:",
+        "     - client/local: http://127.0.0.1:8787/mcp",
+        "     - gateway/both behind nginx: https://your-host.example/api/mcp",
+    ]);
+    printSection("Claude / modern streamable-http example", [
+        "{",
+        '  "mcpServers": {',
+        '    "telegramHuman": {',
+        '      "transport": {',
+        '        "type": "streamable-http",',
+        '        "url": "https://builder.undoo.ru/api/mcp"',
+        "      }",
+        "    }",
+        "  }",
+        "}",
+    ]);
+    printSection("Legacy example", [
+        "{",
+        '  "mcpServers": {',
+        '    "telegramHuman": {',
+        '      "type": "streamable-http",',
+        '      "url": "https://builder.undoo.ru/api/mcp"',
+        "    }",
+        "  }",
+        "}",
+    ]);
+    printSection("With bearer token", [
+        "{",
+        '  "mcpServers": {',
+        '    "telegramHuman": {',
+        '      "transport": {',
+        '        "type": "streamable-http",',
+        '        "url": "https://builder.undoo.ru/api/mcp",',
+        '        "headers": {',
+        '          "Authorization": "Bearer YOUR_TOKEN"',
+        "        }",
+        "      }",
+        "    }",
+        "  }",
+        "}",
+    ]);
+    printSection("Examples", [
+        "  tellymcp mcp --url https://builder.undoo.ru/api/mcp",
+        "  tellymcp mcp --url https://builder.undoo.ru/api/mcp --bearer YOUR_TOKEN",
+        "  tellymcp mcp --url https://builder.undoo.ru/api/mcp --format legacy",
+    ]);
+}
+function fail(message) {
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+}
+function ensureMode(value) {
+    if (value === "client" || value === "gateway" || value === "both") {
+        return value;
+    }
+    fail("Mode must be one of: client, gateway, both.");
+}
+function loadTemplate(mode) {
+    const templateName = mode === "client"
+        ? "env.client.template"
+        : mode === "gateway"
+            ? "env.gateway.template"
+            : "env.both.template";
+    const templatePath = node_path_1.default.join(packageRoot, templateName);
+    const nestedTemplatePath = node_path_1.default.join(packageRoot, "config", "templates", templateName);
+    const resolvedTemplatePath = (0, node_fs_1.existsSync)(templatePath) ? templatePath : nestedTemplatePath;
+    if (!(0, node_fs_1.existsSync)(resolvedTemplatePath)) {
+        fail(`Missing packaged template: ${templateName}`);
+    }
+    return (0, node_fs_1.readFileSync)(resolvedTemplatePath, "utf8");
+}
+function initWorkspace(mode, directoryArg) {
+    const targetDir = node_path_1.default.resolve(directoryArg ?? process.cwd());
+    (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
+    const envPath = node_path_1.default.join(targetDir, ".env");
+    if ((0, node_fs_1.existsSync)(envPath)) {
+        fail(`Refusing to overwrite existing ${envPath}`);
+    }
+    const template = loadTemplate(mode);
+    (0, node_fs_1.writeFileSync)(envPath, template, "utf8");
+    for (const subdir of ["logs", "data", "artifacts"]) {
+        (0, node_fs_1.mkdirSync)(node_path_1.default.join(targetDir, subdir), { recursive: true });
+    }
+    printBanner("workspace initialized");
+    printSection("Created", [
+        `  ${envPath}`,
+        `  ${node_path_1.default.join(targetDir, "logs")}`,
+        `  ${node_path_1.default.join(targetDir, "data")}`,
+        `  ${node_path_1.default.join(targetDir, "artifacts")}`,
+    ]);
+    printSection("Next", [
+        "  1. Edit .env",
+        `  2. cd ${targetDir}`,
+        "  3. tellymcp run",
+    ]);
+}
+function resolveRunEnvPath(args) {
+    const [firstArg, secondArg] = args;
+    if (firstArg?.startsWith("--env=")) {
+        const value = firstArg.slice("--env=".length).trim();
+        if (!value) {
+            fail("Expected a file path after --env=");
+        }
+        return node_path_1.default.resolve(process.cwd(), value);
+    }
+    if (firstArg === "--env") {
+        if (!secondArg?.trim()) {
+            fail("Expected a file path after --env");
+        }
+        return node_path_1.default.resolve(process.cwd(), secondArg);
+    }
+    return node_path_1.default.resolve(process.cwd(), ".env");
+}
+function joinUrlPath(left, right) {
+    const normalizedLeft = left.endsWith("/") ? left.slice(0, -1) : left;
+    const normalizedRight = right.startsWith("/") ? right : `/${right}`;
+    return `${normalizedLeft}${normalizedRight}`.replace(/\/{2,}/gu, "/");
+}
+function deriveGatewayHealthUrlFromPublicUrl(rawUrl) {
+    try {
+        const url = new URL(rawUrl);
+        const pathname = url.pathname.replace(/\/+$/u, "");
+        if (pathname.endsWith("/gateway")) {
+            url.pathname = `${pathname.slice(0, -"/gateway".length) || ""}/healthz`;
+            return url.toString();
+        }
+        if (pathname.endsWith("/webapp")) {
+            url.pathname = `${pathname.slice(0, -"/webapp".length) || ""}/healthz`;
+            return url.toString();
+        }
+        if (pathname.endsWith("/mcp")) {
+            url.pathname = `${pathname.slice(0, -"/mcp".length) || ""}/healthz`;
+            return url.toString();
+        }
+        url.pathname = joinUrlPath(pathname || "/", "/healthz");
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function readFlagValue(args, flagName) {
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === flagName) {
+            const next = args[index + 1]?.trim();
+            if (!next) {
+                fail(`Expected a value after ${flagName}`);
+            }
+            return next;
+        }
+        if (value?.startsWith(`${flagName}=`)) {
+            const inlineValue = value.slice(flagName.length + 1).trim();
+            if (!inlineValue) {
+                fail(`Expected a value after ${flagName}=`);
+            }
+            return inlineValue;
+        }
+    }
+    return null;
+}
+function printMcpConfig(args) {
+    if (args.length === 0 ||
+        args.includes("--help") ||
+        args.includes("-h")) {
+        printMcpHelp();
+        return;
+    }
+    const url = readFlagValue(args, "--url");
+    if (!url) {
+        fail("Missing --url <mcp-endpoint>. Run 'tellymcp mcp --help' for examples.");
+    }
+    const bearer = readFlagValue(args, "--bearer");
+    const format = (readFlagValue(args, "--format") ?? "claude").toLowerCase();
+    if (format !== "claude" && format !== "legacy") {
+        fail("Supported --format values: claude, legacy.");
+    }
+    const config = format === "legacy"
+        ? {
+            mcpServers: {
+                telegramHuman: {
+                    type: "streamable-http",
+                    url,
+                    ...(bearer
+                        ? {
+                            headers: {
+                                Authorization: `Bearer ${bearer}`,
+                            },
+                        }
+                        : {}),
+                },
+            },
+        }
+        : {
+            mcpServers: {
+                telegramHuman: {
+                    transport: {
+                        type: "streamable-http",
+                        url,
+                        ...(bearer
+                            ? {
+                                headers: {
+                                    Authorization: `Bearer ${bearer}`,
+                                },
+                            }
+                            : {}),
+                    },
+                },
+            },
+        };
+    process.stdout.write(`${JSON.stringify(config, null, 2)}\n`);
+}
+async function checkTcpPort(host, port, timeoutMs = 2000) {
+    return await new Promise((resolve) => {
+        const socket = node_net_1.default.connect({ host, port });
+        const finish = (ok, message) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve({ ok, message });
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => finish(true, `${host}:${port} is reachable`));
+        socket.once("timeout", () => finish(false, `${host}:${port} timed out`));
+        socket.once("error", (error) => {
+            finish(false, `${host}:${port} failed: ${error.code ?? error.message}`);
+        });
+    });
+}
+async function checkHttpHealth(url, timeoutMs = 3000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        return {
+            ok: response.ok,
+            message: `${url} returned ${response.status}`,
+        };
+    }
+    catch (error) {
+        clearTimeout(timer);
+        return {
+            ok: false,
+            message: `${url} failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function checkWebSocketUrl(url, timeoutMs = 3000) {
+    return await new Promise((resolve) => {
+        let settled = false;
+        let opened = false;
+        const finish = (ok, message) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            socket.removeAllListeners();
+            try {
+                socket.close();
+            }
+            catch {
+                // ignore
+            }
+            resolve({ ok, message });
+        };
+        const socket = new ws_1.default(url);
+        const timer = setTimeout(() => {
+            finish(false, `${url} timed out`);
+        }, timeoutMs);
+        socket.once("open", () => {
+            opened = true;
+            finish(true, `${url} accepted a WebSocket connection`);
+        });
+        socket.once("unexpected-response", (_req, response) => {
+            finish(false, `${url} returned HTTP ${response.statusCode ?? "unknown"} during WebSocket upgrade`);
+        });
+        socket.once("error", (error) => {
+            finish(false, `${url} failed: ${error.message}`);
+        });
+        socket.once("close", (code) => {
+            if (!opened) {
+                finish(false, `${url} closed before open (code ${code})`);
+            }
+        });
+    });
+}
+async function runDoctor(args) {
+    const envPath = resolveRunEnvPath(args);
+    const tmux = getTmuxStatus();
+    printBanner("doctor", "Local installation diagnostics");
+    if (tmux.found) {
+        printSection("tmux", [
+            `${picocolors_1.default.green("  OK")} ${tmux.version}`,
+            "  Live view and session nudges should work.",
+        ]);
+    }
+    else {
+        printSection("tmux", [
+            `${picocolors_1.default.yellow("  WARN")} tmux was not found.`,
+            "  TellyMCP will still run, but Live view and nudges will be limited.",
+            "  Install examples:",
+            ...getTmuxInstallHints().map((line) => `    ${line}`),
+        ]);
+    }
+    if (!(0, node_fs_1.existsSync)(envPath)) {
+        printSection("env", [
+            `${picocolors_1.default.red("  ERROR")} Missing env file: ${envPath}`,
+            "  Run 'tellymcp init client' or pass --env <file>.",
+        ]);
+        return;
+    }
+    const envContent = (0, node_fs_1.readFileSync)(envPath, "utf8");
+    const parsed = (0, dotenv_1.parse)(envContent);
+    const mode = (parsed.DISTRIBUTED_MODE || "client").trim();
+    const httpHost = (parsed.MCP_HTTP_HOST || "0.0.0.0").trim();
+    const httpPort = mode === "gateway" || mode === "both"
+        ? (parsed.PORT || parsed.MCP_HTTP_PORT || "8080").trim()
+        : (parsed.MCP_HTTP_PORT || "8787").trim();
+    const rootPrefix = mode === "gateway" || mode === "both"
+        ? (parsed.ROOT_PREFIX || "/api").trim()
+        : "";
+    const mcpPath = (parsed.MCP_HTTP_PATH || "/mcp").trim();
+    const webappPath = (parsed.WEBAPP_BASE_PATH || "/webapp").trim();
+    const mcpUrlPath = mode === "gateway" || mode === "both"
+        ? joinUrlPath(rootPrefix, mcpPath)
+        : mcpPath;
+    const webappUrlPath = mode === "gateway" || mode === "both"
+        ? joinUrlPath(rootPrefix, webappPath)
+        : webappPath;
+    const healthUrlPath = mode === "gateway" || mode === "both"
+        ? joinUrlPath(rootPrefix, "/healthz")
+        : "/healthz";
+    const publicGatewayUrl = parsed.GATEWAY_PUBLIC_URL?.trim();
+    const gatewayWsUrl = parsed.GATEWAY_WS_URL?.trim();
+    const publicWebappUrl = parsed.WEBAPP_PUBLIC_URL?.trim();
+    const mcpBearerToken = parsed.MCP_HTTP_BEARER_TOKEN?.trim();
+    const externalHealthUrl = deriveGatewayHealthUrlFromPublicUrl(publicGatewayUrl || "") ??
+        deriveGatewayHealthUrlFromPublicUrl(publicWebappUrl || "");
+    printSection("env", [
+        `${picocolors_1.default.green("  OK")} ${envPath}`,
+        `  mode: ${mode}`,
+        `  bind: http://${httpHost}:${httpPort}`,
+        `  mcp:  http://${httpHost}:${httpPort}${mcpUrlPath}`,
+        `  web:  http://${httpHost}:${httpPort}${webappUrlPath}`,
+        `  mcp auth: ${mcpBearerToken ? "bearer token required" : "disabled"}`,
+        ...(publicGatewayUrl ? [`  public gateway: ${publicGatewayUrl}`] : []),
+        ...(gatewayWsUrl ? [`  public ws:      ${gatewayWsUrl}`] : []),
+        ...(publicWebappUrl ? [`  public web:     ${publicWebappUrl}`] : []),
+        ...(externalHealthUrl ? [`  public health:  ${externalHealthUrl}`] : []),
+    ]);
+    const checks = [];
+    const capabilities = [];
+    const redisHost = (parsed.REDIS_HOST || "127.0.0.1").trim();
+    const redisPort = Number(parsed.REDIS_PORT || 6379);
+    const redisCheck = await checkTcpPort(redisHost, redisPort);
+    checks.push(`${redisCheck.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} redis: ${redisCheck.message}`);
+    if (mode === "client") {
+        const gatewayPublicUrl = parsed.GATEWAY_PUBLIC_URL?.trim();
+        if (gatewayPublicUrl) {
+            const gatewayHealth = await checkHttpHealth(`${gatewayPublicUrl.replace(/\/+$/u, "")}/healthz`);
+            checks.push(`${gatewayHealth.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} gateway: ${gatewayHealth.message}`);
+            capabilities.push(`${gatewayHealth.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} remote collaboration API: ${gatewayHealth.ok ? "available" : "unavailable"}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} gateway: GATEWAY_PUBLIC_URL is empty`);
+            capabilities.push(`${picocolors_1.default.yellow("  WARN")} remote collaboration API: not configured`);
+        }
+        if (gatewayWsUrl) {
+            const gatewayWs = await checkWebSocketUrl(gatewayWsUrl);
+            checks.push(`${gatewayWs.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} gateway ws: ${gatewayWs.message}`);
+            capabilities.push(`${gatewayWs.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} remote live relay: ${gatewayWs.ok ? "available" : "unavailable"}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} gateway ws: GATEWAY_WS_URL is empty`);
+            capabilities.push(`${picocolors_1.default.yellow("  WARN")} remote live relay: not configured`);
+        }
+        if (publicWebappUrl) {
+            const publicWebapp = await checkHttpHealth(publicWebappUrl);
+            checks.push(`${publicWebapp.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public webapp: ${publicWebapp.message}`);
+            capabilities.push(`${publicWebapp.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} remote webapp launcher: ${publicWebapp.ok ? "available" : "unavailable"}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} public webapp: WEBAPP_PUBLIC_URL is empty`);
+            capabilities.push(`${picocolors_1.default.yellow("  WARN")} remote webapp launcher: not configured`);
+        }
+    }
+    if (mode === "gateway" || mode === "both") {
+        const localHealth = await checkHttpHealth(`http://${httpHost}:${httpPort}${healthUrlPath}`);
+        checks.push(`${localHealth.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.yellow("  WARN")} local healthz: ${localHealth.message}`);
+        capabilities.push(`${localHealth.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} local gateway api: ${localHealth.ok ? "available" : "unavailable"}`);
+        if (externalHealthUrl) {
+            const externalHealth = await checkHttpHealth(externalHealthUrl);
+            checks.push(`${externalHealth.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public healthz: ${externalHealth.message}`);
+            capabilities.push(`${externalHealth.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public gateway api: ${externalHealth.ok ? "available" : "unavailable"}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} public healthz: no public gateway/webapp URL is configured`);
+            capabilities.push(`${picocolors_1.default.yellow("  WARN")} public gateway api: not configured`);
+        }
+        if (gatewayWsUrl) {
+            const gatewayWs = await checkWebSocketUrl(gatewayWsUrl);
+            checks.push(`${gatewayWs.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public ws: ${gatewayWs.message}`);
+            capabilities.push(`${gatewayWs.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public live relay: ${gatewayWs.ok ? "available" : "unavailable"}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} public ws: GATEWAY_WS_URL is empty`);
+            capabilities.push(`${picocolors_1.default.yellow("  WARN")} public live relay: not configured`);
+        }
+        if (publicWebappUrl) {
+            const publicWebapp = await checkHttpHealth(publicWebappUrl);
+            checks.push(`${publicWebapp.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public webapp: ${publicWebapp.message}`);
+            capabilities.push(`${publicWebapp.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} public webapp launcher: ${publicWebapp.ok ? "available" : "unavailable"}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} public webapp: WEBAPP_PUBLIC_URL is empty`);
+            capabilities.push(`${picocolors_1.default.yellow("  WARN")} public webapp launcher: not configured`);
+        }
+        const dbHost = parsed.DB_HOST?.trim();
+        if (dbHost) {
+            const dbPort = Number(parsed.DB_PORT || 5432);
+            const dbCheck = await checkTcpPort(dbHost, dbPort);
+            checks.push(`${dbCheck.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} postgres: ${dbCheck.message}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.yellow("  WARN")} postgres: DB_HOST is empty`);
+        }
+        const rmqHost = parsed.RMQ_HOST?.trim();
+        if (rmqHost) {
+            const rmqPort = Number(parsed.RMQ_PORT || 5672);
+            const rmqCheck = await checkTcpPort(rmqHost, rmqPort);
+            checks.push(`${rmqCheck.ok ? picocolors_1.default.green("  OK") : picocolors_1.default.red("  ERROR")} rmq: ${rmqCheck.message}`);
+        }
+        else {
+            checks.push(`${picocolors_1.default.dim("  SKIP")} rmq: RMQ_HOST is not configured`);
+        }
+    }
+    printSection("capabilities", capabilities);
+    printSection("checks", checks);
+    const notes = [];
+    if (!parsed.TELEGRAM_BOT_TOKEN?.trim()) {
+        notes.push(`${picocolors_1.default.yellow("  WARN")} TELEGRAM_BOT_TOKEN is empty`);
+    }
+    if (mcpBearerToken) {
+        notes.push(`${picocolors_1.default.yellow("  WARN")} MCP_HTTP_BEARER_TOKEN is set. MCP clients must send Authorization: Bearer <token>.`);
+    }
+    if ((mode === "gateway" || mode === "both") && !parsed.ROOT_PREFIX?.trim()) {
+        notes.push(`${picocolors_1.default.yellow("  WARN")} ROOT_PREFIX is not set, default /api will be used`);
+    }
+    if ((mode === "gateway" || mode === "both") && !parsed.PORT?.trim()) {
+        notes.push(`${picocolors_1.default.yellow("  WARN")} PORT is not set, default bind port will be used`);
+    }
+    if (notes.length > 0) {
+        printSection("notes", notes);
+    }
+    else {
+        printSection("notes", [`${picocolors_1.default.green("  OK")} No obvious local config issues detected.`]);
+    }
+}
+function runRuntime(args) {
+    const envPath = resolveRunEnvPath(args);
+    if (!(0, node_fs_1.existsSync)(envPath)) {
+        fail(`Missing ${envPath}. Run 'tellymcp init <client|gateway|both>' first or pass --env <file>.`);
+    }
+    const runnerPath = node_path_1.default.join(packageRoot, "node_modules", "moleculer", "bin", "moleculer-runner.js");
+    const configPath = node_path_1.default.join(packageRoot, "dist", "moleculer.config.js");
+    const servicesPath = node_path_1.default.join(packageRoot, "dist", "services");
+    if (!(0, node_fs_1.existsSync)(runnerPath)) {
+        fail(`Missing bundled runner: ${runnerPath}`);
+    }
+    if (!(0, node_fs_1.existsSync)(configPath)) {
+        fail(`Missing compiled config: ${configPath}`);
+    }
+    if (!(0, node_fs_1.existsSync)(servicesPath)) {
+        fail(`Missing compiled services: ${servicesPath}`);
+    }
+    const tmux = getTmuxStatus();
+    if (tmux.found) {
+        process.stdout.write(`${picocolors_1.default.green("tmux detected:")} ${tmux.version}\n`);
+    }
+    else {
+        process.stdout.write(`${picocolors_1.default.yellow("tmux not found.")} Live view and nudges may be limited.\n`);
+    }
+    process.stdout.write(`${picocolors_1.default.cyan("Using env:")} ${envPath}\n\n`);
+    const child = (0, node_child_process_1.spawn)(process.execPath, [
+        runnerPath,
+        servicesPath,
+        "--config",
+        configPath,
+        "--mask",
+        "**/*.service.js",
+    ], {
+        cwd: process.cwd(),
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            ENV_FILE: envPath,
+            TELLYMCP_STANDALONE_HTTP: "true",
+        },
+    });
+    child.on("exit", (code, signal) => {
+        if (signal) {
+            process.kill(process.pid, signal);
+            return;
+        }
+        process.exit(code ?? 0);
+    });
+}
+async function main(argv) {
+    const [rawCommand, firstArg, secondArg] = argv;
+    const command = rawCommand === "init" || rawCommand === "run" || rawCommand === "help" || rawCommand === "mcp" || rawCommand === "doctor"
+        ? rawCommand
+        : "help";
+    if (command === "help" || !rawCommand || rawCommand === "--help" || rawCommand === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "init") {
+        initWorkspace(ensureMode(firstArg), secondArg);
+        return;
+    }
+    if (command === "mcp") {
+        printMcpConfig(argv.slice(1));
+        return;
+    }
+    if (command === "doctor") {
+        await runDoctor(argv.slice(1));
+        return;
+    }
+    runRuntime(argv.slice(1));
+}
+void main(process.argv.slice(2));

package/dist/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/moleculer"), exports);