@deadragdoll/tellymcp 0.0.9 → 0.0.11

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteTelegramInboxMessageTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class DeleteTelegramInboxMessageTool {
-    inboxService;
-    constructor(inboxService) {
-        this.inboxService = inboxService;
-    }
-    register(server) {
-        server.registerTool("delete_telegram_inbox_message", {
-            title: "Delete Telegram Inbox Message",
-            description: "Use this only after you have fully processed an ordinary human Telegram inbox message. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. Delete the message so future inbox reads do not return it again.",
-            inputSchema: schema_1.deleteTelegramInboxMessageInputSchema,
-            outputSchema: schema_1.deleteTelegramInboxMessageOutputSchema,
-        }, async (args) => {
-            const output = await this.inboxService.deleteInboxMessage(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.DeleteTelegramInboxMessageTool = DeleteTelegramInboxMessageTool;

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetTelegramInboxCountTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class GetTelegramInboxCountTool {
-    inboxService;
-    constructor(inboxService) {
-        this.inboxService = inboxService;
-    }
-    register(server) {
-        server.registerTool("get_telegram_inbox_count", {
-            title: "Get Telegram Inbox Count",
-            description: "Use this to cheaply check whether ordinary human Telegram messages are waiting for the session. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. Do not use it for partner-note wakeups; partner notes must be read from .mcp-xchange/SHARED_INDEX.md instead.",
-            inputSchema: schema_1.getTelegramInboxCountInputSchema,
-            outputSchema: schema_1.getTelegramInboxCountOutputSchema,
-        }, async (args) => {
-            const output = await this.inboxService.getInboxCount(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.GetTelegramInboxCountTool = GetTelegramInboxCountTool;

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetTelegramInboxTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class GetTelegramInboxTool {
-    inboxService;
-    constructor(inboxService) {
-        this.inboxService = inboxService;
-    }
-    register(server) {
-        server.registerTool("get_telegram_inbox", {
-            title: "Get Telegram Inbox",
-            description: "Use this to read unsolicited Telegram inbox messages stored for the session. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. Each item now includes message_kind: human or system. Treat system messages as operational instructions from the service, not as normal user prompts. Returned items may also include local attachment paths from .mcp-xchange when the human message contained a photo or document. Do not use this first for partner-note wakeups; partner collaboration notes must be read from .mcp-xchange/SHARED_INDEX.md and the referenced note files.",
-            inputSchema: schema_1.getTelegramInboxInputSchema,
-            outputSchema: schema_1.getTelegramInboxOutputSchema,
-        }, async (args) => {
-            const output = await this.inboxService.getInbox(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.GetTelegramInboxTool = GetTelegramInboxTool;

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

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InboxService = void 0;
-class InboxService {
-    config;
-    inboxStore;
-    _sessionStore;
-    logger;
-    projectIdentityResolver;
-    constructor(config, inboxStore, _sessionStore, logger, projectIdentityResolver) {
-        this.config = config;
-        this.inboxStore = inboxStore;
-        this._sessionStore = _sessionStore;
-        this.logger = logger;
-        this.projectIdentityResolver = projectIdentityResolver;
-    }
-    async getInboxCount(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const total = await this.inboxStore.countInboxMessages(resolved.sessionId);
-        this.logger.info("Telegram inbox count fetched", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-            total,
-        });
-        return {
-            session_id: resolved.sessionId,
-            total,
-        };
-    }
-    async getInbox(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const limit = this.config.telegram.inboxBatchSize;
-        const messages = await this.inboxStore.listInboxMessages(resolved.sessionId, limit);
-        const total = await this.inboxStore.countInboxMessages(resolved.sessionId);
-        this.logger.info("Telegram inbox fetched", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-            limit,
-            returned: messages.length,
-            total,
-        });
-        return {
-            session_id: resolved.sessionId,
-            total,
-            has_more: total > messages.length,
-            messages: messages.map((message) => ({
-                message_id: message.id,
-                source: "telegram",
-                message_kind: message.sourceTelegramMessageId > 0 ? "human" : "system",
-                telegram_chat_id: message.telegramChatId,
-                telegram_user_id: message.telegramUserId,
-                telegram_message_id: message.sourceTelegramMessageId,
-                text: message.text,
-                ...(message.attachments?.length
-                    ? { attachments: message.attachments }
-                    : {}),
-                received_at: message.receivedAt,
-            })),
-        };
-    }
-    async deleteInboxMessage(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const deleted = await this.inboxStore.deleteInboxMessage(resolved.sessionId, input.message_id);
-        this.logger.info("Telegram inbox message deleted", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-            messageId: input.message_id,
-            deleted,
-        });
-        return {
-            deleted,
-            session_id: resolved.sessionId,
-            message_id: input.message_id,
-        };
-    }
-}
-exports.InboxService = InboxService;

package/dist/services/features/telegram-mcp/src/features/pair-session/model/clearSessionPairingTool.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClearSessionPairingTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class ClearSessionPairingTool {
-    pairSessionService;
-    constructor(pairSessionService) {
-        this.pairSessionService = pairSessionService;
-    }
-    register(server) {
-        server.registerTool("clear_session_pairing", {
-            title: "Clear Session Pairing",
-            description: "Use this when the user asks to unpair, unlink, detach, or reset Telegram binding for the current session. Remove Telegram binding for a session so it can be paired again.",
-            inputSchema: schema_1.clearSessionPairingInputSchema,
-            outputSchema: schema_1.clearSessionPairingOutputSchema,
-        }, async (args) => {
-            const output = await this.pairSessionService.clearPairing(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.ClearSessionPairingTool = ClearSessionPairingTool;

package/dist/services/features/telegram-mcp/src/features/pair-session/model/createSessionPairCodeTool.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateSessionPairCodeTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class CreateSessionPairCodeTool {
-    pairSessionService;
-    constructor(pairSessionService) {
-        this.pairSessionService = pairSessionService;
-    }
-    register(server) {
-        server.registerTool("create_session_pair_code", {
-            title: "Create Session Pair Code",
-            description: "Use this when the user asks to link, pair, register, or connect the current agent/session to Telegram. Before calling it, determine the correct workspace cwd and, if tmux is available, collect current tmux attributes. Then create a short-lived Telegram pairing code for that session. After success, remember the returned session_id and pass it explicitly to later session-scoped tools.",
-            inputSchema: schema_1.createSessionPairCodeInputSchema,
-            outputSchema: schema_1.createSessionPairCodeOutputSchema,
-        }, async (args) => {
-            const output = await this.pairSessionService.createPairCode(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.CreateSessionPairCodeTool = CreateSessionPairCodeTool;

package/dist/services/features/telegram-mcp/src/features/pair-session/model/generatePairCode.js

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PairSessionService = void 0;
-const ids_1 = require("../../../shared/lib/ids/ids");
-class PairSessionService {
-    config;
-    sessionStore;
-    bindingStore;
-    maintenanceStore;
-    logger;
-    projectIdentityResolver;
-    static MAX_PAIR_CODE_ATTEMPTS = 20;
-    constructor(config, sessionStore, bindingStore, maintenanceStore, logger, projectIdentityResolver) {
-        this.config = config;
-        this.sessionStore = sessionStore;
-        this.bindingStore = bindingStore;
-        this.maintenanceStore = maintenanceStore;
-        this.logger = logger;
-        this.projectIdentityResolver = projectIdentityResolver;
-    }
-    async unregisterGatewaySession(localSessionId) {
-        if (!this.config.distributed.gatewayPublicUrl) {
-            return;
-        }
-        const clientUuid = await this.maintenanceStore.getGatewayClientUuid();
-        if (!clientUuid) {
-            return;
-        }
-        const url = new URL(this.config.distributed.gatewayPublicUrl);
-        url.pathname = url.pathname.replace(/\/+$/u, "");
-        if (!url.pathname.endsWith("/gateway")) {
-            url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
-        }
-        url.pathname = `${url.pathname}/sessions/unregister`.replace(/\/{2,}/gu, "/");
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                ...(this.config.distributed.gatewayAuthToken
-                    ? { authorization: `Bearer ${this.config.distributed.gatewayAuthToken}` }
-                    : {}),
-            },
-            body: JSON.stringify({
-                client_uuid: clientUuid,
-                local_session_id: localSessionId,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Gateway session unregister failed with status ${response.status}: ${text || response.statusText}`);
-        }
-    }
-    async createPairCode(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const now = new Date();
-        const ttlSeconds = input.expires_in_seconds ?? this.config.pairCodeTtlSeconds;
-        const expiresAt = new Date(now.getTime() + ttlSeconds * 1000).toISOString();
-        let code = null;
-        const existingSession = await this.sessionStore.getSession(resolved.sessionId);
-        await this.sessionStore.setSession({
-            sessionId: resolved.sessionId,
-            ...(input.session_label
-                ? { label: input.session_label }
-                : resolved.sessionLabel
-                    ? { label: resolved.sessionLabel }
-                    : existingSession?.label
-                        ? { label: existingSession.label }
-                        : {}),
-            ...(input.cwd
-                ? { cwd: resolved.cwd }
-                : existingSession?.cwd
-                    ? { cwd: existingSession.cwd }
-                    : { cwd: resolved.cwd }),
-            ...(existingSession?.linkedSessionId
-                ? { linkedSessionId: existingSession.linkedSessionId }
-                : {}),
-            ...(existingSession?.activeProjectUuid
-                ? { activeProjectUuid: existingSession.activeProjectUuid }
-                : {}),
-            ...(existingSession?.activeProjectName
-                ? { activeProjectName: existingSession.activeProjectName }
-                : {}),
-            ...(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 } : {}),
-            ...(input.tmux_session_name
-                ? { tmuxSessionName: input.tmux_session_name }
-                : existingSession?.tmuxSessionName
-                    ? { tmuxSessionName: existingSession.tmuxSessionName }
-                    : {}),
-            ...(input.tmux_window_name
-                ? { tmuxWindowName: input.tmux_window_name }
-                : existingSession?.tmuxWindowName
-                    ? { tmuxWindowName: existingSession.tmuxWindowName }
-                    : {}),
-            ...(typeof input.tmux_window_index === "number"
-                ? { tmuxWindowIndex: input.tmux_window_index }
-                : typeof existingSession?.tmuxWindowIndex === "number"
-                    ? { tmuxWindowIndex: existingSession.tmuxWindowIndex }
-                    : {}),
-            ...(input.tmux_pane_id
-                ? { tmuxPaneId: input.tmux_pane_id, tmuxTarget: input.tmux_pane_id }
-                : existingSession?.tmuxPaneId
-                    ? {
-                        tmuxPaneId: existingSession.tmuxPaneId,
-                        ...(existingSession.tmuxTarget
-                            ? { tmuxTarget: existingSession.tmuxTarget }
-                            : {}),
-                    }
-                    : existingSession?.tmuxTarget
-                        ? { tmuxTarget: existingSession.tmuxTarget }
-                        : {}),
-            ...(typeof input.tmux_pane_index === "number"
-                ? { tmuxPaneIndex: input.tmux_pane_index }
-                : typeof existingSession?.tmuxPaneIndex === "number"
-                    ? { tmuxPaneIndex: existingSession.tmuxPaneIndex }
-                    : {}),
-            ...(existingSession?.lastTmuxNudgeAt
-                ? { lastTmuxNudgeAt: existingSession.lastTmuxNudgeAt }
-                : {}),
-            updatedAt: now.toISOString(),
-        });
-        this.projectIdentityResolver.persistSessionMarker({
-            cwd: resolved.cwd,
-            sessionId: resolved.sessionId,
-            sessionLabel: input.session_label?.trim() || resolved.sessionLabel,
-        });
-        for (let attempt = 0; attempt < PairSessionService.MAX_PAIR_CODE_ATTEMPTS; attempt += 1) {
-            const candidate = (0, ids_1.createPairCode)();
-            const record = {
-                code: candidate,
-                sessionId: resolved.sessionId,
-                ...(resolved.sessionLabel
-                    ? { sessionLabel: resolved.sessionLabel }
-                    : {}),
-                createdAt: now.toISOString(),
-                expiresAt,
-            };
-            const reserved = await this.bindingStore.createPairCode(record, ttlSeconds);
-            if (reserved) {
-                code = candidate;
-                break;
-            }
-        }
-        if (!code) {
-            throw new Error("Failed to reserve a unique 3-digit pairing code. Try again in a moment.");
-        }
-        this.logger.info("Session pair code created", {
-            sessionId: resolved.sessionId,
-            sessionLabel: resolved.sessionLabel,
-            sessionIdDerived: resolved.sessionIdDerived,
-            sessionLabelDerived: resolved.sessionLabelDerived,
-            cwd: input.cwd?.trim(),
-            tmuxSessionName: input.tmux_session_name,
-            tmuxWindowName: input.tmux_window_name,
-            tmuxWindowIndex: input.tmux_window_index,
-            tmuxPaneId: input.tmux_pane_id,
-            tmuxPaneIndex: input.tmux_pane_index,
-            expiresAt,
-            ttlSeconds,
-        });
-        return {
-            session_id: resolved.sessionId,
-            code,
-            expires_at: expiresAt,
-            status: "pending",
-            status_message: "Pairing code created. Send it to the Telegram bot and then use get_session_context to confirm that pairing is active.",
-            ...(this.config.telegram.botUsername
-                ? {
-                    telegram_link_hint: `https://t.me/${this.config.telegram.botUsername}?start=${encodeURIComponent(code)}`,
-                }
-                : {}),
-        };
-    }
-    async clearPairing(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const existingSession = await this.sessionStore.getSession(resolved.sessionId);
-        if (existingSession) {
-            await this.unregisterGatewaySession(resolved.sessionId);
-            await this.sessionStore.setSession({
-                ...existingSession,
-                activeProjectUuid: undefined,
-                activeProjectName: undefined,
-                updatedAt: new Date().toISOString(),
-            });
-        }
-        await this.bindingStore.clearBinding(resolved.sessionId);
-        this.logger.info("Session pairing cleared", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-        });
-        return {
-            cleared: true,
-            session_id: resolved.sessionId,
-        };
-    }
-}
-exports.PairSessionService = PairSessionService;

package/dist/services/features/telegram-mcp/src/features/session-context/model/getTmuxTargetTool.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetTmuxTargetTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class GetTmuxTargetTool {
-    sessionContextService;
-    constructor(sessionContextService) {
-        this.sessionContextService = sessionContextService;
-    }
-    register(server) {
-        server.registerTool("get_tmux_target", {
-            title: "Get tmux Target",
-            description: "Debug/setup tool. Return the stored tmux pane target for a session, including the last time the service nudged that tmux pane. Do not call this in the normal inbox-processing path after a tmux nudge.",
-            inputSchema: schema_1.getTmuxTargetInputSchema,
-            outputSchema: schema_1.getTmuxTargetOutputSchema,
-        }, async (args) => {
-            const output = await this.sessionContextService.getTmuxTarget(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.GetTmuxTargetTool = GetTmuxTargetTool;

package/dist/services/features/telegram-mcp/src/features/session-context/model/setTmuxTargetTool.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetTmuxTargetTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class SetTmuxTargetTool {
-    sessionContextService;
-    constructor(sessionContextService) {
-        this.sessionContextService = sessionContextService;
-    }
-    register(server) {
-        server.registerTool("set_tmux_target", {
-            title: "Set tmux Target",
-            description: "Use this to repair or complete Telegram session setup after pairing, or when tmux pane/session changed. Store the tmux pane target for a session so the long-running MCP service can nudge the agent to check Telegram inbox when new ordinary Telegram messages arrive.",
-            inputSchema: schema_1.setTmuxTargetInputSchema,
-            outputSchema: schema_1.setTmuxTargetOutputSchema,
-        }, async (args) => {
-            const output = await this.sessionContextService.setTmuxTarget(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.SetTmuxTargetTool = SetTmuxTargetTool;