@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/src/features/tools-sync/model/refreshToolsMarkdownTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshToolsMarkdownTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class RefreshToolsMarkdownTool {
+    refreshToolsMarkdownService;
+    constructor(refreshToolsMarkdownService) {
+        this.refreshToolsMarkdownService = refreshToolsMarkdownService;
+    }
+    register(server) {
+        server.registerTool("refresh_tools_markdown", {
+            title: "Refresh TOOLS.md",
+            description: "Use this when the user asks to refresh or update agent instructions, tools documentation, or gateway-side working rules. Download the canonical TOOLS.md from the configured gateway, overwrite the local workspace TOOLS.md, then re-read that local TOOLS.md before continuing. If no gateway is configured, refresh from the local file.",
+            inputSchema: schema_1.refreshToolsMarkdownInputSchema,
+            outputSchema: schema_1.refreshToolsMarkdownOutputSchema,
+        }, async (args) => {
+            const output = await this.refreshToolsMarkdownService.refresh(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.RefreshToolsMarkdownTool = RefreshToolsMarkdownTool;

package/dist/services/features/telegram-mcp/src/processes/human-approval/model/orchestrator.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumanApprovalOrchestrator = void 0;
+const redactSecrets_1 = require("../../../shared/lib/redact-secrets/redactSecrets");
+const ids_1 = require("../../../shared/lib/ids/ids");
+function mergeSavedContext(input, session) {
+    const savedSections = [];
+    if (input.use_saved_context && session?.summary) {
+        savedSections.push(session.summary);
+    }
+    if (input.use_saved_context && session?.files?.length) {
+        savedSections.push(`Known files:\n${session.files.map((file) => `- ${file}`).join("\n")}`);
+    }
+    if (input.use_saved_context && session?.decisions?.length) {
+        savedSections.push(`Known decisions:\n${session.decisions.map((item) => `- ${item}`).join("\n")}`);
+    }
+    if (input.use_saved_context && session?.risks?.length) {
+        savedSections.push(`Known risks:\n${session.risks.map((item) => `- ${item}`).join("\n")}`);
+    }
+    const mergedContext = [input.context, ...savedSections]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+    return {
+        ...(mergedContext ? { context: mergedContext } : {}),
+        ...(input.task
+            ? { task: input.task }
+            : session?.task
+                ? { task: session.task }
+                : {}),
+        ...(session?.label ? { sessionLabel: session.label } : {}),
+    };
+}
+class HumanApprovalOrchestrator {
+    config;
+    sessionStore;
+    bindingStore;
+    pendingStore;
+    transport;
+    logger;
+    projectIdentityResolver;
+    processingQueue = false;
+    queuedJobs = new Map();
+    constructor(config, sessionStore, bindingStore, pendingStore, transport, logger, projectIdentityResolver) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.bindingStore = bindingStore;
+        this.pendingStore = pendingStore;
+        this.transport = transport;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async submit(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults({
+            session_id: input.session_id,
+        });
+        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 session = await this.sessionStore.getSession(resolved.sessionId);
+        const merged = mergeSavedContext(input, session);
+        const requestId = (0, ids_1.createRequestId)();
+        const requestRecord = {
+            requestId,
+            sessionId: resolved.sessionId,
+            ...(merged.sessionLabel
+                ? { sessionLabel: merged.sessionLabel }
+                : resolved.sessionLabel
+                    ? { sessionLabel: resolved.sessionLabel }
+                    : {}),
+            question: (0, redactSecrets_1.redactSecrets)(input.question),
+            ...(merged.task ? { task: (0, redactSecrets_1.redactSecrets)(merged.task) } : {}),
+            ...(merged.context ? { context: (0, redactSecrets_1.redactSecrets)(merged.context) } : {}),
+            ...(input.affected_files?.length
+                ? {
+                    affectedFiles: input.affected_files.map((file) => (0, redactSecrets_1.redactSecrets)(file)),
+                }
+                : {}),
+            ...(input.options?.length
+                ? { options: input.options.map((option) => (0, redactSecrets_1.redactSecrets)(option)) }
+                : {}),
+            ...(input.recommended_option
+                ? { recommendedOption: (0, redactSecrets_1.redactSecrets)(input.recommended_option) }
+                : {}),
+            ...(input.risk_level ? { riskLevel: input.risk_level } : {}),
+            timeoutSeconds: input.timeout_seconds ?? this.config.telegram.defaultTimeoutSeconds,
+            ...(input.fallback_if_timeout
+                ? { fallbackIfTimeout: (0, redactSecrets_1.redactSecrets)(input.fallback_if_timeout) }
+                : {}),
+            telegramChatId: binding.telegramChatId,
+            telegramUserId: binding.telegramUserId,
+            queuedAt: new Date().toISOString(),
+            status: this.config.mode === "queue" ? "queued" : "active",
+        };
+        if (this.config.mode === "reject") {
+            const active = await this.pendingStore.getActive();
+            if (active) {
+                throw new Error(`Another request is already pending: ${active.requestId}`);
+            }
+            return this.runRequest(requestRecord);
+        }
+        return new Promise((resolve, reject) => {
+            this.queuedJobs.set(requestId, {
+                request: requestRecord,
+                resolve,
+                reject,
+            });
+            void this.pendingStore.enqueue(requestRecord).then(() => {
+                void this.processQueue();
+            }, (error) => {
+                this.queuedJobs.delete(requestId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    }
+    async processQueue() {
+        if (this.processingQueue) {
+            return;
+        }
+        this.processingQueue = true;
+        try {
+            while (true) {
+                const next = await this.pendingStore.dequeueNext();
+                if (!next) {
+                    return;
+                }
+                const queuedJob = this.queuedJobs.get(next.requestId);
+                if (!queuedJob) {
+                    continue;
+                }
+                try {
+                    const result = await this.runRequest({
+                        ...next,
+                        status: "active",
+                    });
+                    this.queuedJobs.delete(next.requestId);
+                    queuedJob.resolve(result);
+                }
+                catch (error) {
+                    this.queuedJobs.delete(next.requestId);
+                    queuedJob.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        }
+        finally {
+            this.processingQueue = false;
+        }
+    }
+    async runRequest(request) {
+        const active = {
+            ...request,
+            status: "active",
+        };
+        await this.pendingStore.createPending(active);
+        this.logger.info("Pending request created", {
+            requestId: active.requestId,
+            sessionId: active.sessionId,
+        });
+        try {
+            const sendResult = await this.transport.sendRequest({
+                requestId: active.requestId,
+                sessionId: active.sessionId,
+                ...(active.sessionLabel ? { sessionLabel: active.sessionLabel } : {}),
+                recipient: {
+                    telegramChatId: active.telegramChatId,
+                    telegramUserId: active.telegramUserId,
+                },
+                ...(active.task ? { task: active.task } : {}),
+                question: active.question,
+                ...(active.context ? { context: active.context } : {}),
+                ...(active.affectedFiles
+                    ? { affectedFiles: active.affectedFiles }
+                    : {}),
+                ...(active.options ? { options: active.options } : {}),
+                ...(active.recommendedOption
+                    ? { recommendedOption: active.recommendedOption }
+                    : {}),
+                ...(active.riskLevel ? { riskLevel: active.riskLevel } : {}),
+                ...(active.fallbackIfTimeout
+                    ? { fallbackIfTimeout: active.fallbackIfTimeout }
+                    : {}),
+            });
+            const sentRequest = {
+                ...active,
+                ...(typeof sendResult.externalMessageId === "number"
+                    ? { telegramMessageId: sendResult.externalMessageId }
+                    : {}),
+                sentAt: new Date().toISOString(),
+            };
+            await this.pendingStore.updatePending(sentRequest);
+            const reply = await this.transport.waitForReply(sentRequest.requestId, sentRequest.timeoutSeconds);
+            if (!reply) {
+                await this.pendingStore.resolvePending(sentRequest.requestId, {
+                    status: "timed_out",
+                    ...(sentRequest.fallbackIfTimeout
+                        ? { fallbackUsed: sentRequest.fallbackIfTimeout }
+                        : {}),
+                });
+                this.logger.warn("Pending request timed out", {
+                    requestId: sentRequest.requestId,
+                });
+                return {
+                    request_id: sentRequest.requestId,
+                    answer: null,
+                    timed_out: true,
+                    ...(sentRequest.fallbackIfTimeout
+                        ? { fallback_used: sentRequest.fallbackIfTimeout }
+                        : {}),
+                };
+            }
+            await this.pendingStore.resolvePending(sentRequest.requestId, {
+                status: "answered",
+                answer: (0, redactSecrets_1.redactSecrets)(reply.answer),
+                receivedAt: reply.receivedAt,
+            });
+            this.logger.info("Pending request answered", {
+                requestId: sentRequest.requestId,
+            });
+            return {
+                request_id: sentRequest.requestId,
+                answer: (0, redactSecrets_1.redactSecrets)(reply.answer),
+                timed_out: false,
+                received_at: reply.receivedAt,
+            };
+        }
+        catch (error) {
+            await this.pendingStore.resolvePending(active.requestId, {
+                status: "failed",
+                errorMessage: error instanceof Error ? error.message : String(error),
+            });
+            this.logger.error("Pending request failed", {
+                requestId: active.requestId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    get mode() {
+        return this.config.mode;
+    }
+}
+exports.HumanApprovalOrchestrator = HumanApprovalOrchestrator;

package/dist/services/features/telegram-mcp/src/shared/api/storage/contract.js

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

package/dist/services/features/telegram-mcp/src/shared/api/tool-registry/registry.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+function registerTools(server, tools) {
+    for (const tool of tools) {
+        tool.register(server);
+    }
+}

package/dist/services/features/telegram-mcp/src/shared/api/tool-registry/types.js

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

package/dist/services/features/telegram-mcp/src/shared/api/transport/contract.js

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

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

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinioExchangeStore = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:fs/promises");
+const client_1 = require("../tmux/client");
+function normalizeRelativePath(relativePath) {
+    const normalized = relativePath
+        .split(/[/\\]+/u)
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0 && segment !== "." && segment !== "..")
+        .join("/");
+    if (!normalized) {
+        throw new Error("Relative exchange path is required.");
+    }
+    return normalized;
+}
+function resolveWorkspaceDir(session, _tmuxConfig) {
+    const workspaceDir = session?.cwd?.trim() || "";
+    return workspaceDir || process.cwd();
+}
+class MinioExchangeStore {
+    tmuxConfig;
+    exchangeDirName;
+    logger;
+    constructor(_callBroker, _bindingStore, tmuxConfig, exchangeDirName, _vfsScope, logger, _distributedMode = "client", _gatewayPublicUrl, _gatewayAuthToken) {
+        this.tmuxConfig = tmuxConfig;
+        this.exchangeDirName = exchangeDirName;
+        this.logger = logger;
+    }
+    resolveWorkspaceDir(session) {
+        return resolveWorkspaceDir(session, this.tmuxConfig);
+    }
+    getTempSessionDir(sessionId) {
+        return node_path_1.default.resolve(process.cwd(), this.exchangeDirName, "__legacy__", sessionId);
+    }
+    async storeFile(params) {
+        const relativePath = normalizeRelativePath(params.relativePath);
+        const workspaceDir = this.resolveWorkspaceDir(params.session);
+        const filePath = await (0, client_1.writeXchangeRelativeFile)(this.tmuxConfig, workspaceDir, this.exchangeDirName, relativePath, Buffer.from(params.content));
+        this.logger.info("Exchange file stored locally", {
+            sessionId: params.sessionId,
+            source: params.source,
+            relativePath,
+            filePath,
+        });
+        return {
+            filePath,
+            relativePath,
+            sizeBytes: params.content.byteLength,
+        };
+    }
+    async ensureLocalFile(params) {
+        const candidates = new Set();
+        if (params.filePath?.trim()) {
+            candidates.add(node_path_1.default.isAbsolute(params.filePath)
+                ? node_path_1.default.resolve(params.filePath)
+                : node_path_1.default.resolve(this.resolveWorkspaceDir(params.session), params.filePath));
+        }
+        if (params.relativePath?.trim()) {
+            candidates.add(node_path_1.default.resolve(this.resolveWorkspaceDir(params.session), this.exchangeDirName, normalizeRelativePath(params.relativePath)));
+        }
+        for (const candidate of candidates) {
+            try {
+                await (0, promises_1.access)(candidate);
+                return candidate;
+            }
+            catch {
+                // try next candidate
+            }
+        }
+        throw new Error(params.storageRef
+            ? "Exchange file is not available locally. VFS/S3 relay has been removed."
+            : "Exchange file is not available locally.");
+    }
+    async readStoredContent(_params) {
+        throw new Error("Direct VFS/S3 artifact reads are no longer supported.");
+    }
+    async deleteStoredFile(_params) {
+        // Local exchange files are deleted directly by their workspace path.
+    }
+}
+exports.MinioExchangeStore = MinioExchangeStore;