@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/src/features/browser/model/browserWaitForTool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserWaitForTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [{ type: "text", text: JSON.stringify(output, null, 2) }];
+}
+class BrowserWaitForTool {
+    browserService;
+    constructor(browserService) {
+        this.browserService = browserService;
+    }
+    register(server) {
+        server.registerTool("browser_wait_for", {
+            title: "Browser Wait For",
+            description: "Wait for an element in the session browser page to reach the requested state by CSS selector or visible text.",
+            inputSchema: schema_1.browserWaitForInputSchema,
+            outputSchema: schema_1.browserWaitForOutputSchema,
+        }, async (args) => {
+            const output = await this.browserService.waitFor(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.BrowserWaitForTool = BrowserWaitForTool;

package/dist/services/features/telegram-mcp/src/features/browser/model/browserWaitForUrlTool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserWaitForUrlTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [{ type: "text", text: JSON.stringify(output, null, 2) }];
+}
+class BrowserWaitForUrlTool {
+    browserService;
+    constructor(browserService) {
+        this.browserService = browserService;
+    }
+    register(server) {
+        server.registerTool("browser_wait_for_url", {
+            title: "Browser Wait For URL",
+            description: "Wait for the session browser page to reach an exact URL or contain a URL fragment after navigation.",
+            inputSchema: schema_1.browserWaitForUrlInputSchema,
+            outputSchema: schema_1.browserWaitForUrlOutputSchema,
+        }, async (args) => {
+            const output = await this.browserService.waitForUrl(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.BrowserWaitForUrlTool = BrowserWaitForUrlTool;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/backend.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/features/telegram-mcp/src/features/collaboration/model/collaborationService.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollaborationService = void 0;
+class CollaborationService {
+    backend;
+    logger;
+    projectIdentityResolver;
+    constructor(backend, logger, projectIdentityResolver) {
+        this.backend = backend;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async sendPartnerNote(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const output = await this.backend.sendPartnerNote(input, resolved);
+        this.logger.info("Partner note processed by collaboration service", {
+            sessionId: output.session_id,
+            partnerSessionId: output.partner_session_id,
+            shareId: output.share_id,
+            kind: output.kind,
+            sessionIdDerived: resolved.sessionIdDerived,
+        });
+        return output;
+    }
+}
+exports.CollaborationService = CollaborationService;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/localCollaborationBackend.js

@@ -0,0 +1,390 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCollaborationBackend = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ids_1 = require("../../../shared/lib/ids/ids");
+const client_1 = require("../../../shared/integrations/tmux/client");
+function slugify(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-")
+        .slice(0, 48);
+}
+const SOURCE_ARTIFACT_EXTENSIONS = new Set([
+    ".c",
+    ".cc",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".go",
+    ".h",
+    ".hpp",
+    ".html",
+    ".java",
+    ".js",
+    ".jsx",
+    ".kt",
+    ".less",
+    ".mjs",
+    ".php",
+    ".py",
+    ".rb",
+    ".rs",
+    ".sass",
+    ".scala",
+    ".scss",
+    ".sh",
+    ".sql",
+    ".svelte",
+    ".swift",
+    ".ts",
+    ".tsx",
+    ".vue",
+    ".xml",
+    ".zsh",
+]);
+const PARTNER_INDEX_FILE_NAME = "SHARED_INDEX.md";
+function trimOptional(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function isReplyRequired(kind, input) {
+    if (typeof input.requires_reply === "boolean") {
+        return input.requires_reply;
+    }
+    return kind === "question" || kind === "request";
+}
+function isSourceArtifactPath(filePath) {
+    return SOURCE_ARTIFACT_EXTENSIONS.has(node_path_1.default.extname(filePath).toLowerCase());
+}
+function buildShareId(kind, sourceLabel, summary, now) {
+    const timestamp = now.toISOString().replace(/[:.]/gu, "-");
+    return [
+        timestamp,
+        slugify(sourceLabel) || "session",
+        kind,
+        slugify(summary) || "note",
+    ].join("-");
+}
+function renderYamlArray(values) {
+    if (values.length === 0) {
+        return "[]";
+    }
+    return `\n${values.map((value) => `  - ${JSON.stringify(value)}`).join("\n")}`;
+}
+function buildPartnerInboxText(input) {
+    const kindTitle = input.kind === "question"
+        ? "Partner question received."
+        : input.kind === "reply"
+            ? "Partner reply received."
+            : input.kind === "request"
+                ? "Partner request received."
+                : input.kind === "handoff"
+                    ? "Partner handoff received."
+                    : "Partner update received.";
+    return [
+        kindTitle,
+        `From: ${input.fromLabel}`,
+        `Summary: ${input.summary}`,
+        "",
+        `Immediate action: read ${PARTNER_INDEX_FILE_NAME} and then open the note below.`,
+        `Note: ${input.notePath}`,
+        ...(input.copiedArtifacts.length > 0
+            ? ["", "Artifacts:", ...input.copiedArtifacts.map((item) => `- ${item}`)]
+            : []),
+        ...(input.requiresReply
+            ? [
+                "",
+                "Reply through send_partner_note after you finish the requested work.",
+                "The task is not complete until send_partner_note succeeds.",
+            ]
+            : []),
+    ].join("\n");
+}
+function buildNoteContent(input) {
+    const lines = ["---"];
+    lines.push(`kind: ${JSON.stringify(input.kind)}`);
+    lines.push(`from_session_id: ${JSON.stringify(input.sourceSessionId)}`);
+    lines.push(`from_label: ${JSON.stringify(input.sourceLabel)}`);
+    lines.push(`to_session_id: ${JSON.stringify(input.targetSessionId)}`);
+    lines.push(`to_label: ${JSON.stringify(input.targetLabel)}`);
+    lines.push(`created_at: ${JSON.stringify(input.createdAt)}`);
+    if (input.requiresReply) {
+        lines.push("requires_reply: true");
+    }
+    if (input.inReplyTo) {
+        lines.push(`in_reply_to: ${JSON.stringify(input.inReplyTo)}`);
+    }
+    if (input.copiedArtifacts.length > 0) {
+        lines.push(`artifacts:${renderYamlArray(input.copiedArtifacts)}`);
+    }
+    lines.push("---", "", "# Summary", input.summary.trim(), "", "# Message", input.message.trim());
+    if (input.expectedReply?.trim()) {
+        lines.push("", "# Expected Reply", input.expectedReply.trim());
+    }
+    if (input.requiresReply) {
+        lines.push("", "# Action Required", "You must send a reply via send_partner_note.", "Your task is not complete until send_partner_note succeeds.", "Do not stop after local analysis or a chat explanation.", "Use the current partner route for the reply.", "Only after the tool succeeds may you say that the reply was sent.", "", "# Reply Tool Call Example", "send_partner_note(", `  session_id=${JSON.stringify(input.targetSessionId)},`, `  kind=${JSON.stringify("reply")},`, "  summary=\"Короткий итог\",", "  message=\"Подробный ответ\"", ")");
+    }
+    if (input.copiedArtifacts.length > 0) {
+        lines.push("", "# Artifacts", ...input.copiedArtifacts.map((artifact) => `- ${artifact}`));
+    }
+    return `${lines.join("\n")}\n`;
+}
+function buildShareIndexLine(input) {
+    return [
+        "-",
+        `[${input.createdAt}]`,
+        `${input.sourceLabel} → ${input.targetLabel}`,
+        `| ${input.kind} |`,
+        `${input.summary}`,
+        `| \`${input.relativeNotePath}\``,
+    ].join(" ");
+}
+class LocalCollaborationBackend {
+    config;
+    sessionStore;
+    bindingStore;
+    inboxStore;
+    xchangeFileMetaStore;
+    objectStore;
+    telegramTransport;
+    logger;
+    textEncoder = new TextEncoder();
+    constructor(config, sessionStore, bindingStore, inboxStore, xchangeFileMetaStore, objectStore, telegramTransport, logger) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.bindingStore = bindingStore;
+        this.inboxStore = inboxStore;
+        this.xchangeFileMetaStore = xchangeFileMetaStore;
+        this.objectStore = objectStore;
+        this.telegramTransport = telegramTransport;
+        this.logger = logger;
+    }
+    async sendPartnerNote(input, resolved) {
+        const sourceSession = await this.sessionStore.getSession(resolved.sessionId);
+        if (!sourceSession) {
+            throw new Error(`Session ${resolved.sessionId} was not found. Pair the session before collaborating.`);
+        }
+        const targetSessionId = trimOptional(input.target_session_id) ?? sourceSession.linkedSessionId;
+        if (!targetSessionId) {
+            throw new Error("This session has no linked partner. Link another session in Telegram first.");
+        }
+        const targetSession = await this.sessionStore.getSession(targetSessionId);
+        if (!targetSession) {
+            throw new Error(`Target partner session ${targetSessionId} was not found.`);
+        }
+        const targetBinding = await this.bindingStore.getBinding(targetSession.sessionId);
+        if (!targetBinding) {
+            throw new Error(`Linked partner session ${targetSession.sessionId} is not paired with Telegram.`);
+        }
+        const now = new Date();
+        const createdAt = now.toISOString();
+        const sourceLabel = sourceSession.label ?? sourceSession.sessionId;
+        const targetLabel = targetSession.label ?? targetSession.sessionId;
+        const shareId = buildShareId(input.kind, sourceLabel, input.summary, now);
+        const sourceWorkspaceDir = this.resolveWorkspaceDir(sourceSession, resolved.sessionId);
+        const targetWorkspaceDir = this.resolveWorkspaceDir(targetSession, targetSession.sessionId);
+        const relativeNotePath = `shares/${shareId}.md`;
+        const requiresReply = isReplyRequired(input.kind, input);
+        const copiedArtifacts = await this.copyArtifactsToPartner(sourceSession, targetSession, sourceWorkspaceDir, targetWorkspaceDir, shareId, createdAt, input.artifacts ?? []);
+        const inReplyTo = trimOptional(input.in_reply_to);
+        const expectedReply = trimOptional(input.expected_reply);
+        const noteContent = buildNoteContent({
+            shareId,
+            kind: input.kind,
+            sourceSessionId: sourceSession.sessionId,
+            sourceLabel,
+            targetSessionId: targetSession.sessionId,
+            targetLabel,
+            createdAt,
+            requiresReply,
+            ...(inReplyTo ? { inReplyTo } : {}),
+            copiedArtifacts,
+            summary: input.summary,
+            message: input.message,
+            ...(expectedReply ? { expectedReply } : {}),
+        });
+        const notePath = await (0, client_1.writeXchangeRelativeFile)(this.config.tmux, targetWorkspaceDir, this.config.exchange.dir, relativeNotePath, this.textEncoder.encode(noteContent));
+        await this.xchangeFileMetaStore.setXchangeFileMeta({
+            sessionId: targetSession.sessionId,
+            filePath: notePath,
+            relativePath: relativeNotePath,
+            source: "partner-artifact",
+            uploadedAt: createdAt,
+            mimeType: "text/markdown",
+            sizeBytes: this.textEncoder.encode(noteContent).byteLength,
+        });
+        const shareIndexPath = await (0, client_1.writeXchangeRelativeFile)(this.config.tmux, targetWorkspaceDir, this.config.exchange.dir, PARTNER_INDEX_FILE_NAME, this.textEncoder.encode(`${buildShareIndexLine({
+            createdAt,
+            sourceLabel,
+            targetLabel,
+            kind: input.kind,
+            summary: input.summary.trim(),
+            relativeNotePath,
+        })}\n`), { append: true });
+        const inboxMessage = {
+            id: (0, ids_1.createInboxMessageId)(now),
+            sessionId: targetSession.sessionId,
+            telegramChatId: targetBinding.telegramChatId,
+            telegramUserId: targetBinding.telegramUserId,
+            sourceTelegramMessageId: now.getTime(),
+            text: buildPartnerInboxText({
+                kind: input.kind,
+                fromLabel: sourceLabel,
+                summary: input.summary.trim(),
+                notePath,
+                requiresReply,
+                copiedArtifacts,
+            }),
+            attachments: [notePath, ...copiedArtifacts],
+            receivedAt: createdAt,
+        };
+        await this.inboxStore.createInboxMessage(inboxMessage);
+        await this.telegramTransport.sendNotification({
+            sessionId: targetSession.sessionId,
+            ...(targetSession.label ? { sessionLabel: targetSession.label } : {}),
+            recipient: {
+                telegramChatId: targetBinding.telegramChatId,
+                telegramUserId: targetBinding.telegramUserId,
+            },
+            message: [
+                input.kind === "question"
+                    ? `Получен вопрос от ${sourceLabel}.`
+                    : input.kind === "reply"
+                        ? `Получен ответ от ${sourceLabel}.`
+                        : input.kind === "request"
+                            ? `Получен запрос от ${sourceLabel}.`
+                            : input.kind === "handoff"
+                                ? copiedArtifacts.length > 0
+                                    ? `Получен файл от ${sourceLabel}.`
+                                    : `Получен handoff от ${sourceLabel}.`
+                                : `Получено обновление от ${sourceLabel}.`,
+                `Сессия: ${sourceLabel} -> ${targetLabel}`,
+                `Тип: ${input.kind}`,
+                `Кратко: ${input.summary.trim()}`,
+                ...(copiedArtifacts.length > 0
+                    ? [
+                        "",
+                        `Файлы: ${copiedArtifacts.length}`,
+                        ...copiedArtifacts.map((item) => `- ${node_path_1.default.basename(item)}`),
+                    ]
+                    : []),
+                "",
+                `Note: ${notePath}`,
+            ].join("\n"),
+        });
+        try {
+            await this.telegramTransport.nudgeSessionPartnerNote(targetSession.sessionId);
+        }
+        catch (error) {
+            this.logger.warn("tmux nudge failed after local partner delivery", {
+                sessionId: targetSession.sessionId,
+                partnerSessionId: sourceSession.sessionId,
+                shareId,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+        }
+        this.logger.info("Partner note delivered through local backend", {
+            sessionId: sourceSession.sessionId,
+            partnerSessionId: targetSession.sessionId,
+            shareId,
+            kind: input.kind,
+            notePath,
+            copiedArtifacts,
+            requiresReply,
+            sessionIdDerived: resolved.sessionIdDerived,
+        });
+        return {
+            session_id: sourceSession.sessionId,
+            partner_session_id: targetSession.sessionId,
+            kind: input.kind,
+            share_id: shareId,
+            delivery_status: "delivered",
+            note_path: notePath,
+            share_index_path: shareIndexPath,
+            copied_artifacts: copiedArtifacts,
+            inbox_message_id: inboxMessage.id,
+            requires_reply: requiresReply,
+        };
+    }
+    resolveWorkspaceDir(session, _sessionId) {
+        const workspaceDir = session.cwd?.trim();
+        if (workspaceDir) {
+            return workspaceDir;
+        }
+        return process.cwd();
+    }
+    async copyArtifactsToPartner(sourceSession, targetSession, sourceWorkspaceDir, targetWorkspaceDir, shareId, uploadedAt, artifacts) {
+        const copied = [];
+        const usedArtifactNames = new Set();
+        for (const artifactPath of artifacts) {
+            if (isSourceArtifactPath(artifactPath)) {
+                throw new Error(`Source file artifacts are not allowed for partner exchange: ${artifactPath}. Share summaries, API specs, logs, screenshots, or other derived artifacts instead.`);
+            }
+            const sourceMeta = await this.xchangeFileMetaStore.getXchangeFileMeta(sourceSession.sessionId, artifactPath);
+            const preferredArtifactName = sourceMeta?.originalName ||
+                (sourceMeta?.relativePath
+                    ? node_path_1.default.basename(sourceMeta.relativePath)
+                    : undefined) ||
+                node_path_1.default.basename(artifactPath) ||
+                "artifact.bin";
+            const artifactName = this.allocatePartnerArtifactName(preferredArtifactName, usedArtifactNames);
+            const relativeArtifactPath = [
+                "shares",
+                "files",
+                shareId,
+                artifactName,
+            ].join("/");
+            const ensuredArtifactPath = sourceMeta
+                ? await this.objectStore.ensureLocalFile({
+                    sessionId: sourceSession.sessionId,
+                    session: sourceSession,
+                    filePath: artifactPath,
+                    relativePath: sourceMeta.relativePath,
+                    storageRef: sourceMeta.storageRef,
+                    source: sourceMeta.source,
+                })
+                : artifactPath;
+            const content = await (0, client_1.readWorkspaceFile)(this.config.tmux, sourceWorkspaceDir, ensuredArtifactPath);
+            const materializedArtifactPath = await (0, client_1.writeXchangeRelativeFile)(this.config.tmux, targetWorkspaceDir, this.config.exchange.dir, relativeArtifactPath, content);
+            await this.xchangeFileMetaStore.setXchangeFileMeta({
+                sessionId: targetSession.sessionId,
+                filePath: materializedArtifactPath,
+                relativePath: relativeArtifactPath,
+                source: "partner-artifact",
+                uploadedAt,
+                ...(sourceMeta?.originalName
+                    ? { originalName: sourceMeta.originalName }
+                    : {}),
+                ...(sourceMeta?.caption ? { caption: sourceMeta.caption } : {}),
+                ...(sourceMeta?.mimeType ? { mimeType: sourceMeta.mimeType } : {}),
+                ...(typeof sourceMeta?.sizeBytes === "number"
+                    ? { sizeBytes: sourceMeta.sizeBytes }
+                    : {}),
+            });
+            copied.push(materializedArtifactPath);
+        }
+        return copied;
+    }
+    allocatePartnerArtifactName(fileName, usedArtifactNames) {
+        const baseName = node_path_1.default.basename(fileName).trim() || "artifact.bin";
+        const extension = node_path_1.default.extname(baseName);
+        const stem = node_path_1.default.basename(baseName, extension) || "artifact";
+        for (let attempt = 0; attempt < 1000; attempt += 1) {
+            const candidate = attempt === 0 ? baseName : `${stem}--${attempt}${extension}`;
+            if (usedArtifactNames.has(candidate)) {
+                continue;
+            }
+            usedArtifactNames.add(candidate);
+            return candidate;
+        }
+        throw new Error("Could not allocate a unique partner artifact name.");
+    }
+}
+exports.LocalCollaborationBackend = LocalCollaborationBackend;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/sendPartnerFileService.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendPartnerFileService = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const mime_types_1 = require("mime-types");
+const client_1 = require("../../../shared/integrations/tmux/client");
+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 SendPartnerFileService {
+    config;
+    sessionStore;
+    logger;
+    projectIdentityResolver;
+    collaborationService;
+    constructor(config, sessionStore, logger, projectIdentityResolver, collaborationService) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+        this.collaborationService = collaborationService;
+    }
+    async send(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const session = await this.sessionStore.getSession(resolved.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.tmux, workspaceDir, relativeFilePath);
+        const originalName = node_path_1.default.basename(relativeFilePath);
+        const mimeType = (0, mime_types_1.lookup)(originalName) || "application/octet-stream";
+        const output = await this.collaborationService.sendPartnerNote({
+            session_id: resolved.sessionId,
+            ...(input.target_session_id?.trim()
+                ? { target_session_id: input.target_session_id.trim() }
+                : {}),
+            ...(input.project_uuid?.trim()
+                ? { project_uuid: input.project_uuid.trim() }
+                : {}),
+            kind: input.kind ?? "handoff",
+            summary: input.summary?.trim() || `Передача файла: ${originalName}`,
+            message: input.message?.trim() || `Передаю файл \`${originalName}\`.`,
+            ...(input.expected_reply?.trim()
+                ? { expected_reply: input.expected_reply.trim() }
+                : {}),
+            ...(typeof input.requires_reply === "boolean"
+                ? { requires_reply: input.requires_reply }
+                : {}),
+            ...(input.in_reply_to?.trim()
+                ? { in_reply_to: input.in_reply_to.trim() }
+                : {}),
+            artifacts: [relativeFilePath],
+            artifact_refs: [
+                {
+                    file_path: relativeFilePath,
+                    original_name: originalName,
+                    mime_type: mimeType,
+                    size_bytes: fileContent.byteLength,
+                    content_base64: Buffer.from(fileContent).toString("base64"),
+                },
+            ],
+        });
+        this.logger.info("Partner file sent through send_partner_file", {
+            sessionId: output.session_id,
+            partnerSessionId: output.partner_session_id,
+            filePath: relativeFilePath,
+            kind: output.kind,
+            shareId: output.share_id,
+        });
+        return output;
+    }
+}
+exports.SendPartnerFileService = SendPartnerFileService;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/sendPartnerFileTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendPartnerFileTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class SendPartnerFileTool {
+    sendPartnerFileService;
+    constructor(sendPartnerFileService) {
+        this.sendPartnerFileService = sendPartnerFileService;
+    }
+    register(server) {
+        server.registerTool("send_partner_file", {
+            title: "Send Partner File",
+            description: "Use this when the result must include a real local workspace file for another session. Prefer this over send_partner_note when you already have an existing file path such as sample.txt, report.pdf, or screenshot.png. The tool reads the file from the current session workspace, attaches it as an artifact, and sends the partner note in one step.",
+            inputSchema: schema_1.sendPartnerFileInputSchema,
+            outputSchema: schema_1.sendPartnerNoteOutputSchema,
+        }, async (args) => {
+            const output = await this.sendPartnerFileService.send(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.SendPartnerFileTool = SendPartnerFileTool;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/sendPartnerNoteTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendPartnerNoteTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class SendPartnerNoteTool {
+    collaborationService;
+    constructor(collaborationService) {
+        this.collaborationService = collaborationService;
+    }
+    register(server) {
+        server.registerTool("send_partner_note", {
+            title: "Send Partner Note",
+            description: "Use this for agent-to-agent collaboration: ask another session to do work, send a reply, or share results. Resolve the target explicitly for project/collab work with target_session_id and, if available, project_uuid. If the result includes an existing local file, prefer send_partner_file; mentioning the filename in message text is not enough. For required replies, the task is not complete until this tool succeeds.",
+            inputSchema: schema_1.sendPartnerNoteInputSchema,
+            outputSchema: schema_1.sendPartnerNoteOutputSchema,
+        }, async (args) => {
+            const output = await this.collaborationService.sendPartnerNote(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.SendPartnerNoteTool = SendPartnerNoteTool;