@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/plugin-sdk-internal/signal.js

@@ -0,0 +1,13 @@
+export * from "../plugin-sdk/channel-plugin-common.js";
+export { listEnabledSignalAccounts, listSignalAccountIds, resolveDefaultSignalAccountId, resolveSignalAccount, } from "../../extensions/signal/src/accounts.js";
+export { resolveSignalReactionLevel } from "../../extensions/signal/src/reaction-level.js";
+export { removeReactionSignal, sendReactionSignal, } from "../../extensions/signal/src/send-reactions.js";
+export { sendMessageSignal } from "../../extensions/signal/src/send.js";
+export { looksLikeSignalTargetId, normalizeSignalMessagingTarget, } from "../channels/plugins/normalize/signal.js";
+export { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, } from "../config/runtime-group-policy.js";
+export { signalSetupWizard } from "../../extensions/signal/src/setup-surface.js";
+export { signalSetupAdapter } from "../../extensions/signal/src/setup-core.js";
+export { SignalConfigSchema } from "../config/zod-schema.providers-core.js";
+export { normalizeE164 } from "../utils.js";
+export { resolveChannelMediaMaxBytes } from "../channels/plugins/media-limits.js";
+export { buildBaseAccountStatusSnapshot, buildBaseChannelStatusSummary, collectStatusIssuesFromLastError, createDefaultChannelRuntimeState, } from "../plugin-sdk/status-helpers.js";

package/dist/plugin-sdk-internal/slack.js

@@ -0,0 +1,22 @@
+export * from "../plugin-sdk/channel-plugin-common.js";
+export { listEnabledSlackAccounts, listSlackAccountIds, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackReplyToMode, } from "../../extensions/slack/src/accounts.js";
+export { isSlackInteractiveRepliesEnabled } from "../../extensions/slack/src/interactive-replies.js";
+export { inspectSlackAccount } from "../../extensions/slack/src/account-inspect.js";
+export { projectCredentialSnapshotFields, resolveConfiguredFromCredentialStatuses, resolveConfiguredFromRequiredCredentialStatuses, } from "../channels/account-snapshot-fields.js";
+export { listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, } from "../channels/plugins/directory-config.js";
+export { looksLikeSlackTargetId, normalizeSlackMessagingTarget, } from "../channels/plugins/normalize/slack.js";
+export { parseSlackTarget, resolveSlackChannelId } from "../plugin-sdk/slack-targets.js";
+export { extractSlackToolSend, listSlackMessageActions, } from "../../extensions/slack/src/message-actions.js";
+export { buildSlackThreadingToolContext } from "../../extensions/slack/src/threading-tool-context.js";
+export { parseSlackBlocksInput } from "../../extensions/slack/src/blocks-input.js";
+export { handleSlackHttpRequest } from "../../extensions/slack/src/http/index.js";
+export { sendMessageSlack } from "../../extensions/slack/src/send.js";
+export { deleteSlackMessage, downloadSlackFile, editSlackMessage, getSlackMemberInfo, listSlackEmojis, listSlackPins, listSlackReactions, pinSlackMessage, reactSlackMessage, readSlackMessages, removeOwnSlackReactions, removeSlackReaction, sendSlackMessage, unpinSlackMessage, } from "../../extensions/slack/src/actions.js";
+export { recordSlackThreadParticipation } from "../../extensions/slack/src/sent-thread-cache.js";
+export { buildComputedAccountStatusSnapshot } from "../plugin-sdk/status-helpers.js";
+export { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, } from "../config/runtime-group-policy.js";
+export { resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, } from "../channels/plugins/group-mentions.js";
+export { slackSetupAdapter } from "../../extensions/slack/src/setup-core.js";
+export { slackSetupWizard } from "../../extensions/slack/src/setup-surface.js";
+export { SlackConfigSchema } from "../config/zod-schema.providers-core.js";
+export { handleSlackMessageAction } from "../plugin-sdk/slack-message-actions.js";

package/dist/plugin-sdk-internal/telegram.js

@@ -0,0 +1,32 @@
+export { emptyPluginConfigSchema } from "../plugins/config-schema.js";
+export { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
+export { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, } from "../channels/plugins/setup-helpers.js";
+export { buildChannelConfigSchema } from "../channels/plugins/config-schema.js";
+export { deleteAccountFromConfigSection, clearAccountEntryFields, setAccountEnabledInConfigSection, } from "../channels/plugins/config-helpers.js";
+export { formatPairingApproveHint } from "../channels/plugins/helpers.js";
+export { PAIRING_APPROVED_MESSAGE } from "../channels/plugins/pairing-message.js";
+export { getChatChannelMeta } from "../channels/registry.js";
+export { createTelegramActionGate, listTelegramAccountIds, resolveDefaultTelegramAccountId, resolveTelegramPollActionGateState, resolveTelegramAccount, } from "../../extensions/telegram/src/accounts.js";
+export { inspectTelegramAccount } from "../../extensions/telegram/src/account-inspect.js";
+export { projectCredentialSnapshotFields, resolveConfiguredFromCredentialStatuses, } from "../channels/account-snapshot-fields.js";
+export { listTelegramDirectoryGroupsFromConfig, listTelegramDirectoryPeersFromConfig, } from "../channels/plugins/directory-config.js";
+export { looksLikeTelegramTargetId, normalizeTelegramMessagingTarget, } from "../../extensions/telegram/src/normalize.js";
+export { parseTelegramReplyToMessageId, parseTelegramThreadId, } from "../../extensions/telegram/src/outbound-params.js";
+export { isNumericTelegramUserId, normalizeTelegramAllowFromEntry, } from "../../extensions/telegram/src/allow-from.js";
+export { fetchTelegramChatId } from "../../extensions/telegram/src/api-fetch.js";
+export { resolveTelegramInlineButtonsScope, resolveTelegramTargetChatType, } from "../../extensions/telegram/src/inline-buttons.js";
+export { resolveTelegramReactionLevel } from "../../extensions/telegram/src/reaction-level.js";
+export { createForumTopicTelegram, deleteMessageTelegram, editForumTopicTelegram, editMessageTelegram, reactMessageTelegram, sendMessageTelegram, sendPollTelegram, sendStickerTelegram, } from "../../extensions/telegram/src/send.js";
+export { getCacheStats, searchStickers } from "../../extensions/telegram/src/sticker-cache.js";
+export { resolveTelegramToken } from "../../extensions/telegram/src/token.js";
+export { telegramMessageActions } from "../../extensions/telegram/src/channel-actions.js";
+export { collectTelegramStatusIssues } from "../../extensions/telegram/src/status-issues.js";
+export { sendTelegramPayloadMessages } from "../../extensions/telegram/src/outbound-adapter.js";
+export { buildBrowseProvidersButton, buildModelsKeyboard, buildProviderKeyboard, calculateTotalPages, getModelsPageSize, } from "../../extensions/telegram/src/model-buttons.js";
+export { isTelegramExecApprovalApprover, isTelegramExecApprovalClientEnabled, } from "../../extensions/telegram/src/exec-approvals.js";
+export { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, } from "../config/runtime-group-policy.js";
+export { resolveTelegramGroupRequireMention, resolveTelegramGroupToolPolicy, } from "../channels/plugins/group-mentions.js";
+export { telegramSetupWizard } from "../../extensions/telegram/src/setup-surface.js";
+export { telegramSetupAdapter } from "../../extensions/telegram/src/setup-core.js";
+export { TelegramConfigSchema } from "../config/zod-schema.providers-core.js";
+export { buildTokenChannelStatusSummary } from "../plugin-sdk/status-helpers.js";

package/dist/plugin-sdk-internal/whatsapp.js

@@ -0,0 +1,29 @@
+export { emptyPluginConfigSchema } from "../plugins/config-schema.js";
+export { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
+export { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, } from "../channels/plugins/setup-helpers.js";
+export { buildChannelConfigSchema } from "../channels/plugins/config-schema.js";
+export { formatPairingApproveHint } from "../channels/plugins/helpers.js";
+export { getChatChannelMeta } from "../channels/registry.js";
+export { formatWhatsAppConfigAllowFromEntries, resolveWhatsAppConfigAllowFrom, resolveWhatsAppConfigDefaultTo, } from "../plugin-sdk/channel-config-helpers.js";
+export { listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, } from "../channels/plugins/directory-config.js";
+export { hasAnyWhatsAppAuth, listEnabledWhatsAppAccounts, resolveWhatsAppAccount, } from "../whatsapp/accounts.js";
+export { WA_WEB_AUTH_DIR, logWebSelfId, logoutWeb, pickWebChannel, webAuthExists, } from "../whatsapp/auth-store.js";
+export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, monitorWebChannel, resolveHeartbeatRecipients, runWebHeartbeatOnce, } from "../whatsapp/auto-reply.js";
+export { extractMediaPlaceholder, extractText, monitorWebInbox } from "../whatsapp/inbound.js";
+export { loginWeb } from "../whatsapp/login.js";
+export { getDefaultLocalRoots, loadWebMedia, loadWebMediaRaw, optimizeImageToJpeg, } from "../whatsapp/media.js";
+export { sendMessageWhatsApp, sendPollWhatsApp, sendReactionWhatsApp } from "../whatsapp/send.js";
+export { createWaSocket, formatError, getStatusCode, waitForWaConnection, } from "../whatsapp/session.js";
+export { createWhatsAppLoginTool } from "../whatsapp/agent-tools-login.js";
+export { normalizeWhatsAppAllowFromEntries } from "../channels/plugins/normalize/whatsapp.js";
+export { collectAllowlistProviderGroupPolicyWarnings, collectOpenGroupPolicyRouteAllowlistWarnings, } from "../channels/plugins/group-policy-warnings.js";
+export { buildAccountScopedDmSecurityPolicy } from "../channels/plugins/helpers.js";
+export { resolveWhatsAppOutboundTarget } from "../whatsapp/resolve-outbound-target.js";
+export { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, } from "../config/runtime-group-policy.js";
+export { resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, } from "../channels/plugins/group-mentions.js";
+export { createWhatsAppOutboundBase, resolveWhatsAppGroupIntroHint, resolveWhatsAppMentionStripRegexes, } from "../channels/plugins/whatsapp-shared.js";
+export { resolveWhatsAppHeartbeatRecipients } from "../channels/plugins/whatsapp-heartbeat.js";
+export { WhatsAppConfigSchema } from "../config/zod-schema.providers-whatsapp.js";
+export { createActionGate, readStringParam } from "../agents/tools/common.js";
+export { createPluginRuntimeStore } from "../plugin-sdk/runtime-store.js";
+export { normalizeE164 } from "../utils.js";

package/dist/routing/session-key.js

@@ -1,186 +1,5 @@
-import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
-import { normalizeAccountId } from "./account-id.js";
-export { getSubagentDepth, isCronSessionKey, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, } from "../sessions/session-key-utils.js";
-export { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId, } from "./account-id.js";
-export const DEFAULT_AGENT_ID = "main";
-export const DEFAULT_MAIN_KEY = "main";
-// Pre-compiled regex
-const VALID_ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
-const INVALID_CHARS_RE = /[^a-z0-9_-]+/g;
-const LEADING_DASH_RE = /^-+/;
-const TRAILING_DASH_RE = /-+$/;
-function normalizeToken(value) {
-    return (value ?? "").trim().toLowerCase();
-}
-export function normalizeMainKey(value) {
-    const trimmed = (value ?? "").trim();
-    return trimmed ? trimmed.toLowerCase() : DEFAULT_MAIN_KEY;
-}
-export function toAgentRequestSessionKey(storeKey) {
-    const raw = (storeKey ?? "").trim();
-    if (!raw) {
-        return undefined;
-    }
-    return parseAgentSessionKey(raw)?.rest ?? raw;
-}
-export function toAgentStoreSessionKey(params) {
-    const raw = (params.requestKey ?? "").trim();
-    if (!raw || raw === DEFAULT_MAIN_KEY) {
-        return buildAgentMainSessionKey({ agentId: params.agentId, mainKey: params.mainKey });
-    }
-    const lowered = raw.toLowerCase();
-    if (lowered.startsWith("agent:")) {
-        return lowered;
-    }
-    if (lowered.startsWith("subagent:")) {
-        return `agent:${normalizeAgentId(params.agentId)}:${lowered}`;
-    }
-    return `agent:${normalizeAgentId(params.agentId)}:${lowered}`;
-}
-export function resolveAgentIdFromSessionKey(sessionKey) {
-    const parsed = parseAgentSessionKey(sessionKey);
-    return normalizeAgentId(parsed?.agentId ?? DEFAULT_AGENT_ID);
-}
-export function classifySessionKeyShape(sessionKey) {
-    const raw = (sessionKey ?? "").trim();
-    if (!raw) {
-        return "missing";
-    }
-    if (parseAgentSessionKey(raw)) {
-        return "agent";
-    }
-    return raw.toLowerCase().startsWith("agent:") ? "malformed_agent" : "legacy_or_alias";
-}
-export function normalizeAgentId(value) {
-    const trimmed = (value ?? "").trim();
-    if (!trimmed) {
-        return DEFAULT_AGENT_ID;
-    }
-    // Keep it path-safe + shell-friendly.
-    if (VALID_ID_RE.test(trimmed)) {
-        return trimmed.toLowerCase();
-    }
-    // Best-effort fallback: collapse invalid characters to "-"
-    return (trimmed
-        .toLowerCase()
-        .replace(INVALID_CHARS_RE, "-")
-        .replace(LEADING_DASH_RE, "")
-        .replace(TRAILING_DASH_RE, "")
-        .slice(0, 64) || DEFAULT_AGENT_ID);
-}
-export function sanitizeAgentId(value) {
-    const trimmed = (value ?? "").trim();
-    if (!trimmed) {
-        return DEFAULT_AGENT_ID;
-    }
-    if (VALID_ID_RE.test(trimmed)) {
-        return trimmed.toLowerCase();
-    }
-    return (trimmed
-        .toLowerCase()
-        .replace(INVALID_CHARS_RE, "-")
-        .replace(LEADING_DASH_RE, "")
-        .replace(TRAILING_DASH_RE, "")
-        .slice(0, 64) || DEFAULT_AGENT_ID);
-}
-export function buildAgentMainSessionKey(params) {
-    const agentId = normalizeAgentId(params.agentId);
-    const mainKey = normalizeMainKey(params.mainKey);
-    return `agent:${agentId}:${mainKey}`;
-}
-export function buildAgentPeerSessionKey(params) {
-    const peerKind = params.peerKind ?? "direct";
-    if (peerKind === "direct") {
-        const dmScope = params.dmScope ?? "main";
-        let peerId = (params.peerId ?? "").trim();
-        const linkedPeerId = dmScope === "main"
-            ? null
-            : resolveLinkedPeerId({
-                identityLinks: params.identityLinks,
-                channel: params.channel,
-                peerId,
-            });
-        if (linkedPeerId) {
-            peerId = linkedPeerId;
-        }
-        peerId = peerId.toLowerCase();
-        if (dmScope === "per-account-channel-peer" && peerId) {
-            const channel = (params.channel ?? "").trim().toLowerCase() || "unknown";
-            const accountId = normalizeAccountId(params.accountId);
-            return `agent:${normalizeAgentId(params.agentId)}:${channel}:${accountId}:direct:${peerId}`;
-        }
-        if (dmScope === "per-channel-peer" && peerId) {
-            const channel = (params.channel ?? "").trim().toLowerCase() || "unknown";
-            return `agent:${normalizeAgentId(params.agentId)}:${channel}:direct:${peerId}`;
-        }
-        if (dmScope === "per-peer" && peerId) {
-            return `agent:${normalizeAgentId(params.agentId)}:direct:${peerId}`;
-        }
-        return buildAgentMainSessionKey({
-            agentId: params.agentId,
-            mainKey: params.mainKey,
-        });
-    }
-    const channel = (params.channel ?? "").trim().toLowerCase() || "unknown";
-    const peerId = ((params.peerId ?? "").trim() || "unknown").toLowerCase();
-    return `agent:${normalizeAgentId(params.agentId)}:${channel}:${peerKind}:${peerId}`;
-}
-function resolveLinkedPeerId(params) {
-    const identityLinks = params.identityLinks;
-    if (!identityLinks) {
-        return null;
-    }
-    const peerId = params.peerId.trim();
-    if (!peerId) {
-        return null;
-    }
-    const candidates = new Set();
-    const rawCandidate = normalizeToken(peerId);
-    if (rawCandidate) {
-        candidates.add(rawCandidate);
-    }
-    const channel = normalizeToken(params.channel);
-    if (channel) {
-        const scopedCandidate = normalizeToken(`${channel}:${peerId}`);
-        if (scopedCandidate) {
-            candidates.add(scopedCandidate);
-        }
-    }
-    if (candidates.size === 0) {
-        return null;
-    }
-    for (const [canonical, ids] of Object.entries(identityLinks)) {
-        const canonicalName = canonical.trim();
-        if (!canonicalName) {
-            continue;
-        }
-        if (!Array.isArray(ids)) {
-            continue;
-        }
-        for (const id of ids) {
-            const normalized = normalizeToken(id);
-            if (normalized && candidates.has(normalized)) {
-                return canonicalName;
-            }
-        }
-    }
-    return null;
-}
-export function buildGroupHistoryKey(params) {
-    const channel = normalizeToken(params.channel) || "unknown";
-    const accountId = normalizeAccountId(params.accountId);
-    const peerId = params.peerId.trim().toLowerCase() || "unknown";
-    return `${channel}:${accountId}:${params.peerKind}:${peerId}`;
-}
-export function resolveThreadSessionKeys(params) {
-    const threadId = (params.threadId ?? "").trim();
-    if (!threadId) {
-        return { sessionKey: params.baseSessionKey, parentSessionKey: undefined };
-    }
-    const normalizedThreadId = threadId.toLowerCase();
-    const useSuffix = params.useSuffix ?? true;
-    const sessionKey = useSuffix
-        ? `${params.baseSessionKey}:thread:${normalizedThreadId}`
-        : params.baseSessionKey;
-    return { sessionKey, parentSessionKey: params.parentSessionKey };
+// Stub for routing/session-key.js
+export const DEFAULT_ACCOUNT_ID = "default";
+export function normalizeAccountId(accountId) {
+    return accountId?.trim() || DEFAULT_ACCOUNT_ID;
 }

package/dist/shared/pid-alive.js

@@ -1,69 +1,10 @@
-import fsSync from "node:fs";
-function isValidPid(pid) {
-    return Number.isInteger(pid) && pid > 0;
-}
-/**
- * Check if a process is a zombie on Linux by reading /proc/<pid>/status.
- * Returns false on non-Linux platforms or if the proc file can't be read.
- */
-function isZombieProcess(pid) {
-    if (process.platform !== "linux") {
-        return false;
-    }
-    try {
-        const status = fsSync.readFileSync(`/proc/${pid}/status`, "utf8");
-        const stateMatch = status.match(/^State:\s+(\S)/m);
-        return stateMatch?.[1] === "Z";
-    }
-    catch {
-        return false;
-    }
-}
+// Stub for shared/pid-alive.js
 export function isPidAlive(pid) {
-    if (!isValidPid(pid)) {
-        return false;
-    }
     try {
         process.kill(pid, 0);
+        return true;
     }
     catch {
         return false;
     }
-    if (isZombieProcess(pid)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Read the process start time (field 22 "starttime") from /proc/<pid>/stat.
- * Returns the value in clock ticks since system boot, or null on non-Linux
- * platforms or if the proc file can't be read.
- *
- * This is used to detect PID recycling: if two readings for the same PID
- * return different starttimes, the PID has been reused by a different process.
- */
-export function getProcessStartTime(pid) {
-    if (process.platform !== "linux") {
-        return null;
-    }
-    if (!isValidPid(pid)) {
-        return null;
-    }
-    try {
-        const stat = fsSync.readFileSync(`/proc/${pid}/stat`, "utf8");
-        const commEndIndex = stat.lastIndexOf(")");
-        if (commEndIndex < 0) {
-            return null;
-        }
-        // The comm field (field 2) is wrapped in parens and can contain spaces,
-        // so split after the last ")" to get fields 3..N reliably.
-        const afterComm = stat.slice(commEndIndex + 1).trimStart();
-        const fields = afterComm.split(/\s+/);
-        // field 22 (starttime) = index 19 after the comm-split (field 3 is index 0).
-        const starttime = Number(fields[19]);
-        return Number.isInteger(starttime) && starttime >= 0 ? starttime : null;
-    }
-    catch {
-        return null;
-    }
 }

package/dist/shared/process-scoped-map.js

@@ -1,10 +1,8 @@
+// Stub for shared/process-scoped-map.js
+const processScopedMaps = new Map();
 export function resolveProcessScopedMap(key) {
-    const proc = process;
-    const existing = proc[key];
-    if (existing) {
-        return existing;
+    if (!processScopedMaps.has(key)) {
+        processScopedMaps.set(key, new Map());
     }
-    const created = new Map();
-    proc[key] = created;
-    return created;
+    return processScopedMaps.get(key);
 }

package/dist/signal/channel.js

@@ -0,0 +1,264 @@
+import { buildAccountScopedDmSecurityPolicy, createScopedAccountConfigAccessors, collectAllowlistProviderRestrictSendersWarnings, } from "openclaw/plugin-sdk/compat";
+import { applyAccountNameToChannelSection, buildBaseAccountStatusSnapshot, buildBaseChannelStatusSummary, buildChannelConfigSchema, collectStatusIssuesFromLastError, createDefaultChannelRuntimeState, DEFAULT_ACCOUNT_ID, deleteAccountFromConfigSection, getChatChannelMeta, listSignalAccountIds, looksLikeSignalTargetId, migrateBaseNameToDefaultAccount, normalizeAccountId, normalizeE164, normalizeSignalMessagingTarget, PAIRING_APPROVED_MESSAGE, resolveChannelMediaMaxBytes, resolveDefaultSignalAccountId, resolveSignalAccount, setAccountEnabledInConfigSection, signalOnboardingAdapter, SignalConfigSchema, } from "openclaw/plugin-sdk/signal";
+import { resolveOutboundSendDep } from "../../../src/infra/outbound/send-deps.js";
+import { getSignalRuntime } from "./runtime.js";
+const signalMessageActions = {
+    listActions: (ctx) => getSignalRuntime().channel.signal.messageActions?.listActions?.(ctx) ?? [],
+    supportsAction: (ctx) => getSignalRuntime().channel.signal.messageActions?.supportsAction?.(ctx) ?? false,
+    handleAction: async (ctx) => {
+        const ma = getSignalRuntime().channel.signal.messageActions;
+        if (!ma?.handleAction) {
+            throw new Error("Signal message actions not available");
+        }
+        return ma.handleAction(ctx);
+    },
+};
+const meta = getChatChannelMeta("signal");
+const signalConfigAccessors = createScopedAccountConfigAccessors({
+    resolveAccount: ({ cfg, accountId }) => resolveSignalAccount({ cfg, accountId }),
+    resolveAllowFrom: (account) => account.config.allowFrom,
+    formatAllowFrom: (allowFrom) => allowFrom
+        .map((entry) => String(entry).trim())
+        .filter(Boolean)
+        .map((entry) => (entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))))
+        .filter(Boolean),
+    resolveDefaultTo: (account) => account.config.defaultTo,
+});
+function buildSignalSetupPatch(input) {
+    return {
+        ...(input.signalNumber ? { account: input.signalNumber } : {}),
+        ...(input.cliPath ? { cliPath: input.cliPath } : {}),
+        ...(input.httpUrl ? { httpUrl: input.httpUrl } : {}),
+        ...(input.httpHost ? { httpHost: input.httpHost } : {}),
+        ...(input.httpPort ? { httpPort: Number(input.httpPort) } : {}),
+    };
+}
+async function sendSignalOutbound(params) {
+    const send = resolveOutboundSendDep(params.deps, "signal") ??
+        getSignalRuntime().channel.signal.sendMessageSignal;
+    const maxBytes = resolveChannelMediaMaxBytes({
+        cfg: params.cfg,
+        resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+        accountId: params.accountId,
+    });
+    return await send(params.to, params.text, {
+        cfg: params.cfg,
+        ...(params.mediaUrl ? { mediaUrl: params.mediaUrl } : {}),
+        ...(params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {}),
+        maxBytes,
+        accountId: params.accountId ?? undefined,
+    });
+}
+export const signalPlugin = {
+    id: "signal",
+    meta: {
+        ...meta,
+    },
+    onboarding: signalOnboardingAdapter,
+    pairing: {
+        idLabel: "signalNumber",
+        normalizeAllowEntry: (entry) => entry.replace(/^signal:/i, ""),
+        notifyApproval: async ({ id }) => {
+            await getSignalRuntime().channel.signal.sendMessageSignal(id, PAIRING_APPROVED_MESSAGE);
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        reactions: true,
+    },
+    actions: signalMessageActions,
+    streaming: {
+        blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+    },
+    reload: { configPrefixes: ["channels.signal"] },
+    configSchema: buildChannelConfigSchema(SignalConfigSchema),
+    config: {
+        listAccountIds: (cfg) => listSignalAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveSignalAccount({ cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+            cfg,
+            sectionKey: "signal",
+            accountId,
+            enabled,
+            allowTopLevel: true,
+        }),
+        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+            cfg,
+            sectionKey: "signal",
+            accountId,
+            clearBaseFields: ["account", "httpUrl", "httpHost", "httpPort", "cliPath", "name"],
+        }),
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            baseUrl: account.baseUrl,
+        }),
+        ...signalConfigAccessors,
+    },
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            return buildAccountScopedDmSecurityPolicy({
+                cfg,
+                channelKey: "signal",
+                accountId,
+                fallbackAccountId: account.accountId ?? DEFAULT_ACCOUNT_ID,
+                policy: account.config.dmPolicy,
+                allowFrom: account.config.allowFrom ?? [],
+                policyPathSuffix: "dmPolicy",
+                normalizeEntry: (raw) => normalizeE164(raw.replace(/^signal:/i, "").trim()),
+            });
+        },
+        collectWarnings: ({ account, cfg }) => {
+            return collectAllowlistProviderRestrictSendersWarnings({
+                cfg,
+                providerConfigPresent: cfg.channels?.signal !== undefined,
+                configuredGroupPolicy: account.config.groupPolicy,
+                surface: "Signal groups",
+                openScope: "any member",
+                groupPolicyPath: "channels.signal.groupPolicy",
+                groupAllowFromPath: "channels.signal.groupAllowFrom",
+                mentionGated: false,
+            });
+        },
+    },
+    messaging: {
+        normalizeTarget: normalizeSignalMessagingTarget,
+        targetResolver: {
+            looksLikeId: looksLikeSignalTargetId,
+            hint: "<E.164|uuid:ID|group:ID|signal:group:ID|signal:+E.164>",
+        },
+    },
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg,
+            channelKey: "signal",
+            accountId,
+            name,
+        }),
+        validateInput: ({ input }) => {
+            if (!input.signalNumber &&
+                !input.httpUrl &&
+                !input.httpHost &&
+                !input.httpPort &&
+                !input.cliPath) {
+                return "Signal requires --signal-number or --http-url/--http-host/--http-port/--cli-path.";
+            }
+            return null;
+        },
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const namedConfig = applyAccountNameToChannelSection({
+                cfg,
+                channelKey: "signal",
+                accountId,
+                name: input.name,
+            });
+            const next = accountId !== DEFAULT_ACCOUNT_ID
+                ? migrateBaseNameToDefaultAccount({
+                    cfg: namedConfig,
+                    channelKey: "signal",
+                })
+                : namedConfig;
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        signal: {
+                            ...next.channels?.signal,
+                            enabled: true,
+                            ...buildSignalSetupPatch(input),
+                        },
+                    },
+                };
+            }
+            return {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    signal: {
+                        ...next.channels?.signal,
+                        enabled: true,
+                        accounts: {
+                            ...next.channels?.signal?.accounts,
+                            [accountId]: {
+                                ...next.channels?.signal?.accounts?.[accountId],
+                                enabled: true,
+                                ...buildSignalSetupPatch(input),
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getSignalRuntime().channel.text.chunkText(text, limit),
+        chunkerMode: "text",
+        textChunkLimit: 4000,
+        sendText: async ({ cfg, to, text, accountId, deps }) => {
+            const result = await sendSignalOutbound({
+                cfg,
+                to,
+                text,
+                accountId: accountId ?? undefined,
+                deps,
+            });
+            return { channel: "signal", ...result };
+        },
+        sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps }) => {
+            const result = await sendSignalOutbound({
+                cfg,
+                to,
+                text,
+                mediaUrl,
+                mediaLocalRoots,
+                accountId: accountId ?? undefined,
+                deps,
+            });
+            return { channel: "signal", ...result };
+        },
+    },
+    status: {
+        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+        collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("signal", accounts),
+        buildChannelSummary: ({ snapshot }) => ({
+            ...buildBaseChannelStatusSummary(snapshot),
+            baseUrl: snapshot.baseUrl ?? null,
+            probe: snapshot.probe,
+            lastProbeAt: snapshot.lastProbeAt ?? null,
+        }),
+        probeAccount: async ({ account, timeoutMs }) => {
+            const baseUrl = account.baseUrl;
+            return await getSignalRuntime().channel.signal.probeSignal(baseUrl, timeoutMs);
+        },
+        buildAccountSnapshot: ({ account, runtime, probe }) => ({
+            ...buildBaseAccountStatusSnapshot({ account, runtime, probe }),
+            baseUrl: account.baseUrl,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            ctx.setStatus({
+                accountId: account.accountId,
+                baseUrl: account.baseUrl,
+            });
+            ctx.log?.info(`[${account.accountId}] starting provider (${account.baseUrl})`);
+            // Lazy import: the monitor pulls the reply pipeline; avoid ESM init cycles.
+            return getSignalRuntime().channel.signal.monitorSignalProvider({
+                accountId: account.accountId,
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+                mediaMaxMb: account.config.mediaMaxMb,
+            });
+        },
+    },
+};