@gguf/claw 2026.2.1 → 2026.2.3

package/dist/telegram/bot.js

@@ -3,27 +3,27 @@ import { sequentialize } from "@grammyjs/runner";
 import { apiThrottler } from "@grammyjs/transformer-throttler";
 import { Bot, webhookCallback } from "grammy";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
-import { isControlCommandMessage } from "../auto-reply/command-detection.js";
 import { resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { isControlCommandMessage } from "../auto-reply/command-detection.js";
 import { DEFAULT_GROUP_HISTORY_LIMIT } from "../auto-reply/reply/history.js";
 import { isNativeCommandsExplicitlyDisabled, resolveNativeCommandsEnabled, resolveNativeSkillsEnabled, } from "../config/commands.js";
 import { loadConfig } from "../config/config.js";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention, } from "../config/group-policy.js";
 import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
 import { formatUncaughtError } from "../infra/errors.js";
 import { enqueueSystemEvent } from "../infra/system-events.js";
 import { getChildLogger } from "../logging.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../routing/session-key.js";
 import { resolveTelegramAccount } from "./accounts.js";
-import { buildTelegramGroupPeerId, resolveTelegramForumThreadId, resolveTelegramStreamMode, } from "./bot/helpers.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
 import { registerTelegramHandlers } from "./bot-handlers.js";
 import { createTelegramMessageProcessor } from "./bot-message.js";
 import { registerTelegramNativeCommands } from "./bot-native-commands.js";
 import { buildTelegramUpdateKey, createTelegramUpdateDedupe, resolveTelegramUpdateId, } from "./bot-updates.js";
-import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { buildTelegramGroupPeerId, resolveTelegramForumThreadId, resolveTelegramStreamMode, } from "./bot/helpers.js";
 import { resolveTelegramFetch } from "./fetch.js";
 import { wasSentByBot } from "./sent-message-cache.js";
 export function getTelegramSequentialKey(ctx) {
@@ -361,7 +361,9 @@ export function createTelegramBot(opts) {
             }
             senderLabel = senderLabel || "unknown";
             // Extract forum thread info (similar to message processing)
+            // oxlint-disable-next-line typescript/no-explicit-any
             const messageThreadId = reaction.message_thread_id;
+            // oxlint-disable-next-line typescript/no-explicit-any
             const isForum = reaction.chat.is_forum === true;
             const resolvedThreadId = resolveTelegramForumThreadId({
                 isForum,

package/dist/telegram/download.d.ts

@@ -5,5 +5,5 @@ export type TelegramFileInfo = {
     file_size?: number;
     file_path?: string;
 };
-export declare function getTelegramFile(token: string, fileId: string): Promise<TelegramFileInfo>;
-export declare function downloadTelegramFile(token: string, info: TelegramFileInfo, maxBytes?: number): Promise<SavedMedia>;
+export declare function getTelegramFile(token: string, fileId: string, timeoutMs?: number): Promise<TelegramFileInfo>;
+export declare function downloadTelegramFile(token: string, info: TelegramFileInfo, maxBytes?: number, timeoutMs?: number): Promise<SavedMedia>;

package/dist/telegram/download.js

@@ -1,7 +1,7 @@
 import { detectMime } from "../media/mime.js";
 import { saveMediaBuffer } from "../media/store.js";
-export async function getTelegramFile(token, fileId) {
-    const res = await fetch(`https://api.telegram.org/bot${token}/getFile?file_id=${encodeURIComponent(fileId)}`);
+export async function getTelegramFile(token, fileId, timeoutMs = 30_000) {
+    const res = await fetch(`https://api.telegram.org/bot${token}/getFile?file_id=${encodeURIComponent(fileId)}`, { signal: AbortSignal.timeout(timeoutMs) });
     if (!res.ok) {
         throw new Error(`getFile failed: ${res.status} ${res.statusText}`);
     }
@@ -11,12 +11,12 @@ export async function getTelegramFile(token, fileId) {
     }
     return json.result;
 }
-export async function downloadTelegramFile(token, info, maxBytes) {
+export async function downloadTelegramFile(token, info, maxBytes, timeoutMs = 60_000) {
     if (!info.file_path) {
         throw new Error("file_path missing");
     }
     const url = `https://api.telegram.org/file/bot${token}/${info.file_path}`;
-    const res = await fetch(url);
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
     if (!res.ok || !res.body) {
         throw new Error(`Failed to download telegram file: HTTP ${res.status}`);
     }

package/dist/telegram/draft-stream.d.ts

@@ -1,4 +1,5 @@
 import type { Bot } from "grammy";
+import { type TelegramThreadSpec } from "./bot/helpers.js";
 export type TelegramDraftStream = {
     update: (text: string) => void;
     flush: () => Promise<void>;
@@ -9,7 +10,7 @@ export declare function createTelegramDraftStream(params: {
     chatId: number;
     draftId: number;
     maxChars?: number;
-    messageThreadId?: number;
+    thread?: TelegramThreadSpec | null;
     throttleMs?: number;
     log?: (message: string) => void;
     warn?: (message: string) => void;

package/dist/telegram/draft-stream.js

@@ -7,7 +7,7 @@ export function createTelegramDraftStream(params) {
     const rawDraftId = Number.isFinite(params.draftId) ? Math.trunc(params.draftId) : 1;
     const draftId = rawDraftId === 0 ? 1 : Math.abs(rawDraftId);
     const chatId = params.chatId;
-    const threadParams = buildTelegramThreadParams(params.messageThreadId);
+    const threadParams = buildTelegramThreadParams(params.thread);
     let lastSentText = "";
     let lastSentAt = 0;
     let pendingText = "";

package/dist/telegram/monitor.js

@@ -1,9 +1,10 @@
 import { run } from "@grammyjs/runner";
-import { loadConfig } from "../config/config.js";
 import { resolveAgentMaxConcurrent } from "../config/agent-limits.js";
+import { loadConfig } from "../config/config.js";
 import { computeBackoff, sleepWithAbort } from "../infra/backoff.js";
 import { formatErrorMessage } from "../infra/errors.js";
 import { formatDurationMs } from "../infra/format-duration.js";
+import { registerUnhandledRejectionHandler } from "../infra/unhandled-rejections.js";
 import { resolveTelegramAccount } from "./accounts.js";
 import { resolveTelegramAllowedUpdates } from "./allowed-updates.js";
 import { createTelegramBot } from "./bot.js";
@@ -52,122 +53,126 @@ const isGetUpdatesConflict = (err) => {
         .toLowerCase();
     return haystack.includes("getupdates");
 };
-const NETWORK_ERROR_SNIPPETS = [
-    "fetch failed",
-    "network",
-    "timeout",
-    "socket",
-    "econnreset",
-    "econnrefused",
-    "undici",
-];
-const isNetworkRelatedError = (err) => {
-    if (!err) {
-        return false;
-    }
-    const message = formatErrorMessage(err).toLowerCase();
-    if (!message) {
+/** Check if error is a Grammy HttpError (used to scope unhandled rejection handling) */
+const isGrammyHttpError = (err) => {
+    if (!err || typeof err !== "object") {
         return false;
     }
-    return NETWORK_ERROR_SNIPPETS.some((snippet) => message.includes(snippet));
+    return err.name === "HttpError";
 };
 export async function monitorTelegramProvider(opts = {}) {
-    const cfg = opts.config ?? loadConfig();
-    const account = resolveTelegramAccount({
-        cfg,
-        accountId: opts.accountId,
-    });
-    const token = opts.token?.trim() || account.token;
-    if (!token) {
-        throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
-    }
-    const proxyFetch = opts.proxyFetch ?? (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
-    let lastUpdateId = await readTelegramUpdateOffset({
-        accountId: account.accountId,
-    });
-    const persistUpdateId = async (updateId) => {
-        if (lastUpdateId !== null && updateId <= lastUpdateId) {
-            return;
-        }
-        lastUpdateId = updateId;
-        try {
-            await writeTelegramUpdateOffset({
-                accountId: account.accountId,
-                updateId,
-            });
-        }
-        catch (err) {
-            (opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
+    const log = opts.runtime?.error ?? console.error;
+    // Register handler for Grammy HttpError unhandled rejections.
+    // This catches network errors that escape the polling loop's try-catch
+    // (e.g., from setMyCommands during bot setup).
+    // We gate on isGrammyHttpError to avoid suppressing non-Telegram errors.
+    const unregisterHandler = registerUnhandledRejectionHandler((err) => {
+        if (isGrammyHttpError(err) && isRecoverableTelegramNetworkError(err, { context: "polling" })) {
+            log(`[telegram] Suppressed network error: ${formatErrorMessage(err)}`);
+            return true; // handled - don't crash
         }
-    };
-    const bot = createTelegramBot({
-        token,
-        runtime: opts.runtime,
-        proxyFetch,
-        config: cfg,
-        accountId: account.accountId,
-        updateOffset: {
-            lastUpdateId,
-            onUpdateId: persistUpdateId,
-        },
+        return false;
     });
-    if (opts.useWebhook) {
-        await startTelegramWebhook({
-            token,
+    try {
+        const cfg = opts.config ?? loadConfig();
+        const account = resolveTelegramAccount({
+            cfg,
+            accountId: opts.accountId,
+        });
+        const token = opts.token?.trim() || account.token;
+        if (!token) {
+            throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
+        }
+        const proxyFetch = opts.proxyFetch ?? (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
+        let lastUpdateId = await readTelegramUpdateOffset({
             accountId: account.accountId,
-            config: cfg,
-            path: opts.webhookPath,
-            port: opts.webhookPort,
-            secret: opts.webhookSecret,
-            runtime: opts.runtime,
-            fetch: proxyFetch,
-            abortSignal: opts.abortSignal,
-            publicUrl: opts.webhookUrl,
         });
-        return;
-    }
-    // Use grammyjs/runner for concurrent update processing
-    let restartAttempts = 0;
-    while (!opts.abortSignal?.aborted) {
-        const runner = run(bot, createTelegramRunnerOptions(cfg));
-        const stopOnAbort = () => {
-            if (opts.abortSignal?.aborted) {
-                void runner.stop();
+        const persistUpdateId = async (updateId) => {
+            if (lastUpdateId !== null && updateId <= lastUpdateId) {
+                return;
+            }
+            lastUpdateId = updateId;
+            try {
+                await writeTelegramUpdateOffset({
+                    accountId: account.accountId,
+                    updateId,
+                });
+            }
+            catch (err) {
+                (opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
             }
         };
-        opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
-        try {
-            // runner.task() returns a promise that resolves when the runner stops
-            await runner.task();
+        const bot = createTelegramBot({
+            token,
+            runtime: opts.runtime,
+            proxyFetch,
+            config: cfg,
+            accountId: account.accountId,
+            updateOffset: {
+                lastUpdateId,
+                onUpdateId: persistUpdateId,
+            },
+        });
+        if (opts.useWebhook) {
+            await startTelegramWebhook({
+                token,
+                accountId: account.accountId,
+                config: cfg,
+                path: opts.webhookPath,
+                port: opts.webhookPort,
+                secret: opts.webhookSecret,
+                runtime: opts.runtime,
+                fetch: proxyFetch,
+                abortSignal: opts.abortSignal,
+                publicUrl: opts.webhookUrl,
+            });
             return;
         }
-        catch (err) {
-            if (opts.abortSignal?.aborted) {
-                throw err;
-            }
-            const isConflict = isGetUpdatesConflict(err);
-            const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
-            const isNetworkError = isNetworkRelatedError(err);
-            if (!isConflict && !isRecoverable && !isNetworkError) {
-                throw err;
-            }
-            restartAttempts += 1;
-            const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
-            const reason = isConflict ? "getUpdates conflict" : "network error";
-            const errMsg = formatErrorMessage(err);
-            (opts.runtime?.error ?? console.error)(`Telegram ${reason}: ${errMsg}; retrying in ${formatDurationMs(delayMs)}.`);
+        // Use grammyjs/runner for concurrent update processing
+        let restartAttempts = 0;
+        while (!opts.abortSignal?.aborted) {
+            const runner = run(bot, createTelegramRunnerOptions(cfg));
+            const stopOnAbort = () => {
+                if (opts.abortSignal?.aborted) {
+                    void runner.stop();
+                }
+            };
+            opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
             try {
-                await sleepWithAbort(delayMs, opts.abortSignal);
+                // runner.task() returns a promise that resolves when the runner stops
+                await runner.task();
+                return;
             }
-            catch (sleepErr) {
+            catch (err) {
                 if (opts.abortSignal?.aborted) {
-                    return;
+                    throw err;
+                }
+                const isConflict = isGetUpdatesConflict(err);
+                const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
+                if (!isConflict && !isRecoverable) {
+                    throw err;
+                }
+                restartAttempts += 1;
+                const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
+                const reason = isConflict ? "getUpdates conflict" : "network error";
+                const errMsg = formatErrorMessage(err);
+                (opts.runtime?.error ?? console.error)(`Telegram ${reason}: ${errMsg}; retrying in ${formatDurationMs(delayMs)}.`);
+                try {
+                    await sleepWithAbort(delayMs, opts.abortSignal);
+                }
+                catch (sleepErr) {
+                    if (opts.abortSignal?.aborted) {
+                        return;
+                    }
+                    throw sleepErr;
                 }
-                throw sleepErr;
+            }
+            finally {
+                opts.abortSignal?.removeEventListener("abort", stopOnAbort);
             }
         }
-        finally {
-            opts.abortSignal?.removeEventListener("abort", stopOnAbort);
-        }
+    }
+    finally {
+        unregisterHandler();
     }
 }

package/dist/telegram/network-errors.js

@@ -33,6 +33,8 @@ const RECOVERABLE_MESSAGE_SNIPPETS = [
     "client network socket disconnected",
     "socket hang up",
     "getaddrinfo",
+    "timeout", // catch timeout messages not covered by error codes/names
+    "timed out", // grammY getUpdates returns "timed out after X seconds" (not matched by "timeout")
 ];
 function normalizeCode(code) {
     return code?.trim().toUpperCase() ?? "";
@@ -88,6 +90,14 @@ function collectErrorCandidates(err) {
                     }
                 }
             }
+            // Grammy's HttpError wraps the underlying error in .error (not .cause)
+            // Only follow .error for HttpError to avoid widening the search graph
+            if (getErrorName(current) === "HttpError") {
+                const wrappedError = current.error;
+                if (wrappedError && !seen.has(wrappedError)) {
+                    queue.push(wrappedError);
+                }
+            }
         }
     }
     return candidates;

package/dist/telegram/send.d.ts

@@ -1,7 +1,7 @@
 import type { InlineKeyboardMarkup } from "@grammyjs/types";
 import { Bot } from "grammy";
-import { loadConfig } from "../config/config.js";
 import type { RetryConfig } from "../infra/retry.js";
+import { loadConfig } from "../config/config.js";
 type TelegramSendOpts = {
     token?: string;
     accountId?: string;

package/dist/telegram/send.js

@@ -1,10 +1,10 @@
 import { Bot, HttpError, InputFile } from "grammy";
 import { loadConfig } from "../config/config.js";
+import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { logVerbose } from "../globals.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
-import { withTelegramApiErrorLogging } from "./api-logging.js";
-import { formatErrorMessage, formatUncaughtError } from "../infra/errors.js";
 import { isDiagnosticFlagEnabled } from "../infra/diagnostic-flags.js";
+import { formatErrorMessage, formatUncaughtError } from "../infra/errors.js";
 import { createTelegramRetryRunner } from "../infra/retry-policy.js";
 import { redactSensitiveText } from "../logging/redact.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
@@ -12,16 +12,16 @@ import { mediaKindFromMime } from "../media/constants.js";
 import { isGifMedia } from "../media/mime.js";
 import { loadWebMedia } from "../web/media.js";
 import { resolveTelegramAccount } from "./accounts.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { buildTelegramThreadParams } from "./bot/helpers.js";
+import { splitTelegramCaption } from "./caption.js";
 import { resolveTelegramFetch } from "./fetch.js";
-import { makeProxyFetch } from "./proxy.js";
 import { renderTelegramHtmlText } from "./format.js";
-import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { isRecoverableTelegramNetworkError } from "./network-errors.js";
-import { splitTelegramCaption } from "./caption.js";
+import { makeProxyFetch } from "./proxy.js";
 import { recordSentMessage } from "./sent-message-cache.js";
 import { parseTelegramTarget, stripTelegramInternalPrefixes } from "./targets.js";
 import { resolveTelegramVoiceSend } from "./voice.js";
-import { buildTelegramThreadParams } from "./bot/helpers.js";
 const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
 const diagLogger = createSubsystemLogger("telegram/diagnostic");
 function createTelegramHttpLogger(cfg) {
@@ -145,7 +145,8 @@ export async function sendMessageTelegram(to, text, opts = {}) {
     // Build optional params for forum topics and reply threading.
     // Only include these if actually provided to keep API calls clean.
     const messageThreadId = opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId;
-    const threadIdParams = buildTelegramThreadParams(messageThreadId);
+    const threadSpec = messageThreadId != null ? { id: messageThreadId, scope: "forum" } : undefined;
+    const threadIdParams = buildTelegramThreadParams(threadSpec);
     const threadParams = threadIdParams ? { ...threadIdParams } : {};
     const quoteText = opts.quoteText?.trim();
     if (opts.replyToMessageId != null) {
@@ -504,7 +505,8 @@ export async function sendStickerTelegram(to, fileId, opts = {}) {
     const client = resolveTelegramClientOptions(account);
     const api = opts.api ?? new Bot(token, client ? { client } : undefined).api;
     const messageThreadId = opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId;
-    const threadIdParams = buildTelegramThreadParams(messageThreadId);
+    const threadSpec = messageThreadId != null ? { id: messageThreadId, scope: "forum" } : undefined;
+    const threadIdParams = buildTelegramThreadParams(threadSpec);
     const threadParams = threadIdParams ? { ...threadIdParams } : {};
     if (opts.replyToMessageId != null) {
         threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);

package/dist/telegram/sticker-cache.js

@@ -1,11 +1,11 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { STATE_DIR } from "../config/paths.js";
-import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
-import { logVerbose } from "../globals.js";
-import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveApiKeyForProvider } from "../agents/model-auth.js";
+import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { STATE_DIR } from "../config/paths.js";
+import { logVerbose } from "../globals.js";
+import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
 import { resolveAutoImageModel } from "../media-understanding/runner.js";
 const CACHE_FILE = path.join(STATE_DIR, "telegram", "sticker-cache.json");
 const CACHE_VERSION = 1;

package/dist/telegram/webhook-set.js

@@ -1,6 +1,6 @@
 import { Bot } from "grammy";
-import { resolveTelegramFetch } from "./fetch.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { resolveTelegramFetch } from "./fetch.js";
 export async function setTelegramWebhook(opts) {
     const fetchImpl = resolveTelegramFetch(undefined, { network: opts.network });
     const client = fetchImpl

package/dist/telegram/webhook.js

@@ -1,12 +1,12 @@
-import { createServer } from "node:http";
 import { webhookCallback } from "grammy";
+import { createServer } from "node:http";
 import { isDiagnosticsEnabled } from "../infra/diagnostic-events.js";
 import { formatErrorMessage } from "../infra/errors.js";
-import { defaultRuntime } from "../runtime.js";
 import { logWebhookError, logWebhookProcessed, logWebhookReceived, startDiagnosticHeartbeat, stopDiagnosticHeartbeat, } from "../logging/diagnostic.js";
+import { defaultRuntime } from "../runtime.js";
 import { resolveTelegramAllowedUpdates } from "./allowed-updates.js";
-import { createTelegramBot } from "./bot.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { createTelegramBot } from "./bot.js";
 export async function startTelegramWebhook(opts) {
     const path = opts.path ?? "/telegram-webhook";
     const healthPath = opts.healthPath ?? "/healthz";

package/dist/terminal/restore.d.ts

@@ -0,0 +1 @@
+export declare function restoreTerminalState(reason?: string): void;

package/dist/terminal/restore.js

@@ -0,0 +1,45 @@
+import { clearActiveProgressLine } from "./progress-line.js";
+const RESET_SEQUENCE = "\x1b[0m\x1b[?25h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?2004l";
+function reportRestoreFailure(scope, err, reason) {
+    const suffix = reason ? ` (${reason})` : "";
+    const message = `[terminal] restore ${scope} failed${suffix}: ${String(err)}`;
+    try {
+        process.stderr.write(`${message}\n`);
+    }
+    catch (writeErr) {
+        console.error(`[terminal] restore reporting failed${suffix}: ${String(writeErr)}`);
+    }
+}
+export function restoreTerminalState(reason) {
+    try {
+        clearActiveProgressLine();
+    }
+    catch (err) {
+        reportRestoreFailure("progress line", err, reason);
+    }
+    const stdin = process.stdin;
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+        try {
+            stdin.setRawMode(false);
+        }
+        catch (err) {
+            reportRestoreFailure("raw mode", err, reason);
+        }
+        if (typeof stdin.isPaused === "function" && stdin.isPaused()) {
+            try {
+                stdin.resume();
+            }
+            catch (err) {
+                reportRestoreFailure("stdin resume", err, reason);
+            }
+        }
+    }
+    if (process.stdout.isTTY) {
+        try {
+            process.stdout.write(RESET_SEQUENCE);
+        }
+        catch (err) {
+            reportRestoreFailure("stdout reset", err, reason);
+        }
+    }
+}

package/dist/terminal/table.js

@@ -1,5 +1,5 @@
-import { visibleWidth } from "./ansi.js";
 import { displayString } from "../utils.js";
+import { visibleWidth } from "./ansi.js";
 function repeat(ch, n) {
     if (n <= 0) {
         return "";

package/dist/tts/tts.js

@@ -1,15 +1,15 @@
+import { completeSimple } from "@mariozechner/pi-ai";
+import { EdgeTTS } from "node-edge-tts";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, mkdtempSync, rmSync, renameSync, unlinkSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import { completeSimple } from "@mariozechner/pi-ai";
-import { EdgeTTS } from "node-edge-tts";
+import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
+import { buildModelAliasIndex, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../agents/model-selection.js";
+import { resolveModel } from "../agents/pi-embedded-runner/model.js";
 import { normalizeChannelId } from "../channels/plugins/index.js";
 import { logVerbose } from "../globals.js";
 import { isVoiceCompatibleAudio } from "../media/audio.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
-import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
-import { buildModelAliasIndex, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../agents/model-selection.js";
-import { resolveModel } from "../agents/pi-embedded-runner/model.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_TTS_MAX_LENGTH = 1500;
 const DEFAULT_TTS_SUMMARIZE = true;

package/dist/tui/components/filterable-select-list.d.ts

@@ -1,5 +1,5 @@
-import { type SelectItem, type SelectListTheme } from "@mariozechner/pi-tui";
 import type { Component } from "@mariozechner/pi-tui";
+import { type SelectItem, type SelectListTheme } from "@mariozechner/pi-tui";
 export interface FilterableSelectItem extends SelectItem {
     /** Additional searchable fields beyond label */
     searchText?: string;

package/dist/tui/components/searchable-select-list.js

@@ -169,9 +169,9 @@ export class SearchableSelectList {
             const remainingWidth = width - descriptionStart - 2;
             if (remainingWidth > 10) {
                 const truncatedDesc = truncateToWidth(item.description, remainingWidth, "");
-                const descText = isSelected
-                    ? this.highlightMatch(truncatedDesc, query)
-                    : this.highlightMatch(this.theme.description(truncatedDesc), query);
+                // Highlight plain text first, then apply theme styling to avoid corrupting ANSI codes
+                const highlightedDesc = this.highlightMatch(truncatedDesc, query);
+                const descText = isSelected ? highlightedDesc : this.theme.description(highlightedDesc);
                 const line = `${prefix}${valueText}${spacing}${descText}`;
                 return isSelected ? this.theme.selectedText(line) : line;
             }

package/dist/tui/tui-formatters.js

@@ -1,5 +1,5 @@
-import { formatTokenCount } from "../utils/usage-format.js";
 import { formatRawAssistantErrorForUi } from "../agents/pi-embedded-helpers.js";
+import { formatTokenCount } from "../utils/usage-format.js";
 export function resolveFinalAssistantText(params) {
     const finalText = params.finalText ?? "";
     if (finalText.trim()) {

package/dist/tui/tui.js

@@ -11,9 +11,9 @@ import { createCommandHandlers } from "./tui-command-handlers.js";
 import { createEventHandlers } from "./tui-event-handlers.js";
 import { formatTokens } from "./tui-formatters.js";
 import { createLocalShellRunner } from "./tui-local-shell.js";
-import { buildWaitingStatusMessage, defaultWaitingPhrases } from "./tui-waiting.js";
 import { createOverlayHandlers } from "./tui-overlays.js";
 import { createSessionActions } from "./tui-session-actions.js";
+import { buildWaitingStatusMessage, defaultWaitingPhrases } from "./tui-waiting.js";
 export { resolveFinalAssistantText } from "./tui-formatters.js";
 export function createEditorSubmitHandler(params) {
     return (text) => {
@@ -567,4 +567,10 @@ export async function runTui(opts) {
     updateFooter();
     tui.start();
     client.start();
+    await new Promise((resolve) => {
+        const finish = () => resolve();
+        process.once("exit", finish);
+        process.once("SIGINT", finish);
+        process.once("SIGTERM", finish);
+    });
 }

package/dist/web/accounts.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { resolveOAuthDir } from "../config/paths.js";
-import { DEFAULT_ACCOUNT_ID } from "../routing/session-key.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
 import { resolveUserPath } from "../utils.js";
 import { hasWebCredsSync } from "./auth-store.js";
 function listConfiguredAccountIds(cfg) {
@@ -59,7 +59,7 @@ function resolveAccountConfig(cfg, accountId) {
     return entry;
 }
 function resolveDefaultAuthDir(accountId) {
-    return path.join(resolveOAuthDir(), "whatsapp", accountId);
+    return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
 }
 function resolveLegacyAuthDir() {
     // Legacy Baileys creds lived in the same directory as OAuth tokens.

package/dist/web/auth-store.d.ts

@@ -1,5 +1,5 @@
-import { type RuntimeEnv } from "../runtime.js";
 import type { WebChannel } from "../utils.js";
+import { type RuntimeEnv } from "../runtime.js";
 export declare function resolveDefaultWebAuthDir(): string;
 export declare const WA_WEB_AUTH_DIR: string;
 export declare function resolveWebCredsPath(authDir: string): string;