@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/src/shared/integrations/redis/stateStore.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStateStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const storage_redis_1 = require("@grammyjs/storage-redis");
+const redactSecrets_1 = require("../../lib/redact-secrets/redactSecrets");
+const KEY_PREFIX = "telegram-mcp";
+function sessionKey(sessionId) {
+    return `${KEY_PREFIX}:session:${sessionId}`;
+}
+function bindingKey(sessionId) {
+    return `${KEY_PREFIX}:binding:${sessionId}`;
+}
+function pairCodeKey(code) {
+    return `${KEY_PREFIX}:pair-code:${code}`;
+}
+function requestKey(requestId) {
+    return `${KEY_PREFIX}:request:${requestId}`;
+}
+function principalSessionsKey(principal) {
+    return `${KEY_PREFIX}:principal:${principal.telegramChatId}:${principal.telegramUserId}:sessions`;
+}
+function principalActiveSessionKey(principal) {
+    return `${KEY_PREFIX}:principal:${principal.telegramChatId}:${principal.telegramUserId}:active-session`;
+}
+function principalActiveSessionMatchPattern(telegramUserId) {
+    return `${KEY_PREFIX}:principal:*:${telegramUserId}:active-session`;
+}
+function inboxListKey(sessionId) {
+    return `${KEY_PREFIX}:inbox:${sessionId}`;
+}
+function inboxMessageKey(sessionId, messageId) {
+    return `${KEY_PREFIX}:inbox-message:${sessionId}:${messageId}`;
+}
+function menuPayloadKey(key) {
+    return `${KEY_PREFIX}:menu-payload:${key}`;
+}
+function gatewayClientUuidKey() {
+    return `${KEY_PREFIX}:gateway:client-uuid`;
+}
+function outgoingDeliveryNoticeKey(deliveryUuid) {
+    return `${KEY_PREFIX}:gateway:outgoing-delivery:${deliveryUuid}`;
+}
+function projectMenuViewStateKey(projectUuid, sessionId) {
+    return `${KEY_PREFIX}:project-menu-view:${projectUuid}:${sessionId}`;
+}
+function xchangeFileMetaKey(sessionId, filePath) {
+    const fingerprint = (0, node_crypto_1.createHash)("sha1").update(filePath).digest("hex");
+    return `${KEY_PREFIX}:xchange-file:${sessionId}:${fingerprint}`;
+}
+function activeRequestKey() {
+    return `${KEY_PREFIX}:pending:active`;
+}
+function queueKey() {
+    return `${KEY_PREFIX}:pending:queue`;
+}
+function parseJson(raw) {
+    if (!raw) {
+        return null;
+    }
+    return JSON.parse(raw);
+}
+class RedisStateStore {
+    redis;
+    sessionAdapter;
+    constructor(redis) {
+        this.redis = redis;
+        this.sessionAdapter = new storage_redis_1.RedisAdapter({ instance: redis });
+    }
+    async getSession(sessionId) {
+        const session = await this.sessionAdapter.read(sessionKey(sessionId));
+        return session ?? null;
+    }
+    async listSessions() {
+        const sessions = [];
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", `${KEY_PREFIX}:session:*`, "COUNT", 100);
+            cursor = nextCursor;
+            if (keys.length === 0) {
+                continue;
+            }
+            const rows = await this.redis.mget(...keys);
+            for (const row of rows) {
+                const session = parseJson(row);
+                if (session) {
+                    sessions.push(session);
+                }
+            }
+        } while (cursor !== "0");
+        return sessions;
+    }
+    async setSession(session) {
+        await this.sessionAdapter.write(sessionKey(session.sessionId), session);
+    }
+    async clearSession(sessionId) {
+        await this.unlinkPartnerSession(sessionId);
+        await this.clearInboxMessages(sessionId);
+        await this.clearXchangeFileMetas(sessionId);
+        await this.clearProjectMenuViewStates(sessionId);
+        await this.clearOutgoingDeliveryNoticesForSession(sessionId);
+        await this.sessionAdapter.delete(sessionKey(sessionId));
+    }
+    async createPairCode(record, ttlSeconds) {
+        const result = await this.redis.set(pairCodeKey(record.code), JSON.stringify(record), "EX", ttlSeconds, "NX");
+        return result === "OK";
+    }
+    async consumePairCode(code) {
+        const raw = await this.redis.getdel(pairCodeKey(code));
+        return parseJson(raw);
+    }
+    async getBinding(sessionId) {
+        const raw = await this.redis.get(bindingKey(sessionId));
+        return parseJson(raw);
+    }
+    async setBinding(binding) {
+        const previous = await this.getBinding(binding.sessionId);
+        if (previous &&
+            (previous.telegramChatId !== binding.telegramChatId ||
+                previous.telegramUserId !== binding.telegramUserId)) {
+            await this.detachSessionFromPrincipal(previous, binding.sessionId);
+        }
+        await this.redis.set(bindingKey(binding.sessionId), JSON.stringify(binding));
+        await this.redis.sadd(principalSessionsKey(binding), binding.sessionId);
+        await this.redis.set(principalActiveSessionKey(binding), binding.sessionId);
+    }
+    async clearBinding(sessionId) {
+        await this.unlinkPartnerSession(sessionId);
+        const existing = await this.getBinding(sessionId);
+        await this.redis.del(bindingKey(sessionId));
+        if (existing) {
+            await this.detachSessionFromPrincipal(existing, sessionId);
+        }
+    }
+    async getActiveSessionIdForPrincipal(principal) {
+        return (await this.redis.get(principalActiveSessionKey(principal))) ?? null;
+    }
+    async getActiveSessionIdForTelegramUser(telegramUserId) {
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", principalActiveSessionMatchPattern(telegramUserId), "COUNT", 50);
+            cursor = nextCursor;
+            if (keys.length === 0) {
+                continue;
+            }
+            for (const key of keys) {
+                const sessionId = await this.redis.get(key);
+                if (sessionId) {
+                    return sessionId;
+                }
+            }
+        } while (cursor !== "0");
+        return null;
+    }
+    async setActiveSessionIdForPrincipal(principal, sessionId) {
+        const isBound = await this.redis.sismember(principalSessionsKey(principal), sessionId);
+        if (!isBound) {
+            await this.redis.sadd(principalSessionsKey(principal), sessionId);
+        }
+        await this.redis.set(principalActiveSessionKey(principal), sessionId);
+    }
+    async listBoundSessionIdsForPrincipal(principal) {
+        return this.redis.smembers(principalSessionsKey(principal));
+    }
+    async resetRuntimeState() {
+        await this.redis.del(activeRequestKey());
+        await this.redis.del(queueKey());
+    }
+    async getActive() {
+        const activeId = await this.redis.get(activeRequestKey());
+        if (!activeId) {
+            return null;
+        }
+        const raw = await this.redis.get(requestKey(activeId));
+        return parseJson(raw);
+    }
+    async createPending(request) {
+        await this.redis.set(activeRequestKey(), request.requestId);
+        await this.redis.set(requestKey(request.requestId), JSON.stringify(request));
+    }
+    async updatePending(request) {
+        await this.redis.set(requestKey(request.requestId), JSON.stringify(request));
+    }
+    async resolvePending(requestId, resolution) {
+        const raw = await this.redis.get(requestKey(requestId));
+        const current = parseJson(raw);
+        if (!current) {
+            await this.redis.del(activeRequestKey());
+            return;
+        }
+        const next = {
+            ...current,
+            status: resolution.status,
+            ...(resolution.answer
+                ? { answer: (0, redactSecrets_1.redactSecrets)(resolution.answer) }
+                : {}),
+            ...(resolution.receivedAt ? { receivedAt: resolution.receivedAt } : {}),
+            ...(resolution.fallbackUsed
+                ? { fallbackIfTimeout: resolution.fallbackUsed }
+                : {}),
+        };
+        await this.redis.set(requestKey(requestId), JSON.stringify(next));
+        await this.redis.del(activeRequestKey());
+    }
+    async enqueue(request) {
+        await this.redis.set(requestKey(request.requestId), JSON.stringify(request));
+        await this.redis.rpush(queueKey(), request.requestId);
+    }
+    async dequeueNext() {
+        const requestId = await this.redis.lpop(queueKey());
+        if (!requestId) {
+            return null;
+        }
+        const raw = await this.redis.get(requestKey(requestId));
+        return parseJson(raw);
+    }
+    async createInboxMessage(message) {
+        await this.redis.set(inboxMessageKey(message.sessionId, message.id), JSON.stringify(message));
+        await this.redis.lpush(inboxListKey(message.sessionId), message.id);
+    }
+    async listInboxMessages(sessionId, limit) {
+        const ids = await this.redis.lrange(inboxListKey(sessionId), 0, limit - 1);
+        if (ids.length === 0) {
+            return [];
+        }
+        const rows = await this.redis.mget(...ids.map((messageId) => inboxMessageKey(sessionId, messageId)));
+        return rows
+            .map((row) => parseJson(row))
+            .filter((row) => row !== null);
+    }
+    async countInboxMessages(sessionId) {
+        return this.redis.llen(inboxListKey(sessionId));
+    }
+    async getInboxMessage(sessionId, messageId) {
+        const raw = await this.redis.get(inboxMessageKey(sessionId, messageId));
+        return parseJson(raw);
+    }
+    async deleteInboxMessage(sessionId, messageId) {
+        const deletedCount = await this.redis.del(inboxMessageKey(sessionId, messageId));
+        await this.redis.lrem(inboxListKey(sessionId), 0, messageId);
+        return deletedCount > 0;
+    }
+    async createMenuPayload(record, ttlSeconds) {
+        await this.redis.set(menuPayloadKey(record.key), JSON.stringify(record), "EX", ttlSeconds);
+    }
+    async getMenuPayload(key) {
+        const raw = await this.redis.get(menuPayloadKey(key));
+        return parseJson(raw);
+    }
+    async setXchangeFileMeta(meta) {
+        await this.redis.set(xchangeFileMetaKey(meta.sessionId, meta.filePath), JSON.stringify(meta));
+    }
+    async listXchangeFileMetas(sessionId) {
+        const records = [];
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", `${KEY_PREFIX}:xchange-file:${sessionId}:*`, "COUNT", 200);
+            cursor = nextCursor;
+            if (keys.length === 0) {
+                continue;
+            }
+            const rows = await this.redis.mget(...keys);
+            for (const row of rows) {
+                const meta = parseJson(row);
+                if (meta) {
+                    records.push(meta);
+                }
+            }
+        } while (cursor !== "0");
+        return records.sort((left, right) => right.uploadedAt.localeCompare(left.uploadedAt));
+    }
+    async getXchangeFileMeta(sessionId, filePath) {
+        const raw = await this.redis.get(xchangeFileMetaKey(sessionId, filePath));
+        return parseJson(raw);
+    }
+    async deleteXchangeFileMeta(sessionId, filePath) {
+        const deletedCount = await this.redis.del(xchangeFileMetaKey(sessionId, filePath));
+        return deletedCount > 0;
+    }
+    async pruneAll() {
+        let cursor = "0";
+        let deletedKeys = 0;
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", `${KEY_PREFIX}:*`, "COUNT", 200);
+            cursor = nextCursor;
+            if (keys.length === 0) {
+                continue;
+            }
+            deletedKeys += await this.redis.del(...keys);
+        } while (cursor !== "0");
+        return { deletedKeys };
+    }
+    async getGatewayClientUuid() {
+        return (await this.redis.get(gatewayClientUuidKey())) ?? null;
+    }
+    async setGatewayClientUuid(clientUuid) {
+        await this.redis.set(gatewayClientUuidKey(), clientUuid);
+    }
+    async setProjectMenuViewState(state) {
+        await this.redis.set(projectMenuViewStateKey(state.projectUuid, state.sessionId), JSON.stringify(state));
+    }
+    async listProjectMenuViewStates(projectUuid) {
+        const states = [];
+        let cursor = "0";
+        const pattern = `${KEY_PREFIX}:project-menu-view:${projectUuid}:*`;
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+            cursor = nextCursor;
+            if (keys.length === 0) {
+                continue;
+            }
+            const rows = await this.redis.mget(...keys);
+            for (const row of rows) {
+                const state = parseJson(row);
+                if (state) {
+                    states.push(state);
+                }
+            }
+        } while (cursor !== "0");
+        return states;
+    }
+    async deleteProjectMenuViewState(sessionId, projectUuid) {
+        return ((await this.redis.del(projectMenuViewStateKey(projectUuid, sessionId))) > 0);
+    }
+    async setOutgoingDeliveryNotice(notice) {
+        await this.redis.set(outgoingDeliveryNoticeKey(notice.deliveryUuid), JSON.stringify(notice));
+    }
+    async listOutgoingDeliveryNotices() {
+        const notices = [];
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", `${KEY_PREFIX}:gateway:outgoing-delivery:*`, "COUNT", 100);
+            cursor = nextCursor;
+            if (keys.length === 0) {
+                continue;
+            }
+            const rows = await this.redis.mget(...keys);
+            for (const row of rows) {
+                const notice = parseJson(row);
+                if (notice) {
+                    notices.push(notice);
+                }
+            }
+        } while (cursor !== "0");
+        return notices;
+    }
+    async deleteOutgoingDeliveryNotice(deliveryUuid) {
+        const deleted = await this.redis.del(outgoingDeliveryNoticeKey(deliveryUuid));
+        return deleted > 0;
+    }
+    async detachSessionFromPrincipal(principal, sessionId) {
+        const sessionsKey = principalSessionsKey(principal);
+        const activeKey = principalActiveSessionKey(principal);
+        await this.redis.srem(sessionsKey, sessionId);
+        const activeSessionId = await this.redis.get(activeKey);
+        if (activeSessionId !== sessionId) {
+            return;
+        }
+        const remaining = await this.redis.smembers(sessionsKey);
+        const nextSessionId = remaining[0];
+        if (nextSessionId) {
+            await this.redis.set(activeKey, nextSessionId);
+            return;
+        }
+        await this.redis.del(activeKey);
+    }
+    async unlinkPartnerSession(sessionId) {
+        const sourceSession = await this.getSession(sessionId);
+        if (!sourceSession?.linkedSessionId) {
+            return;
+        }
+        const { linkedSessionId: partnerId } = sourceSession;
+        const { linkedSessionId: _linkedSessionId, ...restSource } = sourceSession;
+        await this.setSession({
+            ...restSource,
+            updatedAt: new Date().toISOString(),
+        });
+        const partnerSession = await this.getSession(partnerId);
+        if (!partnerSession || partnerSession.linkedSessionId !== sessionId) {
+            return;
+        }
+        const { linkedSessionId: _partnerLinkedSessionId, ...restPartner } = partnerSession;
+        await this.setSession({
+            ...restPartner,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    async clearInboxMessages(sessionId) {
+        const listKey = inboxListKey(sessionId);
+        const messageKeys = [];
+        let cursor = "0";
+        const pattern = `${KEY_PREFIX}:inbox-message:${sessionId}:*`;
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 200);
+            cursor = nextCursor;
+            messageKeys.push(...keys);
+        } while (cursor !== "0");
+        if (messageKeys.length > 0) {
+            await this.redis.del(...messageKeys);
+        }
+        await this.redis.del(listKey);
+    }
+    async clearXchangeFileMetas(sessionId) {
+        let cursor = "0";
+        const pattern = `${KEY_PREFIX}:xchange-file:${sessionId}:*`;
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 200);
+            cursor = nextCursor;
+            if (keys.length > 0) {
+                await this.redis.del(...keys);
+            }
+        } while (cursor !== "0");
+    }
+    async clearProjectMenuViewStates(sessionId) {
+        let cursor = "0";
+        const pattern = `${KEY_PREFIX}:project-menu-view:*:${sessionId}`;
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+            cursor = nextCursor;
+            if (keys.length > 0) {
+                await this.redis.del(...keys);
+            }
+        } while (cursor !== "0");
+    }
+    async clearOutgoingDeliveryNoticesForSession(sessionId) {
+        const notices = await this.listOutgoingDeliveryNotices();
+        const deliveryUuids = notices
+            .filter((item) => item.sessionId === sessionId)
+            .map((item) => item.deliveryUuid);
+        if (deliveryUuids.length === 0) {
+            return;
+        }
+        await this.redis.del(...deliveryUuids.map((deliveryUuid) => outgoingDeliveryNoticeKey(deliveryUuid)));
+    }
+}
+exports.RedisStateStore = RedisStateStore;

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/collabSemantics.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExecutorTargetKind = isExecutorTargetKind;
+exports.getCollabRouteSemantics = getCollabRouteSemantics;
+function isExecutorTargetKind(kind) {
+    return kind === "question" || kind === "request";
+}
+function getCollabRouteSemantics(input) {
+    const executesOnTarget = isExecutorTargetKind(input.kind);
+    return executesOnTarget
+        ? {
+            executesOnTarget,
+            route: `${input.targetLabel} -> ${input.sourceLabel}`,
+            expectedReplyRoute: `${input.targetLabel} -> ${input.sourceLabel}`,
+        }
+        : {
+            executesOnTarget,
+            route: `${input.sourceLabel} -> ${input.targetLabel}`,
+            sendRoute: `${input.sourceLabel} -> ${input.targetLabel}`,
+        };
+}

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/collabUi.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectMemberDetailText = buildProjectMemberDetailText;
+exports.buildPartnerNotePromptText = buildPartnerNotePromptText;
+const collabSemantics_1 = require("./collabSemantics");
+function buildProjectMemberDetailText(input) {
+    const askSemantics = (0, collabSemantics_1.getCollabRouteSemantics)({
+        kind: "question",
+        sourceLabel: input.sourceLabel,
+        targetLabel: input.targetLabel,
+    });
+    const shareSemantics = (0, collabSemantics_1.getCollabRouteSemantics)({
+        kind: "share",
+        sourceLabel: input.sourceLabel,
+        targetLabel: input.targetLabel,
+    });
+    return [
+        "🤝 Сессия проекта",
+        "",
+        `Проект: ${input.projectName}`,
+        `Текущая сессия: ${input.sourceLabel}`,
+        `Исполнитель: ${input.targetLabel}`,
+        `Ask: ${askSemantics.route}`,
+        `Share: ${shareSemantics.route}`,
+        "Live: по подтверждению выбранной сессии",
+        "",
+        "Выбери тип действия для этой пары сессий.",
+    ].join("\n");
+}
+function buildPartnerNotePromptText(input) {
+    const semantics = (0, collabSemantics_1.getCollabRouteSemantics)({
+        kind: input.kind,
+        sourceLabel: input.sourceLabel,
+        targetLabel: input.targetLabel,
+    });
+    const executesOnTarget = semantics.executesOnTarget;
+    const kindLabel = input.kind === "question"
+        ? input.isProjectTarget
+            ? "Вопрос участнику"
+            : "Вопрос напарнику"
+        : input.kind === "reply"
+            ? input.isProjectTarget
+                ? "Ответ участнику"
+                : "Ответ напарнику"
+            : input.kind === "handoff"
+                ? input.isProjectTarget
+                    ? "Передача участнику"
+                    : "Передача напарнику"
+                : input.isProjectTarget
+                    ? "Поделиться с участником"
+                    : "Поделиться обновлением";
+    return {
+        kindLabel,
+        text: [
+            `🤝 ${kindLabel}`,
+            "",
+            `Текущая сессия: ${input.sourceLabel}`,
+            executesOnTarget
+                ? input.isProjectTarget
+                    ? `Исполнитель: ${input.targetLabel}`
+                    : `Напарник: ${input.targetLabel}`
+                : input.isProjectTarget
+                    ? `Получатель: ${input.targetLabel}`
+                    : `Напарник: ${input.targetLabel}`,
+            executesOnTarget
+                ? `Ожидаемый ответ: ${semantics.expectedReplyRoute}`
+                : `Маршрут отправки: ${semantics.sendRoute}`,
+            "",
+            executesOnTarget
+                ? "Отправь следующим сообщением задачу для выбранной сессии."
+                : "Отправь следующим сообщением, чем текущая сессия должна поделиться.",
+            executesOnTarget
+                ? input.isProjectTarget
+                    ? "Агент выбранной сессии получит задачу и сможет отправить результат обратно в текущую сессию проекта."
+                    : "Агент напарника получит задачу и сможет отправить результат обратно в текущую сессию."
+                : input.isProjectTarget
+                    ? "Агент текущей сессии получит задачу и сам отправит результат в выбранную сессию проекта."
+                    : "Агент текущей сессии получит задачу и сам отправит результат напарнику.",
+            "Формат:",
+            "1. Первая строка = короткое summary",
+            "2. Пустая строка опциональна",
+            "3. Остальной текст = основное сообщение",
+            "",
+            "Команды вроде /menu или /help отменят этот режим.",
+        ].join("\n"),
+    };
+}

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/messageFormat.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTelegramMessage = formatTelegramMessage;
+exports.formatTelegramNotification = formatTelegramNotification;
+function renderList(items) {
+    return items.map((item, index) => `${index + 1}. ${item}`).join("\n");
+}
+function renderFiles(files) {
+    return files.map((item) => `- ${item}`).join("\n");
+}
+function compactMetaLine(input) {
+    const parts = [];
+    if (input.task) {
+        parts.push(`Task: ${input.task}`);
+    }
+    if (input.riskLevel && input.riskLevel !== "low") {
+        parts.push(`Risk: ${input.riskLevel}`);
+    }
+    return parts.length > 0 ? parts.join(" | ") : null;
+}
+function formatTelegramMessage(input, _limits) {
+    const question = input.question;
+    const context = input.context;
+    const metaLine = compactMetaLine({
+        ...(input.task ? { task: input.task } : {}),
+        ...(input.riskLevel ? { riskLevel: input.riskLevel } : {}),
+    });
+    const sections = [
+        input.sessionLabel ?? input.sessionId,
+        ...(metaLine ? ["", metaLine] : []),
+        "",
+        question,
+        ...(context ? ["", context] : []),
+        ...(input.affectedFiles?.length
+            ? ["", "Files:", renderFiles(input.affectedFiles)]
+            : []),
+        ...(input.options?.length
+            ? ["", "Options:", renderList(input.options)]
+            : []),
+        ...(input.recommendedOption
+            ? ["", `Recommended: ${input.recommendedOption}`]
+            : []),
+        ...(input.fallbackIfTimeout
+            ? ["", `Fallback if no answer: ${input.fallbackIfTimeout}`]
+            : []),
+        "",
+        "Reply to this message.",
+    ];
+    return sections.join("\n");
+}
+function formatTelegramNotification(input, _limits) {
+    const context = input.context;
+    const message = input.message;
+    return [
+        input.sessionLabel ?? input.sessionId,
+        "",
+        message,
+        ...(context ? ["", context] : []),
+    ].join("\n");
+}

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/proxyFetch.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTelegramFetch = createTelegramFetch;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const https_proxy_agent_1 = require("https-proxy-agent");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+function maskProxyUrl(rawUrl) {
+    try {
+        const url = new URL(rawUrl);
+        if (url.username) {
+            url.username = "[REDACTED]";
+        }
+        if (url.password) {
+            url.password = "[REDACTED]";
+        }
+        return url.toString();
+    }
+    catch {
+        return "[INVALID_PROXY_URL]";
+    }
+}
+function createTelegramFetch(config, logger) {
+    if (!config.telegram.proxy) {
+        logger.debug("Telegram proxy disabled");
+        return globalThis.fetch.bind(globalThis);
+    }
+    const agent = config.telegram.proxy.type === "http"
+        ? new https_proxy_agent_1.HttpsProxyAgent(config.telegram.proxy.url)
+        : new socks_proxy_agent_1.SocksProxyAgent(config.telegram.proxy.url);
+    logger.info("Telegram proxy configured", {
+        proxyType: config.telegram.proxy.type,
+        proxyUrl: maskProxyUrl(config.telegram.proxy.url),
+    });
+    const proxiedFetch = async (...args) => {
+        const [input, init] = args;
+        const requestInit = {
+            ...(init ? init : {}),
+            agent,
+        };
+        return (0, node_fetch_1.default)(input, requestInit);
+    };
+    return proxiedFetch;
+}