@deadragdoll/tellymcp 0.0.1

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

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureXchangeDir = ensureXchangeDir;
+exports.writeXchangeFile = writeXchangeFile;
+exports.writeXchangeRelativeFile = writeXchangeRelativeFile;
+exports.listXchangeFiles = listXchangeFiles;
+exports.deleteXchangeFile = deleteXchangeFile;
+exports.readWorkspaceFile = readWorkspaceFile;
+exports.isTmuxUnavailableError = isTmuxUnavailableError;
+exports.getTmuxWindowHeight = getTmuxWindowHeight;
+exports.captureTmuxPaneRange = captureTmuxPaneRange;
+exports.captureVisibleTmuxPane = captureVisibleTmuxPane;
+exports.sendAllowedTmuxAction = sendAllowedTmuxAction;
+exports.sendTmuxLiteralLine = sendTmuxLiteralLine;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const ENTER_AFTER_PASTE_DELAY_MS = 75;
+const SUBMIT_LINE_KEY = "C-m";
+function sanitizeFileName(fileName) {
+    const baseName = node_path_1.default.basename(fileName).trim();
+    const withoutControlChars = Array.from(baseName)
+        .map((char) => (char.charCodeAt(0) < 32 ? "-" : char))
+        .join("");
+    const normalized = withoutControlChars
+        .replace(/[/\\]/g, "-")
+        .replace(/[<>:"|?*]/g, "-")
+        .replace(/\s+/g, " ")
+        .trim();
+    return normalized || "file.bin";
+}
+function sanitizeRelativeXchangePath(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 resolvePathInsideRoot(rootDir, relativePath) {
+    const safeRelativePath = sanitizeRelativeXchangePath(relativePath);
+    const resolvedPath = node_path_1.default.resolve(rootDir, safeRelativePath);
+    const relative = node_path_1.default.relative(rootDir, resolvedPath);
+    if (relative.startsWith("..") ||
+        node_path_1.default.isAbsolute(relative) ||
+        relative.trim() === "") {
+        throw new Error("Resolved path is outside the exchange directory.");
+    }
+    return resolvedPath;
+}
+function resolvePathInsideWorkspace(workspaceDir, filePath) {
+    const resolvedWorkspaceDir = node_path_1.default.resolve(workspaceDir);
+    const resolvedFilePath = node_path_1.default.isAbsolute(filePath)
+        ? node_path_1.default.resolve(filePath)
+        : node_path_1.default.resolve(resolvedWorkspaceDir, filePath);
+    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 resolvedFilePath;
+}
+async function allocateAvailableFilePath(dir, fileName) {
+    const safeFileName = sanitizeFileName(fileName);
+    const extension = node_path_1.default.extname(safeFileName);
+    const baseName = node_path_1.default.basename(safeFileName, extension);
+    for (let attempt = 0; attempt < 1000; attempt += 1) {
+        const candidateName = attempt === 0
+            ? safeFileName
+            : `${baseName}--${attempt}${extension}`;
+        const candidatePath = node_path_1.default.join(dir, candidateName);
+        try {
+            await (0, promises_1.access)(candidatePath);
+        }
+        catch {
+            return candidatePath;
+        }
+    }
+    throw new Error("Could not allocate a unique file name in exchange directory.");
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function execFileAsync(command, args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(command, args, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function execFileOutputAsync(command, args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(command, args, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+function buildTmuxArgs(config, args, socketPath) {
+    const resolvedSocketPath = socketPath ?? config.socketPath;
+    return resolvedSocketPath ? ["-S", resolvedSocketPath, ...args] : args;
+}
+async function ensureXchangeDir(config, workspaceDir, exchangeDirName) {
+    const resolvedDir = node_path_1.default.resolve(workspaceDir, exchangeDirName);
+    await (0, promises_1.mkdir)(resolvedDir, { recursive: true });
+    return resolvedDir;
+}
+async function writeXchangeFile(config, workspaceDir, exchangeDirName, fileName, content) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    const outputPath = await allocateAvailableFilePath(dir, fileName);
+    await (0, promises_1.writeFile)(outputPath, content);
+    return outputPath;
+}
+async function writeXchangeRelativeFile(config, workspaceDir, exchangeDirName, relativePath, content, options) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    const outputPath = resolvePathInsideRoot(dir, relativePath);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(outputPath), { recursive: true });
+    if (options?.append) {
+        await (0, promises_1.appendFile)(outputPath, content);
+    }
+    else {
+        await (0, promises_1.writeFile)(outputPath, content);
+    }
+    return outputPath;
+}
+async function listXchangeFiles(config, workspaceDir, exchangeDirName) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    return listFilesRecursively(dir);
+}
+async function listFilesRecursively(rootDir) {
+    const files = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files.sort((left, right) => right.localeCompare(left));
+}
+async function deleteXchangeFile(config, workspaceDir, exchangeDirName, filePath) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    const resolvedFilePath = node_path_1.default.resolve(filePath);
+    const relative = node_path_1.default.relative(dir, resolvedFilePath);
+    if (relative.startsWith("..") ||
+        node_path_1.default.isAbsolute(relative) ||
+        relative.trim() === "") {
+        throw new Error("File path is outside the exchange directory.");
+    }
+    await (0, promises_1.rm)(resolvedFilePath, { force: true });
+    return true;
+}
+async function readWorkspaceFile(config, workspaceDir, filePath) {
+    const resolvedFilePath = resolvePathInsideWorkspace(workspaceDir, filePath);
+    return (0, promises_1.readFile)(resolvedFilePath);
+}
+function isTmuxUnavailableError(error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    return (message.includes("error connecting to /tmp/tmux-") ||
+        message.includes("No such file or directory") ||
+        message.includes("ENOENT") ||
+        message.includes("tmux is unavailable"));
+}
+async function getTmuxWindowHeight(config, target) {
+    const { stdout: heightRaw } = await execFileOutputAsync("tmux", buildTmuxArgs(config, ["display-message", "-p", "-t", target, "#{window_height}"]));
+    const height = Number.parseInt(heightRaw.trim(), 10);
+    return Number.isFinite(height) && height > 0 ? height : null;
+}
+async function captureTmuxPaneRange(config, target, start, includeEscapes) {
+    const args = [
+        "capture-pane",
+        "-p",
+        ...(includeEscapes ? ["-e"] : []),
+        "-t",
+        target,
+        "-S",
+        start,
+    ];
+    const { stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, args));
+    return stdout.replaceAll("\u0000", "");
+}
+async function captureVisibleTmuxPane(config, target, fallbackLines, visibleScreens) {
+    const height = await getTmuxWindowHeight(config, target);
+    const baseLines = typeof height === "number" && height > 0 ? height : Math.max(1, fallbackLines);
+    const lines = Math.max(1, baseLines * Math.max(1, visibleScreens));
+    let stdout = "";
+    try {
+        ({ stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
+            "capture-pane",
+            "-p",
+            "-e",
+            "-a",
+            "-t",
+            target,
+            "-S",
+            `-${lines}`,
+        ])));
+    }
+    catch (error) {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        if (!message.includes("no alternate screen")) {
+            throw error;
+        }
+        ({ stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
+            "capture-pane",
+            "-p",
+            "-e",
+            "-t",
+            target,
+            "-S",
+            `-${lines}`,
+        ])));
+    }
+    return stdout.replaceAll("\u0000", "");
+}
+async function sendAllowedTmuxAction(config, target, action) {
+    const key = action === "up"
+        ? "Up"
+        : action === "down"
+            ? "Down"
+            : action === "slash"
+                ? "/"
+                : action === "delete"
+                    ? "BSpace"
+                    : action === "tab"
+                        ? "Tab"
+                        : action === "escape"
+                            ? "Escape"
+                            : "Enter";
+    await execFileAsync("tmux", buildTmuxArgs(config, ["send-keys", "-t", target, key]));
+}
+async function sendTmuxLiteralLine(config, target, text) {
+    const normalized = text.replace(/\r?\n/g, " ").trim();
+    const bufferName = `telegram-mcp-${Date.now().toString(36)}`;
+    if (normalized.length > 0) {
+        try {
+            await execFileAsync("tmux", buildTmuxArgs(config, ["set-buffer", "-b", bufferName, normalized]));
+            await execFileAsync("tmux", buildTmuxArgs(config, [
+                "paste-buffer",
+                "-d",
+                "-b",
+                bufferName,
+                "-t",
+                target,
+            ]));
+        }
+        finally {
+            await execFileAsync("tmux", buildTmuxArgs(config, ["delete-buffer", "-b", bufferName])).catch(() => undefined);
+        }
+        await delay(ENTER_AFTER_PASTE_DELAY_MS);
+    }
+    await execFileAsync("tmux", buildTmuxArgs(config, ["send-keys", "-t", target, SUBMIT_LINE_KEY]));
+}

package/dist/services/features/telegram-mcp/src/shared/lib/ids/ids.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestId = createRequestId;
+exports.createPairCode = createPairCode;
+exports.createInboxMessageId = createInboxMessageId;
+exports.createMenuPayloadKey = createMenuPayloadKey;
+const node_crypto_1 = require("node:crypto");
+function randomBase36(size) {
+    return (0, node_crypto_1.randomBytes)(size)
+        .toString("base64url")
+        .replace(/[^A-Za-z0-9]/g, "")
+        .slice(0, size)
+        .toUpperCase();
+}
+function createRequestId(now = new Date()) {
+    const timestamp = now
+        .toISOString()
+        .replace(/[-:.TZ]/g, "")
+        .slice(0, 14);
+    return `req_${timestamp}_${randomBase36(6).toLowerCase()}`;
+}
+function createPairCode() {
+    return (0, node_crypto_1.randomInt)(0, 1000).toString().padStart(3, "0");
+}
+function createInboxMessageId(now = new Date()) {
+    const timestamp = now
+        .toISOString()
+        .replace(/[-:.TZ]/g, "")
+        .slice(0, 14);
+    return `inbox_${timestamp}_${randomBase36(6).toLowerCase()}`;
+}
+function createMenuPayloadKey() {
+    return `mk_${randomBase36(8).toLowerCase()}`;
+}

package/dist/services/features/telegram-mcp/src/shared/lib/logger/logger.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const pino_1 = __importDefault(require("pino"));
+const DEFAULT_LOG_FILE_PATH = ".telegram-human-mcp/log.jsonl";
+function write(logger, level, message, meta) {
+    if (meta) {
+        logger[level](meta, message);
+        return;
+    }
+    logger[level](message);
+}
+function createLogger(config) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(DEFAULT_LOG_FILE_PATH), { recursive: true });
+    const transport = pino_1.default.transport({
+        targets: [
+            {
+                target: "pino/file",
+                level: config.logging.level,
+                options: {
+                    destination: DEFAULT_LOG_FILE_PATH,
+                    mkdir: true,
+                },
+            },
+            {
+                target: "pino-pretty",
+                level: config.logging.level,
+                options: {
+                    destination: 2,
+                    colorize: true,
+                    translateTime: "SYS:standard",
+                    ignore: "pid,hostname",
+                    singleLine: false,
+                },
+            },
+        ],
+    });
+    const baseLogger = (0, pino_1.default)({
+        name: "telegram-human-mcp",
+        level: config.logging.level,
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    }, transport);
+    return {
+        trace(message, meta) {
+            write(baseLogger, "trace", message, meta);
+        },
+        debug(message, meta) {
+            write(baseLogger, "debug", message, meta);
+        },
+        info(message, meta) {
+            write(baseLogger, "info", message, meta);
+        },
+        warn(message, meta) {
+            write(baseLogger, "warn", message, meta);
+        },
+        error(message, meta) {
+            write(baseLogger, "error", message, meta);
+        },
+        fatal(message, meta) {
+            write(baseLogger, "fatal", message, meta);
+        },
+    };
+}

package/dist/services/features/telegram-mcp/src/shared/lib/project-identity/projectIdentity.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectIdentityResolver = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const SESSION_MARKER_FILE_NAME = ".mcpsession.json";
+function slugify(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function shortHash(input) {
+    return (0, node_crypto_1.createHash)("sha1").update(input).digest("hex").slice(0, 8);
+}
+function findUpward(startDir, target) {
+    let current = (0, node_path_1.resolve)(startDir);
+    while (true) {
+        const candidate = (0, node_path_1.join)(current, target);
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+function readPackageName(packageJsonPath) {
+    if (!packageJsonPath) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+        return typeof parsed.name === "string" && parsed.name.trim()
+            ? parsed.name.trim()
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function resolveInputCwd(value) {
+    const trimmed = normalizeOptionalString(value);
+    return trimmed ? (0, node_path_1.resolve)(trimmed) : undefined;
+}
+class ProjectIdentityResolver {
+    config;
+    logger;
+    identity;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.identity = this.buildIdentity();
+        this.logger.info("Project identity resolved", {
+            cwd: this.identity.cwd,
+            cwdName: this.identity.cwdName,
+            gitRoot: this.identity.gitRoot,
+            gitRootName: this.identity.gitRootName,
+            packageName: this.identity.packageName,
+            configuredProjectName: this.identity.configuredProjectName,
+            resolvedTitle: this.identity.resolvedTitle,
+            resolvedSessionId: this.identity.resolvedSessionId,
+            titleSource: this.identity.titleSource,
+        });
+    }
+    getIdentity() {
+        return this.identity;
+    }
+    resolveSessionDefaults(input) {
+        const inputCwd = resolveInputCwd(input.cwd);
+        const resolvedCwd = inputCwd || this.identity.cwd;
+        const titleBase = (0, node_path_1.basename)(resolvedCwd) || this.identity.resolvedTitle || "Project";
+        const sessionMarker = this.readSessionMarker(resolvedCwd);
+        const derivedSessionId = sessionMarker?.localSessionId ||
+            `${slugify(titleBase) || "session"}-${shortHash(resolvedCwd)}`;
+        const derivedSessionLabel = sessionMarker?.sessionLabel || titleBase;
+        const explicitSessionId = input.session_id?.trim();
+        const explicitSessionLabel = input.session_label?.trim();
+        if (!sessionMarker) {
+            this.writeSessionMarker(resolvedCwd, {
+                localSessionId: explicitSessionId || derivedSessionId,
+                sessionLabel: explicitSessionLabel || derivedSessionLabel,
+                cwd: resolvedCwd,
+            });
+        }
+        return {
+            sessionId: explicitSessionId || derivedSessionId,
+            sessionLabel: explicitSessionLabel || derivedSessionLabel,
+            cwd: resolvedCwd,
+            sessionIdDerived: !explicitSessionId,
+            sessionLabelDerived: !explicitSessionLabel,
+        };
+    }
+    persistSessionMarker(input) {
+        const resolvedCwd = resolveInputCwd(input.cwd) || this.identity.cwd;
+        const current = this.readSessionMarker(resolvedCwd);
+        this.writeSessionMarker(resolvedCwd, {
+            localSessionId: input.sessionId,
+            sessionLabel: input.sessionLabel || current?.sessionLabel,
+            cwd: resolvedCwd,
+        });
+    }
+    removeSessionMarker(cwd) {
+        const resolvedCwd = resolveInputCwd(cwd) || this.identity.cwd;
+        const markerPath = (0, node_path_1.join)(resolvedCwd, SESSION_MARKER_FILE_NAME);
+        if (!(0, node_fs_1.existsSync)(markerPath)) {
+            return;
+        }
+        try {
+            (0, node_fs_1.rmSync)(markerPath, { force: true });
+        }
+        catch (error) {
+            this.logger.warn("Failed to remove .mcpsession.json", {
+                cwd: resolvedCwd,
+                markerPath,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+        }
+    }
+    buildIdentity() {
+        const cwd = process.cwd();
+        const cwdName = (0, node_path_1.basename)(cwd);
+        const gitMarkerPath = findUpward(cwd, ".git");
+        const gitRoot = gitMarkerPath ? (0, node_path_1.dirname)(gitMarkerPath) : undefined;
+        const gitRootName = gitRoot ? (0, node_path_1.basename)(gitRoot) : undefined;
+        const packageJsonPath = findUpward(cwd, "package.json");
+        const packageName = readPackageName(packageJsonPath);
+        const configuredProjectName = this.config.project.name;
+        const titleCandidate = configuredProjectName || packageName || gitRootName || cwdName;
+        const titleSource = configuredProjectName
+            ? "env"
+            : packageName
+                ? "package.json"
+                : gitRootName
+                    ? "git"
+                    : cwdName
+                        ? "cwd"
+                        : "generated";
+        const resolvedTitle = titleCandidate || "Project";
+        const slugBase = slugify(resolvedTitle) || "session";
+        const fingerprint = shortHash(gitRoot || packageJsonPath || cwd);
+        const resolvedSessionId = `${slugBase}-${fingerprint}`.slice(0, 64);
+        return {
+            cwd,
+            cwdName,
+            ...(gitRoot ? { gitRoot } : {}),
+            ...(gitRootName ? { gitRootName } : {}),
+            ...(packageJsonPath ? { packageJsonPath } : {}),
+            ...(packageName ? { packageName } : {}),
+            ...(configuredProjectName ? { configuredProjectName } : {}),
+            resolvedTitle,
+            resolvedSessionId,
+            titleSource,
+        };
+    }
+    readSessionMarker(cwd) {
+        const markerPath = (0, node_path_1.join)(cwd, SESSION_MARKER_FILE_NAME);
+        if (!(0, node_fs_1.existsSync)(markerPath)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(markerPath, "utf8"));
+            const localSessionId = typeof parsed.local_session_id === "string"
+                ? parsed.local_session_id.trim()
+                : "";
+            if (!localSessionId) {
+                return null;
+            }
+            return {
+                localSessionId,
+                ...(typeof parsed.session_label === "string" &&
+                    parsed.session_label.trim()
+                    ? { sessionLabel: parsed.session_label.trim() }
+                    : {}),
+                ...(typeof parsed.cwd === "string" && parsed.cwd.trim()
+                    ? { cwd: parsed.cwd.trim() }
+                    : {}),
+            };
+        }
+        catch (error) {
+            this.logger.warn("Failed to read .mcpsession.json, ignoring marker", {
+                cwd,
+                markerPath,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+            return null;
+        }
+    }
+    writeSessionMarker(inputCwd, input) {
+        const markerPath = (0, node_path_1.join)(inputCwd, SESSION_MARKER_FILE_NAME);
+        const now = new Date().toISOString();
+        const current = this.readSessionMarker(inputCwd);
+        try {
+            (0, node_fs_1.writeFileSync)(markerPath, `${JSON.stringify({
+                version: 1,
+                local_session_id: input.localSessionId,
+                ...(input.sessionLabel ? { session_label: input.sessionLabel } : {}),
+                cwd: input.cwd,
+                created_at: now,
+                updated_at: now,
+                ...(current ? { first_seen_local_session_id: current.localSessionId } : {}),
+            }, null, 2)}\n`, "utf8");
+        }
+        catch (error) {
+            this.logger.warn("Failed to write .mcpsession.json", {
+                cwd: inputCwd,
+                markerPath,
+                sessionId: input.localSessionId,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+        }
+    }
+}
+exports.ProjectIdentityResolver = ProjectIdentityResolver;

package/dist/services/features/telegram-mcp/src/shared/lib/redact-secrets/redactSecrets.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSecrets = redactSecrets;
+const SECRET_PATTERNS = [
+    [/sk-[A-Za-z0-9]{20,}/g, "[REDACTED_OPENAI_KEY]"],
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, "[REDACTED_GITHUB_TOKEN]"],
+    [/\bBearer\s+[A-Za-z0-9._\-+/=]+\b/gi, "Bearer [REDACTED]"],
+    [/\bpostgres(?:ql)?:\/\/[^\s]+/gi, "postgres://[REDACTED]"],
+    [/\bDATABASE_URL\s*=\s*[^\s]+/gi, "DATABASE_URL=[REDACTED]"],
+    [
+        /-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g,
+        "[REDACTED_PRIVATE_KEY]",
+    ],
+    [/\b(?:password|passwd|pwd)\s*[:=]\s*[^\s'"]+/gi, "password=[REDACTED]"],
+    [/\bapi[_-]?key\s*[:=]\s*[^\s'"]+/gi, "api_key=[REDACTED]"],
+    [/\bsecret\s*[:=]\s*[^\s'"]+/gi, "secret=[REDACTED]"],
+    [/\btoken\s*[:=]\s*[^\s'"]+/gi, "token=[REDACTED]"],
+    [/\b[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\b/g, "[REDACTED_JWT]"],
+];
+function redactSecrets(input) {
+    return SECRET_PATTERNS.reduce((current, [pattern, replacement]) => current.replace(pattern, replacement), input);
+}

package/dist/services/features/telegram-mcp/src/shared/lib/truncate/truncate.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateText = truncateText;
+function truncateText(input, maxChars, suffix = " [truncated]") {
+    if (input.length <= maxChars) {
+        return input;
+    }
+    if (maxChars <= suffix.length) {
+        return input.slice(0, maxChars);
+    }
+    return `${input.slice(0, maxChars - suffix.length)}${suffix}`;
+}