@deadragdoll/tellymcp 0.0.9 → 0.0.11

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportProjectEvents = void 0;
+class TransportProjectEvents {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async handleProjectMemberJoinedEvent(input) {
+        const rawMemberLabel = input.member_display_name?.trim() ||
+            (input.member_telegram_username?.trim()
+                ? `@${input.member_telegram_username.trim().replace(/^@/u, "")}`
+                : null);
+        const sessions = await this.host.sessionStore.listSessions();
+        const notifiedChats = new Set();
+        for (const session of sessions) {
+            const binding = await this.host.bindingStore.getBinding(session.sessionId);
+            if (!binding || notifiedChats.has(binding.telegramChatId)) {
+                continue;
+            }
+            const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+            const memberLabel = rawMemberLabel ?? this.host.t(locale, "menu:notices.project.new_member");
+            await this.host.sendNotification({
+                sessionId: session.sessionId,
+                ...(session.label ? { sessionLabel: session.label } : {}),
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: this.host.t(locale, "menu:notices.project.member_joined", {
+                    projectName: input.project_name,
+                    memberLabel,
+                }),
+            });
+            notifiedChats.add(binding.telegramChatId);
+        }
+    }
+    async handleProjectMemberLeftEvent(input) {
+        const rawMemberLabel = input.member_display_name?.trim() ||
+            (input.member_telegram_username?.trim()
+                ? `@${input.member_telegram_username.trim().replace(/^@/u, "")}`
+                : null);
+        const sessions = await this.host.sessionStore.listSessions();
+        const notifiedChats = new Set();
+        for (const session of sessions) {
+            const binding = await this.host.bindingStore.getBinding(session.sessionId);
+            if (!binding || notifiedChats.has(binding.telegramChatId)) {
+                continue;
+            }
+            const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+            const memberLabel = rawMemberLabel ?? this.host.t(locale, "menu:notices.project.member");
+            await this.host.sendNotification({
+                sessionId: session.sessionId,
+                ...(session.label ? { sessionLabel: session.label } : {}),
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: this.host.t(locale, "menu:notices.project.member_left", {
+                    projectName: input.project_name,
+                    memberLabel,
+                }),
+            });
+            notifiedChats.add(binding.telegramChatId);
+        }
+    }
+    async handleProjectDeletedEvent(input) {
+        const sessions = await this.host.sessionStore.listSessions();
+        const notifiedChats = new Set();
+        for (const session of sessions) {
+            if (session.activeProjectUuid === input.project_uuid) {
+                await this.host.sessionStore.setSession({
+                    ...session,
+                    activeProjectUuid: undefined,
+                    activeProjectName: undefined,
+                    updatedAt: new Date().toISOString(),
+                });
+            }
+            const binding = await this.host.bindingStore.getBinding(session.sessionId);
+            if (!binding || notifiedChats.has(binding.telegramChatId)) {
+                continue;
+            }
+            const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+            await this.host.sendNotification({
+                sessionId: session.sessionId,
+                ...(session.label ? { sessionLabel: session.label } : {}),
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: this.host.t(locale, "menu:notices.project.deleted", {
+                    projectName: input.project_name,
+                }),
+            });
+            notifiedChats.add(binding.telegramChatId);
+        }
+    }
+}
+exports.TransportProjectEvents = TransportProjectEvents;

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportProjectMenus = void 0;
+const menu_1 = require("@grammyjs/menu");
+class TransportProjectMenus {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    createProjectsMenu() {
+        return new menu_1.Menu("telegram-projects-menu", {
+            fingerprint: async (ctx) => this.host.buildProjectsFingerprint(ctx),
+            ...this.host.createMenuOptions((ctx) => this.host.showProjectsMenu(ctx)),
+        })
+            .dynamic(async (ctx) => {
+            const range = new menu_1.MenuRange();
+            const { session, projects } = await this.host.loadProjectsContext(ctx);
+            if (!session || !projects) {
+                range.text(await this.host.tForContext(ctx, "common:menu.gateway_unavailable"), async (innerCtx) => {
+                    await innerCtx.answerCallbackQuery({
+                        text: await this.host.tForContext(innerCtx, "menu:collab.actions.gateway_only"),
+                        show_alert: true,
+                    });
+                });
+                return range;
+            }
+            if (projects.length === 0) {
+                range
+                    .text(await this.host.tForContext(ctx, "menu:collab.labels.no_projects"), async (innerCtx) => {
+                    await innerCtx.answerCallbackQuery({
+                        text: await this.host.tForContext(innerCtx, "menu:collab.actions.no_projects"),
+                    });
+                })
+                    .row();
+                return range;
+            }
+            for (const project of projects) {
+                const isActive = session.activeProjectUuid === project.project_uuid;
+                range
+                    .text({
+                    text: `${isActive ? "✅" : "📁"} ${project.name}`,
+                    payload: async () => this.host.createProjectMenuPayload(session.sessionId, project.project_uuid, project.name),
+                }, async (innerCtx) => {
+                    await this.host.handleProjectSelect(innerCtx);
+                })
+                    .row();
+            }
+            return range;
+        })
+            .text(async (ctx) => this.host.tForContext(ctx, "menu:collab.buttons.create"), async (ctx) => {
+            await this.host.beginProjectMode(ctx, "create");
+        })
+            .text(async (ctx) => this.host.tForContext(ctx, "menu:collab.buttons.tools"), async (ctx) => {
+            await ctx.answerCallbackQuery({
+                text: await this.host.tForContext(ctx, "menu:collab.actions.open_tools"),
+            });
+            await this.host.showCollabToolsMenu(ctx);
+        })
+            .row()
+            .text(async (ctx) => this.host.tForContext(ctx, "menu:collab.buttons.join"), async (ctx) => {
+            await this.host.beginProjectMode(ctx, "join");
+        })
+            .text(async (ctx) => this.host.tForContext(ctx, "common:menu.back"), async (ctx) => {
+            await ctx.answerCallbackQuery({
+                text: await this.host.tForContext(ctx, "menu:collab.actions.back_to_session_menu"),
+            });
+            await this.host.showMainMenu(ctx);
+        });
+    }
+    createCollabToolsMenu() {
+        return new menu_1.Menu("telegram-collab-tools-menu", this.host.createMenuOptions((ctx) => this.host.showCollabToolsMenu(ctx)))
+            .text(async (ctx) => this.host.tForContext(ctx, "menu:collab.buttons.broadcast"), async (ctx) => {
+            await this.host.beginProjectBroadcast(ctx);
+        })
+            .text(async (ctx) => this.host.tForContext(ctx, "menu:collab.buttons.history"), async (ctx) => {
+            await this.host.handleCollabHistoryExport(ctx);
+        })
+            .row()
+            .text(async (ctx) => this.host.tForContext(ctx, "menu:collab.buttons.delete"), async (ctx) => {
+            await ctx.answerCallbackQuery({
+                text: await this.host.tForContext(ctx, "menu:collab.actions.open_delete"),
+            });
+            await this.host.showCollabDeleteMenu(ctx);
+        })
+            .row()
+            .text(async (ctx) => this.host.tForContext(ctx, "common:menu.back"), async (ctx) => {
+            await ctx.answerCallbackQuery({
+                text: await this.host.tForContext(ctx, "menu:collab.actions.back_to_collab"),
+            });
+            await this.host.showProjectsMenu(ctx);
+        });
+    }
+    createCollabDeleteMenu() {
+        return new menu_1.Menu("telegram-collab-delete-menu", {
+            fingerprint: async (ctx) => this.host.buildProjectsFingerprint(ctx),
+            ...this.host.createMenuOptions((ctx) => this.host.showCollabDeleteMenu(ctx)),
+        })
+            .dynamic(async (ctx) => {
+            const range = new menu_1.MenuRange();
+            const { session, projects } = await this.host.loadProjectsContext(ctx);
+            if (!session || !projects) {
+                range.text(await this.host.tForContext(ctx, "common:menu.gateway_unavailable"), async (innerCtx) => {
+                    await innerCtx.answerCallbackQuery({
+                        text: await this.host.tForContext(innerCtx, "menu:collab.actions.gateway_only"),
+                        show_alert: true,
+                    });
+                });
+                return range;
+            }
+            if (projects.length === 0) {
+                range.text(await this.host.tForContext(ctx, "menu:collab.labels.no_projects"), async (innerCtx) => {
+                    await innerCtx.answerCallbackQuery({
+                        text: await this.host.tForContext(innerCtx, "menu:collab.actions.no_projects"),
+                    });
+                });
+                return range;
+            }
+            for (const project of projects.filter((item) => item.role === "owner")) {
+                range
+                    .text({
+                    text: `🗑 ${project.name}`,
+                    payload: async () => this.host.createProjectDeleteMenuPayload(session.sessionId, project.project_uuid, project.name),
+                }, async (innerCtx) => {
+                    await this.host.handleProjectDeleteSelect(innerCtx);
+                })
+                    .row();
+            }
+            return range;
+        })
+            .text(async (ctx) => this.host.tForContext(ctx, "common:menu.back"), async (ctx) => {
+            await ctx.answerCallbackQuery({
+                text: await this.host.tForContext(ctx, "menu:collab.actions.back_to_tools"),
+            });
+            await this.host.showCollabToolsMenu(ctx);
+        });
+    }
+}
+exports.TransportProjectMenus = TransportProjectMenus;

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

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportProjectState = void 0;
+const relay_1 = require("../../../app/webapp/relay");
+class TransportProjectState {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    extractShortSessionLabel(session, fallback) {
+        const label = session.label?.trim() || fallback;
+        const separator = " · ";
+        const separatorIndex = label.indexOf(separator);
+        if (separatorIndex <= 0) {
+            return label;
+        }
+        return label.slice(0, separatorIndex).trim() || fallback;
+    }
+    async resolveProjectClientTarget(input) {
+        const resolvedSessionId = input.sessionId ??
+            (await this.host.bindingStore.getActiveSessionIdForPrincipal(input.principal));
+        if (resolvedSessionId) {
+            const relay = (0, relay_1.parseLiveRelaySessionId)(resolvedSessionId);
+            if (relay) {
+                return {
+                    clientUuid: relay.clientUuid,
+                    localSessionId: relay.localSessionId,
+                    sessionId: resolvedSessionId,
+                };
+            }
+        }
+        return {
+            clientUuid: await this.ensureGatewayClientUuid(input.principal, input.actor),
+            localSessionId: resolvedSessionId ?? null,
+            sessionId: resolvedSessionId ?? null,
+        };
+    }
+    async ensureGatewayClientUuid(principal, actor) {
+        const existing = await this.host.maintenanceStore.getGatewayClientUuid();
+        if (existing && !actor) {
+            return existing;
+        }
+        const response = await this.host.callGatewayJson("/client/register", {
+            ...(existing ? { client_uuid: existing } : {}),
+            client_label: this.host.config.project.name ||
+                this.host.config.telegram.botUsername ||
+                "telegram-mcp client",
+            bot_username: this.host.config.telegram.botUsername,
+            ...(this.host.config.distributed.gatewayToken
+                ? { gateway_token: this.host.config.distributed.gatewayToken }
+                : {}),
+            meta: {
+                telegram_chat_id: principal.telegramChatId,
+                telegram_user_id: principal.telegramUserId,
+                ...(actor?.telegramUsername
+                    ? { telegram_username: actor.telegramUsername }
+                    : {}),
+                ...(actor?.telegramFirstName
+                    ? { telegram_first_name: actor.telegramFirstName }
+                    : {}),
+                ...(actor?.telegramLastName ? { telegram_last_name: actor.telegramLastName } : {}),
+                ...(actor?.telegramDisplayName
+                    ? { telegram_display_name: actor.telegramDisplayName }
+                    : {}),
+            },
+        });
+        await this.host.maintenanceStore.setGatewayClientUuid(response.client_uuid);
+        return response.client_uuid;
+    }
+    async listGatewayProjects(principal, actor) {
+        const target = await this.resolveProjectClientTarget({
+            principal,
+            ...(actor ? { actor } : {}),
+        });
+        const response = await this.host.callGatewayJson("/projects/list", {
+            client_uuid: target.clientUuid,
+            ...(target.localSessionId
+                ? { local_session_id: target.localSessionId }
+                : {}),
+        });
+        return response.projects;
+    }
+    async listGatewayProjectSessions(principal, projectUuid) {
+        const { clientUuid } = await this.resolveProjectClientTarget({
+            principal,
+        });
+        const response = await this.host.callGatewayJson("/projects/sessions", {
+            client_uuid: clientUuid,
+            project_uuid: projectUuid,
+        });
+        return response.sessions;
+    }
+    async listGatewaySessionHistory(principal, localSessionId) {
+        const { clientUuid } = await this.resolveProjectClientTarget({
+            principal,
+        });
+        const response = await this.host.callGatewayJson("/history/list", {
+            client_uuid: clientUuid,
+            local_session_id: localSessionId,
+            limit: 5,
+        });
+        return Array.isArray(response.history) ? response.history : [];
+    }
+    async ensureProjectSessionRegistered(input) {
+        const session = await this.host.sessionStore.getSession(input.sessionId);
+        if (!session) {
+            throw new Error("Active session not found.");
+        }
+        const target = await this.resolveProjectClientTarget({
+            principal: input.principal,
+            sessionId: input.sessionId,
+        });
+        const localSessionId = target.localSessionId ?? session.sessionId;
+        await this.host.callGatewayJson("/sessions/register", {
+            client_uuid: target.clientUuid,
+            project_uuid: input.projectUuid,
+            local_session_id: localSessionId,
+            label: this.extractShortSessionLabel(session, localSessionId),
+            cwd: session.cwd,
+            status: "active",
+        });
+    }
+    async loadProjectsContext(ctx) {
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal || !this.host.config.distributed.gatewayPublicUrl) {
+            return { principal, session: null, projects: null };
+        }
+        const activeSessionId = await this.host.bindingStore.getActiveSessionIdForPrincipal(principal);
+        if (!activeSessionId) {
+            return { principal, session: null, projects: null };
+        }
+        const session = await this.host.sessionStore.getSession(activeSessionId);
+        if (!session) {
+            return { principal, session: null, projects: null };
+        }
+        const projects = await this.listGatewayProjects(principal, this.host.getGatewayActorFromContext(ctx));
+        return { principal, session, projects };
+    }
+    async activateProjectForSession(input) {
+        const session = await this.host.sessionStore.getSession(input.sessionId);
+        if (!session) {
+            throw new Error("Active session not found.");
+        }
+        await this.host.sessionStore.setSession({
+            ...session,
+            activeProjectUuid: input.projectUuid,
+            activeProjectName: input.projectName,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    async ensureOpenedProjectIsActive(input) {
+        const session = await this.host.sessionStore.getSession(input.sessionId);
+        if (session?.activeProjectUuid === input.projectUuid &&
+            session.activeProjectName === input.projectName) {
+            return;
+        }
+        await this.activateProjectForSession(input);
+    }
+    async buildProjectsFingerprint(ctx) {
+        const { session, projects } = await this.loadProjectsContext(ctx);
+        return `${session?.sessionId ?? "none"}:${session?.activeProjectUuid ?? "none"}:${projects?.map((item) => item.project_uuid).join(",") ?? "none"}`;
+    }
+    async getProjectPayloadByUuid(sessionId, projectUuid) {
+        const session = await this.host.sessionStore.getSession(sessionId);
+        if (!session) {
+            return null;
+        }
+        const principalBinding = await this.host.bindingStore.getBinding(sessionId);
+        if (!principalBinding) {
+            return null;
+        }
+        const projects = await this.listGatewayProjects({
+            telegramChatId: principalBinding.telegramChatId,
+            telegramUserId: principalBinding.telegramUserId,
+        });
+        const project = projects.find((item) => item.project_uuid === projectUuid);
+        if (!project) {
+            return null;
+        }
+        return {
+            sessionId,
+            projectUuid,
+            projectName: project.name,
+            inviteToken: project.invite_token,
+        };
+    }
+    async getProjectMemberPayloadByKey(payloadKey) {
+        const payload = await this.host.menuPayloadStore.getMenuPayload(payloadKey);
+        if (!payload ||
+            (payload.kind !== "project-member" &&
+                payload.kind !== "project-file-target") ||
+            !payload.sessionId ||
+            !payload.projectUuid ||
+            !payload.targetSessionId) {
+            return null;
+        }
+        const project = await this.getProjectPayloadByUuid(String(payload.sessionId), String(payload.projectUuid));
+        if (!project) {
+            return null;
+        }
+        return {
+            sessionId: String(payload.sessionId),
+            projectUuid: String(payload.projectUuid),
+            projectName: project.projectName,
+            inviteToken: project.inviteToken,
+            targetSessionId: String(payload.targetSessionId),
+            targetSessionLabel: String(payload.title ?? payload.targetSessionId),
+            ...(payload.targetClientUuid
+                ? { targetClientUuid: String(payload.targetClientUuid) }
+                : {}),
+            ...(payload.targetLocalSessionId
+                ? { targetLocalSessionId: String(payload.targetLocalSessionId) }
+                : {}),
+            ...(payload.filePath ? { filePath: String(payload.filePath) } : {}),
+        };
+    }
+    async getPartnerFileTargetPayloadByKey(payloadKey) {
+        const payload = await this.host.menuPayloadStore.getMenuPayload(payloadKey);
+        if (!payload ||
+            payload.kind !== "partner-file-target" ||
+            !payload.sessionId ||
+            !payload.targetSessionId ||
+            !payload.filePath) {
+            return null;
+        }
+        return {
+            sessionId: String(payload.sessionId),
+            targetSessionId: String(payload.targetSessionId),
+            targetSessionLabel: String(payload.title ?? payload.targetSessionId),
+            filePath: String(payload.filePath),
+        };
+    }
+    async getLiveApprovalPayloadByKey(payloadKey) {
+        const payload = await this.host.menuPayloadStore.getMenuPayload(payloadKey);
+        if (!payload ||
+            payload.kind !== "live-approval" ||
+            !payload.sessionId ||
+            !payload.sourceSessionId ||
+            !payload.sourceSessionLabel ||
+            !payload.sourceClientUuid ||
+            !payload.sourceLocalSessionId ||
+            !payload.targetSessionId ||
+            !payload.title ||
+            !payload.targetClientUuid ||
+            !payload.targetLocalSessionId) {
+            return null;
+        }
+        return {
+            sessionId: String(payload.sessionId),
+            sourceSessionId: String(payload.sourceSessionId),
+            sourceSessionLabel: String(payload.sourceSessionLabel),
+            sourceClientUuid: String(payload.sourceClientUuid),
+            sourceLocalSessionId: String(payload.sourceLocalSessionId),
+            targetSessionId: String(payload.targetSessionId),
+            targetSessionLabel: String(payload.title),
+            targetClientUuid: String(payload.targetClientUuid),
+            targetLocalSessionId: String(payload.targetLocalSessionId),
+            ...(payload.projectUuid ? { projectUuid: String(payload.projectUuid) } : {}),
+            ...(payload.projectName ? { projectName: String(payload.projectName) } : {}),
+        };
+    }
+    buildRelaySessionContext(input) {
+        const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(input.targetClientUuid, input.targetLocalSessionId);
+        const now = new Date().toISOString();
+        return {
+            sessionId: relaySessionId,
+            label: input.targetSessionLabel,
+            ...(input.projectUuid ? { activeProjectUuid: input.projectUuid } : {}),
+            ...(input.projectName ? { activeProjectName: input.projectName } : {}),
+            updatedAt: now,
+        };
+    }
+    async bindRelaySessionToPrincipal(input) {
+        const session = this.buildRelaySessionContext(input.payload);
+        const existingSession = await this.host.sessionStore.getSession(session.sessionId);
+        await this.host.sessionStore.setSession({
+            ...(existingSession ?? session),
+            ...session,
+            ...(existingSession?.cwd ? { cwd: existingSession.cwd } : {}),
+            ...(existingSession?.task ? { task: existingSession.task } : {}),
+            ...(existingSession?.summary ? { summary: existingSession.summary } : {}),
+            ...(existingSession?.files ? { files: existingSession.files } : {}),
+            ...(existingSession?.decisions
+                ? { decisions: existingSession.decisions }
+                : {}),
+            ...(existingSession?.risks ? { risks: existingSession.risks } : {}),
+            ...(existingSession?.lastSeenToolsHash
+                ? { lastSeenToolsHash: existingSession.lastSeenToolsHash }
+                : {}),
+            ...(existingSession?.lastNotifiedToolsHash
+                ? { lastNotifiedToolsHash: existingSession.lastNotifiedToolsHash }
+                : {}),
+            updatedAt: new Date().toISOString(),
+        });
+        await this.host.bindingStore.setBinding({
+            sessionId: session.sessionId,
+            telegramChatId: input.principal.telegramChatId,
+            telegramUserId: input.principal.telegramUserId,
+            ...(input.ctx.from?.username
+                ? { telegramUsername: input.ctx.from.username }
+                : {}),
+            linkedAt: new Date().toISOString(),
+        });
+        await this.host.bindingStore.setActiveSessionIdForPrincipal(input.principal, session.sessionId);
+        return session;
+    }
+}
+exports.TransportProjectState = TransportProjectState;