cli-wechat-bridge 1.2.1 → 1.2.3

package/dist/channels/local/local-driver.js

@@ -0,0 +1,217 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import { t } from "../../i18n/index.js";
+import fs from "node:fs";
+import path from "node:path";
+import { getWorkspaceChannelPaths } from "../../wechat/channel-config.js";
+/**
+ * Loopback channel for local end-to-end runs. Inbound messages are JSONL
+ * lines appended to the inbox file; every outbound text is appended to the
+ * transcript file so an external harness can drive and observe the full
+ * bridge pipeline without a remote messaging platform.
+ */
+export const LOCAL_CHANNEL_OPERATOR_ID = "local-operator";
+export function getLocalChannelFiles(cwd) {
+    const workspaceDir = getWorkspaceChannelPaths(cwd).workspaceDir;
+    return {
+        inboxFile: path.join(workspaceDir, "local-inbox.jsonl"),
+        transcriptFile: path.join(workspaceDir, "local-transcript.jsonl"),
+    };
+}
+export class LocalChannelDriver {
+    id = "local";
+    displayName = "Local";
+    get operatorDescription() { return t("operator.local"); }
+    capabilities = {
+        streamingReplies: false,
+        outboundAttachments: false,
+        multiConversation: false,
+        pushInbound: true,
+    };
+    operatorId;
+    inboxFile;
+    transcriptFile;
+    pollIntervalMs;
+    log;
+    handlers = null;
+    timer = null;
+    inboxOffset = 0;
+    pendingLine = "";
+    messageSeq = 0;
+    constructor(options) {
+        this.operatorId = options.operatorId;
+        this.inboxFile = options.inboxFile;
+        this.transcriptFile = options.transcriptFile;
+        this.pollIntervalMs = options.pollIntervalMs ?? 200;
+        this.log = options.log ?? (() => { });
+    }
+    defaultConversation() {
+        return this.directConversation(this.operatorId);
+    }
+    directConversation(senderId) {
+        return {
+            channelId: "local",
+            conversationId: senderId,
+            recipientId: senderId,
+            metadata: { chatType: "direct" },
+        };
+    }
+    start(handlers) {
+        this.handlers = handlers;
+        fs.mkdirSync(path.dirname(this.inboxFile), { recursive: true });
+        // Start at end-of-file so lines left over from earlier runs are ignored.
+        this.inboxOffset = this.measureInboxSize();
+        this.pendingLine = "";
+        this.timer = setInterval(() => {
+            void this.pumpInbox();
+        }, this.pollIntervalMs);
+        this.timer.unref?.();
+        this.log("local_channel_started");
+    }
+    /** Clears the inbox watcher. Not part of ChannelDriver; callers may stop explicitly. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+        this.timer = null;
+        this.handlers = null;
+    }
+    waitUntilReady() {
+        return Promise.resolve();
+    }
+    async sendText(params) {
+        const { target, text, context, log } = params;
+        this.appendTranscript({
+            ts: new Date().toISOString(),
+            direction: "outbound",
+            context,
+            conversationId: target.conversationId,
+            recipientId: target.recipientId,
+            text,
+        });
+        log(`local_send_completed: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+        return { status: "sent" };
+    }
+    buildInboundPrompt(text, attachments) {
+        if (attachments.length === 0) {
+            return text;
+        }
+        const lines = attachments.map((attachment) => {
+            const label = attachment.fileName ? ` (${attachment.fileName})` : "";
+            return `- ${attachment.path}${label}`;
+        });
+        return `${text}\n\nLocal attachments:\n${lines.join("\n")}`;
+    }
+    measureInboxSize() {
+        try {
+            return fs.statSync(this.inboxFile).size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async pumpInbox() {
+        const handlers = this.handlers;
+        if (!handlers) {
+            return;
+        }
+        let size;
+        try {
+            size = fs.statSync(this.inboxFile).size;
+        }
+        catch {
+            return;
+        }
+        if (size < this.inboxOffset) {
+            // The inbox was truncated; restart from the beginning.
+            this.inboxOffset = 0;
+            this.pendingLine = "";
+        }
+        if (size === this.inboxOffset) {
+            return;
+        }
+        let chunk;
+        try {
+            const fd = fs.openSync(this.inboxFile, "r");
+            try {
+                const buffer = Buffer.alloc(size - this.inboxOffset);
+                fs.readSync(fd, buffer, 0, buffer.length, this.inboxOffset);
+                chunk = buffer.toString("utf8");
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            return;
+        }
+        this.inboxOffset = size;
+        const complete = chunk.endsWith("\n");
+        const combined = this.pendingLine + chunk;
+        const parts = combined.split("\n");
+        this.pendingLine = complete ? "" : (parts.pop() ?? "");
+        for (const line of parts) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                await this.dispatchInboxLine(trimmed, handlers);
+            }
+            catch (error) {
+                this.log(`local_inbound_failed: error=${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async dispatchInboxLine(line, handlers) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.log("local_inbox_invalid_json: skipped one line");
+            return;
+        }
+        if (typeof parsed?.text !== "string" || !parsed.text.trim()) {
+            this.log("local_inbox_invalid_line: skipped one line without text");
+            return;
+        }
+        const senderId = typeof parsed.senderId === "string" && parsed.senderId
+            ? parsed.senderId
+            : this.operatorId;
+        const conversationId = typeof parsed.conversationId === "string" && parsed.conversationId
+            ? parsed.conversationId
+            : senderId;
+        const attachments = Array.isArray(parsed.attachments)
+            ? parsed.attachments.filter((attachment) => Boolean(attachment) &&
+                typeof attachment.path === "string" &&
+                typeof attachment.kind === "string")
+            : [];
+        this.messageSeq += 1;
+        const message = {
+            id: `local-${Date.now().toString(36)}-${this.messageSeq}`,
+            conversation: { ...this.directConversation(senderId), conversationId },
+            senderId,
+            text: parsed.text,
+            attachments,
+            createdAt: new Date().toISOString(),
+        };
+        this.appendTranscript({
+            ts: message.createdAt,
+            direction: "inbound",
+            context: "inbound",
+            conversationId,
+            recipientId: senderId,
+            text: parsed.text,
+        });
+        await handlers.onInboundMessage(message);
+    }
+    appendTranscript(record) {
+        fs.mkdirSync(path.dirname(this.transcriptFile), { recursive: true });
+        fs.appendFileSync(this.transcriptFile, `${JSON.stringify(record)}\n`, "utf8");
+    }
+}

package/dist/channels/telegram/setup-cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import { runTelegramSetup } from "./setup.js";
+runTelegramSetup().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/channels/telegram/setup.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env bun
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import crypto from "node:crypto";
+import readline from "node:readline";
+import { Writable } from "node:stream";
+import { loadStoredTelegramAccount, resolveTelegramAccount, saveTelegramAccount, } from "./telegram-config.js";
+import { TelegramTransport } from "./telegram-transport.js";
+const PAIRING_TIMEOUT_MS = 10 * 60 * 1000;
+function ask(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function askSecret(prompt) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return ask(prompt);
+    }
+    let muted = false;
+    const output = new Writable({
+        write(chunk, _encoding, callback) {
+            if (!muted) {
+                process.stdout.write(chunk);
+            }
+            callback();
+        },
+    });
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output,
+        terminal: true,
+    });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            muted = false;
+            rl.close();
+            process.stdout.write("\n");
+            resolve(answer.trim());
+        });
+        muted = true;
+    });
+}
+export function createTelegramPairingCode() {
+    return crypto.randomInt(0, 1_000_000).toString().padStart(6, "0");
+}
+export function isTelegramPairingText(text, code) {
+    return text.trim() === `/pair ${code}`;
+}
+/**
+ * Pair the operator: validate the token, then run a temporary long poll and
+ * wait for the operator to send `/pair <code>` from their Telegram account.
+ * Records the user id (authorization gate) and the chat id (send target).
+ */
+export async function pairTelegramOperator(options) {
+    const log = options.log ?? console.log;
+    const code = options.code ?? createTelegramPairingCode();
+    const transport = new TelegramTransport({
+        account: {
+            version: 1,
+            botToken: options.botToken,
+            botUsername: "",
+            operatorUserId: "",
+            operatorChatId: "",
+            pairedAt: new Date().toISOString(),
+        },
+        fetchImpl: options.fetchImpl,
+    });
+    const botUsername = await transport.validateToken();
+    log(`Telegram bot @${botUsername} authenticated.`);
+    try {
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error, account) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error || !account) {
+                    reject(error ?? new Error("Telegram operator pairing failed."));
+                    return;
+                }
+                resolve(account);
+            };
+            const timer = setTimeout(() => {
+                finish(new Error("Telegram operator pairing timed out."));
+            }, options.timeoutMs ?? PAIRING_TIMEOUT_MS);
+            timer.unref?.();
+            transport.setHandlers({
+                onMessage: async () => { },
+                onConnected: async () => {
+                    log(`Send /pair ${code} to @${botUsername} from your Telegram account within 10 minutes.`);
+                },
+                onFatal: async (error) => {
+                    finish(error);
+                },
+                onPreAuthMessage: async (message) => {
+                    if (message.chatType !== "private" || !isTelegramPairingText(message.text, code)) {
+                        return;
+                    }
+                    finish(undefined, {
+                        version: 1,
+                        botToken: options.botToken,
+                        botUsername,
+                        operatorUserId: message.userId,
+                        operatorChatId: message.chatId,
+                        pairedAt: new Date().toISOString(),
+                    });
+                },
+            });
+            void transport.start();
+        });
+    }
+    finally {
+        await transport.stop();
+    }
+}
+export async function ensureTelegramAccount(options = {}) {
+    const existing = resolveTelegramAccount();
+    if (existing) {
+        return existing;
+    }
+    options.log?.("No paired Telegram account found. Starting setup...");
+    return (options.setup ?? (() => runTelegramSetup([])))();
+}
+export async function runTelegramSetup(argv = process.argv.slice(2)) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log("Usage: telegram-setup [--check]");
+        console.log("");
+        console.log("Pairs one Telegram operator with the local CLI bridge.");
+        console.log("The bot token may also be supplied through TELEGRAM_BOT_TOKEN.");
+        process.exit(0);
+    }
+    const resolved = resolveTelegramAccount();
+    if (argv.includes("--check")) {
+        if (!resolved) {
+            throw new Error("No complete Telegram credentials are configured.");
+        }
+        const transport = new TelegramTransport({ account: resolved });
+        const username = await transport.validateToken();
+        console.log(`Telegram credentials are valid. Bot: @${username}, paired operator: ${resolved.operatorUserId}`);
+        return resolved;
+    }
+    const stored = loadStoredTelegramAccount();
+    const botToken = process.env.TELEGRAM_BOT_TOKEN?.trim() ||
+        await askSecret(`Bot Token${stored?.botToken ? " [press Enter to keep saved value]" : " (from @BotFather)"}: `) ||
+        stored?.botToken || "";
+    if (!botToken) {
+        throw new Error("A Telegram bot token is required.");
+    }
+    const account = await pairTelegramOperator({ botToken });
+    saveTelegramAccount(account);
+    console.log("Telegram operator pairing completed.");
+    console.log("Start from a project directory with telegram-codex, telegram-claude, telegram-opencode, telegram-pi, or telegram-daemon.");
+    return account;
+}

package/dist/channels/telegram/telegram-channel-port.js

@@ -0,0 +1,47 @@
+import { forwardWecomFinalReply } from "../wecom/bridge-final-reply.js";
+import { formatTelegramVisibleText } from "./telegram-message.js";
+export class TelegramChannelPort {
+    channelId = "telegram";
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    sendText(target, text, kind) {
+        return this.deps.sendText?.(target, text, kind) ??
+            this.deps.transport.sendText(target, text, kind);
+    }
+    sendAttachment(target, attachment) {
+        return this.deps.sendAttachment?.(target, attachment) ??
+            this.deps.transport.sendAttachment(target, attachment);
+    }
+    async send(output) {
+        if (output.target.channelId !== this.channelId) {
+            throw new Error(`Telegram channel cannot send to ${output.target.channelId}.`);
+        }
+        const prefix = (text) => formatTelegramVisibleText(this.deps.prefixText?.(output.adapter, text) ?? text);
+        if (output.kind === "final_reply") {
+            // Final-reply splitting (attachment extraction etc.) is channel-neutral;
+            // the WeCom implementation is reused verbatim.
+            await forwardWecomFinalReply({
+                adapter: output.adapter ?? "codex",
+                rawText: output.text ?? "",
+                target: output.target,
+                onEmptyVisibleReply: (rawText) => {
+                    this.deps.onEmptyVisibleReply?.(output.adapter, rawText);
+                },
+                sender: {
+                    sendText: (text) => this.sendText(output.target, prefix(text), "final_reply"),
+                    sendAttachment: (attachment) => this.sendAttachment(output.target, attachment),
+                },
+            });
+            return true;
+        }
+        if (output.attachment) {
+            await this.sendAttachment(output.target, output.attachment);
+        }
+        if (output.text?.trim()) {
+            return this.sendText(output.target, prefix(output.text), output.kind);
+        }
+        return true;
+    }
+}

package/dist/channels/telegram/telegram-config.js

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import fs from "node:fs";
+import path from "node:path";
+import { CHANNEL_DATA_DIR, ensureChannelDataDir, } from "../../wechat/channel-config.js";
+export const TELEGRAM_DATA_DIR = path.join(CHANNEL_DATA_DIR, "telegram");
+export const TELEGRAM_CREDENTIALS_FILE = path.join(TELEGRAM_DATA_DIR, "account.json");
+export const TELEGRAM_INBOUND_ATTACHMENTS_DIR = path.join(TELEGRAM_DATA_DIR, "inbound-attachments");
+export const TELEGRAM_INBOUND_MESSAGE_CLAIMS_DIR = path.join(TELEGRAM_DATA_DIR, "inbound-message-claims");
+export function ensureTelegramDataDir() {
+    ensureChannelDataDir();
+    fs.mkdirSync(TELEGRAM_DATA_DIR, { recursive: true });
+}
+export function normalizeStoredTelegramAccount(parsed) {
+    if (parsed.version !== 1 ||
+        typeof parsed.botToken !== "string" ||
+        !parsed.botToken.trim() ||
+        typeof parsed.operatorUserId !== "string" ||
+        !parsed.operatorUserId.trim() ||
+        typeof parsed.operatorChatId !== "string" ||
+        !parsed.operatorChatId.trim() ||
+        typeof parsed.pairedAt !== "string") {
+        return null;
+    }
+    return {
+        version: 1,
+        botToken: parsed.botToken.trim(),
+        botUsername: typeof parsed.botUsername === "string" ? parsed.botUsername.trim() : "",
+        operatorUserId: parsed.operatorUserId.trim(),
+        operatorChatId: parsed.operatorChatId.trim(),
+        pairedAt: parsed.pairedAt,
+    };
+}
+export function loadStoredTelegramAccount(filePath = TELEGRAM_CREDENTIALS_FILE) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return normalizeStoredTelegramAccount(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveTelegramAccount(account, filePath = TELEGRAM_CREDENTIALS_FILE) {
+    ensureTelegramDataDir();
+    fs.writeFileSync(filePath, `${JSON.stringify(account, null, 2)}\n`, "utf-8");
+}
+export function resolveTelegramAccount(env = process.env, stored = loadStoredTelegramAccount()) {
+    const botToken = env.TELEGRAM_BOT_TOKEN?.trim() || stored?.botToken || "";
+    const operatorUserId = env.TELEGRAM_OPERATOR_USER_ID?.trim() || stored?.operatorUserId || "";
+    const operatorChatId = env.TELEGRAM_OPERATOR_CHAT_ID?.trim() || stored?.operatorChatId || "";
+    if (!botToken || !operatorUserId || !operatorChatId) {
+        return null;
+    }
+    return {
+        version: 1,
+        botToken,
+        botUsername: env.TELEGRAM_BOT_USERNAME?.trim() || stored?.botUsername || "",
+        operatorUserId,
+        operatorChatId,
+        pairedAt: stored?.pairedAt ?? new Date().toISOString(),
+    };
+}

package/dist/channels/telegram/telegram-driver.js

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import { t } from "../../i18n/index.js";
+import { buildTelegramInboundPrompt, formatTelegramVisibleText, toTelegramOutputKind, } from "./telegram-message.js";
+import { truncatePreview } from "../../core/text-utils.js";
+/** ChannelDriver over the official Telegram Bot API long-poll transport. */
+export class TelegramChannelDriver {
+    id = "telegram";
+    displayName = "Telegram";
+    get operatorDescription() { return t("operator.telegram"); }
+    capabilities = {
+        streamingReplies: false,
+        outboundAttachments: true,
+        multiConversation: true,
+        pushInbound: true,
+    };
+    transport;
+    accountId;
+    operatorId;
+    logError;
+    constructor(options) {
+        this.transport = options.transport;
+        this.accountId = options.accountId;
+        this.operatorId = options.operatorId;
+        this.logError = options.logError;
+    }
+    defaultConversation() {
+        return this.directConversation(this.operatorId);
+    }
+    directConversation(senderId) {
+        return {
+            channelId: "telegram",
+            accountId: this.accountId,
+            conversationId: senderId,
+            recipientId: senderId,
+            metadata: { chatType: "direct" },
+        };
+    }
+    start(handlers) {
+        this.transport.setHandlers({
+            onMessage: async (message) => {
+                await handlers.onInboundMessage(message);
+            },
+            onUnauthorized: handlers.onUnauthorizedSender
+                ? async (senderId, chatType) => {
+                    await handlers.onUnauthorizedSender(senderId, chatType);
+                }
+                : undefined,
+            onFatal: handlers.onChannelFatal
+                ? async (error) => {
+                    await handlers.onChannelFatal(error);
+                }
+                : undefined,
+            onConnected: handlers.onChannelConnected
+                ? async () => {
+                    await handlers.onChannelConnected();
+                }
+                : undefined,
+        });
+        void this.transport.start();
+    }
+    async waitUntilReady() {
+        // The long-poll loop reports readiness through onConnected; there is no
+        // separate handshake to await, so readiness is immediate once started.
+        await Promise.resolve();
+    }
+    async sendText(params) {
+        const { target, text, context, log } = params;
+        const startedAtMs = Date.now();
+        log(`telegram_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+        try {
+            await this.transport.sendText(target, formatTelegramVisibleText(text), toTelegramOutputKind(context));
+            log(`telegram_send_completed: context=${context} recipient=${target.recipientId} elapsed_ms=${Date.now() - startedAtMs}`);
+            return { status: "sent" };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log(`telegram_send_failed: context=${context} recipient=${target.recipientId} error=${truncatePreview(message, 400)}`);
+            this.logError(`Failed to send Telegram ${context}: ${message}`);
+            return {
+                status: "failed",
+                error,
+                target,
+            };
+        }
+    }
+    buildInboundPrompt(text, attachments) {
+        return buildTelegramInboundPrompt(text, attachments);
+    }
+    formatVisibleText(text) {
+        return formatTelegramVisibleText(text);
+    }
+    async beginTyping(recipientId) {
+        await this.transport.beginTyping(recipientId);
+    }
+    async endTyping(recipientId) {
+        await this.transport.endTyping(recipientId);
+    }
+    async endAllTyping() {
+        this.transport.endAllTyping();
+    }
+}

package/dist/channels/telegram/telegram-message.js

@@ -0,0 +1,41 @@
+export function toTelegramOutputKind(context) {
+    const known = new Set([
+        "status",
+        "notice",
+        "thinking",
+        "final_reply",
+        "approval_required",
+        "user_input_required",
+        "mirrored_input",
+        "task_failed",
+        "fatal_error",
+    ]);
+    return known.has(context)
+        ? context
+        : context === "mirrored_user_input"
+            ? "mirrored_input"
+            : "notice";
+}
+export function buildTelegramInboundPrompt(text, attachments = []) {
+    const normalizedText = text.trim();
+    if (attachments.length === 0) {
+        return normalizedText;
+    }
+    const lines = [
+        "[Telegram inbound attachments — ACTION REQUIRED]",
+        "Use the local attachment paths below when the user asks you to inspect or process them.",
+    ];
+    attachments.forEach((attachment, index) => {
+        const metadata = [
+            `kind=${attachment.kind}`,
+            attachment.fileName ? `name=${attachment.fileName}` : "",
+            typeof attachment.sizeBytes === "number" ? `bytes=${attachment.sizeBytes}` : "",
+        ].filter(Boolean);
+        lines.push(`${index + 1}. ${metadata.join(" ")} path=${attachment.path}`);
+    });
+    return [normalizedText || "Received Telegram attachment(s).", lines.join("\n")].join("\n\n");
+}
+/** Telegram displays plain text; identity keeps one shaping point per channel. */
+export function formatTelegramVisibleText(text) {
+    return text;
+}