@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/auto-reply/reply/bash-command.js

@@ -3,9 +3,11 @@ import { getFinishedSession, getSession, markExited } from "../../agents/bash-pr
 import { createExecTool } from "../../agents/bash-tools.js";
 import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
 import { killProcessTree } from "../../agents/shell-utils.js";
-import { formatCliCommand } from "../../cli/command-format.js";
+import { isCommandFlagEnabled } from "../../config/commands.js";
 import { logVerbose } from "../../globals.js";
 import { clampInt } from "../../utils.js";
+import { buildDisabledCommandReply } from "./command-gates.js";
+import { formatElevatedUnavailableMessage } from "./elevated-unavailable.js";
 import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
 const CHAT_BASH_SCOPE_KEY = "chat:bash";
 const DEFAULT_FOREGROUND_MS = 2000;
@@ -13,20 +15,23 @@ const MAX_FOREGROUND_MS = 30_000;
 let activeJob = null;
 function resolveForegroundMs(cfg) {
     const raw = cfg.commands?.bashForegroundMs;
-    if (typeof raw !== "number" || Number.isNaN(raw))
+    if (typeof raw !== "number" || Number.isNaN(raw)) {
         return DEFAULT_FOREGROUND_MS;
+    }
     return clampInt(raw, 0, MAX_FOREGROUND_MS);
 }
 function formatSessionSnippet(sessionId) {
     const trimmed = sessionId.trim();
-    if (trimmed.length <= 12)
+    if (trimmed.length <= 12) {
         return trimmed;
+    }
     return `${trimmed.slice(0, 8)}…`;
 }
 function formatOutputBlock(text) {
     const trimmed = text.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "(no output)";
+    }
     return `\`\`\`txt\n${trimmed}\n\`\`\``;
 }
 function parseBashRequest(raw) {
@@ -34,8 +39,9 @@ function parseBashRequest(raw) {
     let restSource = "";
     if (trimmed.toLowerCase().startsWith("/bash")) {
         const match = trimmed.match(/^\/bash(?:\s*:\s*|\s+|$)([\s\S]*)$/i);
-        if (!match)
+        if (!match) {
             return null;
+        }
         restSource = match[1] ?? "";
     }
     else if (trimmed.startsWith("!")) {
@@ -48,8 +54,9 @@ function parseBashRequest(raw) {
         return null;
     }
     const rest = restSource.trimStart();
-    if (!rest)
+    if (!rest) {
         return { action: "help" };
+    }
     const tokenMatch = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
     const token = tokenMatch?.[1]?.trim() ?? "";
     const remainder = tokenMatch?.[2]?.trim() ?? "";
@@ -74,21 +81,26 @@ function resolveRawCommandBody(params) {
 }
 function getScopedSession(sessionId) {
     const running = getSession(sessionId);
-    if (running && running.scopeKey === CHAT_BASH_SCOPE_KEY)
+    if (running && running.scopeKey === CHAT_BASH_SCOPE_KEY) {
         return { running };
+    }
     const finished = getFinishedSession(sessionId);
-    if (finished && finished.scopeKey === CHAT_BASH_SCOPE_KEY)
+    if (finished && finished.scopeKey === CHAT_BASH_SCOPE_KEY) {
         return { finished };
+    }
     return {};
 }
 function ensureActiveJobState() {
-    if (!activeJob)
+    if (!activeJob) {
         return null;
-    if (activeJob.state === "starting")
+    }
+    if (activeJob.state === "starting") {
         return activeJob;
+    }
     const { running, finished } = getScopedSession(activeJob.sessionId);
-    if (running)
+    if (running) {
         return activeJob;
+    }
     if (finished) {
         activeJob = null;
         return null;
@@ -97,16 +109,20 @@ function ensureActiveJobState() {
     return null;
 }
 function attachActiveWatcher(sessionId) {
-    if (!activeJob || activeJob.state !== "running")
+    if (!activeJob || activeJob.state !== "running") {
         return;
-    if (activeJob.sessionId !== sessionId)
+    }
+    if (activeJob.sessionId !== sessionId) {
         return;
-    if (activeJob.watcherAttached)
+    }
+    if (activeJob.watcherAttached) {
         return;
+    }
     const { running } = getScopedSession(sessionId);
     const child = running?.child;
-    if (!child)
+    if (!child) {
         return;
+    }
     activeJob.watcherAttached = true;
     child.once("close", () => {
         if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
@@ -125,30 +141,13 @@ function buildUsageReply() {
         ].join("\n"),
     };
 }
-function formatElevatedUnavailableMessage(params) {
-    const lines = [];
-    lines.push(`elevated is not available right now (runtime=${params.runtimeSandboxed ? "sandboxed" : "direct"}).`);
-    if (params.failures.length > 0) {
-        lines.push(`Failing gates: ${params.failures.map((f) => `${f.gate} (${f.key})`).join(", ")}`);
-    }
-    else {
-        lines.push("Failing gates: enabled (tools.elevated.enabled / agents.list[].tools.elevated.enabled), allowFrom (tools.elevated.allowFrom.<provider>).");
-    }
-    lines.push("Fix-it keys:");
-    lines.push("- tools.elevated.enabled");
-    lines.push("- tools.elevated.allowFrom.<provider>");
-    lines.push("- agents.list[].tools.elevated.enabled");
-    lines.push("- agents.list[].tools.elevated.allowFrom.<provider>");
-    if (params.sessionKey) {
-        lines.push(`See: ${formatCliCommand(`poolbot sandbox explain --session ${params.sessionKey}`)}`);
-    }
-    return lines.join("\n");
-}
 export async function handleBashChatCommand(params) {
-    if (params.cfg.commands?.bash !== true) {
-        return {
-            text: "⚠️ bash is disabled. Set commands.bash=true to enable. Docs: https://docs.molt.bot/tools/slash-commands#config",
-        };
+    if (!isCommandFlagEnabled(params.cfg, "bash")) {
+        return buildDisabledCommandReply({
+            label: "bash",
+            configKey: "bash",
+            docsUrl: "https://docs.molt.bot/tools/slash-commands#config",
+        });
     }
     const agentId = params.agentId ??
         resolveSessionAgentId({
@@ -262,8 +261,9 @@ export async function handleBashChatCommand(params) {
         };
     }
     const commandText = request.command.trim();
-    if (!commandText)
+    if (!commandText) {
         return buildUsageReply();
+    }
     activeJob = {
         state: "starting",
         startedAt: Date.now(),
@@ -274,12 +274,14 @@ export async function handleBashChatCommand(params) {
         const shouldBackgroundImmediately = foregroundMs <= 0;
         const timeoutSec = params.cfg.tools?.exec?.timeoutSec;
         const notifyOnExit = params.cfg.tools?.exec?.notifyOnExit;
+        const notifyOnExitEmptySuccess = params.cfg.tools?.exec?.notifyOnExitEmptySuccess;
         const execTool = createExecTool({
             scopeKey: CHAT_BASH_SCOPE_KEY,
             allowBackground: true,
             timeoutSec,
             sessionKey: params.sessionKey,
             notifyOnExit,
+            notifyOnExitEmptySuccess,
             elevated: {
                 enabled: params.elevated.enabled,
                 allowed: params.elevated.allowed,

package/dist/auto-reply/reply/command-gates.js

@@ -0,0 +1,25 @@
+import { isCommandFlagEnabled } from "../../config/commands.js";
+import { logVerbose } from "../../globals.js";
+export function rejectUnauthorizedCommand(params, commandLabel) {
+    if (params.command.isAuthorizedSender) {
+        return null;
+    }
+    logVerbose(`Ignoring ${commandLabel} from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+    return { shouldContinue: false };
+}
+export function buildDisabledCommandReply(params) {
+    const disabledVerb = params.disabledVerb ?? "is";
+    const docsSuffix = params.docsUrl ? ` Docs: ${params.docsUrl}` : "";
+    return {
+        text: `⚠️ ${params.label} ${disabledVerb} disabled. Set commands.${params.configKey}=true to enable.${docsSuffix}`,
+    };
+}
+export function requireCommandFlagEnabled(cfg, params) {
+    if (isCommandFlagEnabled(cfg, params.configKey)) {
+        return null;
+    }
+    return {
+        shouldContinue: false,
+        reply: buildDisabledCommandReply(params),
+    };
+}

package/dist/auto-reply/reply/commands-allowlist.js

@@ -1,28 +1,30 @@
-import { readConfigFileSnapshot, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
-import { resolveChannelConfigWrites } from "../../channels/plugins/config-writes.js";
 import { getChannelDock } from "../../channels/dock.js";
-import { normalizeChannelId } from "../../channels/registry.js";
+import { resolveChannelConfigWrites } from "../../channels/plugins/config-writes.js";
 import { listPairingChannels } from "../../channels/plugins/pairing.js";
-import { logVerbose } from "../../globals.js";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../../routing/session-key.js";
+import { normalizeChannelId } from "../../channels/registry.js";
+import { readConfigFileSnapshot, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
 import { resolveDiscordAccount } from "../../discord/accounts.js";
+import { resolveDiscordUserAllowlist } from "../../discord/resolve-users.js";
 import { resolveIMessageAccount } from "../../imessage/accounts.js";
+import { addChannelAllowFromStoreEntry, readChannelAllowFromStore, removeChannelAllowFromStoreEntry, } from "../../pairing/pairing-store.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../../routing/session-key.js";
 import { resolveSignalAccount } from "../../signal/accounts.js";
 import { resolveSlackAccount } from "../../slack/accounts.js";
+import { resolveSlackUserAllowlist } from "../../slack/resolve-users.js";
 import { resolveTelegramAccount } from "../../telegram/accounts.js";
 import { resolveWhatsAppAccount } from "../../web/accounts.js";
-import { resolveSlackUserAllowlist } from "../../slack/resolve-users.js";
-import { resolveDiscordUserAllowlist } from "../../discord/resolve-users.js";
-import { addChannelAllowFromStoreEntry, readChannelAllowFromStore, removeChannelAllowFromStoreEntry, } from "../../pairing/pairing-store.js";
+import { rejectUnauthorizedCommand, requireCommandFlagEnabled } from "./command-gates.js";
 const ACTIONS = new Set(["list", "add", "remove"]);
 const SCOPES = new Set(["dm", "group", "all"]);
 function parseAllowlistCommand(raw) {
     const trimmed = raw.trim();
-    if (!trimmed.toLowerCase().startsWith("/allowlist"))
+    if (!trimmed.toLowerCase().startsWith("/allowlist")) {
         return null;
+    }
     const rest = trimmed.slice("/allowlist".length).trim();
-    if (!rest)
+    if (!rest) {
         return { action: "list", scope: "dm" };
+    }
     const tokens = rest.split(/\s+/);
     let action = "list";
     let scope = "dm";
@@ -70,13 +72,15 @@ function parseAllowlistCommand(raw) {
             const key = kv[0]?.trim().toLowerCase();
             const value = kv[1]?.trim();
             if (key === "channel") {
-                if (value)
+                if (value) {
                     channel = value;
+                }
                 continue;
             }
             if (key === "account") {
-                if (value)
+                if (value) {
                     account = value;
+                }
                 continue;
             }
             if (key === "scope" && value && SCOPES.has(value.toLowerCase())) {
@@ -107,8 +111,9 @@ function normalizeAllowFrom(params) {
     return params.values.map((entry) => String(entry).trim()).filter(Boolean);
 }
 function formatEntryList(entries, resolved) {
-    if (entries.length === 0)
+    if (entries.length === 0) {
         return "(none)";
+    }
     return entries
         .map((entry) => {
         const name = resolved?.get(entry);
@@ -136,8 +141,9 @@ function resolveAccountTarget(parsed, channelId, accountId) {
 function getNestedValue(root, path) {
     let current = root;
     for (const key of path) {
-        if (!current || typeof current !== "object")
+        if (!current || typeof current !== "object") {
             return undefined;
+        }
         current = current[key];
     }
     return current;
@@ -154,8 +160,9 @@ function ensureNestedObject(root, path) {
     return current;
 }
 function setNestedValue(root, path, value) {
-    if (path.length === 0)
+    if (path.length === 0) {
         return;
+    }
     if (path.length === 1) {
         root[path[0]] = value;
         return;
@@ -164,80 +171,86 @@ function setNestedValue(root, path, value) {
     parent[path[path.length - 1]] = value;
 }
 function deleteNestedValue(root, path) {
-    if (path.length === 0)
+    if (path.length === 0) {
         return;
+    }
     if (path.length === 1) {
         delete root[path[0]];
         return;
     }
     const parent = getNestedValue(root, path.slice(0, -1));
-    if (!parent || typeof parent !== "object")
+    if (!parent || typeof parent !== "object") {
         return;
+    }
     delete parent[path[path.length - 1]];
 }
 function resolveChannelAllowFromPaths(channelId, scope) {
-    if (scope === "all")
+    const supportsGroupAllowlist = channelId === "telegram" ||
+        channelId === "whatsapp" ||
+        channelId === "signal" ||
+        channelId === "imessage";
+    if (scope === "all") {
         return null;
+    }
     if (scope === "dm") {
-        if (channelId === "slack" || channelId === "discord")
-            return ["dm", "allowFrom"];
-        if (channelId === "telegram" ||
-            channelId === "whatsapp" ||
-            channelId === "signal" ||
-            channelId === "imessage") {
+        if (channelId === "slack" || channelId === "discord") {
+            // Canonical DM allowlist location for Slack/Discord. Legacy: dm.allowFrom.
+            return ["allowFrom"];
+        }
+        if (supportsGroupAllowlist) {
             return ["allowFrom"];
         }
         return null;
     }
     if (scope === "group") {
-        if (channelId === "telegram" ||
-            channelId === "whatsapp" ||
-            channelId === "signal" ||
-            channelId === "imessage") {
+        if (supportsGroupAllowlist) {
             return ["groupAllowFrom"];
         }
         return null;
     }
     return null;
 }
+function mapResolvedAllowlistNames(entries) {
+    const map = new Map();
+    for (const entry of entries) {
+        if (entry.resolved && entry.name) {
+            map.set(entry.input, entry.name);
+        }
+    }
+    return map;
+}
 async function resolveSlackNames(params) {
     const account = resolveSlackAccount({ cfg: params.cfg, accountId: params.accountId });
     const token = account.config.userToken?.trim() || account.botToken?.trim();
-    if (!token)
+    if (!token) {
         return new Map();
-    const resolved = await resolveSlackUserAllowlist({ token, entries: params.entries });
-    const map = new Map();
-    for (const entry of resolved) {
-        if (entry.resolved && entry.name)
-            map.set(entry.input, entry.name);
     }
-    return map;
+    const resolved = await resolveSlackUserAllowlist({ token, entries: params.entries });
+    return mapResolvedAllowlistNames(resolved);
 }
 async function resolveDiscordNames(params) {
     const account = resolveDiscordAccount({ cfg: params.cfg, accountId: params.accountId });
     const token = account.token?.trim();
-    if (!token)
+    if (!token) {
         return new Map();
-    const resolved = await resolveDiscordUserAllowlist({ token, entries: params.entries });
-    const map = new Map();
-    for (const entry of resolved) {
-        if (entry.resolved && entry.name)
-            map.set(entry.input, entry.name);
     }
-    return map;
+    const resolved = await resolveDiscordUserAllowlist({ token, entries: params.entries });
+    return mapResolvedAllowlistNames(resolved);
 }
 export const handleAllowlistCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const parsed = parseAllowlistCommand(params.command.commandBodyNormalized);
-    if (!parsed)
+    if (!parsed) {
         return null;
+    }
     if (parsed.action === "error") {
-        return { shouldContinue: false, reply: { text: `⚠️ ${parsed.message}` } };
+        return { shouldContinue: false, reply: { text: `\u26a0\ufe0f ${parsed.message}` } };
     }
-    if (!params.command.isAuthorizedSender) {
-        logVerbose(`Ignoring /allowlist from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
-        return { shouldContinue: false };
+    const unauthorized = rejectUnauthorizedCommand(params, "/allowlist");
+    if (unauthorized) {
+        return unauthorized;
     }
     const channelId = normalizeChannelId(parsed.channel) ??
         params.command.channelId ??
@@ -245,7 +258,7 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
     if (!channelId) {
         return {
             shouldContinue: false,
-            reply: { text: "⚠️ Unknown channel. Add channel=<id> to the command." },
+            reply: { text: "\u26a0\ufe0f Unknown channel. Add channel=<id> to the command." },
         };
     }
     const accountId = normalizeAccountId(parsed.account ?? params.ctx.AccountId);
@@ -305,7 +318,7 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
         }
         else if (channelId === "slack") {
             const account = resolveSlackAccount({ cfg: params.cfg, accountId });
-            dmAllowFrom = (account.dm?.allowFrom ?? []).map(String);
+            dmAllowFrom = (account.config.allowFrom ?? account.config.dm?.allowFrom ?? []).map(String);
             groupPolicy = account.groupPolicy;
             const channels = account.channels ?? {};
             groupOverrides = Object.entries(channels)
@@ -317,7 +330,7 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
         }
         else if (channelId === "discord") {
             const account = resolveDiscordAccount({ cfg: params.cfg, accountId });
-            dmAllowFrom = (account.config.dm?.allowFrom ?? []).map(String);
+            dmAllowFrom = (account.config.allowFrom ?? account.config.dm?.allowFrom ?? []).map(String);
             groupPolicy = account.config.groupPolicy;
             const guilds = account.config.guilds ?? {};
             for (const [guildKey, guildCfg] of Object.entries(guilds)) {
@@ -374,12 +387,14 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
                     entries: groupOverrideDisplay,
                 })
                 : undefined;
-        const lines = ["🧾 Allowlist"];
+        const lines = ["\ud83e\uddf6 Allowlist"];
         lines.push(`Channel: ${channelId}${accountId ? ` (account ${accountId})` : ""}`);
-        if (dmPolicy)
+        if (dmPolicy) {
             lines.push(`DM policy: ${dmPolicy}`);
-        if (groupPolicy)
+        }
+        if (groupPolicy) {
             lines.push(`Group policy: ${groupPolicy}`);
+        }
         const showDm = scope === "dm" || scope === "all";
         const showGroup = scope === "group" || scope === "all";
         if (showDm) {
@@ -413,11 +428,13 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
         }
         return { shouldContinue: false, reply: { text: lines.join("\n") } };
     }
-    if (params.cfg.commands?.config !== true) {
-        return {
-            shouldContinue: false,
-            reply: { text: "⚠️ /allowlist edits are disabled. Set commands.config=true to enable." },
-        };
+    const disabled = requireCommandFlagEnabled(params.cfg, {
+        label: "/allowlist edits",
+        configKey: "config",
+        disabledVerb: "are",
+    });
+    if (disabled) {
+        return disabled;
     }
     const shouldUpdateConfig = parsed.target !== "store";
     const shouldTouchStore = parsed.target !== "config" && listPairingChannels().includes(channelId);
@@ -431,7 +448,9 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
             const hint = `channels.${channelId}.configWrites=true`;
             return {
                 shouldContinue: false,
-                reply: { text: `⚠️ Config writes are disabled for ${channelId}. Set ${hint} to enable.` },
+                reply: {
+                    text: `\u26a0\ufe0f Config writes are disabled for ${channelId}. Set ${hint} to enable.`,
+                },
             };
         }
         const allowlistPath = resolveChannelAllowFromPaths(channelId, scope);
@@ -439,7 +458,7 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
             return {
                 shouldContinue: false,
                 reply: {
-                    text: `⚠️ ${channelId} does not support ${scope} allowlist edits via /allowlist.`,
+                    text: `\u26a0\ufe0f ${channelId} does not support ${scope} allowlist edits via /allowlist.`,
                 },
             };
         }
@@ -447,15 +466,29 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
         if (!snapshot.valid || !snapshot.parsed || typeof snapshot.parsed !== "object") {
             return {
                 shouldContinue: false,
-                reply: { text: "⚠️ Config file is invalid; fix it before using /allowlist." },
+                reply: { text: "\u26a0\ufe0f Config file is invalid; fix it before using /allowlist." },
             };
         }
         const parsedConfig = structuredClone(snapshot.parsed);
         const { target, pathPrefix, accountId: normalizedAccountId, } = resolveAccountTarget(parsedConfig, channelId, accountId);
-        const existingRaw = getNestedValue(target, allowlistPath);
-        const existing = Array.isArray(existingRaw)
-            ? existingRaw.map((entry) => String(entry).trim()).filter(Boolean)
-            : [];
+        const existing = [];
+        const existingPaths = scope === "dm" && (channelId === "slack" || channelId === "discord")
+            ? // Read both while legacy alias may still exist; write canonical below.
+                [allowlistPath, ["dm", "allowFrom"]]
+            : [allowlistPath];
+        for (const path of existingPaths) {
+            const existingRaw = getNestedValue(target, path);
+            if (!Array.isArray(existingRaw)) {
+                continue;
+            }
+            for (const entry of existingRaw) {
+                const value = String(entry).trim();
+                if (!value || existing.includes(value)) {
+                    continue;
+                }
+                existing.push(value);
+            }
+        }
         const normalizedEntry = normalizeAllowFrom({
             cfg: params.cfg,
             channelId,
@@ -465,7 +498,7 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
         if (normalizedEntry.length === 0) {
             return {
                 shouldContinue: false,
-                reply: { text: "⚠️ Invalid allowlist entry." },
+                reply: { text: "\u26a0\ufe0f Invalid allowlist entry." },
             };
         }
         const existingNormalized = normalizeAllowFrom({
@@ -508,6 +541,10 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
             else {
                 setNestedValue(target, allowlistPath, next);
             }
+            if (scope === "dm" && (channelId === "slack" || channelId === "discord")) {
+                // Remove legacy DM allowlist alias to prevent drift.
+                deleteNestedValue(target, ["dm", "allowFrom"]);
+            }
         }
         if (configChanged) {
             const validated = validateConfigObjectWithPlugins(parsedConfig);
@@ -515,13 +552,15 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
                 const issue = validated.issues[0];
                 return {
                     shouldContinue: false,
-                    reply: { text: `⚠️ Config invalid after update (${issue.path}: ${issue.message}).` },
+                    reply: {
+                        text: `\u26a0\ufe0f Config invalid after update (${issue.path}: ${issue.message}).`,
+                    },
                 };
             }
             await writeConfigFile(validated.config);
         }
         if (!configChanged && !shouldTouchStore) {
-            const message = parsed.action === "add" ? "✅ Already allowlisted." : "⚠️ Entry not found.";
+            const message = parsed.action === "add" ? "\u2705 Already allowlisted." : "\u26a0\ufe0f Entry not found.";
             return { shouldContinue: false, reply: { text: message } };
         }
         if (shouldTouchStore) {
@@ -545,14 +584,14 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
         return {
             shouldContinue: false,
             reply: {
-                text: `✅ ${scopeLabel} allowlist ${actionLabel}: ${targetLabel}.`,
+                text: `\u2705 ${scopeLabel} allowlist ${actionLabel}: ${targetLabel}.`,
             },
         };
     }
     if (!shouldTouchStore) {
         return {
             shouldContinue: false,
-            reply: { text: "⚠️ This channel does not support allowlist storage." },
+            reply: { text: "\u26a0\ufe0f This channel does not support allowlist storage." },
         };
     }
     if (parsed.action === "add") {
@@ -565,6 +604,6 @@ export const handleAllowlistCommand = async (params, allowTextCommands) => {
     const scopeLabel = scope === "dm" ? "DM" : "group";
     return {
         shouldContinue: false,
-        reply: { text: `✅ ${scopeLabel} allowlist ${actionLabel} in pairing store.` },
+        reply: { text: `\u2705 ${scopeLabel} allowlist ${actionLabel} in pairing store.` },
     };
 };

package/dist/auto-reply/reply/commands-bash.js

@@ -1,17 +1,18 @@
-import { logVerbose } from "../../globals.js";
 import { handleBashChatCommand } from "./bash-command.js";
+import { rejectUnauthorizedCommand } from "./command-gates.js";
 export const handleBashCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const { command } = params;
     const bashSlashRequested = command.commandBodyNormalized === "/bash" || command.commandBodyNormalized.startsWith("/bash ");
     const bashBangRequested = command.commandBodyNormalized.startsWith("!");
     if (!bashSlashRequested && !(bashBangRequested && command.isAuthorizedSender)) {
         return null;
     }
-    if (!command.isAuthorizedSender) {
-        logVerbose(`Ignoring /bash from unauthorized sender: ${command.senderId || "<unknown>"}`);
-        return { shouldContinue: false };
+    const unauthorized = rejectUnauthorizedCommand(params, "/bash");
+    if (unauthorized) {
+        return unauthorized;
     }
     const reply = await handleBashChatCommand({
         ctx: params.ctx,