@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessLocalSessionStore = void 0;
+class ProcessLocalSessionStore {
+    sessions = new Map();
+    onClearSession;
+    constructor(input = {}) {
+        this.onClearSession = input.onClearSession;
+        for (const session of input.initialSessions ?? []) {
+            this.sessions.set(session.sessionId, session);
+        }
+    }
+    async getSession(sessionId) {
+        return this.sessions.get(sessionId) ?? null;
+    }
+    async listSessions() {
+        return Array.from(this.sessions.values()).sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+    }
+    async setSession(session) {
+        this.sessions.set(session.sessionId, session);
+    }
+    async clearSession(sessionId) {
+        this.sessions.delete(sessionId);
+        await this.onClearSession?.(sessionId);
+    }
+}
+exports.ProcessLocalSessionStore = ProcessLocalSessionStore;

package/dist/services/features/telegram-mcp/src/shared/integrations/object-storage/minioExchangeStore.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinioExchangeStore = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = require("node:fs/promises");
-const client_1 = require("../tmux/client");
+const client_1 = require("../terminal/client");
 function normalizeRelativePath(relativePath) {
     const normalized = relativePath
         .split(/[/\\]+/u)
@@ -18,21 +18,24 @@ function normalizeRelativePath(relativePath) {
     }
     return normalized;
 }
-function resolveWorkspaceDir(session, _tmuxConfig) {
+function resolveWorkspaceDir(session, _terminalConfig) {
     const workspaceDir = session?.cwd?.trim() || "";
-    return workspaceDir || process.cwd();
+    if (!workspaceDir) {
+        throw new Error("Workspace cwd is not registered for this console.");
+    }
+    return workspaceDir;
 }
 class MinioExchangeStore {
-    tmuxConfig;
+    terminalConfig;
     exchangeDirName;
     logger;
-    constructor(_callBroker, _bindingStore, tmuxConfig, exchangeDirName, _vfsScope, logger, _distributedMode = "client", _gatewayPublicUrl, _gatewayAuthToken) {
-        this.tmuxConfig = tmuxConfig;
+    constructor(_callBroker, _bindingStore, terminalConfig, exchangeDirName, _vfsScope, logger, _distributedMode = "client", _gatewayPublicUrl, _gatewayAuthToken) {
+        this.terminalConfig = terminalConfig;
         this.exchangeDirName = exchangeDirName;
         this.logger = logger;
     }
     resolveWorkspaceDir(session) {
-        return resolveWorkspaceDir(session, this.tmuxConfig);
+        return resolveWorkspaceDir(session, this.terminalConfig);
     }
     getTempSessionDir(sessionId) {
         return node_path_1.default.resolve(process.cwd(), this.exchangeDirName, "__legacy__", sessionId);
@@ -40,7 +43,7 @@ class MinioExchangeStore {
     async storeFile(params) {
         const relativePath = normalizeRelativePath(params.relativePath);
         const workspaceDir = this.resolveWorkspaceDir(params.session);
-        const filePath = await (0, client_1.writeXchangeRelativeFile)(this.tmuxConfig, workspaceDir, this.exchangeDirName, relativePath, Buffer.from(params.content));
+        const filePath = await (0, client_1.writeXchangeRelativeFile)(this.terminalConfig, workspaceDir, this.exchangeDirName, relativePath, Buffer.from(params.content));
         this.logger.info("Exchange file stored locally", {
             sessionId: params.sessionId,
             source: params.source,

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

@@ -26,11 +26,8 @@ function principalActiveSessionKey(principal) {
 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 bindingMatchPattern() {
+    return `${KEY_PREFIX}:binding:*`;
 }
 function menuPayloadKey(key) {
     return `${KEY_PREFIX}:menu-payload:${key}`;
@@ -38,6 +35,12 @@ function menuPayloadKey(key) {
 function userLocaleKey(telegramUserId) {
     return `${KEY_PREFIX}:user-locale:${telegramUserId}`;
 }
+function adminAuthorizedKey(principal) {
+    return `${KEY_PREFIX}:admin-auth:${principal.telegramChatId}:${principal.telegramUserId}`;
+}
+function adminAuthorizedMatchPattern() {
+    return `${KEY_PREFIX}:admin-auth:*:*`;
+}
 function gatewayClientUuidKey() {
     return `${KEY_PREFIX}:gateway:client-uuid`;
 }
@@ -97,8 +100,6 @@ class RedisStateStore {
         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);
@@ -122,6 +123,39 @@ class RedisStateStore {
     async setUserLocale(telegramUserId, locale) {
         await this.redis.set(userLocaleKey(telegramUserId), locale);
     }
+    async isAdminAuthorized(principal) {
+        return (await this.redis.get(adminAuthorizedKey(principal))) === "1";
+    }
+    async setAdminAuthorized(principal) {
+        await this.redis.set(adminAuthorizedKey(principal), "1");
+    }
+    async clearAdminAuthorized(principal) {
+        await this.redis.del(adminAuthorizedKey(principal));
+    }
+    async listAdminAuthorizedPrincipals() {
+        const principals = [];
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", adminAuthorizedMatchPattern(), "COUNT", 100);
+            cursor = nextCursor;
+            for (const key of keys) {
+                const match = key.match(/^telegram-mcp:admin-auth:(-?\d+):(-?\d+)$/u);
+                if (!match) {
+                    continue;
+                }
+                const telegramChatId = Number(match[1]);
+                const telegramUserId = Number(match[2]);
+                if (!Number.isFinite(telegramChatId) || !Number.isFinite(telegramUserId)) {
+                    continue;
+                }
+                principals.push({
+                    telegramChatId,
+                    telegramUserId,
+                });
+            }
+        } while (cursor !== "0");
+        return principals;
+    }
     async setBinding(binding) {
         const previous = await this.getBinding(binding.sessionId);
         if (previous &&
@@ -134,7 +168,6 @@ class RedisStateStore {
         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) {
@@ -161,6 +194,9 @@ class RedisStateStore {
         } while (cursor !== "0");
         return null;
     }
+    async clearActiveSessionIdForPrincipal(principal) {
+        await this.redis.del(principalActiveSessionKey(principal));
+    }
     async setActiveSessionIdForPrincipal(principal, sessionId) {
         const isBound = await this.redis.sismember(principalSessionsKey(principal), sessionId);
         if (!isBound) {
@@ -171,6 +207,31 @@ class RedisStateStore {
     async listBoundSessionIdsForPrincipal(principal) {
         return this.redis.smembers(principalSessionsKey(principal));
     }
+    async listBoundPrincipals() {
+        const principals = new Map();
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", bindingMatchPattern(), "COUNT", 100);
+            cursor = nextCursor;
+            for (const key of keys) {
+                const raw = await this.redis.get(key);
+                const binding = parseJson(raw);
+                if (!binding) {
+                    continue;
+                }
+                const telegramChatId = Number(binding.telegramChatId);
+                const telegramUserId = Number(binding.telegramUserId);
+                if (!Number.isFinite(telegramChatId) || !Number.isFinite(telegramUserId)) {
+                    continue;
+                }
+                principals.set(`${telegramChatId}:${telegramUserId}`, {
+                    telegramChatId,
+                    telegramUserId,
+                });
+            }
+        } while (cursor !== "0");
+        return Array.from(principals.values());
+    }
     async resetRuntimeState() {
         await this.redis.del(activeRequestKey());
         await this.redis.del(queueKey());
@@ -223,32 +284,6 @@ class RedisStateStore {
         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);
     }
@@ -373,42 +408,6 @@ class RedisStateStore {
         }
         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}:*`;

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

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTelegramBaseFetchConfig = createTelegramBaseFetchConfig;
 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) {
@@ -22,25 +19,27 @@ function maskProxyUrl(rawUrl) {
         return "[INVALID_PROXY_URL]";
     }
 }
-function createTelegramFetch(config, logger) {
-    if (!config.telegram.proxy) {
+function createTelegramBaseFetchConfig(config, logger) {
+    const agent = config.telegram.proxy
+        ? 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)
+        : undefined;
+    if (config.telegram.proxy) {
+        logger.info("Telegram proxy configured", {
+            proxyType: config.telegram.proxy.type,
+            proxyUrl: maskProxyUrl(config.telegram.proxy.url),
+        });
+    }
+    else {
         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),
+    return agent ? { agent } : {};
+}
+function createTelegramFetch(config, logger) {
+    const baseFetchConfig = createTelegramBaseFetchConfig(config, logger);
+    return async (input, init) => globalThis.fetch(input, {
+        ...baseFetchConfig,
+        ...(init ?? {}),
     });
-    const proxiedFetch = async (...args) => {
-        const [input, init] = args;
-        const requestInit = {
-            ...(init ? init : {}),
-            agent,
-        };
-        return (0, node_fetch_1.default)(input, requestInit);
-    };
-    return proxiedFetch;
 }