@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/slack/monitor/reconnect-policy.js

@@ -0,0 +1,78 @@
+const SLACK_AUTH_ERROR_RE = /account_inactive|invalid_auth|token_revoked|token_expired|not_authed|org_login_required|team_access_not_granted|missing_scope|cannot_find_service|invalid_token/i;
+export const SLACK_SOCKET_RECONNECT_POLICY = {
+    initialMs: 2_000,
+    maxMs: 30_000,
+    factor: 1.8,
+    jitter: 0.25,
+    maxAttempts: 12,
+};
+export function getSocketEmitter(app) {
+    const receiver = app.receiver;
+    const client = receiver && typeof receiver === "object"
+        ? receiver.client
+        : undefined;
+    if (!client || typeof client !== "object") {
+        return null;
+    }
+    const on = client.on;
+    const off = client.off;
+    if (typeof on !== "function" || typeof off !== "function") {
+        return null;
+    }
+    return {
+        on: (event, listener) => on.call(client, event, listener),
+        off: (event, listener) => off.call(client, event, listener),
+    };
+}
+export function waitForSlackSocketDisconnect(app, abortSignal) {
+    return new Promise((resolve) => {
+        const emitter = getSocketEmitter(app);
+        if (!emitter) {
+            abortSignal?.addEventListener("abort", () => resolve({ event: "disconnect" }), {
+                once: true,
+            });
+            return;
+        }
+        const disconnectListener = () => resolveOnce({ event: "disconnect" });
+        const startFailListener = (error) => resolveOnce({ event: "unable_to_socket_mode_start", error });
+        const errorListener = (error) => resolveOnce({ event: "error", error });
+        const abortListener = () => resolveOnce({ event: "disconnect" });
+        const cleanup = () => {
+            emitter.off("disconnected", disconnectListener);
+            emitter.off("unable_to_socket_mode_start", startFailListener);
+            emitter.off("error", errorListener);
+            abortSignal?.removeEventListener("abort", abortListener);
+        };
+        const resolveOnce = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        emitter.on("disconnected", disconnectListener);
+        emitter.on("unable_to_socket_mode_start", startFailListener);
+        emitter.on("error", errorListener);
+        abortSignal?.addEventListener("abort", abortListener, { once: true });
+    });
+}
+/**
+ * Detect non-recoverable Slack API / auth errors that should NOT be retried.
+ * These indicate permanent credential problems (revoked bot, deactivated account, etc.)
+ * and retrying will never succeed — continuing to retry blocks the entire gateway.
+ */
+export function isNonRecoverableSlackAuthError(error) {
+    const msg = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+    return SLACK_AUTH_ERROR_RE.test(msg);
+}
+export function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return "unknown error";
+    }
+}

package/dist/slack/monitor/slash-commands.runtime.js

@@ -0,0 +1 @@
+export { buildCommandTextFromArgs, findCommandByNativeName, listNativeCommandSpecsForConfig, parseCommandArgs, resolveCommandArgMenu, } from "../../../../src/auto-reply/commands-registry.js";

package/dist/slack/monitor/slash-dispatch.runtime.js

@@ -0,0 +1,9 @@
+export { resolveChunkMode } from "../../../../src/auto-reply/chunk.js";
+export { finalizeInboundContext } from "../../../../src/auto-reply/reply/inbound-context.js";
+export { dispatchReplyWithDispatcher } from "../../../../src/auto-reply/reply/provider-dispatcher.js";
+export { resolveConversationLabel } from "../../../../src/channels/conversation-label.js";
+export { createReplyPrefixOptions } from "../../../../src/channels/reply-prefix.js";
+export { recordInboundSessionMetaSafe } from "../../../../src/channels/session-meta.js";
+export { resolveMarkdownTableMode } from "../../../../src/config/markdown-tables.js";
+export { resolveAgentRoute } from "../../../../src/routing/resolve-route.js";
+export { deliverSlackSlashReplies } from "./replies.js";

package/dist/slack/monitor/slash-skill-commands.runtime.js

@@ -0,0 +1 @@
+export { listSkillCommandsForAgents } from "../../../../src/auto-reply/skill-commands.js";

package/dist/slack/resolve-allowlist-common.js

@@ -0,0 +1,36 @@
+function readSlackNextCursor(response) {
+    const next = response.response_metadata?.next_cursor?.trim();
+    return next ? next : undefined;
+}
+export async function collectSlackCursorItems(params) {
+    const items = [];
+    let cursor;
+    do {
+        const response = await params.fetchPage(cursor);
+        items.push(...params.collectPageItems(response));
+        cursor = readSlackNextCursor(response);
+    } while (cursor);
+    return items;
+}
+export function resolveSlackAllowlistEntries(params) {
+    const results = [];
+    for (const input of params.entries) {
+        const parsed = params.parseInput(input);
+        if (parsed.id) {
+            const match = params.findById(params.lookup, parsed.id);
+            results.push(params.buildIdResolved({ input, parsed, match }));
+            continue;
+        }
+        const resolved = params.resolveNonId({
+            input,
+            parsed,
+            lookup: params.lookup,
+        });
+        if (resolved) {
+            results.push(resolved);
+            continue;
+        }
+        results.push(params.buildUnresolved(input));
+    }
+    return results;
+}

package/dist/slack/runtime.js

@@ -0,0 +1,3 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
+const { setRuntime: setSlackRuntime, getRuntime: getSlackRuntime } = createPluginRuntimeStore("Slack runtime not initialized");
+export { getSlackRuntime, setSlackRuntime };

package/dist/slack/sent-thread-cache.js

@@ -0,0 +1,61 @@
+import { resolveGlobalMap } from "../../../src/shared/global-singleton.js";
+/**
+ * In-memory cache of Slack threads the bot has participated in.
+ * Used to auto-respond in threads without requiring @mention after the first reply.
+ * Follows a similar TTL pattern to the MS Teams and Telegram sent-message caches.
+ */
+const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_ENTRIES = 5000;
+/**
+ * Keep Slack thread participation shared across bundled chunks so thread
+ * auto-reply gating does not diverge between prepare/dispatch call paths.
+ */
+const SLACK_THREAD_PARTICIPATION_KEY = Symbol.for("openclaw.slackThreadParticipation");
+const threadParticipation = resolveGlobalMap(SLACK_THREAD_PARTICIPATION_KEY);
+function makeKey(accountId, channelId, threadTs) {
+    return `${accountId}:${channelId}:${threadTs}`;
+}
+function evictExpired() {
+    const now = Date.now();
+    for (const [key, timestamp] of threadParticipation) {
+        if (now - timestamp > TTL_MS) {
+            threadParticipation.delete(key);
+        }
+    }
+}
+function evictOldest() {
+    const oldest = threadParticipation.keys().next().value;
+    if (oldest) {
+        threadParticipation.delete(oldest);
+    }
+}
+export function recordSlackThreadParticipation(accountId, channelId, threadTs) {
+    if (!accountId || !channelId || !threadTs) {
+        return;
+    }
+    if (threadParticipation.size >= MAX_ENTRIES) {
+        evictExpired();
+    }
+    if (threadParticipation.size >= MAX_ENTRIES) {
+        evictOldest();
+    }
+    threadParticipation.set(makeKey(accountId, channelId, threadTs), Date.now());
+}
+export function hasSlackThreadParticipation(accountId, channelId, threadTs) {
+    if (!accountId || !channelId || !threadTs) {
+        return false;
+    }
+    const key = makeKey(accountId, channelId, threadTs);
+    const timestamp = threadParticipation.get(key);
+    if (timestamp == null) {
+        return false;
+    }
+    if (Date.now() - timestamp > TTL_MS) {
+        threadParticipation.delete(key);
+        return false;
+    }
+    return true;
+}
+export function clearSlackThreadParticipationCache() {
+    threadParticipation.clear();
+}

package/dist/slack/truncate.js

@@ -0,0 +1,10 @@
+export function truncateSlackText(value, max) {
+    const trimmed = value.trim();
+    if (trimmed.length <= max) {
+        return trimmed;
+    }
+    if (max <= 1) {
+        return trimmed.slice(0, max);
+    }
+    return `${trimmed.slice(0, max - 1)}…`;
+}

package/dist/telegram/account-inspect.js

@@ -0,0 +1,175 @@
+import { coerceSecretRef, hasConfiguredSecretInput, normalizeSecretInputString, } from "../../../src/config/types.secrets.js";
+import { tryReadSecretFileSync } from "../../../src/infra/secret-file.js";
+import { resolveAccountWithDefaultFallback } from "../../../src/plugin-sdk/account-resolution.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../../../src/routing/session-key.js";
+import { resolveDefaultSecretProviderAlias } from "../../../src/secrets/ref-contract.js";
+import { mergeTelegramAccountConfig, resolveDefaultTelegramAccountId, resolveTelegramAccountConfig, } from "./accounts.js";
+function inspectTokenFile(pathValue) {
+    const tokenFile = typeof pathValue === "string" ? pathValue.trim() : "";
+    if (!tokenFile) {
+        return null;
+    }
+    const token = tryReadSecretFileSync(tokenFile, "Telegram bot token", {
+        rejectSymlink: true,
+    });
+    return {
+        token: token ?? "",
+        tokenSource: "tokenFile",
+        tokenStatus: token ? "available" : "configured_unavailable",
+    };
+}
+function canResolveEnvSecretRefInReadOnlyPath(params) {
+    const providerConfig = params.cfg.secrets?.providers?.[params.provider];
+    if (!providerConfig) {
+        return params.provider === resolveDefaultSecretProviderAlias(params.cfg, "env");
+    }
+    if (providerConfig.source !== "env") {
+        return false;
+    }
+    const allowlist = providerConfig.allowlist;
+    return !allowlist || allowlist.includes(params.id);
+}
+function inspectTokenValue(params) {
+    // Try to resolve env-based SecretRefs from process.env for read-only inspection
+    const ref = coerceSecretRef(params.value, params.cfg.secrets?.defaults);
+    if (ref?.source === "env") {
+        if (!canResolveEnvSecretRefInReadOnlyPath({
+            cfg: params.cfg,
+            provider: ref.provider,
+            id: ref.id,
+        })) {
+            return {
+                token: "",
+                tokenSource: "env",
+                tokenStatus: "configured_unavailable",
+            };
+        }
+        const envValue = process.env[ref.id];
+        if (envValue && envValue.trim()) {
+            return {
+                token: envValue.trim(),
+                tokenSource: "env",
+                tokenStatus: "available",
+            };
+        }
+        return {
+            token: "",
+            tokenSource: "env",
+            tokenStatus: "configured_unavailable",
+        };
+    }
+    const token = normalizeSecretInputString(params.value);
+    if (token) {
+        return {
+            token,
+            tokenSource: "config",
+            tokenStatus: "available",
+        };
+    }
+    if (hasConfiguredSecretInput(params.value, params.cfg.secrets?.defaults)) {
+        return {
+            token: "",
+            tokenSource: "config",
+            tokenStatus: "configured_unavailable",
+        };
+    }
+    return null;
+}
+function inspectTelegramAccountPrimary(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const merged = mergeTelegramAccountConfig(params.cfg, accountId);
+    const enabled = params.cfg.channels?.telegram?.enabled !== false && merged.enabled !== false;
+    const accountConfig = resolveTelegramAccountConfig(params.cfg, accountId);
+    const accountTokenFile = inspectTokenFile(accountConfig?.tokenFile);
+    if (accountTokenFile) {
+        return {
+            accountId,
+            enabled,
+            name: merged.name?.trim() || undefined,
+            token: accountTokenFile.token,
+            tokenSource: accountTokenFile.tokenSource,
+            tokenStatus: accountTokenFile.tokenStatus,
+            configured: accountTokenFile.tokenStatus !== "missing",
+            config: merged,
+        };
+    }
+    const accountToken = inspectTokenValue({ cfg: params.cfg, value: accountConfig?.botToken });
+    if (accountToken) {
+        return {
+            accountId,
+            enabled,
+            name: merged.name?.trim() || undefined,
+            token: accountToken.token,
+            tokenSource: accountToken.tokenSource,
+            tokenStatus: accountToken.tokenStatus,
+            configured: accountToken.tokenStatus !== "missing",
+            config: merged,
+        };
+    }
+    const channelTokenFile = inspectTokenFile(params.cfg.channels?.telegram?.tokenFile);
+    if (channelTokenFile) {
+        return {
+            accountId,
+            enabled,
+            name: merged.name?.trim() || undefined,
+            token: channelTokenFile.token,
+            tokenSource: channelTokenFile.tokenSource,
+            tokenStatus: channelTokenFile.tokenStatus,
+            configured: channelTokenFile.tokenStatus !== "missing",
+            config: merged,
+        };
+    }
+    const channelToken = inspectTokenValue({
+        cfg: params.cfg,
+        value: params.cfg.channels?.telegram?.botToken,
+    });
+    if (channelToken) {
+        return {
+            accountId,
+            enabled,
+            name: merged.name?.trim() || undefined,
+            token: channelToken.token,
+            tokenSource: channelToken.tokenSource,
+            tokenStatus: channelToken.tokenStatus,
+            configured: channelToken.tokenStatus !== "missing",
+            config: merged,
+        };
+    }
+    const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+    const envToken = allowEnv ? (params.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim() : "";
+    if (envToken) {
+        return {
+            accountId,
+            enabled,
+            name: merged.name?.trim() || undefined,
+            token: envToken,
+            tokenSource: "env",
+            tokenStatus: "available",
+            configured: true,
+            config: merged,
+        };
+    }
+    return {
+        accountId,
+        enabled,
+        name: merged.name?.trim() || undefined,
+        token: "",
+        tokenSource: "none",
+        tokenStatus: "missing",
+        configured: false,
+        config: merged,
+    };
+}
+export function inspectTelegramAccount(params) {
+    return resolveAccountWithDefaultFallback({
+        accountId: params.accountId,
+        normalizeAccountId,
+        resolvePrimary: (accountId) => inspectTelegramAccountPrimary({
+            cfg: params.cfg,
+            accountId,
+            envToken: params.envToken,
+        }),
+        hasCredential: (account) => account.tokenSource !== "none",
+        resolveDefaultAccountId: () => resolveDefaultTelegramAccountId(params.cfg),
+    });
+}

package/dist/telegram/allow-from.js

@@ -0,0 +1,10 @@
+export function normalizeTelegramAllowFromEntry(raw) {
+    const base = typeof raw === "string" ? raw : typeof raw === "number" ? String(raw) : "";
+    return base
+        .trim()
+        .replace(/^(telegram|tg):/i, "")
+        .trim();
+}
+export function isNumericTelegramUserId(raw) {
+    return /^-?\d+$/.test(raw);
+}

package/dist/telegram/api-fetch.js

@@ -0,0 +1,18 @@
+export async function fetchTelegramChatId(params) {
+    const url = `https://api.telegram.org/bot${params.token}/getChat?chat_id=${encodeURIComponent(params.chatId)}`;
+    try {
+        const res = await fetch(url, params.signal ? { signal: params.signal } : undefined);
+        if (!res.ok) {
+            return null;
+        }
+        const data = (await res.json().catch(() => null));
+        const id = data?.ok ? data?.result?.id : undefined;
+        if (typeof id === "number" || typeof id === "string") {
+            return String(id);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/telegram/approval-buttons.js

@@ -0,0 +1,30 @@
+const MAX_CALLBACK_DATA_BYTES = 64;
+function fitsCallbackData(value) {
+    return Buffer.byteLength(value, "utf8") <= MAX_CALLBACK_DATA_BYTES;
+}
+export function buildTelegramExecApprovalButtons(approvalId) {
+    return buildTelegramExecApprovalButtonsForDecisions(approvalId, [
+        "allow-once",
+        "allow-always",
+        "deny",
+    ]);
+}
+function buildTelegramExecApprovalButtonsForDecisions(approvalId, allowedDecisions) {
+    const allowOnce = `/approve ${approvalId} allow-once`;
+    if (!allowedDecisions.includes("allow-once") || !fitsCallbackData(allowOnce)) {
+        return undefined;
+    }
+    const primaryRow = [
+        { text: "Allow Once", callback_data: allowOnce },
+    ];
+    const allowAlways = `/approve ${approvalId} allow-always`;
+    if (allowedDecisions.includes("allow-always") && fitsCallbackData(allowAlways)) {
+        primaryRow.push({ text: "Allow Always", callback_data: allowAlways });
+    }
+    const rows = [primaryRow];
+    const deny = `/approve ${approvalId} deny`;
+    if (allowedDecisions.includes("deny") && fitsCallbackData(deny)) {
+        rows.push([{ text: "Deny", callback_data: deny }]);
+    }
+    return rows;
+}

package/dist/telegram/audit-membership-runtime.js

@@ -0,0 +1,61 @@
+import { isRecord } from "../../../src/utils.js";
+import { fetchWithTimeout } from "../../../src/utils/fetch-timeout.js";
+import { resolveTelegramFetch } from "./fetch.js";
+import { makeProxyFetch } from "./proxy.js";
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+export async function auditTelegramGroupMembershipImpl(params) {
+    const proxyFetch = params.proxyUrl ? makeProxyFetch(params.proxyUrl) : undefined;
+    const fetcher = resolveTelegramFetch(proxyFetch, { network: params.network });
+    const base = `${TELEGRAM_API_BASE}/bot${params.token}`;
+    const groups = [];
+    for (const chatId of params.groupIds) {
+        try {
+            const url = `${base}/getChatMember?chat_id=${encodeURIComponent(chatId)}&user_id=${encodeURIComponent(String(params.botId))}`;
+            const res = await fetchWithTimeout(url, {}, params.timeoutMs, fetcher);
+            const json = (await res.json());
+            if (!res.ok || !isRecord(json) || !json.ok) {
+                const desc = isRecord(json) && !json.ok && typeof json.description === "string"
+                    ? json.description
+                    : `getChatMember failed (${res.status})`;
+                groups.push({
+                    chatId,
+                    ok: false,
+                    status: null,
+                    error: desc,
+                    matchKey: chatId,
+                    matchSource: "id",
+                });
+                continue;
+            }
+            const status = isRecord(json.result)
+                ? (json.result.status ?? null)
+                : null;
+            const ok = status === "creator" || status === "administrator" || status === "member";
+            groups.push({
+                chatId,
+                ok,
+                status,
+                error: ok ? null : "bot not in group",
+                matchKey: chatId,
+                matchSource: "id",
+            });
+        }
+        catch (err) {
+            groups.push({
+                chatId,
+                ok: false,
+                status: null,
+                error: err instanceof Error ? err.message : String(err),
+                matchKey: chatId,
+                matchSource: "id",
+            });
+        }
+    }
+    return {
+        ok: groups.every((g) => g.ok),
+        checkedGroups: groups.length,
+        unresolvedGroups: 0,
+        hasWildcardUnmentionedGroups: false,
+        groups,
+    };
+}