@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/services/features/telegram-mcp/src/features/notify/model/notifyService.js

@@ -1,7 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotifyService = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const schema_1 = require("../../../entities/request/model/schema");
 const redactSecrets_1 = require("../../../shared/lib/redact-secrets/redactSecrets");
+const client_1 = require("../../../shared/integrations/terminal/client");
+const relay_1 = require("../../../app/webapp/relay");
+const gatewayClientAccess_1 = require("../../distributed-client/model/gatewayClientAccess");
 function mergeSavedContext(input, session) {
     const savedSections = [];
     if (input.use_saved_context && session?.summary) {
@@ -30,28 +38,111 @@ function mergeSavedContext(input, session) {
         ...(session?.label ? { sessionLabel: session.label } : {}),
     };
 }
+function normalizeNotifyTelegramOutput(value) {
+    const candidate = value && typeof value === "object" && "structuredContent" in value
+        ? value.structuredContent
+        : value && typeof value === "object" && "result" in value
+            ? value.result
+            : value;
+    const parsed = schema_1.notifyTelegramOutputSchema.safeParse(candidate);
+    if (parsed.success) {
+        return parsed.data;
+    }
+    return null;
+}
+function normalizeSendFileToTelegramOutput(value) {
+    const candidate = value && typeof value === "object" && "structuredContent" in value
+        ? value.structuredContent
+        : value && typeof value === "object" && "result" in value
+            ? value.result
+            : value;
+    const parsed = schema_1.sendFileToTelegramOutputSchema.safeParse(candidate);
+    if (parsed.success) {
+        return parsed.data;
+    }
+    return null;
+}
+function resolveWorkspaceDir(input) {
+    if (input.inputCwd?.trim()) {
+        return node_path_1.default.resolve(input.inputCwd.trim());
+    }
+    if (input.sessionCwd?.trim()) {
+        return node_path_1.default.resolve(input.sessionCwd.trim());
+    }
+    return node_path_1.default.resolve(input.resolvedCwd);
+}
+function normalizeWorkspaceRelativePath(workspaceDir, filePath) {
+    const trimmed = filePath.trim();
+    if (!trimmed) {
+        throw new Error("file_path is required.");
+    }
+    const resolvedWorkspaceDir = node_path_1.default.resolve(workspaceDir);
+    const resolvedFilePath = node_path_1.default.isAbsolute(trimmed)
+        ? node_path_1.default.resolve(trimmed)
+        : node_path_1.default.resolve(resolvedWorkspaceDir, trimmed);
+    const relative = node_path_1.default.relative(resolvedWorkspaceDir, resolvedFilePath);
+    if (relative.startsWith("..") ||
+        node_path_1.default.isAbsolute(relative) ||
+        relative.trim() === "") {
+        throw new Error("File path is outside the workspace directory.");
+    }
+    return relative.split(node_path_1.default.sep).join("/");
+}
 class NotifyService {
     _config;
     sessionStore;
     bindingStore;
+    maintenanceStore;
     transport;
     logger;
     projectIdentityResolver;
-    constructor(_config, sessionStore, bindingStore, transport, logger, projectIdentityResolver) {
+    remoteConsoleInvoker;
+    gatewaySessionTargetResolver;
+    constructor(_config, sessionStore, bindingStore, maintenanceStore, transport, logger, projectIdentityResolver, remoteConsoleInvoker, gatewaySessionTargetResolver) {
         this._config = _config;
         this.sessionStore = sessionStore;
         this.bindingStore = bindingStore;
+        this.maintenanceStore = maintenanceStore;
         this.transport = transport;
         this.logger = logger;
         this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
+        this.gatewaySessionTargetResolver = gatewaySessionTargetResolver;
     }
     async send(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
         const binding = await this.bindingStore.getBinding(resolved.sessionId);
         if (!binding) {
-            throw new Error("Session is not linked to Telegram. Call create_session_pair_code first.");
+            const remoteTarget = this._config.distributed.mode !== "client" &&
+                this.gatewaySessionTargetResolver
+                ? await this.gatewaySessionTargetResolver(resolved.sessionId)
+                : null;
+            if (remoteTarget) {
+                return this.sendForGatewayBoundSession({
+                    clientUuid: remoteTarget.client_uuid,
+                    localSessionId: remoteTarget.local_session_id,
+                    message: input.message,
+                    sessionLabel: remoteTarget.session_label ??
+                        resolved.sessionLabel ??
+                        remoteTarget.local_session_id,
+                    ...(input.task ? { task: input.task } : {}),
+                    ...(input.context ? { context: input.context } : {}),
+                    ...(input.risk_level ? { riskLevel: input.risk_level } : {}),
+                });
+            }
+            if (this._config.distributed.gatewayPublicUrl) {
+                return this.sendViaGatewayBoundSession({
+                    sessionId: resolved.sessionId,
+                    sessionLabel: resolved.sessionLabel,
+                    message: input.message,
+                    ...(input.task ? { task: input.task } : {}),
+                    ...(input.context ? { context: input.context } : {}),
+                    ...(input.risk_level ? { riskLevel: input.risk_level } : {}),
+                });
+            }
+            throw new Error("Session is not available through the gateway console registry yet. Open /menu in the gateway bot and select the console first.");
         }
-        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const session = await this.resolveSessionContextForNotification(resolved.sessionId);
         const merged = mergeSavedContext(input, session);
         this.logger.info("Telegram notification requested", {
             sessionId: resolved.sessionId,
@@ -89,5 +180,293 @@ class NotifyService {
                 : {}),
         };
     }
+    async sendDocument(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForWorkspace(resolved.sessionId);
+        const remote = this._config.distributed.mode !== "client"
+            ? normalizeSendFileToTelegramOutput(await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.notify.sendDocumentRemote", {
+                ...input,
+                session_id: sessionId,
+            }))
+            : null;
+        if (remote) {
+            return remote;
+        }
+        const session = await this.sessionStore.getSession(sessionId);
+        const workspaceDir = resolveWorkspaceDir({
+            inputCwd: input.cwd,
+            sessionCwd: session?.cwd,
+            resolvedCwd: resolved.cwd,
+        });
+        const relativeFilePath = normalizeWorkspaceRelativePath(workspaceDir, input.file_path);
+        const fileContent = await (0, client_1.readWorkspaceFile)(this._config.terminal, workspaceDir, relativeFilePath);
+        const fileName = node_path_1.default.basename(relativeFilePath);
+        const caption = input.caption?.trim();
+        if (this._config.distributed.mode === "client") {
+            return this.sendDocumentViaGatewayBoundSession({
+                sessionId,
+                filePath: relativeFilePath,
+                fileName,
+                contentBase64: Buffer.from(fileContent).toString("base64"),
+                ...(caption ? { caption } : {}),
+            });
+        }
+        const binding = await this.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            throw new Error("Session is not linked to Telegram, so the file cannot be sent there.");
+        }
+        const absoluteFilePath = node_path_1.default.resolve(workspaceDir, relativeFilePath);
+        const sent = await this.transport.sendDocumentToChat?.(binding.telegramChatId, absoluteFilePath, caption);
+        if (!sent) {
+            throw new Error("Telegram document transport is unavailable.");
+        }
+        return {
+            session_id: sessionId,
+            file_path: absoluteFilePath,
+            sent: true,
+            ...(typeof sent.messageId === "number"
+                ? { message_id: sent.messageId }
+                : {}),
+        };
+    }
+    async sendForGatewayBoundSession(input) {
+        const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(input.clientUuid, input.localSessionId);
+        const binding = await this.bindingStore.getBinding(relaySessionId);
+        if (!binding) {
+            throw new Error(`Gateway relay session '${relaySessionId}' has no active Telegram route.`);
+        }
+        const session = await this.sessionStore.getSession(relaySessionId);
+        const sendResult = await this.transport.sendNotification({
+            sessionId: relaySessionId,
+            sessionLabel: input.sessionLabel ?? session?.label ?? input.localSessionId,
+            recipient: {
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+            },
+            message: (0, redactSecrets_1.redactSecrets)(input.message),
+            ...(input.task ? { task: (0, redactSecrets_1.redactSecrets)(input.task) } : {}),
+            ...(input.context ? { context: (0, redactSecrets_1.redactSecrets)(input.context) } : {}),
+            ...(input.riskLevel ? { riskLevel: input.riskLevel } : {}),
+        });
+        return {
+            sent: true,
+            ...(typeof sendResult.externalMessageId === "number"
+                ? { message_id: sendResult.externalMessageId }
+                : {}),
+        };
+    }
+    async sendRequestForGatewayBoundSession(input) {
+        const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(input.clientUuid, input.localSessionId);
+        const binding = await this.bindingStore.getBinding(relaySessionId);
+        if (!binding) {
+            throw new Error("Gateway relay session has no active Telegram route yet.");
+        }
+        const session = await this.sessionStore.getSession(relaySessionId);
+        const sendResult = await this.transport.sendRequestForGatewayBoundSession?.({
+            requestId: input.requestId,
+            sourceClientUuid: input.clientUuid,
+            sessionId: relaySessionId,
+            sessionLabel: input.sessionLabel ?? session?.label ?? input.localSessionId,
+            recipient: {
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+            },
+            ...(input.task ? { task: input.task } : {}),
+            question: input.question,
+            ...(input.context ? { context: input.context } : {}),
+            ...(input.affectedFiles ? { affectedFiles: input.affectedFiles } : {}),
+            ...(input.options ? { options: input.options } : {}),
+            ...(input.recommendedOption
+                ? { recommendedOption: input.recommendedOption }
+                : {}),
+            ...(input.riskLevel ? { riskLevel: input.riskLevel } : {}),
+            ...(input.fallbackIfTimeout
+                ? { fallbackIfTimeout: input.fallbackIfTimeout }
+                : {}),
+        });
+        if (!sendResult) {
+            throw new Error("Gateway transport request proxy is unavailable.");
+        }
+        return {
+            request_id: input.requestId,
+            ...(typeof sendResult.externalMessageId === "number"
+                ? { message_id: sendResult.externalMessageId }
+                : {}),
+        };
+    }
+    async sendDocumentForGatewayBoundSession(input) {
+        const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(input.clientUuid, input.localSessionId);
+        const binding = await this.bindingStore.getBinding(relaySessionId);
+        if (!binding) {
+            throw new Error("Gateway relay session has no active Telegram route yet.");
+        }
+        const sendResult = await this.transport.sendDocumentBufferToChat?.(binding.telegramChatId, input.fileName, Buffer.from(input.contentBase64, "base64"), input.caption);
+        if (!sendResult) {
+            throw new Error("Gateway transport document proxy is unavailable.");
+        }
+        return {
+            sent: true,
+            ...(typeof sendResult.messageId === "number"
+                ? { message_id: sendResult.messageId }
+                : {}),
+        };
+    }
+    async sendViaGatewayBoundSession(input) {
+        if (!this._config.distributed.gatewayPublicUrl) {
+            throw new Error("Gateway is not configured.");
+        }
+        const clientUuid = await (0, gatewayClientAccess_1.ensureGatewayClientUuid)({
+            maintenanceStore: this.maintenanceStore,
+            gatewayPublicUrl: this._config.distributed.gatewayPublicUrl,
+            ...(this._config.distributed.gatewayAuthToken
+                ? { gatewayAuthToken: this._config.distributed.gatewayAuthToken }
+                : {}),
+            ...(this._config.distributed.gatewayToken
+                ? { gatewayToken: this._config.distributed.gatewayToken }
+                : {}),
+            ...(this._config.project.name
+                ? { projectName: this._config.project.name }
+                : {}),
+            ...(this._config.telegram.botUsername
+                ? { botUsername: this._config.telegram.botUsername }
+                : {}),
+        });
+        const url = (0, gatewayClientAccess_1.normalizeGatewayBaseUrl)(this._config.distributed.gatewayPublicUrl);
+        url.pathname = `${url.pathname}/transport/notify`.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: input.sessionId,
+                ...(input.sessionLabel ? { session_label: input.sessionLabel } : {}),
+                message: (0, redactSecrets_1.redactSecrets)(input.message),
+                ...(input.task ? { task: (0, redactSecrets_1.redactSecrets)(input.task) } : {}),
+                ...(input.context ? { context: (0, redactSecrets_1.redactSecrets)(input.context) } : {}),
+                ...(input.riskLevel ? { risk_level: input.riskLevel } : {}),
+            }),
+        });
+        if (!response.ok) {
+            const message = await response.text();
+            throw new Error(message || response.statusText);
+        }
+        const rawOutput = (await response.json());
+        const normalized = normalizeNotifyTelegramOutput(rawOutput);
+        if (normalized) {
+            return normalized;
+        }
+        this.logger.error("notify_telegram received invalid gateway output", {
+            sessionId: input.sessionId,
+            output: rawOutput,
+        });
+        throw new Error(`Invalid notify_telegram gateway output: ${JSON.stringify(rawOutput)}`);
+    }
+    async sendDocumentViaGatewayBoundSession(input) {
+        if (!this._config.distributed.gatewayPublicUrl) {
+            throw new Error("File delivery to Telegram on client nodes requires GATEWAY_PUBLIC_URL.");
+        }
+        const clientUuid = await (0, gatewayClientAccess_1.ensureGatewayClientUuid)({
+            maintenanceStore: this.maintenanceStore,
+            gatewayPublicUrl: this._config.distributed.gatewayPublicUrl,
+            ...(this._config.distributed.gatewayAuthToken
+                ? { gatewayAuthToken: this._config.distributed.gatewayAuthToken }
+                : {}),
+            ...(this._config.distributed.gatewayToken
+                ? { gatewayToken: this._config.distributed.gatewayToken }
+                : {}),
+            ...(this._config.project.name
+                ? { projectName: this._config.project.name }
+                : {}),
+            ...(this._config.telegram.botUsername
+                ? { botUsername: this._config.telegram.botUsername }
+                : {}),
+            ...(this._config.distributed.gatewayUserUuid
+                ? { gatewayUserUuid: this._config.distributed.gatewayUserUuid }
+                : {}),
+        });
+        const output = await (0, gatewayClientAccess_1.callGatewayJson)({
+            gatewayPublicUrl: this._config.distributed.gatewayPublicUrl,
+            ...(this._config.distributed.gatewayAuthToken
+                ? { gatewayAuthToken: this._config.distributed.gatewayAuthToken }
+                : {}),
+            endpointPath: "/transport/document",
+            body: {
+                client_uuid: clientUuid,
+                local_session_id: input.sessionId,
+                file_name: input.fileName,
+                content_base64: input.contentBase64,
+                ...(input.caption ? { caption: input.caption } : {}),
+            },
+        });
+        if (!output.sent) {
+            throw new Error("Gateway did not confirm Telegram document delivery for the file.");
+        }
+        return {
+            session_id: input.sessionId,
+            file_path: input.filePath,
+            sent: true,
+            ...(typeof output.message_id === "number"
+                ? { message_id: output.message_id }
+                : {}),
+        };
+    }
+    async normalizeSessionIdForWorkspace(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return trimmed;
+        }
+        const direct = await this.sessionStore.getSession(trimmed);
+        if (direct) {
+            return trimmed;
+        }
+        const separatorIndex = trimmed.indexOf(":");
+        if (separatorIndex <= 0) {
+            return trimmed;
+        }
+        const localClientUuid = await this.maintenanceStore.getGatewayClientUuid();
+        const clientUuid = trimmed.slice(0, separatorIndex).trim();
+        const localSessionId = trimmed.slice(separatorIndex + 1).trim();
+        if (!localClientUuid || clientUuid !== localClientUuid || !localSessionId) {
+            return trimmed;
+        }
+        const localSession = await this.sessionStore.getSession(localSessionId);
+        return localSession ? localSessionId : trimmed;
+    }
+    async resolveSessionContextForNotification(sessionId) {
+        const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.sessionContext.getContextRemote", { session_id: sessionId });
+        if (remote?.context) {
+            return {
+                sessionId: remote.session_id,
+                ...(remote.context.session_label
+                    ? { label: remote.context.session_label }
+                    : {}),
+                ...(remote.context.cwd ? { cwd: remote.context.cwd } : {}),
+                ...(remote.context.active_project_uuid
+                    ? { activeProjectUuid: remote.context.active_project_uuid }
+                    : {}),
+                ...(remote.context.active_project_name
+                    ? { activeProjectName: remote.context.active_project_name }
+                    : {}),
+                ...(remote.context.task ? { task: remote.context.task } : {}),
+                ...(remote.context.summary ? { summary: remote.context.summary } : {}),
+                ...(remote.context.files ? { files: remote.context.files } : {}),
+                ...(remote.context.decisions
+                    ? { decisions: remote.context.decisions }
+                    : {}),
+                ...(remote.context.risks ? { risks: remote.context.risks } : {}),
+                ...(remote.context.updated_at
+                    ? { updatedAt: remote.context.updated_at }
+                    : { updatedAt: new Date().toISOString() }),
+            };
+        }
+        return this.sessionStore.getSession(sessionId);
+    }
 }
 exports.NotifyService = NotifyService;

package/dist/services/features/telegram-mcp/src/features/notify/model/notifyTelegramTool.js

@@ -18,7 +18,7 @@ class NotifyTelegramTool {
     register(server) {
         server.registerTool("notify_telegram", {
             title: "Notify Telegram",
-            description: "Use this for one-way status or progress notifications to the human linked to the session. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. This does not wait for a reply and does not create inbox work for the agent.",
+            description: "Use this for one-way status or progress notifications to the human linked to the current console. Pass session_id explicitly; do not rely on implicit defaults unless cwd is also correct for this agent workspace. This does not wait for a reply and does not create a new work item for the agent.",
             inputSchema: schema_1.notifyTelegramInputSchema,
             outputSchema: schema_1.notifyTelegramOutputSchema,
         }, async (args) => {

package/dist/services/features/telegram-mcp/src/features/notify/model/sendFileToTelegramTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendFileToTelegramTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class SendFileToTelegramTool {
+    notifyService;
+    constructor(notifyService) {
+        this.notifyService = notifyService;
+    }
+    register(server) {
+        server.registerTool("send_file_to_telegram", {
+            title: "Send File To Telegram",
+            description: "Send an existing local workspace file to the human linked to the current console in Telegram. Use this when another console returned a real artifact or file and the final human-facing result must be delivered to Telegram. Pass session_id explicitly for gateway-routed consoles.",
+            inputSchema: schema_1.sendFileToTelegramInputSchema,
+            outputSchema: schema_1.sendFileToTelegramOutputSchema,
+        }, async (args) => {
+            const output = await this.notifyService.sendDocument(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.SendFileToTelegramTool = SendFileToTelegramTool;

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

@@ -18,7 +18,7 @@ class ClearSessionContextTool {
     register(server) {
         server.registerTool("clear_session_context", {
             title: "Clear Session Context",
-            description: "Use this for full session cleanup/reset. It removes saved context, pairing, and related per-session state for the session.",
+            description: "Use this for full console cleanup/reset. It removes saved context and related per-console state for the target console.",
             inputSchema: schema_1.clearSessionContextInputSchema,
             outputSchema: schema_1.clearSessionContextOutputSchema,
         }, async (args) => {

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

@@ -18,7 +18,7 @@ class GetSessionContextTool {
     register(server) {
         server.registerTool("get_session_context", {
             title: "Get Session Context",
-            description: "Debug/setup tool. Read the saved context and Telegram binding status for a session. Do not call this in the normal inbox-processing path after a tmux nudge unless you are diagnosing state.",
+            description: "Debug/setup tool. Read the saved context and routing status for the current console. Use this when you need to inspect stored task summary, files, risks, or gateway-facing route state. Do not call it in the normal xchange-processing path unless you are diagnosing state.",
             inputSchema: schema_1.getSessionContextInputSchema,
             outputSchema: schema_1.getSessionContextOutputSchema,
         }, async (args) => {

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

@@ -18,7 +18,7 @@ class RenameSessionTool {
     register(server) {
         server.registerTool("rename_session", {
             title: "Rename Session",
-            description: "Rename only the human-readable session label. Use this when the user wants a clearer session name; it does not change session_id, pairing, tmux target, or saved context.",
+            description: "Rename only the human-readable console label. Use this when the user wants a clearer console name; it does not change session_id or saved context.",
             inputSchema: schema_1.renameSessionInputSchema,
             outputSchema: schema_1.renameSessionOutputSchema,
         }, async (args) => {