@poolzin/pool-bot 2026.2.25 → 2026.2.26

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,

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

@@ -1,28 +1,29 @@
-import { readConfigFileSnapshot, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
-import { getConfigValueAtPath, parseConfigPath, setConfigValueAtPath, unsetConfigValueAtPath, } from "../../config/config-paths.js";
-import { getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride, } from "../../config/runtime-overrides.js";
 import { resolveChannelConfigWrites } from "../../channels/plugins/config-writes.js";
 import { normalizeChannelId } from "../../channels/registry.js";
-import { logVerbose } from "../../globals.js";
+import { getConfigValueAtPath, parseConfigPath, setConfigValueAtPath, unsetConfigValueAtPath, } from "../../config/config-paths.js";
+import { readConfigFileSnapshot, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
+import { getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride, } from "../../config/runtime-overrides.js";
+import { rejectUnauthorizedCommand, requireCommandFlagEnabled } from "./command-gates.js";
 import { parseConfigCommand } from "./config-commands.js";
 import { parseDebugCommand } from "./debug-commands.js";
 export const handleConfigCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const configCommand = parseConfigCommand(params.command.commandBodyNormalized);
-    if (!configCommand)
+    if (!configCommand) {
         return null;
-    if (!params.command.isAuthorizedSender) {
-        logVerbose(`Ignoring /config from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
-        return { shouldContinue: false };
     }
-    if (params.cfg.commands?.config !== true) {
-        return {
-            shouldContinue: false,
-            reply: {
-                text: "⚠️ /config is disabled. Set commands.config=true to enable.",
-            },
-        };
+    const unauthorized = rejectUnauthorizedCommand(params, "/config");
+    if (unauthorized) {
+        return unauthorized;
+    }
+    const disabled = requireCommandFlagEnabled(params.cfg, {
+        label: "/config",
+        configKey: "config",
+    });
+    if (disabled) {
+        return disabled;
     }
     if (configCommand.action === "error") {
         return {
@@ -149,22 +150,23 @@ export const handleConfigCommand = async (params, allowTextCommands) => {
     return null;
 };
 export const handleDebugCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const debugCommand = parseDebugCommand(params.command.commandBodyNormalized);
-    if (!debugCommand)
+    if (!debugCommand) {
         return null;
-    if (!params.command.isAuthorizedSender) {
-        logVerbose(`Ignoring /debug from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
-        return { shouldContinue: false };
     }
-    if (params.cfg.commands?.debug !== true) {
-        return {
-            shouldContinue: false,
-            reply: {
-                text: "⚠️ /debug is disabled. Set commands.debug=true to enable.",
-            },
-        };
+    const unauthorized = rejectUnauthorizedCommand(params, "/debug");
+    if (unauthorized) {
+        return unauthorized;
+    }
+    const disabled = requireCommandFlagEnabled(params.cfg, {
+        label: "/debug",
+        configKey: "debug",
+    });
+    if (disabled) {
+        return disabled;
     }
     if (debugCommand.action === "error") {
         return {

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

@@ -12,7 +12,7 @@ import { handleConfigCommand, handleDebugCommand } from "./commands-config.js";
 import { handleCommandsListCommand, handleContextCommand, handleExportSessionCommand, handleHelpCommand, handleStatusCommand, handleWhoamiCommand, } from "./commands-info.js";
 import { handleModelsCommand } from "./commands-models.js";
 import { handlePluginCommand } from "./commands-plugin.js";
-import { handleAbortTrigger, handleActivationCommand, handleRestartCommand, handleSendPolicyCommand, handleStopCommand, handleUsageCommand, } from "./commands-session.js";
+import { handleAbortTrigger, handleActivationCommand, handleRestartCommand, handleSessionCommand, handleSendPolicyCommand, handleStopCommand, handleUsageCommand, } from "./commands-session.js";
 import { handleSubagentsCommand } from "./commands-subagents.js";
 import { handleTtsCommands } from "./commands-tts.js";
 import { routeReply } from "./route-reply.js";
@@ -26,6 +26,7 @@ export async function handleCommands(params) {
             handleActivationCommand,
             handleSendPolicyCommand,
             handleUsageCommand,
+            handleSessionCommand,
             handleRestartCommand,
             handleTtsCommands,
             handleHelpCommand,

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

@@ -103,6 +103,7 @@ export const handleStatusCommand = async (params, allowTextCommands) => {
         command: params.command,
         sessionEntry: params.sessionEntry,
         sessionKey: params.sessionKey,
+        parentSessionKey: params.ctx.ParentSessionKey,
         sessionScope: params.sessionScope,
         provider: params.provider,
         model: params.model,