@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/pairing/pairing-store.js

@@ -2,9 +2,11 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import lockfile from "proper-lockfile";
 import { getPairingAdapter } from "../channels/plugins/pairing.js";
 import { resolveOAuthDir, resolveStateDir } from "../config/paths.js";
+import { withFileLock as withPathLock } from "../infra/file-lock.js";
+import { resolveRequiredHomeDir } from "../infra/home-dir.js";
+import { readJsonFileWithFallback, writeJsonFileAtomically } from "../plugin-sdk/json-store.js";
 const PAIRING_CODE_LENGTH = 8;
 const PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 const PAIRING_PENDING_TTL_MS = 60 * 60 * 1000;
@@ -20,57 +22,58 @@ const PAIRING_STORE_LOCK_OPTIONS = {
     stale: 30_000,
 };
 function resolveCredentialsDir(env = process.env) {
-    const stateDir = resolveStateDir(env, os.homedir);
+    const stateDir = resolveStateDir(env, () => resolveRequiredHomeDir(env, os.homedir));
     return resolveOAuthDir(env, stateDir);
 }
 /** Sanitize channel ID for use in filenames (prevent path traversal). */
 function safeChannelKey(channel) {
     const raw = String(channel).trim().toLowerCase();
-    if (!raw)
+    if (!raw) {
         throw new Error("invalid pairing channel");
+    }
     const safe = raw.replace(/[\\/:*?"<>|]/g, "_").replace(/\.\./g, "_");
-    if (!safe || safe === "_")
+    if (!safe || safe === "_") {
         throw new Error("invalid pairing channel");
+    }
     return safe;
 }
 function resolvePairingPath(channel, env = process.env) {
     return path.join(resolveCredentialsDir(env), `${safeChannelKey(channel)}-pairing.json`);
 }
-function resolveAllowFromPath(channel, env = process.env) {
-    return path.join(resolveCredentialsDir(env), `${safeChannelKey(channel)}-allowFrom.json`);
-}
-function safeParseJson(raw) {
-    try {
-        return JSON.parse(raw);
+function safeAccountKey(accountId) {
+    const raw = String(accountId).trim().toLowerCase();
+    if (!raw) {
+        throw new Error("invalid pairing account id");
     }
-    catch {
-        return null;
+    const safe = raw.replace(/[\\/:*?"<>|]/g, "_").replace(/\.\./g, "_");
+    if (!safe || safe === "_") {
+        throw new Error("invalid pairing account id");
     }
+    return safe;
 }
-async function readJsonFile(filePath, fallback) {
-    try {
-        const raw = await fs.promises.readFile(filePath, "utf-8");
-        const parsed = safeParseJson(raw);
-        if (parsed == null)
-            return { value: fallback, exists: true };
-        return { value: parsed, exists: true };
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            return { value: fallback, exists: false };
-        return { value: fallback, exists: false };
+function resolveAllowFromPath(channel, env = process.env, accountId) {
+    const base = safeChannelKey(channel);
+    const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+    if (!normalizedAccountId) {
+        return path.join(resolveCredentialsDir(env), `${base}-allowFrom.json`);
     }
+    return path.join(resolveCredentialsDir(env), `${base}-${safeAccountKey(normalizedAccountId)}-allowFrom.json`);
+}
+async function readJsonFile(filePath, fallback) {
+    return await readJsonFileWithFallback(filePath, fallback);
 }
 async function writeJsonFile(filePath, value) {
-    const dir = path.dirname(filePath);
-    await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
-    const tmp = path.join(dir, `${path.basename(filePath)}.${crypto.randomUUID()}.tmp`);
-    await fs.promises.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, {
-        encoding: "utf-8",
+    await writeJsonFileAtomically(filePath, value);
+}
+async function readPairingRequests(filePath) {
+    const { value } = await readJsonFile(filePath, {
+        version: 1,
+        requests: [],
     });
-    await fs.promises.chmod(tmp, 0o600);
-    await fs.promises.rename(tmp, filePath);
+    return Array.isArray(value.requests) ? value.requests : [];
+}
+async function readPrunedPairingRequests(filePath) {
+    return pruneExpiredRequests(await readPairingRequests(filePath), Date.now());
 }
 async function ensureJsonFile(filePath, fallback) {
     try {
@@ -82,34 +85,25 @@ async function ensureJsonFile(filePath, fallback) {
 }
 async function withFileLock(filePath, fallback, fn) {
     await ensureJsonFile(filePath, fallback);
-    let release;
-    try {
-        release = await lockfile.lock(filePath, PAIRING_STORE_LOCK_OPTIONS);
+    return await withPathLock(filePath, PAIRING_STORE_LOCK_OPTIONS, async () => {
         return await fn();
-    }
-    finally {
-        if (release) {
-            try {
-                await release();
-            }
-            catch {
-                // ignore unlock errors
-            }
-        }
-    }
+    });
 }
 function parseTimestamp(value) {
-    if (!value)
+    if (!value) {
         return null;
+    }
     const parsed = Date.parse(value);
-    if (!Number.isFinite(parsed))
+    if (!Number.isFinite(parsed)) {
         return null;
+    }
     return parsed;
 }
 function isExpired(entry, nowMs) {
     const createdAt = parseTimestamp(entry.createdAt);
-    if (!createdAt)
+    if (!createdAt) {
         return true;
+    }
     return nowMs - createdAt > PAIRING_PENDING_TTL_MS;
 }
 function pruneExpiredRequests(reqs, nowMs) {
@@ -131,7 +125,7 @@ function pruneExcessRequests(reqs, maxPending) {
     if (maxPending <= 0 || reqs.length <= maxPending) {
         return { requests: reqs, removed: false };
     }
-    const sorted = reqs.slice().sort((a, b) => resolveLastSeenAt(a) - resolveLastSeenAt(b));
+    const sorted = reqs.slice().toSorted((a, b) => resolveLastSeenAt(a) - resolveLastSeenAt(b));
     return { requests: sorted.slice(-maxPending), removed: true };
 }
 function randomCode() {
@@ -146,91 +140,150 @@ function randomCode() {
 function generateUniqueCode(existing) {
     for (let attempt = 0; attempt < 500; attempt += 1) {
         const code = randomCode();
-        if (!existing.has(code))
+        if (!existing.has(code)) {
             return code;
+        }
     }
     throw new Error("failed to generate unique pairing code");
 }
+function normalizePairingAccountId(accountId) {
+    return accountId?.trim().toLowerCase() || "";
+}
+function requestMatchesAccountId(entry, normalizedAccountId) {
+    if (!normalizedAccountId) {
+        return true;
+    }
+    return (String(entry.meta?.accountId ?? "")
+        .trim()
+        .toLowerCase() === normalizedAccountId);
+}
 function normalizeId(value) {
     return String(value).trim();
 }
 function normalizeAllowEntry(channel, entry) {
     const trimmed = entry.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "";
-    if (trimmed === "*")
+    }
+    if (trimmed === "*") {
         return "";
+    }
     const adapter = getPairingAdapter(channel);
     const normalized = adapter?.normalizeAllowEntry ? adapter.normalizeAllowEntry(trimmed) : trimmed;
     return String(normalized).trim();
 }
-export async function readChannelAllowFromStore(channel, env = process.env) {
-    const filePath = resolveAllowFromPath(channel, env);
+function normalizeAllowFromList(channel, store) {
+    const list = Array.isArray(store.allowFrom) ? store.allowFrom : [];
+    return list.map((v) => normalizeAllowEntry(channel, String(v))).filter(Boolean);
+}
+function normalizeAllowFromInput(channel, entry) {
+    return normalizeAllowEntry(channel, normalizeId(entry));
+}
+function dedupePreserveOrder(entries) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of entries) {
+        const normalized = String(entry).trim();
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+async function readAllowFromStateForPath(channel, filePath) {
     const { value } = await readJsonFile(filePath, {
         version: 1,
         allowFrom: [],
     });
-    const list = Array.isArray(value.allowFrom) ? value.allowFrom : [];
-    return list.map((v) => normalizeAllowEntry(channel, String(v))).filter(Boolean);
+    return normalizeAllowFromList(channel, value);
 }
-export async function addChannelAllowFromStoreEntry(params) {
+async function readAllowFromState(params) {
+    const { value } = await readJsonFile(params.filePath, {
+        version: 1,
+        allowFrom: [],
+    });
+    const current = normalizeAllowFromList(params.channel, value);
+    const normalized = normalizeAllowFromInput(params.channel, params.entry);
+    return { current, normalized: normalized || null };
+}
+async function writeAllowFromState(filePath, allowFrom) {
+    await writeJsonFile(filePath, {
+        version: 1,
+        allowFrom,
+    });
+}
+async function updateAllowFromStoreEntry(params) {
     const env = params.env ?? process.env;
-    const filePath = resolveAllowFromPath(params.channel, env);
+    const filePath = resolveAllowFromPath(params.channel, env, params.accountId);
     return await withFileLock(filePath, { version: 1, allowFrom: [] }, async () => {
-        const { value } = await readJsonFile(filePath, {
-            version: 1,
-            allowFrom: [],
+        const { current, normalized } = await readAllowFromState({
+            channel: params.channel,
+            entry: params.entry,
+            filePath,
         });
-        const current = (Array.isArray(value.allowFrom) ? value.allowFrom : [])
-            .map((v) => normalizeAllowEntry(params.channel, String(v)))
-            .filter(Boolean);
-        const normalized = normalizeAllowEntry(params.channel, normalizeId(params.entry));
-        if (!normalized)
+        if (!normalized) {
             return { changed: false, allowFrom: current };
-        if (current.includes(normalized))
+        }
+        const next = params.apply(current, normalized);
+        if (!next) {
             return { changed: false, allowFrom: current };
-        const next = [...current, normalized];
-        await writeJsonFile(filePath, {
-            version: 1,
-            allowFrom: next,
-        });
+        }
+        await writeAllowFromState(filePath, next);
         return { changed: true, allowFrom: next };
     });
 }
+export async function readChannelAllowFromStore(channel, env = process.env, accountId) {
+    const normalizedAccountId = accountId?.trim().toLowerCase() ?? "";
+    if (!normalizedAccountId) {
+        const filePath = resolveAllowFromPath(channel, env);
+        return await readAllowFromStateForPath(channel, filePath);
+    }
+    const scopedPath = resolveAllowFromPath(channel, env, accountId);
+    const scopedEntries = await readAllowFromStateForPath(channel, scopedPath);
+    // Backward compatibility: legacy channel-level allowFrom store was unscoped.
+    // Keep honoring it alongside account-scoped files to prevent re-pair prompts after upgrades.
+    const legacyPath = resolveAllowFromPath(channel, env);
+    const legacyEntries = await readAllowFromStateForPath(channel, legacyPath);
+    return dedupePreserveOrder([...scopedEntries, ...legacyEntries]);
+}
+async function updateChannelAllowFromStore(params) {
+    return await updateAllowFromStoreEntry({
+        channel: params.channel,
+        entry: params.entry,
+        accountId: params.accountId,
+        env: params.env,
+        apply: params.apply,
+    });
+}
+export async function addChannelAllowFromStoreEntry(params) {
+    return await updateChannelAllowFromStore({
+        ...params,
+        apply: (current, normalized) => {
+            if (current.includes(normalized)) {
+                return null;
+            }
+            return [...current, normalized];
+        },
+    });
+}
 export async function removeChannelAllowFromStoreEntry(params) {
-    const env = params.env ?? process.env;
-    const filePath = resolveAllowFromPath(params.channel, env);
-    return await withFileLock(filePath, { version: 1, allowFrom: [] }, async () => {
-        const { value } = await readJsonFile(filePath, {
-            version: 1,
-            allowFrom: [],
-        });
-        const current = (Array.isArray(value.allowFrom) ? value.allowFrom : [])
-            .map((v) => normalizeAllowEntry(params.channel, String(v)))
-            .filter(Boolean);
-        const normalized = normalizeAllowEntry(params.channel, normalizeId(params.entry));
-        if (!normalized)
-            return { changed: false, allowFrom: current };
-        const next = current.filter((entry) => entry !== normalized);
-        if (next.length === current.length)
-            return { changed: false, allowFrom: current };
-        await writeJsonFile(filePath, {
-            version: 1,
-            allowFrom: next,
-        });
-        return { changed: true, allowFrom: next };
+    return await updateChannelAllowFromStore({
+        ...params,
+        apply: (current, normalized) => {
+            const next = current.filter((entry) => entry !== normalized);
+            if (next.length === current.length) {
+                return null;
+            }
+            return next;
+        },
     });
 }
-export async function listChannelPairingRequests(channel, env = process.env) {
+export async function listChannelPairingRequests(channel, env = process.env, accountId) {
     const filePath = resolvePairingPath(channel, env);
     return await withFileLock(filePath, { version: 1, requests: [] }, async () => {
-        const { value } = await readJsonFile(filePath, {
-            version: 1,
-            requests: [],
-        });
-        const reqs = Array.isArray(value.requests) ? value.requests : [];
-        const nowMs = Date.now();
-        const { requests: prunedExpired, removed: expiredRemoved } = pruneExpiredRequests(reqs, nowMs);
+        const { requests: prunedExpired, removed: expiredRemoved } = await readPrunedPairingRequests(filePath);
         const { requests: pruned, removed: cappedRemoved } = pruneExcessRequests(prunedExpired, PAIRING_PENDING_MAX);
         if (expiredRemoved || cappedRemoved) {
             await writeJsonFile(filePath, {
@@ -238,32 +291,34 @@ export async function listChannelPairingRequests(channel, env = process.env) {
                 requests: pruned,
             });
         }
-        return pruned
+        const normalizedAccountId = normalizePairingAccountId(accountId);
+        const filtered = normalizedAccountId
+            ? pruned.filter((entry) => requestMatchesAccountId(entry, normalizedAccountId))
+            : pruned;
+        return filtered
             .filter((r) => r &&
             typeof r.id === "string" &&
             typeof r.code === "string" &&
             typeof r.createdAt === "string")
             .slice()
-            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            .toSorted((a, b) => a.createdAt.localeCompare(b.createdAt));
     });
 }
 export async function upsertChannelPairingRequest(params) {
     const env = params.env ?? process.env;
     const filePath = resolvePairingPath(params.channel, env);
     return await withFileLock(filePath, { version: 1, requests: [] }, async () => {
-        const { value } = await readJsonFile(filePath, {
-            version: 1,
-            requests: [],
-        });
         const now = new Date().toISOString();
         const nowMs = Date.now();
         const id = normalizeId(params.id);
-        const meta = params.meta && typeof params.meta === "object"
+        const normalizedAccountId = params.accountId?.trim();
+        const baseMeta = params.meta && typeof params.meta === "object"
             ? Object.fromEntries(Object.entries(params.meta)
                 .map(([k, v]) => [k, String(v ?? "").trim()])
                 .filter(([_, v]) => Boolean(v)))
             : undefined;
-        let reqs = Array.isArray(value.requests) ? value.requests : [];
+        const meta = normalizedAccountId ? { ...baseMeta, accountId: normalizedAccountId } : baseMeta;
+        let reqs = await readPairingRequests(filePath);
         const { requests: prunedExpired, removed: expiredRemoved } = pruneExpiredRequests(reqs, nowMs);
         reqs = prunedExpired;
         const existingIdx = reqs.findIndex((r) => r.id === id);
@@ -318,18 +373,19 @@ export async function upsertChannelPairingRequest(params) {
 export async function approveChannelPairingCode(params) {
     const env = params.env ?? process.env;
     const code = params.code.trim().toUpperCase();
-    if (!code)
+    if (!code) {
         return null;
+    }
     const filePath = resolvePairingPath(params.channel, env);
     return await withFileLock(filePath, { version: 1, requests: [] }, async () => {
-        const { value } = await readJsonFile(filePath, {
-            version: 1,
-            requests: [],
+        const { requests: pruned, removed } = await readPrunedPairingRequests(filePath);
+        const normalizedAccountId = normalizePairingAccountId(params.accountId);
+        const idx = pruned.findIndex((r) => {
+            if (String(r.code ?? "").toUpperCase() !== code) {
+                return false;
+            }
+            return requestMatchesAccountId(r, normalizedAccountId);
         });
-        const reqs = Array.isArray(value.requests) ? value.requests : [];
-        const nowMs = Date.now();
-        const { requests: pruned, removed } = pruneExpiredRequests(reqs, nowMs);
-        const idx = pruned.findIndex((r) => String(r.code ?? "").toUpperCase() === code);
         if (idx < 0) {
             if (removed) {
                 await writeJsonFile(filePath, {
@@ -340,16 +396,19 @@ export async function approveChannelPairingCode(params) {
             return null;
         }
         const entry = pruned[idx];
-        if (!entry)
+        if (!entry) {
             return null;
+        }
         pruned.splice(idx, 1);
         await writeJsonFile(filePath, {
             version: 1,
             requests: pruned,
         });
+        const entryAccountId = String(entry.meta?.accountId ?? "").trim() || undefined;
         await addChannelAllowFromStoreEntry({
             channel: params.channel,
             entry: entry.id,
+            accountId: params.accountId?.trim() || entryAccountId,
             env,
         });
         return { id: entry.id, entry };

package/dist/plugin-sdk/index.js

@@ -1,23 +1,46 @@
+export { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
 export { CHANNEL_MESSAGE_ACTION_NAMES } from "../channels/plugins/message-action-names.js";
 export { BLUEBUBBLES_ACTIONS, BLUEBUBBLES_ACTION_NAMES, BLUEBUBBLES_GROUP_ACTIONS, } from "../channels/plugins/bluebubbles-actions.js";
 export { normalizePluginHttpPath } from "../plugins/http-path.js";
 export { registerPluginHttpRoute } from "../plugins/http-registry.js";
 export { emptyPluginConfigSchema } from "../plugins/config-schema.js";
+export { acquireFileLock, withFileLock } from "./file-lock.js";
+export { normalizeWebhookPath, resolveWebhookPath } from "./webhook-path.js";
+export { registerWebhookTarget, rejectNonPostWebhookRequest, resolveWebhookTargets, } from "./webhook-targets.js";
+export { buildAgentMediaPayload } from "./agent-media-payload.js";
+export { buildBaseChannelStatusSummary, collectStatusIssuesFromLastError, createDefaultChannelRuntimeState, } from "./status-helpers.js";
+export { buildOauthProviderAuthResult } from "./provider-auth-result.js";
 export { getChatChannelMeta } from "../channels/registry.js";
 export { DiscordConfigSchema, GoogleChatConfigSchema, IMessageConfigSchema, MSTeamsConfigSchema, SignalConfigSchema, SlackConfigSchema, TelegramConfigSchema, } from "../config/zod-schema.providers-core.js";
 export { WhatsAppConfigSchema } from "../config/zod-schema.providers-whatsapp.js";
-export { BlockStreamingCoalesceSchema, DmConfigSchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, MarkdownTableModeSchema, normalizeAllowFrom, requireOpenAllowFrom, } from "../config/zod-schema.core.js";
+export { BlockStreamingCoalesceSchema, DmConfigSchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, MarkdownTableModeSchema, normalizeAllowFrom, requireOpenAllowFrom, TtsAutoSchema, TtsConfigSchema, TtsModeSchema, TtsProviderSchema, } from "../config/zod-schema.core.js";
 export { ToolPolicySchema } from "../config/zod-schema.agent-runtime.js";
 export { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
+export { formatAllowFromLowercase, isAllowedParsedChatSender } from "./allow-from.js";
+export { resolveSenderCommandAuthorization } from "./command-auth.js";
+export { handleSlackMessageAction } from "./slack-message-actions.js";
+export { extractToolSend } from "./tool-send.js";
+export { resolveChannelAccountConfigBasePath } from "./config-paths.js";
+export { chunkTextForOutbound } from "./text-chunking.js";
+export { readJsonFileWithFallback, writeJsonFileAtomically } from "./json-store.js";
 export { resolveAckReaction } from "../agents/identity.js";
 export { SILENT_REPLY_TOKEN, isSilentReplyText } from "../auto-reply/tokens.js";
+export { approveDevicePairing, listDevicePairing, rejectDevicePairing, } from "../infra/device-pairing.js";
+export { createDedupeCache } from "../infra/dedupe.js";
+export { formatErrorMessage } from "../infra/errors.js";
+export { DEFAULT_WEBHOOK_BODY_TIMEOUT_MS, DEFAULT_WEBHOOK_MAX_BODY_BYTES, RequestBodyLimitError, installRequestBodyLimitGuard, isRequestBodyLimitError, readJsonBodyWithLimit, readRequestBodyWithLimit, requestBodyErrorToText, } from "../infra/http-body.js";
+export { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
+export { SsrFBlockedError, isBlockedHostname, isPrivateIpAddress } from "../infra/net/ssrf.js";
+export { rawDataToString } from "../infra/ws.js";
+export { isWSLSync, isWSL2Sync, isWSLEnv } from "../infra/wsl.js";
+export { isTruthyEnvValue } from "../infra/env.js";
 export { resolveToolsBySender } from "../config/group-policy.js";
 export { buildPendingHistoryContextFromMap, clearHistoryEntries, clearHistoryEntriesIfEnabled, DEFAULT_GROUP_HISTORY_LIMIT, recordPendingHistoryEntry, recordPendingHistoryEntryIfEnabled, } from "../auto-reply/reply/history.js";
 export { mergeAllowlist, summarizeMapping } from "../channels/allowlists/resolve-utils.js";
 export { resolveMentionGating, resolveMentionGatingWithBypass, } from "../channels/mention-gating.js";
 export { removeAckReactionAfterReply, shouldAckReaction, shouldAckReactionForWhatsApp, } from "../channels/ack-reactions.js";
 export { createTypingCallbacks } from "../channels/typing.js";
-export { createReplyPrefixContext } from "../channels/reply-prefix.js";
+export { createReplyPrefixContext, createReplyPrefixOptions } from "../channels/reply-prefix.js";
 export { logAckFailure, logInboundDrop, logTypingFailure } from "../channels/logging.js";
 export { resolveChannelMediaMaxBytes } from "../channels/plugins/media-limits.js";
 export { formatLocationText, toLocationContext } from "../channels/location.js";
@@ -26,18 +49,19 @@ export { resolveBlueBubblesGroupRequireMention, resolveDiscordGroupRequireMentio
 export { recordInboundSession } from "../channels/session.js";
 export { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatch, resolveChannelEntryMatchWithFallback, resolveNestedAllowlistDecision, } from "../channels/plugins/channel-config.js";
 export { listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listTelegramDirectoryGroupsFromConfig, listTelegramDirectoryPeersFromConfig, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, } from "../channels/plugins/directory-config.js";
-export { formatAllowlistMatchMeta } from "../channels/plugins/allowlist-match.js";
+export { formatAllowlistMatchMeta, resolveAllowlistMatchSimple, } from "../channels/plugins/allowlist-match.js";
 export { optionalStringEnum, stringEnum } from "../agents/schema/typebox.js";
 export { buildChannelConfigSchema } from "../channels/plugins/config-schema.js";
 export { deleteAccountFromConfigSection, setAccountEnabledInConfigSection, } from "../channels/plugins/config-helpers.js";
 export { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, } from "../channels/plugins/setup-helpers.js";
 export { formatPairingApproveHint } from "../channels/plugins/helpers.js";
 export { PAIRING_APPROVED_MESSAGE } from "../channels/plugins/pairing-message.js";
-export { addWildcardAllowFrom, promptAccountId } from "../channels/plugins/onboarding/helpers.js";
+export { addWildcardAllowFrom, mergeAllowFromEntries, promptAccountId, } from "../channels/plugins/onboarding/helpers.js";
 export { promptChannelAccessConfig } from "../channels/plugins/onboarding/channel-access.js";
 export { createActionGate, jsonResult, readNumberParam, readReactionParams, readStringParam, } from "../agents/tools/common.js";
 export { formatDocsLink } from "../terminal/links.js";
-export { normalizeE164 } from "../utils.js";
+export { clamp, escapeRegExp, normalizeE164, safeParseJson, sleep } from "../utils.js";
+export { stripAnsi } from "../terminal/ansi.js";
 export { missingTargetError } from "../infra/outbound/target-errors.js";
 export { registerLogTransport } from "../logging/logger.js";
 export { emitDiagnosticEvent, isDiagnosticsEnabled, onDiagnosticEvent, } from "../infra/diagnostic-events.js";
@@ -47,14 +71,16 @@ export { extractOriginalFilename } from "../media/store.js";
 export { listDiscordAccountIds, resolveDefaultDiscordAccountId, resolveDiscordAccount, } from "../discord/accounts.js";
 export { collectDiscordAuditChannelIds } from "../discord/audit.js";
 export { discordOnboardingAdapter } from "../channels/plugins/onboarding/discord.js";
-export { looksLikeDiscordTargetId, normalizeDiscordMessagingTarget, } from "../channels/plugins/normalize/discord.js";
+export { looksLikeDiscordTargetId, normalizeDiscordMessagingTarget, normalizeDiscordOutboundTarget, } from "../channels/plugins/normalize/discord.js";
 export { collectDiscordStatusIssues } from "../channels/plugins/status-issues/discord.js";
 // Channel: iMessage
 export { listIMessageAccountIds, resolveDefaultIMessageAccountId, resolveIMessageAccount, } from "../imessage/accounts.js";
 export { imessageOnboardingAdapter } from "../channels/plugins/onboarding/imessage.js";
 export { looksLikeIMessageTargetId, normalizeIMessageMessagingTarget, } from "../channels/plugins/normalize/imessage.js";
+export { parseChatAllowTargetPrefixes, parseChatTargetPrefixesOrThrow, resolveServicePrefixedAllowTarget, resolveServicePrefixedTarget, } from "../imessage/target-parsing-helpers.js";
 // Channel: Slack
 export { listEnabledSlackAccounts, listSlackAccountIds, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackReplyToMode, } from "../slack/accounts.js";
+export { extractSlackToolSend, listSlackMessageActions } from "../slack/message-actions.js";
 export { slackOnboardingAdapter } from "../channels/plugins/onboarding/slack.js";
 export { looksLikeSlackTargetId, normalizeSlackMessagingTarget, } from "../channels/plugins/normalize/slack.js";
 export { buildSlackThreadingToolContext } from "../slack/threading-tool-context.js";
@@ -63,6 +89,7 @@ export { listTelegramAccountIds, resolveDefaultTelegramAccountId, resolveTelegra
 export { telegramOnboardingAdapter } from "../channels/plugins/onboarding/telegram.js";
 export { looksLikeTelegramTargetId, normalizeTelegramMessagingTarget, } from "../channels/plugins/normalize/telegram.js";
 export { collectTelegramStatusIssues } from "../channels/plugins/status-issues/telegram.js";
+export { parseTelegramReplyToMessageId, parseTelegramThreadId, } from "../telegram/outbound-params.js";
 // Channel: Signal
 export { listSignalAccountIds, resolveDefaultSignalAccountId, resolveSignalAccount, } from "../signal/accounts.js";
 export { signalOnboardingAdapter } from "../channels/plugins/onboarding/signal.js";
@@ -70,6 +97,7 @@ export { looksLikeSignalTargetId, normalizeSignalMessagingTarget, } from "../cha
 // Channel: WhatsApp
 export { listWhatsAppAccountIds, resolveDefaultWhatsAppAccountId, resolveWhatsAppAccount, } from "../web/accounts.js";
 export { isWhatsAppGroupJid, normalizeWhatsAppTarget } from "../whatsapp/normalize.js";
+export { resolveWhatsAppOutboundTarget } from "../whatsapp/resolve-outbound-target.js";
 export { whatsappOnboardingAdapter } from "../channels/plugins/onboarding/whatsapp.js";
 export { resolveWhatsAppHeartbeatRecipients } from "../channels/plugins/whatsapp-heartbeat.js";
 export { looksLikeWhatsAppTargetId, normalizeWhatsAppMessagingTarget, } from "../channels/plugins/normalize/whatsapp.js";