@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/telegram/targets.js

@@ -13,8 +13,9 @@ export function stripTelegramInternalPrefixes(to) {
             }
             return trimmed;
         })();
-        if (next === trimmed)
+        if (next === trimmed) {
             return trimmed;
+        }
         trimmed = next;
     }
 }
@@ -26,6 +27,16 @@ export function stripTelegramInternalPrefixes(to) {
  * - `chatId:topicId` (numeric topic/thread ID)
  * - `chatId:topic:topicId` (explicit topic marker; preferred)
  */
+function resolveTelegramChatType(chatId) {
+    const trimmed = chatId.trim();
+    if (!trimmed) {
+        return "unknown";
+    }
+    if (/^-?\d+$/.test(trimmed)) {
+        return trimmed.startsWith("-") ? "group" : "direct";
+    }
+    return "unknown";
+}
 export function parseTelegramTarget(to) {
     const normalized = stripTelegramInternalPrefixes(to);
     const topicMatch = /^(.+?):topic:(\d+)$/.exec(normalized);
@@ -33,6 +44,7 @@ export function parseTelegramTarget(to) {
         return {
             chatId: topicMatch[1],
             messageThreadId: Number.parseInt(topicMatch[2], 10),
+            chatType: resolveTelegramChatType(topicMatch[1]),
         };
     }
     const colonMatch = /^(.+):(\d+)$/.exec(normalized);
@@ -40,7 +52,14 @@ export function parseTelegramTarget(to) {
         return {
             chatId: colonMatch[1],
             messageThreadId: Number.parseInt(colonMatch[2], 10),
+            chatType: resolveTelegramChatType(colonMatch[1]),
         };
     }
-    return { chatId: normalized };
+    return {
+        chatId: normalized,
+        chatType: resolveTelegramChatType(normalized),
+    };
+}
+export function resolveTelegramTargetChatType(target) {
+    return parseTelegramTarget(target).chatType;
 }

package/dist/telegram/update-offset-store.js

@@ -6,8 +6,9 @@ import { resolveStateDir } from "../config/paths.js";
 const STORE_VERSION = 1;
 function normalizeAccountId(accountId) {
     const trimmed = accountId?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "default";
+    }
     return trimmed.replace(/[^a-z0-9._-]+/gi, "_");
 }
 function resolveTelegramUpdateOffsetPath(accountId, env = process.env) {
@@ -18,8 +19,9 @@ function resolveTelegramUpdateOffsetPath(accountId, env = process.env) {
 function safeParseState(raw) {
     try {
         const parsed = JSON.parse(raw);
-        if (parsed?.version !== STORE_VERSION)
+        if (parsed?.version !== STORE_VERSION) {
             return null;
+        }
         if (parsed.lastUpdateId !== null && typeof parsed.lastUpdateId !== "number") {
             return null;
         }
@@ -38,8 +40,9 @@ export async function readTelegramUpdateOffset(params) {
     }
     catch (err) {
         const code = err.code;
-        if (code === "ENOENT")
+        if (code === "ENOENT") {
             return null;
+        }
         return null;
     }
 }
@@ -58,3 +61,16 @@ export async function writeTelegramUpdateOffset(params) {
     await fs.chmod(tmp, 0o600);
     await fs.rename(tmp, filePath);
 }
+export async function deleteTelegramUpdateOffset(params) {
+    const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
+    try {
+        await fs.unlink(filePath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            return;
+        }
+        throw err;
+    }
+}

package/dist/terminal/restore.js

@@ -10,7 +10,10 @@ function reportRestoreFailure(scope, err, reason) {
         console.error(`[terminal] restore reporting failed${suffix}: ${String(writeErr)}`);
     }
 }
-export function restoreTerminalState(reason) {
+export function restoreTerminalState(reason, options = {}) {
+    // Docker TTY note: resuming stdin can keep a container process alive even
+    // after the wizard is "done" (stdin_open: true), making installers appear hung.
+    const resumeStdin = options.resumeStdinIfPaused ?? options.resumeStdin ?? false;
     try {
         clearActiveProgressLine();
     }
@@ -25,7 +28,7 @@ export function restoreTerminalState(reason) {
         catch (err) {
             reportRestoreFailure("raw mode", err, reason);
         }
-        if (typeof stdin.isPaused === "function" && stdin.isPaused()) {
+        if (resumeStdin && typeof stdin.isPaused === "function" && stdin.isPaused()) {
             try {
                 stdin.resume();
             }

package/dist/test-utils/fetch-mock.js

@@ -0,0 +1,5 @@
+export function withFetchPreconnect(fn) {
+    return Object.assign(fn, {
+        preconnect: (_url, _options) => { },
+    });
+}

package/dist/version.js

@@ -18,10 +18,12 @@ function readVersionFromJsonCandidates(moduleUrl, candidates, opts = {}) {
             try {
                 const parsed = require(candidate);
                 const version = parsed.version?.trim();
-                if (!version)
+                if (!version) {
                     continue;
-                if (opts.requirePackageName && parsed.name !== CORE_PACKAGE_NAME)
+                }
+                if (opts.requirePackageName && parsed.name !== CORE_PACKAGE_NAME) {
                     continue;
+                }
                 return version;
             }
             catch {
@@ -34,6 +36,15 @@ function readVersionFromJsonCandidates(moduleUrl, candidates, opts = {}) {
         return null;
     }
 }
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
 export function readVersionFromPackageJsonForModuleUrl(moduleUrl) {
     return readVersionFromJsonCandidates(moduleUrl, PACKAGE_JSON_CANDIDATES, {
         requirePackageName: true,
@@ -46,11 +57,13 @@ export function resolveVersionFromModuleUrl(moduleUrl) {
     return (readVersionFromPackageJsonForModuleUrl(moduleUrl) ||
         readVersionFromBuildInfoForModuleUrl(moduleUrl));
 }
-// Single source of truth for the current poolbot version.
+export function resolveRuntimeServiceVersion(env = process.env, fallback = "dev") {
+    return (firstNonEmpty(env["POOLBOT_VERSION"], env["POOLBOT_SERVICE_VERSION"], env["npm_package_version"]) ?? fallback);
+}
+// Single source of truth for the current Pool Bot version.
 // - Embedded/bundled builds: injected define or env var.
 // - Dev/npm builds: package.json.
-export const VERSION = (typeof __CLAWDBOT_VERSION__ === "string" && __CLAWDBOT_VERSION__) ||
+export const VERSION = (typeof __POOLBOT_VERSION__ === "string" && __POOLBOT_VERSION__) ||
     process.env.POOLBOT_BUNDLED_VERSION ||
-    process.env.CLAWDBOT_BUNDLED_VERSION ||
     resolveVersionFromModuleUrl(import.meta.url) ||
     "0.0.0";

package/dist/web/auto-reply/monitor/broadcast.js

@@ -4,10 +4,12 @@ import { formatError } from "../../session.js";
 import { whatsappInboundLog } from "../loggers.js";
 export async function maybeBroadcastMessage(params) {
     const broadcastAgents = params.cfg.broadcast?.[params.peerId];
-    if (!broadcastAgents || !Array.isArray(broadcastAgents))
+    if (!broadcastAgents || !Array.isArray(broadcastAgents)) {
         return false;
-    if (broadcastAgents.length === 0)
+    }
+    if (broadcastAgents.length === 0) {
         return false;
+    }
     const strategy = params.cfg.broadcast?.strategy || "parallel";
     whatsappInboundLog.info(`Broadcasting message to ${broadcastAgents.length} agents (${strategy})`);
     const agentIds = params.cfg.agents?.list?.map((agent) => normalizeAgentId(agent.id));
@@ -27,11 +29,13 @@ export async function maybeBroadcastMessage(params) {
             sessionKey: buildAgentSessionKey({
                 agentId: normalizedAgentId,
                 channel: "whatsapp",
+                accountId: params.route.accountId,
                 peer: {
-                    kind: params.msg.chatType === "group" ? "group" : "dm",
+                    kind: params.msg.chatType === "group" ? "group" : "direct",
                     id: params.peerId,
                 },
                 dmScope: params.cfg.session?.dmScope,
+                identityLinks: params.cfg.session?.identityLinks,
             }),
             mainSessionKey: buildAgentMainSessionKey({
                 agentId: normalizedAgentId,

package/dist/web/auto-reply/monitor/on-message.js

@@ -1,3 +1,4 @@
+import { loadConfig } from "../../../config/config.js";
 import { logVerbose } from "../../../globals.js";
 import { resolveAgentRoute } from "../../../routing/resolve-route.js";
 import { buildGroupHistoryKey } from "../../../routing/session-key.js";
@@ -31,12 +32,13 @@ export function createWebOnMessageHandler(params) {
     return async (msg) => {
         const conversationId = msg.conversationId ?? msg.from;
         const peerId = resolvePeerId(msg);
+        // Fresh config for bindings lookup; other routing inputs are payload-derived.
         const route = resolveAgentRoute({
-            cfg: params.cfg,
+            cfg: loadConfig(),
             channel: "whatsapp",
             accountId: msg.accountId,
             peer: {
-                kind: msg.chatType === "group" ? "group" : "dm",
+                kind: msg.chatType === "group" ? "group" : "direct",
                 id: peerId,
             },
         });
@@ -101,8 +103,9 @@ export function createWebOnMessageHandler(params) {
                 logVerbose,
                 replyLogger: params.replyLogger,
             });
-            if (!gating.shouldProcess)
+            if (!gating.shouldProcess) {
                 return;
+            }
         }
         else {
             // Ensure `peerId` for DMs is stable and stored as E.164 when possible.

package/dist/web/inbound/media.js

@@ -4,16 +4,42 @@ function unwrapMessage(message) {
     const normalized = normalizeMessageContent(message);
     return normalized;
 }
-export async function downloadInboundMedia(msg, sock) {
-    const message = unwrapMessage(msg.message);
-    if (!message)
-        return undefined;
-    const mimetype = message.imageMessage?.mimetype ??
+/**
+ * Resolve the MIME type for an inbound media message.
+ * Falls back to WhatsApp's standard formats when Baileys omits the MIME.
+ */
+function resolveMediaMimetype(message) {
+    const explicit = message.imageMessage?.mimetype ??
         message.videoMessage?.mimetype ??
         message.documentMessage?.mimetype ??
         message.audioMessage?.mimetype ??
         message.stickerMessage?.mimetype ??
         undefined;
+    if (explicit) {
+        return explicit;
+    }
+    // WhatsApp voice messages (PTT) and audio use OGG Opus by default
+    if (message.audioMessage) {
+        return "audio/ogg; codecs=opus";
+    }
+    if (message.imageMessage) {
+        return "image/jpeg";
+    }
+    if (message.videoMessage) {
+        return "video/mp4";
+    }
+    if (message.stickerMessage) {
+        return "image/webp";
+    }
+    return undefined;
+}
+export async function downloadInboundMedia(msg, sock) {
+    const message = unwrapMessage(msg.message);
+    if (!message) {
+        return undefined;
+    }
+    const mimetype = resolveMediaMimetype(message);
+    const fileName = message.documentMessage?.fileName ?? undefined;
     if (!message.imageMessage &&
         !message.videoMessage &&
         !message.documentMessage &&
@@ -22,11 +48,11 @@ export async function downloadInboundMedia(msg, sock) {
         return undefined;
     }
     try {
-        const buffer = (await downloadMediaMessage(msg, "buffer", {}, {
+        const buffer = await downloadMediaMessage(msg, "buffer", {}, {
             reuploadRequest: sock.updateMediaMessage,
             logger: sock.logger,
-        }));
-        return { buffer, mimetype };
+        });
+        return { buffer, mimetype, fileName };
     }
     catch (err) {
         logVerbose(`downloadMediaMessage failed: ${String(err)}`);

package/dist/web/inbound/monitor.js

@@ -1,11 +1,11 @@
 import { DisconnectReason, isJidGroup } from "@whiskeysockets/baileys";
+import { createInboundDebouncer } from "../../auto-reply/inbound-debounce.js";
 import { formatLocationText } from "../../channels/location.js";
 import { logVerbose, shouldLogVerbose } from "../../globals.js";
 import { recordChannelActivity } from "../../infra/channel-activity.js";
 import { getChildLogger } from "../../logging/logger.js";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { saveMediaBuffer } from "../../media/store.js";
-import { createInboundDebouncer } from "../../auto-reply/inbound-debounce.js";
 import { jidToE164, resolveJidToE164 } from "../../utils.js";
 import { createWaSocket, getStatusCode, waitForWaConnection } from "../session.js";
 import { checkInboundAccessControl } from "./access-control.js";
@@ -26,16 +26,18 @@ export async function monitorWebInbox(options) {
         onCloseResolve = resolve;
     });
     const resolveClose = (reason) => {
-        if (!onCloseResolve)
+        if (!onCloseResolve) {
             return;
+        }
         const resolver = onCloseResolve;
         onCloseResolve = null;
         resolver(reason);
     };
     try {
         await sock.sendPresenceUpdate("available");
-        if (shouldLogVerbose())
+        if (shouldLogVerbose()) {
             logVerbose("Sent global 'available' presence on connect");
+        }
     }
     catch (err) {
         logVerbose(`Failed to send 'available' presence on connect: ${String(err)}`);
@@ -48,24 +50,27 @@ export async function monitorWebInbox(options) {
             const senderKey = msg.chatType === "group"
                 ? (msg.senderJid ?? msg.senderE164 ?? msg.senderName ?? msg.from)
                 : msg.from;
-            if (!senderKey)
+            if (!senderKey) {
                 return null;
+            }
             const conversationKey = msg.chatType === "group" ? msg.chatId : msg.from;
             return `${msg.accountId}:${conversationKey}:${senderKey}`;
         },
         shouldDebounce: options.shouldDebounce,
         onFlush: async (entries) => {
             const last = entries.at(-1);
-            if (!last)
+            if (!last) {
                 return;
+            }
             if (entries.length === 1) {
                 await options.onMessage(last);
                 return;
             }
             const mentioned = new Set();
             for (const entry of entries) {
-                for (const jid of entry.mentionedJids ?? [])
+                for (const jid of entry.mentionedJids ?? []) {
                     mentioned.add(jid);
+                }
             }
             const combinedBody = entries
                 .map((entry) => entry.body)
@@ -89,8 +94,9 @@ export async function monitorWebInbox(options) {
     const resolveInboundJid = async (jid) => resolveJidToE164(jid, { authDir: options.authDir, lidLookup });
     const getGroupMeta = async (jid) => {
         const cached = groupMetaCache.get(jid);
-        if (cached && cached.expires > Date.now())
+        if (cached && cached.expires > Date.now()) {
             return cached;
+        }
         try {
             const meta = await sock.groupMetadata(jid);
             const participants = (await Promise.all(meta.participants?.map(async (p) => {
@@ -111,8 +117,9 @@ export async function monitorWebInbox(options) {
         }
     };
     const handleMessagesUpsert = async (upsert) => {
-        if (upsert.type !== "notify" && upsert.type !== "append")
+        if (upsert.type !== "notify" && upsert.type !== "append") {
             return;
+        }
         for (const msg of upsert.messages ?? []) {
             recordChannelActivity({
                 channel: "whatsapp",
@@ -121,20 +128,24 @@ export async function monitorWebInbox(options) {
             });
             const id = msg.key?.id ?? undefined;
             const remoteJid = msg.key?.remoteJid;
-            if (!remoteJid)
+            if (!remoteJid) {
                 continue;
-            if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast"))
+            }
+            if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) {
                 continue;
+            }
             const group = isJidGroup(remoteJid) === true;
             if (id) {
                 const dedupeKey = `${options.accountId}:${remoteJid}:${id}`;
-                if (isRecentInboundMessage(dedupeKey))
+                if (isRecentInboundMessage(dedupeKey)) {
                     continue;
+                }
             }
             const participantJid = msg.key?.participant ?? undefined;
             const from = group ? remoteJid : await resolveInboundJid(remoteJid);
-            if (!from)
+            if (!from) {
                 continue;
+            }
             const senderE164 = group
                 ? participantJid
                     ? await resolveInboundJid(participantJid)
@@ -163,8 +174,9 @@ export async function monitorWebInbox(options) {
                 sock: { sendMessage: (jid, content) => sock.sendMessage(jid, content) },
                 remoteJid,
             });
-            if (!access.allowed)
+            if (!access.allowed) {
                 continue;
+            }
             if (id && !access.isSelfChat && options.sendReadReceipts !== false) {
                 const participant = msg.key?.participant;
                 try {
@@ -183,8 +195,9 @@ export async function monitorWebInbox(options) {
                 logVerbose(`Self-chat mode: skipping read receipt for ${id}`);
             }
             // If this is history/offline catch-up, mark read above but skip auto-reply.
-            if (upsert.type === "append")
+            if (upsert.type === "append") {
                 continue;
+            }
             const location = extractLocationData(msg.message ?? undefined);
             const locationText = location ? formatLocationText(location) : undefined;
             let body = extractText(msg.message ?? undefined);
@@ -193,12 +206,14 @@ export async function monitorWebInbox(options) {
             }
             if (!body) {
                 body = extractMediaPlaceholder(msg.message ?? undefined);
-                if (!body)
+                if (!body) {
                     continue;
+                }
             }
             const replyContext = describeReplyContext(msg.message);
             let mediaPath;
             let mediaType;
+            let mediaFileName;
             try {
                 const inboundMedia = await downloadInboundMedia(msg, sock);
                 if (inboundMedia) {
@@ -206,9 +221,10 @@ export async function monitorWebInbox(options) {
                         ? options.mediaMaxMb
                         : 50;
                     const maxBytes = maxMb * 1024 * 1024;
-                    const saved = await saveMediaBuffer(inboundMedia.buffer, inboundMedia.mimetype, "inbound", maxBytes);
+                    const saved = await saveMediaBuffer(inboundMedia.buffer, inboundMedia.mimetype, "inbound", maxBytes, inboundMedia.fileName);
                     mediaPath = saved.path;
                     mediaType = inboundMedia.mimetype;
+                    mediaFileName = inboundMedia.fileName;
                 }
             }
             catch (err) {
@@ -232,7 +248,7 @@ export async function monitorWebInbox(options) {
             const timestamp = messageTimestampMs;
             const mentionedJids = extractMentionedJids(msg.message);
             const senderName = msg.pushName ?? undefined;
-            inboundLogger.info({ from, to: selfE164 ?? "me", body, mediaPath, mediaType, timestamp }, "inbound message");
+            inboundLogger.info({ from, to: selfE164 ?? "me", body, mediaPath, mediaType, mediaFileName, timestamp }, "inbound message");
             const inboundMessage = {
                 id,
                 from,
@@ -263,6 +279,7 @@ export async function monitorWebInbox(options) {
                 sendMedia,
                 mediaPath,
                 mediaType,
+                mediaFileName,
             };
             try {
                 const task = Promise.resolve(debouncer.enqueue(inboundMessage));

package/dist/web/inbound/send-api.js

@@ -1,5 +1,17 @@
 import { recordChannelActivity } from "../../infra/channel-activity.js";
 import { toWhatsappJid } from "../../utils.js";
+function recordWhatsAppOutbound(accountId) {
+    recordChannelActivity({
+        channel: "whatsapp",
+        accountId,
+        direction: "outbound",
+    });
+}
+function resolveOutboundMessageId(result) {
+    return typeof result === "object" && result && "key" in result
+        ? String(result.key?.id ?? "unknown")
+        : "unknown";
+}
 export function createWebSendApi(params) {
     return {
         sendMessage: async (to, text, mediaBuffer, mediaType, sendOptions) => {
@@ -26,9 +38,10 @@ export function createWebSendApi(params) {
                     };
                 }
                 else {
+                    const fileName = sendOptions?.fileName?.trim() || "file";
                     payload = {
                         document: mediaBuffer,
-                        fileName: "file",
+                        fileName,
                         caption: text || undefined,
                         mimetype: mediaType,
                     };
@@ -39,14 +52,8 @@ export function createWebSendApi(params) {
             }
             const result = await params.sock.sendMessage(jid, payload);
             const accountId = sendOptions?.accountId ?? params.defaultAccountId;
-            recordChannelActivity({
-                channel: "whatsapp",
-                accountId,
-                direction: "outbound",
-            });
-            const messageId = typeof result === "object" && result && "key" in result
-                ? String(result.key?.id ?? "unknown")
-                : "unknown";
+            recordWhatsAppOutbound(accountId);
+            const messageId = resolveOutboundMessageId(result);
             return { messageId };
         },
         sendPoll: async (to, poll) => {
@@ -58,14 +65,8 @@ export function createWebSendApi(params) {
                     selectableCount: poll.maxSelections ?? 1,
                 },
             });
-            recordChannelActivity({
-                channel: "whatsapp",
-                accountId: params.defaultAccountId,
-                direction: "outbound",
-            });
-            const messageId = typeof result === "object" && result && "key" in result
-                ? String(result.key?.id ?? "unknown")
-                : "unknown";
+            recordWhatsAppOutbound(params.defaultAccountId);
+            const messageId = resolveOutboundMessageId(result);
             return { messageId };
         },
         sendReaction: async (chatJid, messageId, emoji, fromMe, participant) => {

package/dist/web/outbound.js

@@ -1,11 +1,12 @@
 import { randomUUID } from "node:crypto";
+import { loadConfig } from "../config/config.js";
+import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { getChildLogger } from "../logging/logger.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
+import { convertMarkdownTables } from "../markdown/tables.js";
+import { markdownToWhatsApp } from "../markdown/whatsapp.js";
 import { normalizePollInput } from "../polls.js";
 import { toWhatsappJid } from "../utils.js";
-import { loadConfig } from "../config/config.js";
-import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
-import { convertMarkdownTables } from "../markdown/tables.js";
 import { requireActiveWebListener } from "./active-listener.js";
 import { loadWebMedia } from "./media.js";
 const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
@@ -21,6 +22,7 @@ export async function sendMessageWhatsApp(to, body, options) {
         accountId: resolvedAccountId ?? options.accountId,
     });
     text = convertMarkdownTables(text ?? "", tableMode);
+    text = markdownToWhatsApp(text);
     const logger = getChildLogger({
         module: "web-outbound",
         correlationId,
@@ -30,8 +32,11 @@ export async function sendMessageWhatsApp(to, body, options) {
         const jid = toWhatsappJid(to);
         let mediaBuffer;
         let mediaType;
+        let documentFileName;
         if (options.mediaUrl) {
-            const media = await loadWebMedia(options.mediaUrl);
+            const media = await loadWebMedia(options.mediaUrl, {
+                localRoots: options.mediaLocalRoots,
+            });
             const caption = text || undefined;
             mediaBuffer = media.buffer;
             mediaType = media.contentType;
@@ -50,6 +55,7 @@ export async function sendMessageWhatsApp(to, body, options) {
             }
             else {
                 text = caption ?? "";
+                documentFileName = media.fileName;
             }
         }
         outboundLog.info(`Sending message -> ${jid}${options.mediaUrl ? " (media)" : ""}`);
@@ -57,9 +63,10 @@ export async function sendMessageWhatsApp(to, body, options) {
         await active.sendComposingTo(to);
         const hasExplicitAccountId = Boolean(options.accountId?.trim());
         const accountId = hasExplicitAccountId ? resolvedAccountId : undefined;
-        const sendOptions = options.gifPlayback || accountId
+        const sendOptions = options.gifPlayback || accountId || documentFileName
             ? {
                 ...(options.gifPlayback ? { gifPlayback: true } : {}),
+                ...(documentFileName ? { fileName: documentFileName } : {}),
                 accountId,
             }
             : undefined;

package/dist/wizard/clack-prompter.js

@@ -1,5 +1,6 @@
-import { cancel, confirm, intro, isCancel, multiselect, outro, select, spinner, text, } from "@clack/prompts";
+import { autocompleteMultiselect, cancel, confirm, intro, isCancel, multiselect, outro, select, spinner, text, } from "@clack/prompts";
 import { createCliProgress } from "../cli/progress.js";
+import { stripAnsi } from "../terminal/ansi.js";
 import { note as emitNote } from "../terminal/note.js";
 import { stylePromptHint, stylePromptMessage, stylePromptTitle } from "../terminal/prompt-style.js";
 import { theme } from "../terminal/theme.js";
@@ -11,6 +12,27 @@ function guardCancel(value) {
     }
     return value;
 }
+function normalizeSearchTokens(search) {
+    return search
+        .toLowerCase()
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+function buildOptionSearchText(option) {
+    const label = stripAnsi(option.label ?? "");
+    const hint = stripAnsi(option.hint ?? "");
+    const value = String(option.value ?? "");
+    return `${label} ${hint} ${value}`.toLowerCase();
+}
+export function tokenizedOptionFilter(search, option) {
+    const tokens = normalizeSearchTokens(search);
+    if (tokens.length === 0) {
+        return true;
+    }
+    const haystack = buildOptionSearchText(option);
+    return tokens.every((token) => haystack.includes(token));
+}
 export function createClackPrompter() {
     return {
         intro: async (title) => {
@@ -30,14 +52,25 @@ export function createClackPrompter() {
             }),
             initialValue: params.initialValue,
         })),
-        multiselect: async (params) => guardCancel(await multiselect({
-            message: stylePromptMessage(params.message),
-            options: params.options.map((opt) => {
+        multiselect: async (params) => {
+            const options = params.options.map((opt) => {
                 const base = { value: opt.value, label: opt.label };
                 return opt.hint === undefined ? base : { ...base, hint: stylePromptHint(opt.hint) };
-            }),
-            initialValues: params.initialValues,
-        })),
+            });
+            if (params.searchable) {
+                return guardCancel(await autocompleteMultiselect({
+                    message: stylePromptMessage(params.message),
+                    options,
+                    initialValues: params.initialValues,
+                    filter: tokenizedOptionFilter,
+                }));
+            }
+            return guardCancel(await multiselect({
+                message: stylePromptMessage(params.message),
+                options,
+                initialValues: params.initialValues,
+            }));
+        },
         text: async (params) => {
             const validate = params.validate;
             return guardCancel(await text({