@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/discord/monitor/message-utils.js

@@ -1,9 +1,11 @@
+import { StickerFormatType } from "discord-api-types/v10";
 import { logVerbose } from "../../globals.js";
 import { fetchRemoteMedia } from "../../media/fetch.js";
 import { saveMediaBuffer } from "../../media/store.js";
 const DISCORD_CHANNEL_INFO_CACHE_TTL_MS = 5 * 60 * 1000;
 const DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS = 30 * 1000;
 const DISCORD_CHANNEL_INFO_CACHE = new Map();
+const DISCORD_STICKER_ASSET_BASE_URL = "https://media.discordapp.net/stickers";
 export function __resetDiscordChannelInfoCacheForTest() {
     DISCORD_CHANNEL_INFO_CACHE.clear();
 }
@@ -66,18 +68,45 @@ export async function resolveDiscordChannelInfo(client, channelId) {
         return null;
     }
 }
-export async function resolveMediaList(message, maxBytes) {
-    const attachments = message.attachments ?? [];
-    if (attachments.length === 0) {
+function normalizeStickerItems(value) {
+    if (!Array.isArray(value)) {
         return [];
     }
+    return value.filter((entry) => Boolean(entry) &&
+        typeof entry === "object" &&
+        typeof entry.id === "string" &&
+        typeof entry.name === "string");
+}
+export function resolveDiscordMessageStickers(message) {
+    const stickers = message.stickers;
+    const normalized = normalizeStickerItems(stickers);
+    if (normalized.length > 0) {
+        return normalized;
+    }
+    const rawData = message
+        .rawData;
+    return normalizeStickerItems(rawData?.sticker_items ?? rawData?.stickers);
+}
+function resolveDiscordSnapshotStickers(snapshot) {
+    return normalizeStickerItems(snapshot.stickers ?? snapshot.sticker_items);
+}
+export function hasDiscordMessageStickers(message) {
+    return resolveDiscordMessageStickers(message).length > 0;
+}
+export async function resolveMediaList(message, maxBytes) {
     const out = [];
     await appendResolvedMediaFromAttachments({
-        attachments,
+        attachments: message.attachments ?? [],
         maxBytes,
         out,
         errorPrefix: "discord: failed to download attachment",
     });
+    await appendResolvedMediaFromStickers({
+        stickers: resolveDiscordMessageStickers(message),
+        maxBytes,
+        out,
+        errorPrefix: "discord: failed to download sticker",
+    });
     return out;
 }
 export async function resolveForwardedMediaList(message, maxBytes) {
@@ -93,6 +122,12 @@ export async function resolveForwardedMediaList(message, maxBytes) {
             out,
             errorPrefix: "discord: failed to download forwarded attachment",
         });
+        await appendResolvedMediaFromStickers({
+            stickers: snapshot.message ? resolveDiscordSnapshotStickers(snapshot.message) : [],
+            maxBytes,
+            out,
+            errorPrefix: "discord: failed to download forwarded sticker",
+        });
     }
     return out;
 }
@@ -106,6 +141,7 @@ async function appendResolvedMediaFromAttachments(params) {
             const fetched = await fetchRemoteMedia({
                 url: attachment.url,
                 filePathHint: attachment.filename ?? attachment.url,
+                maxBytes: params.maxBytes,
             });
             const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType ?? attachment.content_type, "inbound", params.maxBytes);
             params.out.push({
@@ -120,6 +156,85 @@ async function appendResolvedMediaFromAttachments(params) {
         }
     }
 }
+function resolveStickerAssetCandidates(sticker) {
+    const baseName = sticker.name?.trim() || `sticker-${sticker.id}`;
+    switch (sticker.format_type) {
+        case StickerFormatType.GIF:
+            return [
+                {
+                    url: `${DISCORD_STICKER_ASSET_BASE_URL}/${sticker.id}.gif`,
+                    fileName: `${baseName}.gif`,
+                },
+            ];
+        case StickerFormatType.Lottie:
+            return [
+                {
+                    url: `${DISCORD_STICKER_ASSET_BASE_URL}/${sticker.id}.png?size=160`,
+                    fileName: `${baseName}.png`,
+                },
+                {
+                    url: `${DISCORD_STICKER_ASSET_BASE_URL}/${sticker.id}.json`,
+                    fileName: `${baseName}.json`,
+                },
+            ];
+        case StickerFormatType.APNG:
+        case StickerFormatType.PNG:
+        default:
+            return [
+                {
+                    url: `${DISCORD_STICKER_ASSET_BASE_URL}/${sticker.id}.png`,
+                    fileName: `${baseName}.png`,
+                },
+            ];
+    }
+}
+function formatStickerError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    if (typeof err === "string") {
+        return err;
+    }
+    try {
+        return JSON.stringify(err) ?? "unknown error";
+    }
+    catch {
+        return "unknown error";
+    }
+}
+async function appendResolvedMediaFromStickers(params) {
+    const stickers = params.stickers;
+    if (!stickers || stickers.length === 0) {
+        return;
+    }
+    for (const sticker of stickers) {
+        const candidates = resolveStickerAssetCandidates(sticker);
+        let lastError;
+        for (const candidate of candidates) {
+            try {
+                const fetched = await fetchRemoteMedia({
+                    url: candidate.url,
+                    filePathHint: candidate.fileName,
+                    maxBytes: params.maxBytes,
+                });
+                const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", params.maxBytes);
+                params.out.push({
+                    path: saved.path,
+                    contentType: saved.contentType,
+                    placeholder: "<media:sticker>",
+                });
+                lastError = null;
+                break;
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        if (lastError) {
+            logVerbose(`${params.errorPrefix} ${sticker.id}: ${formatStickerError(lastError)}`);
+        }
+    }
+}
 function inferPlaceholder(attachment) {
     const mime = attachment.content_type ?? "";
     if (mime.startsWith("image/")) {
@@ -155,9 +270,28 @@ function buildDiscordAttachmentPlaceholder(attachments) {
     const tag = allImages ? "<media:image>" : "<media:document>";
     return `${tag} (${count} ${suffix})`;
 }
+function buildDiscordStickerPlaceholder(stickers) {
+    if (!stickers || stickers.length === 0) {
+        return "";
+    }
+    const count = stickers.length;
+    const label = count === 1 ? "sticker" : "stickers";
+    return `<media:sticker> (${count} ${label})`;
+}
+function buildDiscordMediaPlaceholder(params) {
+    const attachmentText = buildDiscordAttachmentPlaceholder(params.attachments);
+    const stickerText = buildDiscordStickerPlaceholder(params.stickers);
+    if (attachmentText && stickerText) {
+        return `${attachmentText}\n${stickerText}`;
+    }
+    return attachmentText || stickerText || "";
+}
 export function resolveDiscordMessageText(message, options) {
     const baseText = message.content?.trim() ||
-        buildDiscordAttachmentPlaceholder(message.attachments) ||
+        buildDiscordMediaPlaceholder({
+            attachments: message.attachments ?? undefined,
+            stickers: resolveDiscordMessageStickers(message),
+        }) ||
         message.embeds?.[0]?.description ||
         options?.fallbackText?.trim() ||
         "";
@@ -212,7 +346,10 @@ function resolveDiscordMessageSnapshots(message) {
 }
 function resolveDiscordSnapshotMessageText(snapshot) {
     const content = snapshot.content?.trim() ?? "";
-    const attachmentText = buildDiscordAttachmentPlaceholder(snapshot.attachments ?? undefined);
+    const attachmentText = buildDiscordMediaPlaceholder({
+        attachments: snapshot.attachments ?? undefined,
+        stickers: resolveDiscordSnapshotStickers(snapshot),
+    });
     const embed = snapshot.embeds?.[0];
     const embedText = embed?.description?.trim() || embed?.title?.trim() || "";
     return content || attachmentText || embedText || "";

package/dist/discord/monitor/model-picker-preferences.js

@@ -0,0 +1,143 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { normalizeProviderId } from "../../agents/model-selection.js";
+import { resolveStateDir } from "../../config/paths.js";
+import { withFileLock } from "../../infra/file-lock.js";
+import { resolveRequiredHomeDir } from "../../infra/home-dir.js";
+import { normalizeAccountId as normalizeSharedAccountId } from "../../routing/account-id.js";
+const MODEL_PICKER_PREFERENCES_LOCK_OPTIONS = {
+    retries: {
+        retries: 8,
+        factor: 2,
+        minTimeout: 50,
+        maxTimeout: 5_000,
+        randomize: true,
+    },
+    stale: 15_000,
+};
+const DEFAULT_RECENT_LIMIT = 5;
+function resolvePreferencesStorePath(env = process.env) {
+    const stateDir = resolveStateDir(env, () => resolveRequiredHomeDir(env, os.homedir));
+    return path.join(stateDir, "discord", "model-picker-preferences.json");
+}
+function normalizeId(value) {
+    return value?.trim() ?? "";
+}
+export function buildDiscordModelPickerPreferenceKey(scope) {
+    const userId = normalizeId(scope.userId);
+    if (!userId) {
+        return null;
+    }
+    const accountId = normalizeSharedAccountId(scope.accountId);
+    const guildId = normalizeId(scope.guildId);
+    if (guildId) {
+        return `discord:${accountId}:guild:${guildId}:user:${userId}`;
+    }
+    return `discord:${accountId}:dm:user:${userId}`;
+}
+function normalizeModelRef(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return null;
+    }
+    const slashIndex = value.indexOf("/");
+    if (slashIndex <= 0 || slashIndex >= value.length - 1) {
+        return null;
+    }
+    const provider = normalizeProviderId(value.slice(0, slashIndex));
+    const model = value.slice(slashIndex + 1).trim();
+    if (!provider || !model) {
+        return null;
+    }
+    return `${provider}/${model}`;
+}
+function sanitizeRecentModels(models, limit) {
+    const deduped = [];
+    const seen = new Set();
+    for (const item of models ?? []) {
+        const normalized = normalizeModelRef(item);
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        deduped.push(normalized);
+        if (deduped.length >= limit) {
+            break;
+        }
+    }
+    return deduped;
+}
+async function readJsonFileWithFallback(filePath, fallback) {
+    try {
+        const raw = await fs.promises.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { value: parsed, exists: true };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            return { value: fallback, exists: false };
+        }
+        return { value: fallback, exists: false };
+    }
+}
+async function writeJsonFileAtomically(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`, "utf-8");
+    await fs.promises.chmod(tmp, 0o600);
+    await fs.promises.rename(tmp, filePath);
+}
+async function readPreferencesStore(filePath) {
+    const { value } = await readJsonFileWithFallback(filePath, {
+        version: 1,
+        entries: {},
+    });
+    if (!value || typeof value !== "object" || value.version !== 1) {
+        return { version: 1, entries: {} };
+    }
+    return {
+        version: 1,
+        entries: value.entries && typeof value.entries === "object" ? value.entries : {},
+    };
+}
+export async function readDiscordModelPickerRecentModels(params) {
+    const key = buildDiscordModelPickerPreferenceKey(params.scope);
+    if (!key) {
+        return [];
+    }
+    const limit = Math.max(1, Math.min(params.limit ?? DEFAULT_RECENT_LIMIT, 10));
+    const filePath = resolvePreferencesStorePath(params.env);
+    const store = await readPreferencesStore(filePath);
+    const entry = store.entries[key];
+    const recent = sanitizeRecentModels(entry?.recent, limit);
+    if (!params.allowedModelRefs || params.allowedModelRefs.size === 0) {
+        return recent;
+    }
+    return recent.filter((modelRef) => params.allowedModelRefs?.has(modelRef));
+}
+export async function recordDiscordModelPickerRecentModel(params) {
+    const key = buildDiscordModelPickerPreferenceKey(params.scope);
+    const normalizedModelRef = normalizeModelRef(params.modelRef);
+    if (!key || !normalizedModelRef) {
+        return;
+    }
+    const limit = Math.max(1, Math.min(params.limit ?? DEFAULT_RECENT_LIMIT, 10));
+    const filePath = resolvePreferencesStorePath(params.env);
+    await withFileLock(filePath, MODEL_PICKER_PREFERENCES_LOCK_OPTIONS, async () => {
+        const store = await readPreferencesStore(filePath);
+        const existing = sanitizeRecentModels(store.entries[key]?.recent, limit);
+        const next = [
+            normalizedModelRef,
+            ...existing.filter((entry) => entry !== normalizedModelRef),
+        ].slice(0, limit);
+        store.entries[key] = {
+            recent: next,
+            updatedAt: new Date().toISOString(),
+        };
+        await writeJsonFileAtomically(filePath, store);
+    });
+}