@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/src/app/webapp/auth.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAppSessionRegistry = exports.WebAppLaunchRegistry = void 0;
+exports.validateTelegramWebAppInitData = validateTelegramWebAppInitData;
+const node_crypto_1 = require("node:crypto");
+class WebAppLaunchRegistry {
+    launches = new Map();
+    set(telegramUserId, sessionId, ttlSeconds, details) {
+        this.cleanupExpired();
+        const nowMs = Date.now();
+        const record = {
+            telegramUserId,
+            sessionId,
+            ...(details?.telegramChatId !== undefined
+                ? { telegramChatId: details.telegramChatId }
+                : {}),
+            ...(details?.telegramMessageId !== undefined
+                ? { telegramMessageId: details.telegramMessageId }
+                : {}),
+            expiresAtMs: nowMs + ttlSeconds * 1000,
+            createdAtMs: nowMs,
+        };
+        this.launches.set(telegramUserId, record);
+        return record;
+    }
+    getByUserId(telegramUserId) {
+        this.cleanupExpired();
+        const record = this.launches.get(telegramUserId);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= Date.now()) {
+            this.launches.delete(telegramUserId);
+            return null;
+        }
+        return record;
+    }
+    deleteByUserId(telegramUserId) {
+        this.launches.delete(telegramUserId);
+    }
+    cleanupExpired() {
+        const nowMs = Date.now();
+        for (const [telegramUserId, record] of this.launches.entries()) {
+            if (record.expiresAtMs <= nowMs) {
+                this.launches.delete(telegramUserId);
+            }
+        }
+    }
+}
+exports.WebAppLaunchRegistry = WebAppLaunchRegistry;
+class WebAppSessionRegistry {
+    sessions = new Map();
+    create(sessionId, telegramUserId, ttlSeconds) {
+        this.cleanupExpired();
+        const nowMs = Date.now();
+        const record = {
+            token: (0, node_crypto_1.randomUUID)(),
+            sessionId,
+            telegramUserId,
+            expiresAtMs: nowMs + ttlSeconds * 1000,
+            createdAtMs: nowMs,
+            lastActionAtMs: 0,
+        };
+        this.sessions.set(record.token, record);
+        return record;
+    }
+    get(token) {
+        this.cleanupExpired();
+        const record = this.sessions.get(token);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= Date.now()) {
+            this.sessions.delete(token);
+            return null;
+        }
+        return record;
+    }
+    touchAction(token, nowMs) {
+        const record = this.sessions.get(token);
+        if (!record) {
+            return;
+        }
+        this.sessions.set(token, {
+            ...record,
+            lastActionAtMs: nowMs,
+        });
+    }
+    cleanupExpired() {
+        const nowMs = Date.now();
+        for (const [token, record] of this.sessions.entries()) {
+            if (record.expiresAtMs <= nowMs) {
+                this.sessions.delete(token);
+            }
+        }
+    }
+}
+exports.WebAppSessionRegistry = WebAppSessionRegistry;
+function normalizeTelegramWebAppInitData(rawInitData) {
+    let normalized = rawInitData.trim();
+    if (normalized.startsWith("#")) {
+        normalized = normalized.slice(1);
+    }
+    if (normalized.startsWith("tgWebAppData=")) {
+        normalized = normalized.slice("tgWebAppData=".length);
+    }
+    const extraMarkers = [
+        "&tgWebAppVersion=",
+        "&tgWebAppPlatform=",
+        "&tgWebAppThemeParams=",
+    ];
+    let cutIndex = -1;
+    for (const marker of extraMarkers) {
+        const markerIndex = normalized.indexOf(marker);
+        if (markerIndex >= 0 && (cutIndex < 0 || markerIndex < cutIndex)) {
+            cutIndex = markerIndex;
+        }
+    }
+    if (cutIndex >= 0) {
+        normalized = normalized.slice(0, cutIndex);
+    }
+    return normalized.trim();
+}
+function normalizeUnsafeUser(user) {
+    if (!user || typeof user !== "object" || typeof user.id !== "number") {
+        return null;
+    }
+    return {
+        id: user.id,
+        ...(typeof user.first_name === "string" ? { first_name: user.first_name } : {}),
+        ...(typeof user.last_name === "string" ? { last_name: user.last_name } : {}),
+        ...(typeof user.username === "string" ? { username: user.username } : {}),
+        ...(typeof user.language_code === "string"
+            ? { language_code: user.language_code }
+            : {}),
+        ...(typeof user.photo_url === "string" ? { photo_url: user.photo_url } : {}),
+    };
+}
+function buildOfficialRawValidation(rawInitData, botToken) {
+    const params = new URLSearchParams(rawInitData);
+    const receivedHash = params.get("hash");
+    if (!receivedHash) {
+        return null;
+    }
+    const checkString = [...params.entries()]
+        .filter(([key, value]) => key !== "hash" && value !== undefined)
+        .sort((left, right) => left[0].localeCompare(right[0]))
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n");
+    const secretKey = (0, node_crypto_1.createHmac)("sha256", "WebAppData")
+        .update(botToken.trim())
+        .digest();
+    const computed = (0, node_crypto_1.createHmac)("sha256", secretKey)
+        .update(checkString)
+        .digest("hex");
+    const matches = computed.length === receivedHash.length &&
+        (0, node_crypto_1.timingSafeEqual)(Buffer.from(computed, "utf8"), Buffer.from(receivedHash, "utf8"));
+    return {
+        checkString,
+        computedHash: computed,
+        providedHash: receivedHash,
+        matches,
+    };
+}
+function buildUserFieldsValidation(unsafe, botToken) {
+    if (!unsafe) {
+        return null;
+    }
+    const user = normalizeUnsafeUser(unsafe.user);
+    const authDateValue = typeof unsafe.auth_date === "number" || typeof unsafe.auth_date === "string"
+        ? unsafe.auth_date
+        : undefined;
+    const receivedHash = typeof unsafe.hash === "string" && unsafe.hash.length > 0
+        ? unsafe.hash
+        : undefined;
+    if (!user || authDateValue === undefined || !receivedHash) {
+        return null;
+    }
+    const params = {
+        id: user.id,
+        first_name: user.first_name,
+        last_name: user.last_name,
+        username: user.username,
+        photo_url: user.photo_url,
+        auth_date: authDateValue,
+    };
+    const checkString = Object.keys(params)
+        .sort()
+        .filter((key) => params[key] !== undefined)
+        .map((key) => `${key}=${params[key]}`)
+        .join("\n");
+    const secretKey = (0, node_crypto_1.createHash)("sha256")
+        .update(botToken.trim())
+        .digest();
+    const computed = (0, node_crypto_1.createHmac)("sha256", secretKey)
+        .update(checkString)
+        .digest("hex");
+    const matches = computed.length === receivedHash.length &&
+        (0, node_crypto_1.timingSafeEqual)(Buffer.from(computed, "utf8"), Buffer.from(receivedHash, "utf8"));
+    return {
+        checkString,
+        computedHash: computed,
+        providedHash: receivedHash,
+        matches,
+    };
+}
+function validateTelegramWebAppInitData(rawInitData, unsafeInitData, botToken, maxAgeSeconds) {
+    const normalizedRaw = rawInitData
+        ? normalizeTelegramWebAppInitData(rawInitData)
+        : "";
+    const normalizedUnsafe = unsafeInitData ?? null;
+    if (!normalizedRaw && !normalizedUnsafe) {
+        throw new Error("Telegram WebApp initData is empty.");
+    }
+    const officialRawValidation = buildOfficialRawValidation(normalizedRaw, botToken);
+    const userFieldsValidation = buildUserFieldsValidation(normalizedUnsafe, botToken);
+    if (!officialRawValidation?.matches && !userFieldsValidation?.matches) {
+        throw new Error("Telegram WebApp initData hash validation failed.");
+    }
+    if (!normalizedUnsafe) {
+        throw new Error("Telegram WebApp unsafe init data is missing.");
+    }
+    const user = normalizeUnsafeUser(normalizedUnsafe.user);
+    const authDateRaw = typeof normalizedUnsafe.auth_date === "number" ||
+        typeof normalizedUnsafe.auth_date === "string"
+        ? String(normalizedUnsafe.auth_date)
+        : null;
+    if (!authDateRaw || !user) {
+        throw new Error("Telegram WebApp initData is missing auth_date or user.");
+    }
+    const authDate = Number.parseInt(authDateRaw, 10);
+    if (!Number.isFinite(authDate) || authDate <= 0) {
+        throw new Error("Telegram WebApp auth_date is invalid.");
+    }
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    if (nowSeconds - authDate > maxAgeSeconds) {
+        throw new Error("Telegram WebApp initData is expired.");
+    }
+    return {
+        user,
+        authDate,
+        rawInitData: normalizedRaw,
+        ...(typeof normalizedUnsafe.query_id === "string"
+            ? { queryId: normalizedUnsafe.query_id }
+            : {}),
+        ...(typeof normalizedUnsafe.start_param === "string"
+            ? { startParam: normalizedUnsafe.start_param }
+            : {}),
+        validationDebug: {
+            providedHash: officialRawValidation?.providedHash ??
+                userFieldsValidation?.providedHash ??
+                "",
+            officialRaw: {
+                checkString: officialRawValidation?.checkString ?? "",
+                computedHash: officialRawValidation?.computedHash ?? "",
+                matches: officialRawValidation?.matches ?? false,
+            },
+            userFields: userFieldsValidation
+                ? {
+                    checkString: userFieldsValidation.checkString,
+                    computedHash: userFieldsValidation.computedHash,
+                    matches: userFieldsValidation.matches,
+                }
+                : null,
+        },
+    };
+}

package/dist/services/features/telegram-mcp/src/app/webapp/relay.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIVE_RELAY_SESSION_PREFIX = void 0;
+exports.buildLiveRelaySessionId = buildLiveRelaySessionId;
+exports.parseLiveRelaySessionId = parseLiveRelaySessionId;
+exports.resolveGatewayWebAppBaseUrl = resolveGatewayWebAppBaseUrl;
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/u, "");
+}
+function normalizeBasePath(value) {
+    const trimmed = trimTrailingSlashes(value.trim());
+    if (!trimmed) {
+        return "/";
+    }
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+exports.LIVE_RELAY_SESSION_PREFIX = "relay~";
+function buildLiveRelaySessionId(clientUuid, localSessionId, sourceClientUuid) {
+    return `${exports.LIVE_RELAY_SESSION_PREFIX}${clientUuid}~${encodeURIComponent(localSessionId)}${sourceClientUuid ? `~${sourceClientUuid}` : ""}`;
+}
+function parseLiveRelaySessionId(value) {
+    if (!value || !value.startsWith(exports.LIVE_RELAY_SESSION_PREFIX)) {
+        return null;
+    }
+    const payload = value.slice(exports.LIVE_RELAY_SESSION_PREFIX.length);
+    const parts = payload.split("~");
+    if (parts.length < 2) {
+        return null;
+    }
+    const clientUuid = (parts[0] ?? "").trim();
+    const encodedSessionId = (parts[1] ?? "").trim();
+    const sourceClientUuid = (parts[2] ?? "").trim();
+    if (!clientUuid || !encodedSessionId) {
+        return null;
+    }
+    try {
+        const localSessionId = decodeURIComponent(encodedSessionId);
+        return localSessionId
+            ? {
+                clientUuid,
+                localSessionId,
+                ...(sourceClientUuid ? { sourceClientUuid } : {}),
+            }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveGatewayWebAppBaseUrl(gatewayPublicUrl, webAppBasePath) {
+    const rootPrefix = normalizeBasePath(process.env.ROOT_PREFIX || "/api");
+    const normalizedWebAppBasePath = normalizeBasePath(webAppBasePath || "/webapp");
+    const expectedPath = rootPrefix === "/"
+        ? normalizedWebAppBasePath
+        : `${rootPrefix}${normalizedWebAppBasePath}`;
+    const url = new URL(gatewayPublicUrl);
+    url.pathname = trimTrailingSlashes(url.pathname);
+    if (url.pathname.endsWith("/gateway")) {
+        url.pathname = url.pathname.slice(0, -"/gateway".length) || "/";
+    }
+    const currentPath = normalizeBasePath(url.pathname || "/");
+    if (currentPath === "/" || currentPath === rootPrefix) {
+        url.pathname = expectedPath;
+    }
+    else {
+        url.pathname = `${trimTrailingSlashes(currentPath)}${normalizedWebAppBasePath}`.replace(/\/{2,}/gu, "/");
+    }
+    return trimTrailingSlashes(url.toString());
+}

package/dist/services/features/telegram-mcp/src/app/webapp/tmux.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendAllowedTmuxAction = exports.isTmuxUnavailableError = exports.getTmuxWindowHeight = exports.captureVisibleTmuxPane = exports.captureTmuxPaneRange = void 0;
+var client_1 = require("../../shared/integrations/tmux/client");
+Object.defineProperty(exports, "captureTmuxPaneRange", { enumerable: true, get: function () { return client_1.captureTmuxPaneRange; } });
+Object.defineProperty(exports, "captureVisibleTmuxPane", { enumerable: true, get: function () { return client_1.captureVisibleTmuxPane; } });
+Object.defineProperty(exports, "getTmuxWindowHeight", { enumerable: true, get: function () { return client_1.getTmuxWindowHeight; } });
+Object.defineProperty(exports, "isTmuxUnavailableError", { enumerable: true, get: function () { return client_1.isTmuxUnavailableError; } });
+Object.defineProperty(exports, "sendAllowedTmuxAction", { enumerable: true, get: function () { return client_1.sendAllowedTmuxAction; } });

package/dist/services/features/telegram-mcp/src/entities/auth/model/types.js

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

package/dist/services/features/telegram-mcp/src/entities/browser/model/types.js

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

package/dist/services/features/telegram-mcp/src/entities/collaboration/model/types.js

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

package/dist/services/features/telegram-mcp/src/entities/inbox/model/types.js

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