clawdbot 2026.1.4-1

package/dist/telegram/probe.js

@@ -0,0 +1,63 @@
+import { makeProxyFetch } from "./proxy.js";
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+async function fetchWithTimeout(url, timeoutMs, fetcher) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetcher(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function probeTelegram(token, timeoutMs, proxyUrl) {
+    const started = Date.now();
+    const fetcher = proxyUrl ? makeProxyFetch(proxyUrl) : fetch;
+    const base = `${TELEGRAM_API_BASE}/bot${token}`;
+    const result = {
+        ok: false,
+        status: null,
+        error: null,
+        elapsedMs: 0,
+    };
+    try {
+        const meRes = await fetchWithTimeout(`${base}/getMe`, timeoutMs, fetcher);
+        const meJson = (await meRes.json());
+        if (!meRes.ok || !meJson?.ok) {
+            result.status = meRes.status;
+            result.error = meJson?.description ?? `getMe failed (${meRes.status})`;
+            return { ...result, elapsedMs: Date.now() - started };
+        }
+        result.bot = {
+            id: meJson.result?.id ?? null,
+            username: meJson.result?.username ?? null,
+        };
+        // Try to fetch webhook info, but don't fail health if it errors.
+        try {
+            const webhookRes = await fetchWithTimeout(`${base}/getWebhookInfo`, timeoutMs, fetcher);
+            const webhookJson = (await webhookRes.json());
+            if (webhookRes.ok && webhookJson?.ok) {
+                result.webhook = {
+                    url: webhookJson.result?.url ?? null,
+                    hasCustomCert: webhookJson.result?.has_custom_certificate ?? null,
+                };
+            }
+        }
+        catch {
+            // ignore webhook errors for probe
+        }
+        result.ok = true;
+        result.status = null;
+        result.error = null;
+        result.elapsedMs = Date.now() - started;
+        return result;
+    }
+    catch (err) {
+        return {
+            ...result,
+            status: err instanceof Response ? err.status : result.status,
+            error: err instanceof Error ? err.message : String(err),
+            elapsedMs: Date.now() - started,
+        };
+    }
+}

package/dist/telegram/proxy.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { ProxyAgent } from "undici";
+export function makeProxyFetch(proxyUrl) {
+    const agent = new ProxyAgent(proxyUrl);
+    return (input, init) => {
+        const base = init ? { ...init } : {};
+        return fetch(input, { ...base, dispatcher: agent });
+    };
+}

package/dist/telegram/send.js

@@ -0,0 +1,138 @@
+// @ts-nocheck
+import { Bot, InputFile } from "grammy";
+import { formatErrorMessage } from "../infra/errors.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { loadWebMedia } from "../web/media.js";
+const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+function resolveToken(explicit) {
+    const token = explicit ?? process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+        throw new Error("TELEGRAM_BOT_TOKEN is required for Telegram sends (Bot API)");
+    }
+    return token.trim();
+}
+function normalizeChatId(to) {
+    const trimmed = to.trim();
+    if (!trimmed)
+        throw new Error("Recipient is required for Telegram sends");
+    // Common internal prefixes that sometimes leak into outbound sends.
+    // - ctx.To uses `telegram:<id>`
+    // - group sessions often use `telegram:group:<id>`
+    let normalized = trimmed.replace(/^(telegram|tg|group):/i, "").trim();
+    // Accept t.me links for public chats/channels.
+    // (Invite links like `t.me/+...` are not resolvable via Bot API.)
+    const m = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ??
+        /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+    if (m?.[1])
+        normalized = `@${m[1]}`;
+    if (!normalized)
+        throw new Error("Recipient is required for Telegram sends");
+    if (normalized.startsWith("@"))
+        return normalized;
+    if (/^-?\d+$/.test(normalized))
+        return normalized;
+    // If the user passed a username without `@`, assume they meant a public chat/channel.
+    if (/^[A-Za-z0-9_]{5,}$/i.test(normalized))
+        return `@${normalized}`;
+    return normalized;
+}
+export async function sendMessageTelegram(to, text, opts = {}) {
+    const token = resolveToken(opts.token);
+    const chatId = normalizeChatId(to);
+    const bot = opts.api ? null : new Bot(token);
+    const api = opts.api ?? bot?.api;
+    const mediaUrl = opts.mediaUrl?.trim();
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const sendWithRetry = async (fn, label) => {
+        let lastErr;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                lastErr = err;
+                const errText = formatErrorMessage(err);
+                const terminal = attempt === 3 ||
+                    !/429|timeout|connect|reset|closed|unavailable|temporarily/i.test(errText);
+                if (terminal)
+                    break;
+                const backoff = 400 * attempt;
+                if (opts.verbose) {
+                    console.warn(`telegram send retry ${attempt}/2 for ${label} in ${backoff}ms: ${errText}`);
+                }
+                await sleep(backoff);
+            }
+        }
+        throw lastErr ?? new Error(`Telegram send failed (${label})`);
+    };
+    const wrapChatNotFound = (err) => {
+        if (!/400: Bad Request: chat not found/i.test(formatErrorMessage(err)))
+            return err;
+        return new Error([
+            `Telegram send failed: chat not found (chat_id=${chatId}).`,
+            "Likely: bot not started in DM, bot removed from group/channel, group migrated (new -100… id), or wrong bot token.",
+            `Input was: ${JSON.stringify(to)}.`,
+        ].join(" "));
+    };
+    if (mediaUrl) {
+        const media = await loadWebMedia(mediaUrl, opts.maxBytes);
+        const kind = mediaKindFromMime(media.contentType ?? undefined);
+        const file = new InputFile(media.buffer, media.fileName ?? inferFilename(kind) ?? "file");
+        const caption = text?.trim() || undefined;
+        let result;
+        if (kind === "image") {
+            result = await sendWithRetry(() => api.sendPhoto(chatId, file, { caption }), "photo").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else if (kind === "video") {
+            result = await sendWithRetry(() => api.sendVideo(chatId, file, { caption }), "video").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else if (kind === "audio") {
+            result = await sendWithRetry(() => api.sendAudio(chatId, file, { caption }), "audio").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else {
+            result = await sendWithRetry(() => api.sendDocument(chatId, file, { caption }), "document").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        const messageId = String(result?.message_id ?? "unknown");
+        return { messageId, chatId: String(result?.chat?.id ?? chatId) };
+    }
+    if (!text || !text.trim()) {
+        throw new Error("Message must be non-empty for Telegram sends");
+    }
+    const res = await sendWithRetry(() => api.sendMessage(chatId, text, { parse_mode: "Markdown" }), "message").catch(async (err) => {
+        // Telegram rejects malformed Markdown (e.g., unbalanced '_' or '*').
+        // When that happens, fall back to plain text so the message still delivers.
+        const errText = formatErrorMessage(err);
+        if (PARSE_ERR_RE.test(errText)) {
+            if (opts.verbose) {
+                console.warn(`telegram markdown parse failed, retrying as plain text: ${errText}`);
+            }
+            return await sendWithRetry(() => api.sendMessage(chatId, text), "message-plain").catch((err2) => {
+                throw wrapChatNotFound(err2);
+            });
+        }
+        throw wrapChatNotFound(err);
+    });
+    const messageId = String(res?.message_id ?? "unknown");
+    return { messageId, chatId: String(res?.chat?.id ?? chatId) };
+}
+function inferFilename(kind) {
+    switch (kind) {
+        case "image":
+            return "image.jpg";
+        case "video":
+            return "video.mp4";
+        case "audio":
+            return "audio.ogg";
+        default:
+            return "file.bin";
+    }
+}
+// @ts-nocheck

package/dist/telegram/token.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+export function resolveTelegramToken(cfg, opts = {}) {
+    const envToken = (opts.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim();
+    if (envToken) {
+        return { token: envToken, source: "env" };
+    }
+    const tokenFile = cfg?.telegram?.tokenFile?.trim();
+    if (tokenFile) {
+        if (!fs.existsSync(tokenFile)) {
+            opts.logMissingFile?.(`telegram.tokenFile not found: ${tokenFile}`);
+            return { token: "", source: "none" };
+        }
+        try {
+            const token = fs.readFileSync(tokenFile, "utf-8").trim();
+            if (token) {
+                return { token, source: "tokenFile" };
+            }
+        }
+        catch (err) {
+            opts.logMissingFile?.(`telegram.tokenFile read failed: ${String(err)}`);
+            return { token: "", source: "none" };
+        }
+        return { token: "", source: "none" };
+    }
+    const configToken = cfg?.telegram?.botToken?.trim();
+    if (configToken) {
+        return { token: configToken, source: "config" };
+    }
+    return { token: "", source: "none" };
+}

package/dist/telegram/webhook-set.js

@@ -0,0 +1,12 @@
+import { Bot } from "grammy";
+export async function setTelegramWebhook(opts) {
+    const bot = new Bot(opts.token);
+    await bot.api.setWebhook(opts.url, {
+        secret_token: opts.secret,
+        drop_pending_updates: opts.dropPendingUpdates ?? false,
+    });
+}
+export async function deleteTelegramWebhook(opts) {
+    const bot = new Bot(opts.token);
+    await bot.api.deleteWebhook();
+}

package/dist/telegram/webhook.js

@@ -0,0 +1,56 @@
+import { createServer } from "node:http";
+import { webhookCallback } from "grammy";
+import { formatErrorMessage } from "../infra/errors.js";
+import { defaultRuntime } from "../runtime.js";
+import { createTelegramBot } from "./bot.js";
+export async function startTelegramWebhook(opts) {
+    const path = opts.path ?? "/telegram-webhook";
+    const healthPath = opts.healthPath ?? "/healthz";
+    const port = opts.port ?? 8787;
+    const host = opts.host ?? "0.0.0.0";
+    const runtime = opts.runtime ?? defaultRuntime;
+    const bot = createTelegramBot({
+        token: opts.token,
+        runtime,
+        proxyFetch: opts.fetch,
+    });
+    const handler = webhookCallback(bot, "http", {
+        secretToken: opts.secret,
+    });
+    const server = createServer((req, res) => {
+        if (req.url === healthPath) {
+            res.writeHead(200);
+            res.end("ok");
+            return;
+        }
+        if (req.url !== path || req.method !== "POST") {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        const handled = handler(req, res);
+        if (handled && typeof handled.catch === "function") {
+            void handled.catch((err) => {
+                runtime.log?.(`webhook handler failed: ${formatErrorMessage(err)}`);
+                if (!res.headersSent)
+                    res.writeHead(500);
+                res.end();
+            });
+        }
+    });
+    const publicUrl = opts.publicUrl ??
+        `http://${host === "0.0.0.0" ? "localhost" : host}:${port}${path}`;
+    await bot.api.setWebhook(publicUrl, {
+        secret_token: opts.secret,
+    });
+    await new Promise((resolve) => server.listen(port, host, resolve));
+    runtime.log?.(`webhook listening on ${publicUrl}`);
+    const shutdown = () => {
+        server.close();
+        void bot.stop();
+    };
+    if (opts.abortSignal) {
+        opts.abortSignal.addEventListener("abort", shutdown, { once: true });
+    }
+    return { server, bot, stop: shutdown };
+}

package/dist/tui/commands.js

@@ -0,0 +1,74 @@
+const THINK_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const VERBOSE_LEVELS = ["on", "off"];
+const ELEVATED_LEVELS = ["on", "off"];
+const ACTIVATION_LEVELS = ["mention", "always"];
+const TOGGLE = ["on", "off"];
+export function parseCommand(input) {
+    const trimmed = input.replace(/^\//, "").trim();
+    if (!trimmed)
+        return { name: "", args: "" };
+    const [name, ...rest] = trimmed.split(/\s+/);
+    return { name: name.toLowerCase(), args: rest.join(" ").trim() };
+}
+export function getSlashCommands() {
+    return [
+        { name: "help", description: "Show slash command help" },
+        { name: "status", description: "Show gateway status summary" },
+        { name: "session", description: "Switch session (or open picker)" },
+        { name: "sessions", description: "Open session picker" },
+        {
+            name: "model",
+            description: "Set model (or open picker)",
+        },
+        { name: "models", description: "Open model picker" },
+        {
+            name: "think",
+            description: "Set thinking level",
+            getArgumentCompletions: (prefix) => THINK_LEVELS.filter((v) => v.startsWith(prefix.toLowerCase())).map((value) => ({ value, label: value })),
+        },
+        {
+            name: "verbose",
+            description: "Set verbose on/off",
+            getArgumentCompletions: (prefix) => VERBOSE_LEVELS.filter((v) => v.startsWith(prefix.toLowerCase())).map((value) => ({ value, label: value })),
+        },
+        {
+            name: "elevated",
+            description: "Set elevated on/off",
+            getArgumentCompletions: (prefix) => ELEVATED_LEVELS.filter((v) => v.startsWith(prefix.toLowerCase())).map((value) => ({ value, label: value })),
+        },
+        {
+            name: "activation",
+            description: "Set group activation",
+            getArgumentCompletions: (prefix) => ACTIVATION_LEVELS.filter((v) => v.startsWith(prefix.toLowerCase())).map((value) => ({ value, label: value })),
+        },
+        {
+            name: "deliver",
+            description: "Toggle delivery of assistant replies",
+            getArgumentCompletions: (prefix) => TOGGLE.filter((v) => v.startsWith(prefix.toLowerCase())).map((value) => ({ value, label: value })),
+        },
+        { name: "abort", description: "Abort active run" },
+        { name: "new", description: "Reset the session" },
+        { name: "reset", description: "Reset the session" },
+        { name: "settings", description: "Open settings" },
+        { name: "exit", description: "Exit the TUI" },
+        { name: "quit", description: "Exit the TUI" },
+    ];
+}
+export function helpText() {
+    return [
+        "Slash commands:",
+        "/help",
+        "/status",
+        "/session <key> (or /sessions)",
+        "/model <provider/model> (or /models)",
+        "/think <off|minimal|low|medium|high>",
+        "/verbose <on|off>",
+        "/elevated <on|off>",
+        "/activation <mention|always>",
+        "/deliver <on|off>",
+        "/new or /reset",
+        "/abort",
+        "/settings",
+        "/exit",
+    ].join("\n");
+}

package/dist/tui/components/assistant-message.js

@@ -0,0 +1,16 @@
+import { Container, Markdown, Spacer } from "@mariozechner/pi-tui";
+import { markdownTheme, theme } from "../theme/theme.js";
+export class AssistantMessageComponent extends Container {
+    body;
+    constructor(text) {
+        super();
+        this.body = new Markdown(text, 1, 0, markdownTheme, {
+            color: (line) => theme.fg(line),
+        });
+        this.addChild(new Spacer(1));
+        this.addChild(this.body);
+    }
+    setText(text) {
+        this.body.setText(text);
+    }
+}

package/dist/tui/components/chat-log.js

@@ -0,0 +1,92 @@
+import { Container, Spacer, Text } from "@mariozechner/pi-tui";
+import { theme } from "../theme/theme.js";
+import { AssistantMessageComponent } from "./assistant-message.js";
+import { ToolExecutionComponent } from "./tool-execution.js";
+import { UserMessageComponent } from "./user-message.js";
+export class ChatLog extends Container {
+    toolById = new Map();
+    streamingAssistant = null;
+    streamingRunId = null;
+    streamingText = null;
+    toolsExpanded = false;
+    clearAll() {
+        this.clear();
+        this.toolById.clear();
+        this.streamingAssistant = null;
+        this.streamingRunId = null;
+        this.streamingText = null;
+    }
+    addSystem(text) {
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.system(text), 1, 0));
+    }
+    addUser(text) {
+        this.addChild(new UserMessageComponent(text));
+    }
+    startAssistant(text, runId) {
+        const component = new AssistantMessageComponent(text);
+        this.streamingAssistant = component;
+        this.streamingRunId = runId ?? null;
+        this.streamingText = text;
+        this.addChild(component);
+        return component;
+    }
+    updateAssistant(text, runId) {
+        if (!this.streamingAssistant ||
+            (runId && this.streamingRunId && runId !== this.streamingRunId)) {
+            this.startAssistant(text, runId);
+            return;
+        }
+        this.streamingText = text;
+        this.streamingAssistant.setText(text);
+    }
+    finalizeAssistant(text, runId) {
+        if (this.streamingAssistant &&
+            (!runId || runId === this.streamingRunId || text === this.streamingText)) {
+            this.streamingText = text;
+            this.streamingAssistant.setText(text);
+        }
+        else {
+            this.startAssistant(text, runId);
+        }
+        this.streamingAssistant = null;
+        this.streamingRunId = null;
+        this.streamingText = null;
+    }
+    startTool(toolCallId, toolName, args) {
+        const existing = this.toolById.get(toolCallId);
+        if (existing) {
+            existing.setArgs(args);
+            return existing;
+        }
+        const component = new ToolExecutionComponent(toolName, args);
+        component.setExpanded(this.toolsExpanded);
+        this.toolById.set(toolCallId, component);
+        this.addChild(component);
+        return component;
+    }
+    updateToolArgs(toolCallId, args) {
+        const existing = this.toolById.get(toolCallId);
+        if (!existing)
+            return;
+        existing.setArgs(args);
+    }
+    updateToolResult(toolCallId, result, opts) {
+        const existing = this.toolById.get(toolCallId);
+        if (!existing)
+            return;
+        if (opts?.partial) {
+            existing.setPartialResult(result);
+            return;
+        }
+        existing.setResult(result, {
+            isError: opts?.isError,
+        });
+    }
+    setToolsExpanded(expanded) {
+        this.toolsExpanded = expanded;
+        for (const tool of this.toolById.values()) {
+            tool.setExpanded(expanded);
+        }
+    }
+}

package/dist/tui/components/custom-editor.js

@@ -0,0 +1,53 @@
+import { Editor, isAltEnter, isCtrlC, isCtrlD, isCtrlL, isCtrlO, isCtrlP, isCtrlT, isEscape, isShiftTab, } from "@mariozechner/pi-tui";
+export class CustomEditor extends Editor {
+    onEscape;
+    onCtrlC;
+    onCtrlD;
+    onCtrlL;
+    onCtrlO;
+    onCtrlP;
+    onCtrlT;
+    onShiftTab;
+    onAltEnter;
+    handleInput(data) {
+        if (isAltEnter(data) && this.onAltEnter) {
+            this.onAltEnter();
+            return;
+        }
+        if (isCtrlL(data) && this.onCtrlL) {
+            this.onCtrlL();
+            return;
+        }
+        if (isCtrlO(data) && this.onCtrlO) {
+            this.onCtrlO();
+            return;
+        }
+        if (isCtrlP(data) && this.onCtrlP) {
+            this.onCtrlP();
+            return;
+        }
+        if (isCtrlT(data) && this.onCtrlT) {
+            this.onCtrlT();
+            return;
+        }
+        if (isShiftTab(data) && this.onShiftTab) {
+            this.onShiftTab();
+            return;
+        }
+        if (isEscape(data) && this.onEscape && !this.isShowingAutocomplete()) {
+            this.onEscape();
+            return;
+        }
+        if (isCtrlC(data) && this.onCtrlC) {
+            this.onCtrlC();
+            return;
+        }
+        if (isCtrlD(data)) {
+            if (this.getText().length === 0 && this.onCtrlD) {
+                this.onCtrlD();
+            }
+            return;
+        }
+        super.handleInput(data);
+    }
+}

package/dist/tui/components/selectors.js

@@ -0,0 +1,8 @@
+import { SelectList, SettingsList, } from "@mariozechner/pi-tui";
+import { selectListTheme, settingsListTheme } from "../theme/theme.js";
+export function createSelectList(items, maxVisible = 7) {
+    return new SelectList(items, maxVisible, selectListTheme);
+}
+export function createSettingsList(items, onChange, onCancel, maxVisible = 7) {
+    return new SettingsList(items, maxVisible, settingsListTheme, onChange, onCancel);
+}

package/dist/tui/components/tool-execution.js

@@ -0,0 +1,111 @@
+import { Box, Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { formatToolDetail, resolveToolDisplay, } from "../../agents/tool-display.js";
+import { markdownTheme, theme } from "../theme/theme.js";
+const PREVIEW_LINES = 12;
+function formatArgs(toolName, args) {
+    const display = resolveToolDisplay({ name: toolName, args });
+    const detail = formatToolDetail(display);
+    if (detail)
+        return detail;
+    if (!args || typeof args !== "object")
+        return "";
+    try {
+        return JSON.stringify(args);
+    }
+    catch {
+        return "";
+    }
+}
+function extractText(result) {
+    if (!result?.content)
+        return "";
+    const lines = [];
+    for (const entry of result.content) {
+        if (entry.type === "text" && entry.text) {
+            lines.push(entry.text);
+        }
+        else if (entry.type === "image") {
+            const mime = entry.mimeType ?? "image";
+            const size = entry.bytes ? ` ${Math.round(entry.bytes / 1024)}kb` : "";
+            const omitted = entry.omitted ? " (omitted)" : "";
+            lines.push(`[${mime}${size}${omitted}]`);
+        }
+    }
+    return lines.join("\n").trim();
+}
+export class ToolExecutionComponent extends Container {
+    box;
+    header;
+    argsLine;
+    output;
+    toolName;
+    args;
+    result;
+    expanded = false;
+    isError = false;
+    isPartial = true;
+    constructor(toolName, args) {
+        super();
+        this.toolName = toolName;
+        this.args = args;
+        this.box = new Box(1, 1, (line) => theme.toolPendingBg(line));
+        this.header = new Text("", 0, 0);
+        this.argsLine = new Text("", 0, 0);
+        this.output = new Markdown("", 0, 0, markdownTheme, {
+            color: (line) => theme.toolOutput(line),
+        });
+        this.addChild(new Spacer(1));
+        this.addChild(this.box);
+        this.box.addChild(this.header);
+        this.box.addChild(this.argsLine);
+        this.box.addChild(this.output);
+        this.refresh();
+    }
+    setArgs(args) {
+        this.args = args;
+        this.refresh();
+    }
+    setExpanded(expanded) {
+        this.expanded = expanded;
+        this.refresh();
+    }
+    setResult(result, opts) {
+        this.result = result;
+        this.isPartial = false;
+        this.isError = Boolean(opts?.isError);
+        this.refresh();
+    }
+    setPartialResult(result) {
+        this.result = result;
+        this.isPartial = true;
+        this.refresh();
+    }
+    refresh() {
+        const bg = this.isPartial
+            ? theme.toolPendingBg
+            : this.isError
+                ? theme.toolErrorBg
+                : theme.toolSuccessBg;
+        this.box.setBgFn((line) => bg(line));
+        const display = resolveToolDisplay({
+            name: this.toolName,
+            args: this.args,
+        });
+        const title = `${display.emoji} ${display.label}${this.isPartial ? " (running)" : ""}`;
+        this.header.setText(theme.toolTitle(theme.bold(title)));
+        const argLine = formatArgs(this.toolName, this.args);
+        this.argsLine.setText(argLine ? theme.dim(argLine) : theme.dim(" "));
+        const raw = extractText(this.result);
+        const text = raw || (this.isPartial ? "…" : "");
+        if (!this.expanded && text) {
+            const lines = text.split("\n");
+            const preview = lines.length > PREVIEW_LINES
+                ? `${lines.slice(0, PREVIEW_LINES).join("\n")}\n…`
+                : text;
+            this.output.setText(preview);
+        }
+        else {
+            this.output.setText(text);
+        }
+    }
+}