@poolzin/pool-bot 2026.2.25 → 2026.2.26

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

@@ -4,20 +4,51 @@ import { AssistantMessageComponent } from "./assistant-message.js";
 import { ToolExecutionComponent } from "./tool-execution.js";
 import { UserMessageComponent } from "./user-message.js";
 export class ChatLog extends Container {
+    maxComponents;
     toolById = new Map();
     streamingRuns = new Map();
     toolsExpanded = false;
+    constructor(maxComponents = 180) {
+        super();
+        this.maxComponents = Math.max(20, Math.floor(maxComponents));
+    }
+    dropComponentReferences(component) {
+        for (const [toolId, tool] of this.toolById.entries()) {
+            if (tool === component) {
+                this.toolById.delete(toolId);
+            }
+        }
+        for (const [runId, message] of this.streamingRuns.entries()) {
+            if (message === component) {
+                this.streamingRuns.delete(runId);
+            }
+        }
+    }
+    pruneOverflow() {
+        while (this.children.length > this.maxComponents) {
+            const oldest = this.children[0];
+            if (!oldest) {
+                return;
+            }
+            this.removeChild(oldest);
+            this.dropComponentReferences(oldest);
+        }
+    }
+    append(component) {
+        this.addChild(component);
+        this.pruneOverflow();
+    }
     clearAll() {
         this.clear();
         this.toolById.clear();
         this.streamingRuns.clear();
     }
     addSystem(text) {
-        this.addChild(new Spacer(1));
-        this.addChild(new Text(theme.system(text), 1, 0));
+        this.append(new Spacer(1));
+        this.append(new Text(theme.system(text), 1, 0));
     }
     addUser(text) {
-        this.addChild(new UserMessageComponent(text));
+        this.append(new UserMessageComponent(text));
     }
     resolveRunId(runId) {
         return runId ?? "default";
@@ -25,7 +56,7 @@ export class ChatLog extends Container {
     startAssistant(text, runId) {
         const component = new AssistantMessageComponent(text);
         this.streamingRuns.set(this.resolveRunId(runId), component);
-        this.addChild(component);
+        this.append(component);
         return component;
     }
     updateAssistant(text, runId) {
@@ -45,7 +76,7 @@ export class ChatLog extends Container {
             this.streamingRuns.delete(effectiveRunId);
             return;
         }
-        this.addChild(new AssistantMessageComponent(text));
+        this.append(new AssistantMessageComponent(text));
     }
     dropAssistant(runId) {
         const effectiveRunId = this.resolveRunId(runId);
@@ -65,19 +96,21 @@ export class ChatLog extends Container {
         const component = new ToolExecutionComponent(toolName, args);
         component.setExpanded(this.toolsExpanded);
         this.toolById.set(toolCallId, component);
-        this.addChild(component);
+        this.append(component);
         return component;
     }
     updateToolArgs(toolCallId, args) {
         const existing = this.toolById.get(toolCallId);
-        if (!existing)
+        if (!existing) {
             return;
+        }
         existing.setArgs(args);
     }
     updateToolResult(toolCallId, result, opts) {
         const existing = this.toolById.get(toolCallId);
-        if (!existing)
+        if (!existing) {
             return;
+        }
         if (opts?.partial) {
             existing.setPartialResult(result);
             return;

package/dist/tui/theme/theme.js

@@ -4,20 +4,20 @@ import { createSyntaxTheme } from "./syntax-theme.js";
 const palette = {
     text: "#E8E3D5",
     dim: "#7B7F87",
-    accent: "#A855F7", // vivid purple (was gold #F6C453)
-    accentSoft: "#C084FC", // soft purple (was orange #F2A65A)
+    accent: "#F6C453",
+    accentSoft: "#F2A65A",
     border: "#3C414B",
     userBg: "#2B2F36",
     userText: "#F3EEE0",
     systemText: "#9BA3B2",
-    toolPendingBg: "#1F1F2F", // slight purple tint (was teal #1F2A2F)
+    toolPendingBg: "#1F2A2F",
     toolSuccessBg: "#1E2D23",
     toolErrorBg: "#2F1F1F",
-    toolTitle: "#A855F7", // vivid purple (was gold #F6C453)
+    toolTitle: "#F6C453",
     toolOutput: "#E1DACB",
     quote: "#8CC8FF",
     quoteBorder: "#3B4D6B",
-    code: "#D4BBFF", // light lavender (was gold #F0C987)
+    code: "#F0C987",
     codeBlock: "#1E232A",
     codeBorder: "#343A45",
     link: "#7DD3A5",
@@ -50,6 +50,7 @@ function highlightCode(code, lang) {
 }
 export const theme = {
     fg: fg(palette.text),
+    assistantText: (text) => text,
     dim: fg(palette.dim),
     accent: fg(palette.accent),
     accentSoft: fg(palette.accentSoft),
@@ -85,15 +86,16 @@ export const markdownTheme = {
     underline: (text) => chalk.underline(text),
     highlightCode,
 };
-export const selectListTheme = {
+const baseSelectListTheme = {
     selectedPrefix: (text) => fg(palette.accent)(text),
     selectedText: (text) => chalk.bold(fg(palette.accent)(text)),
     description: (text) => fg(palette.dim)(text),
     scrollInfo: (text) => fg(palette.dim)(text),
     noMatch: (text) => fg(palette.dim)(text),
 };
+export const selectListTheme = baseSelectListTheme;
 export const filterableSelectListTheme = {
-    ...selectListTheme,
+    ...baseSelectListTheme,
     filterLabel: (text) => fg(palette.dim)(text),
 };
 export const settingsListTheme = {
@@ -108,11 +110,7 @@ export const editorTheme = {
     selectList: selectListTheme,
 };
 export const searchableSelectListTheme = {
-    selectedPrefix: (text) => fg(palette.accent)(text),
-    selectedText: (text) => chalk.bold(fg(palette.accent)(text)),
-    description: (text) => fg(palette.dim)(text),
-    scrollInfo: (text) => fg(palette.dim)(text),
-    noMatch: (text) => fg(palette.dim)(text),
+    ...baseSelectListTheme,
     searchPrompt: (text) => fg(palette.accentSoft)(text),
     searchInput: (text) => fg(palette.text)(text),
     matchHighlight: (text) => chalk.bold(fg(palette.accent)(text)),

package/dist/tui/tui-local-shell.js

@@ -9,10 +9,12 @@ export function createLocalShellRunner(deps) {
     const env = deps.env ?? process.env;
     const maxChars = deps.maxOutputChars ?? 40_000;
     const ensureLocalExecAllowed = async () => {
-        if (localExecAllowed)
+        if (localExecAllowed) {
             return true;
-        if (localExecAsked)
+        }
+        if (localExecAsked) {
             return false;
+        }
         localExecAsked = true;
         return await new Promise((resolve) => {
             deps.chatLog.addSystem("Allow local shell commands for this session?");
@@ -49,20 +51,28 @@ export function createLocalShellRunner(deps) {
         const cmd = line.slice(1);
         // NOTE: A lone '!' is handled by the submit handler as a normal message.
         // Keep this guard anyway in case this is called directly.
-        if (cmd === "")
+        if (cmd === "") {
             return;
+        }
         if (localExecAsked && !localExecAllowed) {
             deps.chatLog.addSystem("local shell: not enabled for this session");
             deps.tui.requestRender();
             return;
         }
         const allowed = await ensureLocalExecAllowed();
-        if (!allowed)
+        if (!allowed) {
             return;
+        }
         deps.chatLog.addSystem(`[local] $ ${cmd}`);
         deps.tui.requestRender();
+        const appendWithCap = (text, chunk) => {
+            const combined = text + chunk;
+            return combined.length > maxChars ? combined.slice(-maxChars) : combined;
+        };
         await new Promise((resolve) => {
             const child = spawnCommand(cmd, {
+                // Intentionally a shell: this is an operator-only local TUI feature (prefixed with `!`)
+                // and is gated behind an explicit in-session approval prompt.
                 shell: true,
                 cwd: getCwd(),
                 env,
@@ -70,10 +80,10 @@ export function createLocalShellRunner(deps) {
             let stdout = "";
             let stderr = "";
             child.stdout.on("data", (buf) => {
-                stdout += buf.toString("utf8");
+                stdout = appendWithCap(stdout, buf.toString("utf8"));
             });
             child.stderr.on("data", (buf) => {
-                stderr += buf.toString("utf8");
+                stderr = appendWithCap(stderr, buf.toString("utf8"));
             });
             child.on("close", (code, signal) => {
                 const combined = (stdout + (stderr ? (stdout ? "\n" : "") + stderr : ""))

package/dist/tui/tui.js

@@ -1,4 +1,4 @@
-import { CombinedAutocompleteProvider, Container, Loader, ProcessTerminal, Text, TUI, } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, Key, Loader, matchesKey, ProcessTerminal, Text, TUI, } from "@mariozechner/pi-tui";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { loadConfig } from "../config/config.js";
 import { buildAgentMainSessionKey, normalizeAgentId, normalizeMainKey, parseAgentSessionKey, } from "../routing/session-key.js";
@@ -43,13 +43,21 @@ export function createEditorSubmitHandler(params) {
 }
 export function shouldEnableWindowsGitBashPasteFallback(params) {
     const platform = params?.platform ?? process.platform;
+    const env = params?.env ?? process.env;
+    const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
+    // Some macOS terminals emit multiline paste as rapid single-line submits.
+    // Enable burst coalescing so pasted blocks stay as one user message.
+    if (platform === "darwin") {
+        if (termProgram.includes("iterm") || termProgram.includes("apple_terminal")) {
+            return true;
+        }
+        return false;
+    }
     if (platform !== "win32") {
         return false;
     }
-    const env = params?.env ?? process.env;
     const msystem = (env.MSYSTEM ?? "").toUpperCase();
     const shell = env.SHELL ?? "";
-    const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
     if (msystem.startsWith("MINGW") || msystem.startsWith("MSYS")) {
         return true;
     }
@@ -137,6 +145,36 @@ export function resolveTuiSessionKey(params) {
     }
     return `agent:${params.currentAgentId}:${trimmed}`;
 }
+export function resolveGatewayDisconnectState(reason) {
+    const reasonLabel = reason?.trim() ? reason.trim() : "closed";
+    if (/pairing required/i.test(reasonLabel)) {
+        return {
+            connectionStatus: `gateway disconnected: ${reasonLabel}`,
+            activityStatus: "pairing required: run poolbot devices list",
+            pairingHint: "Pairing required. Run `poolbot devices list`, approve your request ID, then reconnect.",
+        };
+    }
+    return {
+        connectionStatus: `gateway disconnected: ${reasonLabel}`,
+        activityStatus: "idle",
+    };
+}
+export function createBackspaceDeduper(params) {
+    const dedupeWindowMs = Math.max(0, Math.floor(params?.dedupeWindowMs ?? 8));
+    const now = params?.now ?? (() => Date.now());
+    let lastBackspaceAt = -1;
+    return (data) => {
+        if (!matchesKey(data, Key.backspace)) {
+            return data;
+        }
+        const ts = now();
+        if (lastBackspaceAt >= 0 && ts - lastBackspaceAt <= dedupeWindowMs) {
+            return "";
+        }
+        lastBackspaceAt = ts;
+        return data;
+    };
+}
 export async function runTui(opts) {
     const config = loadConfig();
     const initialSessionInput = (opts.session ?? "").trim();
@@ -155,6 +193,7 @@ export async function runTui(opts) {
     let wasDisconnected = false;
     let toolsExpanded = false;
     let showThinking = false;
+    let pairingHintShown = false;
     const localRunIds = new Set();
     const deliverDefault = opts.deliver ?? false;
     const autoMessage = opts.message?.trim();
@@ -308,6 +347,14 @@ export async function runTui(opts) {
         password: opts.password,
     });
     const tui = new TUI(new ProcessTerminal());
+    const dedupeBackspace = createBackspaceDeduper();
+    tui.addInputListener((data) => {
+        const next = dedupeBackspace(data);
+        if (next.length === 0) {
+            return { consume: true };
+        }
+        return { data: next };
+    });
     const header = new Text("", 1, 0);
     const statusContainer = new Container();
     const footer = new Text("", 1, 0);
@@ -648,6 +695,7 @@ export async function runTui(opts) {
     };
     client.onConnected = () => {
         isConnected = true;
+        pairingHintShown = false;
         const reconnected = wasDisconnected;
         wasDisconnected = false;
         setConnectionStatus("connected");
@@ -669,9 +717,13 @@ export async function runTui(opts) {
         isConnected = false;
         wasDisconnected = true;
         historyLoaded = false;
-        const reasonLabel = reason?.trim() ? reason.trim() : "closed";
-        setConnectionStatus(`gateway disconnected: ${reasonLabel}`, 5000);
-        setActivityStatus("idle");
+        const disconnectState = resolveGatewayDisconnectState(reason);
+        setConnectionStatus(disconnectState.connectionStatus, 5000);
+        setActivityStatus(disconnectState.activityStatus);
+        if (disconnectState.pairingHint && !pairingHintShown) {
+            pairingHintShown = true;
+            chatLog.addSystem(disconnectState.pairingHint);
+        }
         updateFooter();
         tui.requestRender();
     };

package/dist/utils/account-id.js

@@ -1,6 +1,4 @@
+import { normalizeOptionalAccountId } from "../routing/account-id.js";
 export function normalizeAccountId(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed || undefined;
+    return normalizeOptionalAccountId(value);
 }

package/dist/utils/boolean.js

@@ -3,20 +3,25 @@ const DEFAULT_FALSY = ["false", "0", "no", "off"];
 const DEFAULT_TRUTHY_SET = new Set(DEFAULT_TRUTHY);
 const DEFAULT_FALSY_SET = new Set(DEFAULT_FALSY);
 export function parseBooleanValue(value, options = {}) {
-    if (typeof value === "boolean")
+    if (typeof value === "boolean") {
         return value;
-    if (typeof value !== "string")
+    }
+    if (typeof value !== "string") {
         return undefined;
+    }
     const normalized = value.trim().toLowerCase();
-    if (!normalized)
+    if (!normalized) {
         return undefined;
+    }
     const truthy = options.truthy ?? DEFAULT_TRUTHY;
     const falsy = options.falsy ?? DEFAULT_FALSY;
     const truthySet = truthy === DEFAULT_TRUTHY ? DEFAULT_TRUTHY_SET : new Set(truthy);
     const falsySet = falsy === DEFAULT_FALSY ? DEFAULT_FALSY_SET : new Set(falsy);
-    if (truthySet.has(normalized))
+    if (truthySet.has(normalized)) {
         return true;
-    if (falsySet.has(normalized))
+    }
+    if (falsySet.has(normalized)) {
         return false;
+    }
     return undefined;
 }

package/dist/utils/directive-tags.js

@@ -6,6 +6,17 @@ function normalizeDirectiveWhitespace(text) {
         .replace(/[ \t]*\n[ \t]*/g, "\n")
         .trim();
 }
+export function stripInlineDirectiveTagsForDisplay(text) {
+    if (!text) {
+        return { text, changed: false };
+    }
+    const withoutAudio = text.replace(AUDIO_TAG_RE, "");
+    const stripped = withoutAudio.replace(REPLY_TAG_RE, "");
+    return {
+        text: stripped,
+        changed: stripped !== text,
+    };
+}
 export function parseInlineDirectives(text, options = {}) {
     const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
     if (!text) {

package/dist/utils/queue-helpers.js

@@ -1,6 +1,34 @@
+export function clearQueueSummaryState(state) {
+    state.droppedCount = 0;
+    state.summaryLines = [];
+}
+export function previewQueueSummaryPrompt(params) {
+    return buildQueueSummaryPrompt({
+        state: {
+            dropPolicy: params.state.dropPolicy,
+            droppedCount: params.state.droppedCount,
+            summaryLines: [...params.state.summaryLines],
+        },
+        noun: params.noun,
+        title: params.title,
+    });
+}
+export function applyQueueRuntimeSettings(params) {
+    params.target.mode = params.settings.mode;
+    params.target.debounceMs =
+        typeof params.settings.debounceMs === "number"
+            ? Math.max(0, params.settings.debounceMs)
+            : params.target.debounceMs;
+    params.target.cap =
+        typeof params.settings.cap === "number" && params.settings.cap > 0
+            ? Math.floor(params.settings.cap)
+            : params.target.cap;
+    params.target.dropPolicy = params.settings.dropPolicy ?? params.target.dropPolicy;
+}
 export function elideQueueText(text, limit = 140) {
-    if (text.length <= limit)
+    if (text.length <= limit) {
         return text;
+    }
     return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
 }
 export function buildQueueSummaryLine(text, limit = 160) {
@@ -8,16 +36,19 @@ export function buildQueueSummaryLine(text, limit = 160) {
     return elideQueueText(cleaned, limit);
 }
 export function shouldSkipQueueItem(params) {
-    if (!params.dedupe)
+    if (!params.dedupe) {
         return false;
+    }
     return params.dedupe(params.item, params.items);
 }
 export function applyQueueDropPolicy(params) {
     const cap = params.queue.cap;
-    if (cap <= 0 || params.queue.items.length < cap)
+    if (cap <= 0 || params.queue.items.length < cap) {
         return true;
-    if (params.queue.dropPolicy === "new")
+    }
+    if (params.queue.dropPolicy === "new") {
         return false;
+    }
     const dropCount = params.queue.items.length - cap + 1;
     const dropped = params.queue.items.splice(0, dropCount);
     if (params.queue.dropPolicy === "summarize") {
@@ -26,15 +57,17 @@ export function applyQueueDropPolicy(params) {
             params.queue.summaryLines.push(buildQueueSummaryLine(params.summarize(item)));
         }
         const limit = Math.max(0, params.summaryLimit ?? cap);
-        while (params.queue.summaryLines.length > limit)
+        while (params.queue.summaryLines.length > limit) {
             params.queue.summaryLines.shift();
+        }
     }
     return true;
 }
 export function waitForQueueDebounce(queue) {
     const debounceMs = Math.max(0, queue.debounceMs);
-    if (debounceMs <= 0)
+    if (debounceMs <= 0) {
         return Promise.resolve();
+    }
     return new Promise((resolve) => {
         const check = () => {
             const since = Date.now() - queue.lastEnqueuedAt;
@@ -47,6 +80,25 @@ export function waitForQueueDebounce(queue) {
         check();
     });
 }
+export async function drainNextQueueItem(items, run) {
+    const next = items[0];
+    if (!next) {
+        return false;
+    }
+    await run(next);
+    items.shift();
+    return true;
+}
+export async function drainCollectItemIfNeeded(params) {
+    if (!params.forceIndividualCollect && !params.isCrossChannel) {
+        return "skipped";
+    }
+    if (params.isCrossChannel) {
+        params.setForceIndividualCollect?.(true);
+    }
+    const drained = await drainNextQueueItem(params.items, params.run);
+    return drained ? "drained" : "empty";
+}
 export function buildQueueSummaryPrompt(params) {
     if (params.state.dropPolicy !== "summarize" || params.state.droppedCount <= 0) {
         return undefined;
@@ -61,14 +113,14 @@ export function buildQueueSummaryPrompt(params) {
             lines.push(`- ${line}`);
         }
     }
-    params.state.droppedCount = 0;
-    params.state.summaryLines = [];
+    clearQueueSummaryState(params.state);
     return lines.join("\n");
 }
 export function buildCollectPrompt(params) {
     const blocks = [params.title];
-    if (params.summary)
+    if (params.summary) {
         blocks.push(params.summary);
+    }
     params.items.forEach((item, idx) => {
         blocks.push(params.renderItem(item, idx));
     });
@@ -79,17 +131,20 @@ export function hasCrossChannelItems(items, resolveKey) {
     let hasUnkeyed = false;
     for (const item of items) {
         const resolved = resolveKey(item);
-        if (resolved.cross)
+        if (resolved.cross) {
             return true;
+        }
         if (!resolved.key) {
             hasUnkeyed = true;
             continue;
         }
         keys.add(resolved.key);
     }
-    if (keys.size === 0)
+    if (keys.size === 0) {
         return false;
-    if (hasUnkeyed)
+    }
+    if (hasUnkeyed) {
         return true;
+    }
     return keys.size > 1;
 }

package/dist/web/auto-reply/deliver-reply.js

@@ -1,6 +1,8 @@
 import { chunkMarkdownTextWithMode } from "../../auto-reply/chunk.js";
-import { convertMarkdownTables } from "../../markdown/tables.js";
 import { logVerbose, shouldLogVerbose } from "../../globals.js";
+import { convertMarkdownTables } from "../../markdown/tables.js";
+import { markdownToWhatsApp } from "../../markdown/whatsapp.js";
+import { sleep } from "../../utils.js";
 import { loadWebMedia } from "../media.js";
 import { newConnectionId } from "../reconnect.js";
 import { formatError } from "../session.js";
@@ -11,14 +13,13 @@ export async function deliverWebReply(params) {
     const replyStarted = Date.now();
     const tableMode = params.tableMode ?? "code";
     const chunkMode = params.chunkMode ?? "length";
-    const convertedText = convertMarkdownTables(replyResult.text || "", tableMode);
+    const convertedText = markdownToWhatsApp(convertMarkdownTables(replyResult.text || "", tableMode));
     const textChunks = chunkMarkdownTextWithMode(convertedText, textLimit, chunkMode);
     const mediaList = replyResult.mediaUrls?.length
         ? replyResult.mediaUrls
         : replyResult.mediaUrl
             ? [replyResult.mediaUrl]
             : [];
-    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     const sendWithRetry = async (fn, label, maxAttempts = 3) => {
         let lastErr;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -69,7 +70,10 @@ export async function deliverWebReply(params) {
     for (const [index, mediaUrl] of mediaList.entries()) {
         const caption = index === 0 ? remainingText.shift() || undefined : undefined;
         try {
-            const media = await loadWebMedia(mediaUrl, maxMediaBytes);
+            const media = await loadWebMedia(mediaUrl, {
+                maxBytes: maxMediaBytes,
+                localRoots: params.mediaLocalRoots,
+            });
             if (shouldLogVerbose()) {
                 logVerbose(`Web auto-reply media size: ${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB`);
                 logVerbose(`Web auto-reply media source: ${mediaUrl} (kind ${media.kind})`);

package/dist/web/auto-reply/mentions.js

@@ -20,12 +20,14 @@ export function isBotMentionedFromTargets(msg, mentionCfg, targets) {
     const isSelfChat = isSelfChatMode(targets.selfE164, mentionCfg.allowFrom);
     const hasMentions = (msg.mentionedJids?.length ?? 0) > 0;
     if (hasMentions && !isSelfChat) {
-        if (targets.selfE164 && targets.normalizedMentions.includes(targets.selfE164))
+        if (targets.selfE164 && targets.normalizedMentions.includes(targets.selfE164)) {
             return true;
+        }
         if (targets.selfJid) {
             // Some mentions use the bare JID; match on E.164 to be safe.
-            if (targets.normalizedMentions.includes(targets.selfJid))
+            if (targets.normalizedMentions.includes(targets.selfJid)) {
                 return true;
+            }
         }
         // If the message explicitly mentions someone else, do not fall back to regex matches.
         return false;
@@ -34,19 +36,22 @@ export function isBotMentionedFromTargets(msg, mentionCfg, targets) {
         // Self-chat mode: ignore WhatsApp @mention JIDs, otherwise @mentioning the owner in group chats triggers the bot.
     }
     const bodyClean = clean(msg.body);
-    if (mentionCfg.mentionRegexes.some((re) => re.test(bodyClean)))
+    if (mentionCfg.mentionRegexes.some((re) => re.test(bodyClean))) {
         return true;
+    }
     // Fallback: detect body containing our own number (with or without +, spacing)
     if (targets.selfE164) {
         const selfDigits = targets.selfE164.replace(/\D/g, "");
         if (selfDigits) {
             const bodyDigits = bodyClean.replace(/[^\d]/g, "");
-            if (bodyDigits.includes(selfDigits))
+            if (bodyDigits.includes(selfDigits)) {
                 return true;
+            }
             const bodyNoSpace = msg.body.replace(/[\s-]/g, "");
             const pattern = new RegExp(`\\+?${selfDigits}`, "i");
-            if (pattern.test(bodyNoSpace))
+            if (pattern.test(bodyNoSpace)) {
                 return true;
+            }
         }
     }
     return false;

package/dist/web/auto-reply/monitor/group-members.js

@@ -1,11 +1,13 @@
 import { normalizeE164 } from "../../../utils.js";
 export function noteGroupMember(groupMemberNames, conversationId, e164, name) {
-    if (!e164 || !name)
+    if (!e164 || !name) {
         return;
+    }
     const normalized = normalizeE164(e164);
     const key = normalized ?? e164;
-    if (!key)
+    if (!key) {
         return;
+    }
     let roster = groupMemberNames.get(conversationId);
     if (!roster) {
         roster = new Map();
@@ -19,11 +21,13 @@ export function formatGroupMembers(params) {
     const ordered = [];
     if (participants?.length) {
         for (const entry of participants) {
-            if (!entry)
+            if (!entry) {
                 continue;
+            }
             const normalized = normalizeE164(entry) ?? entry;
-            if (!normalized || seen.has(normalized))
+            if (!normalized || seen.has(normalized)) {
                 continue;
+            }
             seen.add(normalized);
             ordered.push(normalized);
         }
@@ -31,19 +35,22 @@ export function formatGroupMembers(params) {
     if (roster) {
         for (const entry of roster.keys()) {
             const normalized = normalizeE164(entry) ?? entry;
-            if (!normalized || seen.has(normalized))
+            if (!normalized || seen.has(normalized)) {
                 continue;
+            }
             seen.add(normalized);
             ordered.push(normalized);
         }
     }
     if (ordered.length === 0 && fallbackE164) {
         const normalized = normalizeE164(fallbackE164) ?? fallbackE164;
-        if (normalized)
+        if (normalized) {
             ordered.push(normalized);
+        }
     }
-    if (ordered.length === 0)
+    if (ordered.length === 0) {
         return undefined;
+    }
     return ordered
         .map((entry) => {
         const name = roster?.get(entry);