@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/dist/telegram/group-access.js

@@ -0,0 +1,65 @@
+import { isSenderAllowed } from "./bot-access.js";
+import { firstDefined } from "./bot-access.js";
+export const evaluateTelegramGroupBaseAccess = (params) => {
+    if (!params.isGroup) {
+        return { allowed: true };
+    }
+    if (params.groupConfig?.enabled === false) {
+        return { allowed: false, reason: "group-disabled" };
+    }
+    if (params.topicConfig?.enabled === false) {
+        return { allowed: false, reason: "topic-disabled" };
+    }
+    if (!params.enforceAllowOverride || !params.hasGroupAllowOverride) {
+        return { allowed: true };
+    }
+    const senderId = params.senderId ?? "";
+    if (params.requireSenderForAllowOverride && !senderId) {
+        return { allowed: false, reason: "group-override-unauthorized" };
+    }
+    const allowed = isSenderAllowed({
+        allow: params.effectiveGroupAllow,
+        senderId,
+        senderUsername: params.senderUsername ?? "",
+    });
+    if (!allowed) {
+        return { allowed: false, reason: "group-override-unauthorized" };
+    }
+    return { allowed: true };
+};
+export const evaluateTelegramGroupPolicyAccess = (params) => {
+    const fallbackPolicy = firstDefined(params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy, "open") ?? "open";
+    const groupPolicy = params.useTopicAndGroupOverrides
+        ? (firstDefined(params.topicConfig?.groupPolicy, params.groupConfig?.groupPolicy, params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy, "open") ?? "open")
+        : fallbackPolicy;
+    if (!params.isGroup || !params.enforcePolicy) {
+        return { allowed: true, groupPolicy };
+    }
+    if (groupPolicy === "disabled") {
+        return { allowed: false, reason: "group-policy-disabled", groupPolicy };
+    }
+    if (groupPolicy === "allowlist" && params.enforceAllowlistAuthorization) {
+        const senderId = params.senderId ?? "";
+        if (params.requireSenderForAllowlistAuthorization && !senderId) {
+            return { allowed: false, reason: "group-policy-allowlist-no-sender", groupPolicy };
+        }
+        if (!params.allowEmptyAllowlistEntries && !params.effectiveGroupAllow.hasEntries) {
+            return { allowed: false, reason: "group-policy-allowlist-empty", groupPolicy };
+        }
+        const senderUsername = params.senderUsername ?? "";
+        if (!isSenderAllowed({
+            allow: params.effectiveGroupAllow,
+            senderId,
+            senderUsername,
+        })) {
+            return { allowed: false, reason: "group-policy-allowlist-unauthorized", groupPolicy };
+        }
+    }
+    if (params.checkChatAllowlist) {
+        const groupAllowlist = params.resolveGroupPolicy(params.chatId);
+        if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) {
+            return { allowed: false, reason: "group-chat-not-allowed", groupPolicy };
+        }
+    }
+    return { allowed: true, groupPolicy };
+};

package/dist/telegram/outbound-params.js

@@ -0,0 +1,21 @@
+export function parseTelegramReplyToMessageId(replyToId) {
+    if (!replyToId) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(replyToId, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+export function parseTelegramThreadId(threadId) {
+    if (threadId == null) {
+        return undefined;
+    }
+    if (typeof threadId === "number") {
+        return Number.isFinite(threadId) ? Math.trunc(threadId) : undefined;
+    }
+    const trimmed = threadId.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/telegram/poll-vote-cache.js

@@ -0,0 +1,21 @@
+const TTL_MS = 24 * 60 * 60 * 1000;
+const pollById = new Map();
+function cleanupExpired() {
+    const now = Date.now();
+    for (const [pollId, poll] of pollById) {
+        if (now - poll.createdAt > TTL_MS) {
+            pollById.delete(pollId);
+        }
+    }
+}
+export function recordSentPoll(poll) {
+    cleanupExpired();
+    pollById.set(poll.pollId, { ...poll, createdAt: Date.now() });
+}
+export function getSentPoll(pollId) {
+    cleanupExpired();
+    return pollById.get(pollId);
+}
+export function clearSentPollCache() {
+    pollById.clear();
+}

package/dist/terminal/health-style.js

@@ -0,0 +1,36 @@
+import { theme } from "./theme.js";
+export function styleHealthChannelLine(line, rich) {
+    if (!rich) {
+        return line;
+    }
+    const colon = line.indexOf(":");
+    if (colon === -1) {
+        return line;
+    }
+    const label = line.slice(0, colon + 1);
+    const detail = line.slice(colon + 1).trimStart();
+    const normalized = detail.toLowerCase();
+    const applyPrefix = (prefix, color) => `${label} ${color(detail.slice(0, prefix.length))}${detail.slice(prefix.length)}`;
+    if (normalized.startsWith("failed")) {
+        return applyPrefix("failed", theme.error);
+    }
+    if (normalized.startsWith("ok")) {
+        return applyPrefix("ok", theme.success);
+    }
+    if (normalized.startsWith("linked")) {
+        return applyPrefix("linked", theme.success);
+    }
+    if (normalized.startsWith("configured")) {
+        return applyPrefix("configured", theme.success);
+    }
+    if (normalized.startsWith("not linked")) {
+        return applyPrefix("not linked", theme.warn);
+    }
+    if (normalized.startsWith("not configured")) {
+        return applyPrefix("not configured", theme.muted);
+    }
+    if (normalized.startsWith("unknown")) {
+        return applyPrefix("unknown", theme.warn);
+    }
+    return line;
+}

package/dist/test-utils/chunk-test-helpers.js

@@ -0,0 +1,21 @@
+export function countLines(text) {
+    return text.split("\n").length;
+}
+export function hasBalancedFences(chunk) {
+    let open = null;
+    for (const line of chunk.split("\n")) {
+        const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
+        if (!match) {
+            continue;
+        }
+        const marker = match[2];
+        if (!open) {
+            open = { markerChar: marker[0], markerLen: marker.length };
+            continue;
+        }
+        if (open.markerChar === marker[0] && marker.length >= open.markerLen) {
+            open = null;
+        }
+    }
+    return open === null;
+}

package/dist/test-utils/env.js

@@ -0,0 +1,72 @@
+export function captureEnv(keys) {
+    const snapshot = new Map();
+    for (const key of keys) {
+        snapshot.set(key, process.env[key]);
+    }
+    return {
+        restore() {
+            for (const [key, value] of snapshot) {
+                if (value === undefined) {
+                    delete process.env[key];
+                }
+                else {
+                    process.env[key] = value;
+                }
+            }
+        },
+    };
+}
+export function captureFullEnv() {
+    const snapshot = { ...process.env };
+    return {
+        restore() {
+            for (const key of Object.keys(process.env)) {
+                if (!(key in snapshot)) {
+                    delete process.env[key];
+                }
+            }
+            for (const [key, value] of Object.entries(snapshot)) {
+                if (value === undefined) {
+                    delete process.env[key];
+                }
+                else {
+                    process.env[key] = value;
+                }
+            }
+        },
+    };
+}
+export function withEnv(env, fn) {
+    const snapshot = captureEnv(Object.keys(env));
+    try {
+        for (const [key, value] of Object.entries(env)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+        return fn();
+    }
+    finally {
+        snapshot.restore();
+    }
+}
+export async function withEnvAsync(env, fn) {
+    const snapshot = captureEnv(Object.keys(env));
+    try {
+        for (const [key, value] of Object.entries(env)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+        return await fn();
+    }
+    finally {
+        snapshot.restore();
+    }
+}

package/dist/test-utils/exec-assertions.js

@@ -0,0 +1,12 @@
+import { expect } from "vitest";
+export function expectSingleNpmInstallIgnoreScriptsCall(params) {
+    const npmCalls = params.calls.filter((call) => Array.isArray(call[0]) && call[0][0] === "npm");
+    expect(npmCalls.length).toBe(1);
+    const first = npmCalls[0];
+    if (!first) {
+        throw new Error("expected npm install call");
+    }
+    const [argv, opts] = first;
+    expect(argv).toEqual(["npm", "install", "--omit=dev", "--silent", "--ignore-scripts"]);
+    expect(opts?.cwd).toBe(params.expectedCwd);
+}

package/dist/test-utils/imessage-test-plugin.js

@@ -0,0 +1,54 @@
+import { imessageOutbound } from "../channels/plugins/outbound/imessage.js";
+import { normalizeIMessageHandle } from "../imessage/targets.js";
+export const createIMessageTestPlugin = (params) => ({
+    id: "imessage",
+    meta: {
+        id: "imessage",
+        label: "iMessage",
+        selectionLabel: "iMessage (imsg)",
+        docsPath: "/channels/imessage",
+        blurb: "iMessage test stub.",
+        aliases: ["imsg"],
+    },
+    capabilities: { chatTypes: ["direct", "group"], media: true },
+    config: {
+        listAccountIds: () => [],
+        resolveAccount: () => ({}),
+    },
+    status: {
+        collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+            const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
+            if (!lastError) {
+                return [];
+            }
+            return [
+                {
+                    channel: "imessage",
+                    accountId: account.accountId,
+                    kind: "runtime",
+                    message: `Channel error: ${lastError}`,
+                },
+            ];
+        }),
+    },
+    outbound: params?.outbound ?? imessageOutbound,
+    messaging: {
+        targetResolver: {
+            looksLikeId: (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed) {
+                    return false;
+                }
+                if (/^(imessage:|sms:|auto:|chat_id:|chat_guid:|chat_identifier:)/i.test(trimmed)) {
+                    return true;
+                }
+                if (trimmed.includes("@")) {
+                    return true;
+                }
+                return /^\+?\d{3,}$/.test(trimmed);
+            },
+            hint: "<handle|chat_id:ID>",
+        },
+        normalizeTarget: (raw) => normalizeIMessageHandle(raw),
+    },
+});

package/dist/test-utils/mock-http-response.js

@@ -0,0 +1,17 @@
+export function createMockServerResponse() {
+    const headers = {};
+    const res = {
+        headersSent: false,
+        statusCode: 200,
+        setHeader: (key, value) => {
+            headers[key.toLowerCase()] = value;
+            return res;
+        },
+        end: (body) => {
+            res.headersSent = true;
+            res.body = body;
+            return res;
+        },
+    };
+    return res;
+}

package/dist/test-utils/vitest-mock-fn.js

@@ -0,0 +1 @@
+export {};