@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/telegram/status-reaction-variants.js

@@ -0,0 +1,208 @@
+import { DEFAULT_EMOJIS } from "../channels/status-reactions.js";
+const TELEGRAM_GENERIC_REACTION_FALLBACKS = ["👍", "👀", "🔥"];
+const TELEGRAM_SUPPORTED_REACTION_EMOJIS = new Set([
+    "❤",
+    "👍",
+    "👎",
+    "🔥",
+    "🥰",
+    "👏",
+    "😁",
+    "🤔",
+    "🤯",
+    "😱",
+    "🤬",
+    "😢",
+    "🎉",
+    "🤩",
+    "🤮",
+    "💩",
+    "🙏",
+    "👌",
+    "🕊",
+    "🤡",
+    "🥱",
+    "🥴",
+    "😍",
+    "🐳",
+    "❤‍🔥",
+    "🌚",
+    "🌭",
+    "💯",
+    "🤣",
+    "⚡",
+    "🍌",
+    "🏆",
+    "💔",
+    "🤨",
+    "😐",
+    "🍓",
+    "🍾",
+    "💋",
+    "🖕",
+    "😈",
+    "😴",
+    "😭",
+    "🤓",
+    "👻",
+    "👨‍💻",
+    "👀",
+    "🎃",
+    "🙈",
+    "😇",
+    "😨",
+    "🤝",
+    "✍",
+    "🤗",
+    "🫡",
+    "🎅",
+    "🎄",
+    "☃",
+    "💅",
+    "🤪",
+    "🗿",
+    "🆒",
+    "💘",
+    "🙉",
+    "🦄",
+    "😘",
+    "💊",
+    "🙊",
+    "😎",
+    "👾",
+    "🤷‍♂",
+    "🤷",
+    "🤷‍♀",
+    "😡",
+]);
+export const TELEGRAM_STATUS_REACTION_VARIANTS = {
+    queued: ["👀", "👍", "🔥"],
+    thinking: ["🤔", "🤓", "👀"],
+    tool: ["🔥", "⚡", "👍"],
+    coding: ["👨‍💻", "🔥", "⚡"],
+    web: ["⚡", "🔥", "👍"],
+    done: ["👍", "🎉", "💯"],
+    error: ["😱", "😨", "🤯"],
+    stallSoft: ["🥱", "😴", "🤔"],
+    stallHard: ["😨", "😱", "⚡"],
+};
+const STATUS_REACTION_EMOJI_KEYS = [
+    "queued",
+    "thinking",
+    "tool",
+    "coding",
+    "web",
+    "done",
+    "error",
+    "stallSoft",
+    "stallHard",
+];
+function normalizeEmoji(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function toUniqueNonEmpty(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+export function resolveTelegramStatusReactionEmojis(params) {
+    const { overrides } = params;
+    const queuedFallback = normalizeEmoji(params.initialEmoji) ?? DEFAULT_EMOJIS.queued;
+    return {
+        queued: normalizeEmoji(overrides?.queued) ?? queuedFallback,
+        thinking: normalizeEmoji(overrides?.thinking) ?? DEFAULT_EMOJIS.thinking,
+        tool: normalizeEmoji(overrides?.tool) ?? DEFAULT_EMOJIS.tool,
+        coding: normalizeEmoji(overrides?.coding) ?? DEFAULT_EMOJIS.coding,
+        web: normalizeEmoji(overrides?.web) ?? DEFAULT_EMOJIS.web,
+        done: normalizeEmoji(overrides?.done) ?? DEFAULT_EMOJIS.done,
+        error: normalizeEmoji(overrides?.error) ?? DEFAULT_EMOJIS.error,
+        stallSoft: normalizeEmoji(overrides?.stallSoft) ?? DEFAULT_EMOJIS.stallSoft,
+        stallHard: normalizeEmoji(overrides?.stallHard) ?? DEFAULT_EMOJIS.stallHard,
+    };
+}
+export function buildTelegramStatusReactionVariants(emojis) {
+    const variantsByRequested = new Map();
+    for (const key of STATUS_REACTION_EMOJI_KEYS) {
+        const requested = normalizeEmoji(emojis[key]);
+        if (!requested) {
+            continue;
+        }
+        const fallbackVariants = TELEGRAM_STATUS_REACTION_VARIANTS[key] ?? [];
+        const candidates = toUniqueNonEmpty([requested, ...fallbackVariants]);
+        variantsByRequested.set(requested, candidates);
+    }
+    return variantsByRequested;
+}
+export function isTelegramSupportedReactionEmoji(emoji) {
+    return TELEGRAM_SUPPORTED_REACTION_EMOJIS.has(emoji);
+}
+export function extractTelegramAllowedEmojiReactions(chat) {
+    if (!chat || typeof chat !== "object") {
+        return undefined;
+    }
+    if (!Object.prototype.hasOwnProperty.call(chat, "available_reactions")) {
+        return undefined;
+    }
+    const availableReactions = chat.available_reactions;
+    if (availableReactions == null) {
+        // Explicitly omitted/null => all emoji reactions are allowed in this chat.
+        return null;
+    }
+    if (!Array.isArray(availableReactions)) {
+        return new Set();
+    }
+    const allowed = new Set();
+    for (const reaction of availableReactions) {
+        if (!reaction || typeof reaction !== "object") {
+            continue;
+        }
+        const typedReaction = reaction;
+        if (typedReaction.type !== "emoji" || typeof typedReaction.emoji !== "string") {
+            continue;
+        }
+        const emoji = typedReaction.emoji.trim();
+        if (emoji) {
+            allowed.add(emoji);
+        }
+    }
+    return allowed;
+}
+export async function resolveTelegramAllowedEmojiReactions(params) {
+    const fromMessage = extractTelegramAllowedEmojiReactions(params.chat);
+    if (fromMessage !== undefined) {
+        return fromMessage;
+    }
+    if (params.getChat) {
+        try {
+            const chatInfo = await params.getChat(params.chatId);
+            const fromLookup = extractTelegramAllowedEmojiReactions(chatInfo);
+            if (fromLookup !== undefined) {
+                return fromLookup;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    // If unavailable, assume no explicit restriction.
+    return null;
+}
+export function resolveTelegramReactionVariant(params) {
+    const requestedEmoji = normalizeEmoji(params.requestedEmoji);
+    if (!requestedEmoji) {
+        return undefined;
+    }
+    const configuredVariants = params.variantsByRequestedEmoji.get(requestedEmoji) ?? [
+        requestedEmoji,
+    ];
+    const variants = toUniqueNonEmpty([
+        ...configuredVariants,
+        ...TELEGRAM_GENERIC_REACTION_FALLBACKS,
+    ]);
+    for (const candidate of variants) {
+        const isAllowedByChat = params.allowedEmojiReactions == null || params.allowedEmojiReactions.has(candidate);
+        if (isAllowedByChat && isTelegramSupportedReactionEmoji(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}

package/dist/telegram/sticker-cache.js

@@ -1,11 +1,11 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { STATE_DIR } from "../config/paths.js";
-import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
-import { logVerbose } from "../globals.js";
-import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveApiKeyForProvider } from "../agents/model-auth.js";
+import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { STATE_DIR } from "../config/paths.js";
+import { logVerbose } from "../globals.js";
+import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
 import { resolveAutoImageModel } from "../media-understanding/runner.js";
 const CACHE_FILE = path.join(STATE_DIR, "telegram", "sticker-cache.json");
 const CACHE_VERSION = 1;
@@ -74,7 +74,7 @@ export function searchStickers(query, limit = 10) {
         }
     }
     return results
-        .sort((a, b) => b.score - a.score)
+        .toSorted((a, b) => b.score - a.score)
         .slice(0, limit)
         .map((r) => r.sticker);
 }
@@ -94,7 +94,7 @@ export function getCacheStats() {
     if (stickers.length === 0) {
         return { count: 0 };
     }
-    const sorted = [...stickers].sort((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
+    const sorted = [...stickers].toSorted((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
     return {
         count: stickers.length,
         oldestAt: sorted[0]?.cachedAt,
@@ -135,12 +135,13 @@ export async function describeStickerImage(params) {
     };
     const selectCatalogModel = (provider) => {
         const entries = catalog.filter((entry) => entry.provider.toLowerCase() === provider.toLowerCase() && modelSupportsVision(entry));
-        if (entries.length === 0)
+        if (entries.length === 0) {
             return undefined;
+        }
         const defaultId = provider === "openai"
             ? "gpt-5-mini"
             : provider === "anthropic"
-                ? "claude-opus-4-5"
+                ? "claude-opus-4-6"
                 : provider === "google"
                     ? "gemini-3-flash-preview"
                     : "MiniMax-VL-01";
@@ -155,8 +156,9 @@ export async function describeStickerImage(params) {
     }
     if (!resolved) {
         for (const provider of VISION_PROVIDERS) {
-            if (!(await hasProviderKey(provider)))
+            if (!(await hasProviderKey(provider))) {
                 continue;
+            }
             const entry = selectCatalogModel(provider);
             if (entry) {
                 resolved = { provider, model: entry.id };

package/dist/terminal/prompt-select-styled.js

@@ -0,0 +1,9 @@
+import { select } from "@clack/prompts";
+import { stylePromptHint, stylePromptMessage } from "./prompt-style.js";
+export function selectStyled(params) {
+    return select({
+        ...params,
+        message: stylePromptMessage(params.message),
+        options: params.options.map((opt) => opt.hint === undefined ? opt : { ...opt, hint: stylePromptHint(opt.hint) }),
+    });
+}

package/dist/terminal/theme.js

@@ -1,22 +1,22 @@
 import chalk, { Chalk } from "chalk";
-import { POOLBOT_PALETTE } from "./palette.js";
+import { LOBSTER_PALETTE } from "./palette.js";
 const hasForceColor = typeof process.env.FORCE_COLOR === "string" &&
     process.env.FORCE_COLOR.trim().length > 0 &&
     process.env.FORCE_COLOR.trim() !== "0";
 const baseChalk = process.env.NO_COLOR && !hasForceColor ? new Chalk({ level: 0 }) : chalk;
 const hex = (value) => baseChalk.hex(value);
 export const theme = {
-    accent: hex(POOLBOT_PALETTE.accent),
-    accentBright: hex(POOLBOT_PALETTE.accentBright),
-    accentDim: hex(POOLBOT_PALETTE.accentDim),
-    info: hex(POOLBOT_PALETTE.info),
-    success: hex(POOLBOT_PALETTE.success),
-    warn: hex(POOLBOT_PALETTE.warn),
-    error: hex(POOLBOT_PALETTE.error),
-    muted: hex(POOLBOT_PALETTE.muted),
-    heading: baseChalk.bold.hex(POOLBOT_PALETTE.accent),
-    command: hex(POOLBOT_PALETTE.accentBright),
-    option: hex(POOLBOT_PALETTE.info),
+    accent: hex(LOBSTER_PALETTE.accent),
+    accentBright: hex(LOBSTER_PALETTE.accentBright),
+    accentDim: hex(LOBSTER_PALETTE.accentDim),
+    info: hex(LOBSTER_PALETTE.info),
+    success: hex(LOBSTER_PALETTE.success),
+    warn: hex(LOBSTER_PALETTE.warn),
+    error: hex(LOBSTER_PALETTE.error),
+    muted: hex(LOBSTER_PALETTE.muted),
+    heading: baseChalk.bold.hex(LOBSTER_PALETTE.accent),
+    command: hex(LOBSTER_PALETTE.accentBright),
+    option: hex(LOBSTER_PALETTE.warn),
 };
 export const isRich = () => Boolean(baseChalk.level > 0);
 export const colorize = (rich, color, value) => rich ? color(value) : value;

package/dist/test-utils/command-runner.js

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+export async function runRegisteredCli(params) {
+    const program = new Command();
+    params.register(program);
+    await program.parseAsync(params.argv, { from: "user" });
+}

package/dist/test-utils/internal-hook-event-payload.js

@@ -0,0 +1,10 @@
+export function createInternalHookEventPayload(type, action, sessionKey, context) {
+    return {
+        type,
+        action,
+        sessionKey,
+        context,
+        timestamp: new Date(),
+        messages: [],
+    };
+}

package/dist/test-utils/model-auth-mock.js

@@ -0,0 +1,12 @@
+import { vi } from "vitest";
+export function createModelAuthMockModule() {
+    return {
+        resolveApiKeyForProvider: vi.fn(),
+        requireApiKey: (auth, provider) => {
+            if (auth?.apiKey) {
+                return auth.apiKey;
+            }
+            throw new Error(`No API key resolved for provider "${provider}" (auth mode: ${auth?.mode}).`);
+        },
+    };
+}

package/dist/test-utils/provider-usage-fetch.js

@@ -0,0 +1,14 @@
+import { vi } from "vitest";
+import { withFetchPreconnect } from "./fetch-mock.js";
+export function makeResponse(status, body) {
+    const payload = typeof body === "string" ? body : JSON.stringify(body);
+    const headers = typeof body === "string" ? undefined : { "Content-Type": "application/json" };
+    return new Response(payload, { status, headers });
+}
+export function toRequestUrl(input) {
+    return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+}
+export function createProviderUsageFetch(handler) {
+    const mockFetch = vi.fn(async (input, init) => handler(toRequestUrl(input), init));
+    return withFetchPreconnect(mockFetch);
+}

package/dist/test-utils/temp-home.js

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { captureEnv } from "./env.js";
+const HOME_ENV_KEYS = [
+    "HOME",
+    "USERPROFILE",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "CLAWDBOT_STATE_DIR",
+];
+export async function createTempHomeEnv(prefix) {
+    const home = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+    await fs.mkdir(path.join(home, ".poolbot"), { recursive: true });
+    const snapshot = captureEnv([...HOME_ENV_KEYS]);
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+    process.env.CLAWDBOT_STATE_DIR = path.join(home, ".poolbot");
+    if (process.platform === "win32") {
+        const match = home.match(/^([A-Za-z]:)(.*)$/);
+        if (match) {
+            process.env.HOMEDRIVE = match[1];
+            process.env.HOMEPATH = match[2] || "\\";
+        }
+    }
+    return {
+        home,
+        restore: async () => {
+            snapshot.restore();
+            await fs.rm(home, { recursive: true, force: true });
+        },
+    };
+}