@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/config/legacy.migrations.part-1.js

@@ -1,63 +1,71 @@
+import { resolveDiscordPreviewStreamMode, resolveSlackNativeStreaming, resolveSlackStreamingMode, resolveTelegramPreviewStreamMode, } from "./discord-preview-streaming.js";
 import { ensureRecord, getRecord, isRecord, mergeMissing, } from "./legacy.shared.js";
+function migrateBindings(raw, changes, changeNote, mutator) {
+    const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
+    if (!bindings) {
+        return;
+    }
+    let touched = false;
+    for (const entry of bindings) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const match = getRecord(entry.match);
+        if (!match) {
+            continue;
+        }
+        if (!mutator(match)) {
+            continue;
+        }
+        entry.match = match;
+        touched = true;
+    }
+    if (touched) {
+        raw.bindings = bindings;
+        changes.push(changeNote);
+    }
+}
+function ensureDefaultGroupEntry(section) {
+    const groups = isRecord(section.groups) ? section.groups : {};
+    const defaultKey = "*";
+    const entry = isRecord(groups[defaultKey]) ? groups[defaultKey] : {};
+    return { groups, entry };
+}
 export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
     {
         id: "bindings.match.provider->bindings.match.channel",
         describe: "Move bindings[].match.provider to bindings[].match.channel",
         apply: (raw, changes) => {
-            const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
-            if (!bindings)
-                return;
-            let touched = false;
-            for (const entry of bindings) {
-                if (!isRecord(entry))
-                    continue;
-                const match = getRecord(entry.match);
-                if (!match)
-                    continue;
-                if (typeof match.channel === "string" && match.channel.trim())
-                    continue;
+            migrateBindings(raw, changes, "Moved bindings[].match.provider → bindings[].match.channel.", (match) => {
+                if (typeof match.channel === "string" && match.channel.trim()) {
+                    return false;
+                }
                 const provider = typeof match.provider === "string" ? match.provider.trim() : "";
-                if (!provider)
-                    continue;
+                if (!provider) {
+                    return false;
+                }
                 match.channel = provider;
                 delete match.provider;
-                entry.match = match;
-                touched = true;
-            }
-            if (touched) {
-                raw.bindings = bindings;
-                changes.push("Moved bindings[].match.provider → bindings[].match.channel.");
-            }
+                return true;
+            });
         },
     },
     {
         id: "bindings.match.accountID->bindings.match.accountId",
         describe: "Move bindings[].match.accountID to bindings[].match.accountId",
         apply: (raw, changes) => {
-            const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
-            if (!bindings)
-                return;
-            let touched = false;
-            for (const entry of bindings) {
-                if (!isRecord(entry))
-                    continue;
-                const match = getRecord(entry.match);
-                if (!match)
-                    continue;
-                if (match.accountId !== undefined)
-                    continue;
+            migrateBindings(raw, changes, "Moved bindings[].match.accountID → bindings[].match.accountId.", (match) => {
+                if (match.accountId !== undefined) {
+                    return false;
+                }
                 const accountID = typeof match.accountID === "string" ? match.accountID.trim() : match.accountID;
-                if (!accountID)
-                    continue;
+                if (!accountID) {
+                    return false;
+                }
                 match.accountId = accountID;
                 delete match.accountID;
-                entry.match = match;
-                touched = true;
-            }
-            if (touched) {
-                raw.bindings = bindings;
-                changes.push("Moved bindings[].match.accountID → bindings[].match.accountId.");
-            }
+                return true;
+            });
         },
     },
     {
@@ -65,26 +73,33 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move session.sendPolicy.rules[].match.provider to match.channel",
         apply: (raw, changes) => {
             const session = getRecord(raw.session);
-            if (!session)
+            if (!session) {
                 return;
+            }
             const sendPolicy = getRecord(session.sendPolicy);
-            if (!sendPolicy)
+            if (!sendPolicy) {
                 return;
+            }
             const rules = Array.isArray(sendPolicy.rules) ? sendPolicy.rules : null;
-            if (!rules)
+            if (!rules) {
                 return;
+            }
             let touched = false;
             for (const rule of rules) {
-                if (!isRecord(rule))
+                if (!isRecord(rule)) {
                     continue;
+                }
                 const match = getRecord(rule.match);
-                if (!match)
+                if (!match) {
                     continue;
-                if (typeof match.channel === "string" && match.channel.trim())
+                }
+                if (typeof match.channel === "string" && match.channel.trim()) {
                     continue;
+                }
                 const provider = typeof match.provider === "string" ? match.provider.trim() : "";
-                if (!provider)
+                if (!provider) {
                     continue;
+                }
                 match.channel = provider;
                 delete match.provider;
                 rule.match = match;
@@ -103,13 +118,16 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move messages.queue.byProvider to messages.queue.byChannel",
         apply: (raw, changes) => {
             const messages = getRecord(raw.messages);
-            if (!messages)
+            if (!messages) {
                 return;
+            }
             const queue = getRecord(messages.queue);
-            if (!queue)
+            if (!queue) {
                 return;
-            if (queue.byProvider === undefined)
+            }
+            if (queue.byProvider === undefined) {
                 return;
+            }
             if (queue.byChannel === undefined) {
                 queue.byChannel = queue.byProvider;
                 changes.push("Moved messages.queue.byProvider → messages.queue.byChannel.");
@@ -136,13 +154,15 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
                 "msteams",
             ];
             const legacyEntries = legacyKeys.filter((key) => isRecord(raw[key]));
-            if (legacyEntries.length === 0)
+            if (legacyEntries.length === 0) {
                 return;
+            }
             const channels = ensureRecord(raw, "channels");
             for (const key of legacyEntries) {
                 const legacy = getRecord(raw[key]);
-                if (!legacy)
+                if (!legacy) {
                     continue;
+                }
                 const channelEntry = ensureRecord(channels, key);
                 const hadEntries = Object.keys(channelEntry).length > 0;
                 mergeMissing(channelEntry, legacy);
@@ -153,16 +173,109 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
             raw.channels = channels;
         },
     },
+    {
+        id: "channels.streaming-keys->channels.streaming",
+        describe: "Normalize legacy streaming keys to channels.<provider>.streaming (Telegram/Discord/Slack)",
+        apply: (raw, changes) => {
+            const channels = getRecord(raw.channels);
+            if (!channels) {
+                return;
+            }
+            const migrateProviderEntry = (params) => {
+                const hasLegacyStreamMode = params.entry.streamMode !== undefined;
+                const legacyStreaming = params.entry.streaming;
+                const legacyNativeStreaming = params.entry.nativeStreaming;
+                if (params.provider === "telegram") {
+                    if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") {
+                        return;
+                    }
+                    const resolved = resolveTelegramPreviewStreamMode(params.entry);
+                    params.entry.streaming = resolved;
+                    if (hasLegacyStreamMode) {
+                        delete params.entry.streamMode;
+                        changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
+                    }
+                    if (typeof legacyStreaming === "boolean") {
+                        changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
+                    }
+                    return;
+                }
+                if (params.provider === "discord") {
+                    if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") {
+                        return;
+                    }
+                    const resolved = resolveDiscordPreviewStreamMode(params.entry);
+                    params.entry.streaming = resolved;
+                    if (hasLegacyStreamMode) {
+                        delete params.entry.streamMode;
+                        changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
+                    }
+                    if (typeof legacyStreaming === "boolean") {
+                        changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
+                    }
+                    return;
+                }
+                if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") {
+                    return;
+                }
+                const resolvedStreaming = resolveSlackStreamingMode(params.entry);
+                const resolvedNativeStreaming = resolveSlackNativeStreaming(params.entry);
+                params.entry.streaming = resolvedStreaming;
+                params.entry.nativeStreaming = resolvedNativeStreaming;
+                if (hasLegacyStreamMode) {
+                    delete params.entry.streamMode;
+                    changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolvedStreaming}).`);
+                }
+                if (typeof legacyStreaming === "boolean") {
+                    changes.push(`Moved ${params.pathPrefix}.streaming (boolean) → ${params.pathPrefix}.nativeStreaming (${resolvedNativeStreaming}).`);
+                }
+                else if (typeof legacyNativeStreaming !== "boolean" && hasLegacyStreamMode) {
+                    changes.push(`Set ${params.pathPrefix}.nativeStreaming → ${resolvedNativeStreaming}.`);
+                }
+            };
+            const migrateProvider = (provider) => {
+                const providerEntry = getRecord(channels[provider]);
+                if (!providerEntry) {
+                    return;
+                }
+                migrateProviderEntry({
+                    provider,
+                    entry: providerEntry,
+                    pathPrefix: `channels.${provider}`,
+                });
+                const accounts = getRecord(providerEntry.accounts);
+                if (!accounts) {
+                    return;
+                }
+                for (const [accountId, accountValue] of Object.entries(accounts)) {
+                    const account = getRecord(accountValue);
+                    if (!account) {
+                        continue;
+                    }
+                    migrateProviderEntry({
+                        provider,
+                        entry: account,
+                        pathPrefix: `channels.${provider}.accounts.${accountId}`,
+                    });
+                }
+            };
+            migrateProvider("telegram");
+            migrateProvider("discord");
+            migrateProvider("slack");
+        },
+    },
     {
         id: "routing.allowFrom->channels.whatsapp.allowFrom",
         describe: "Move routing.allowFrom to channels.whatsapp.allowFrom",
         apply: (raw, changes) => {
             const routing = raw.routing;
-            if (!routing || typeof routing !== "object")
+            if (!routing || typeof routing !== "object") {
                 return;
+            }
             const allowFrom = routing.allowFrom;
-            if (allowFrom === undefined)
+            if (allowFrom === undefined) {
                 return;
+            }
             const channels = getRecord(raw.channels);
             const whatsapp = channels ? getRecord(channels.whatsapp) : null;
             if (!whatsapp) {
@@ -193,31 +306,30 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move routing.groupChat.requireMention to channels.whatsapp/telegram/imessage groups",
         apply: (raw, changes) => {
             const routing = raw.routing;
-            if (!routing || typeof routing !== "object")
+            if (!routing || typeof routing !== "object") {
                 return;
+            }
             const groupChat = routing.groupChat &&
                 typeof routing.groupChat === "object"
                 ? routing.groupChat
                 : null;
-            if (!groupChat)
+            if (!groupChat) {
                 return;
+            }
             const requireMention = groupChat.requireMention;
-            if (requireMention === undefined)
+            if (requireMention === undefined) {
                 return;
+            }
             const channels = ensureRecord(raw, "channels");
             const applyTo = (key, options) => {
-                if (options?.requireExisting && !isRecord(channels[key]))
+                if (options?.requireExisting && !isRecord(channels[key])) {
                     return;
+                }
                 const section = channels[key] && typeof channels[key] === "object"
                     ? channels[key]
                     : {};
-                const groups = section.groups && typeof section.groups === "object"
-                    ? section.groups
-                    : {};
+                const { groups, entry } = ensureDefaultGroupEntry(section);
                 const defaultKey = "*";
-                const entry = groups[defaultKey] && typeof groups[defaultKey] === "object"
-                    ? groups[defaultKey]
-                    : {};
                 if (entry.requireMention === undefined) {
                     entry.requireMention = requireMention;
                     groups[defaultKey] = entry;
@@ -247,19 +359,22 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move gateway.token to gateway.auth.token",
         apply: (raw, changes) => {
             const gateway = raw.gateway;
-            if (!gateway || typeof gateway !== "object")
+            if (!gateway || typeof gateway !== "object") {
                 return;
+            }
             const token = gateway.token;
-            if (token === undefined)
+            if (token === undefined) {
                 return;
+            }
             const gatewayObj = gateway;
             const auth = gatewayObj.auth && typeof gatewayObj.auth === "object"
                 ? gatewayObj.auth
                 : {};
             if (auth.token === undefined) {
                 auth.token = token;
-                if (!auth.mode)
+                if (!auth.mode) {
                     auth.mode = "token";
+                }
                 changes.push("Moved gateway.token → gateway.auth.token.");
             }
             else {
@@ -278,19 +393,15 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         apply: (raw, changes) => {
             const channels = ensureRecord(raw, "channels");
             const telegram = channels.telegram;
-            if (!telegram || typeof telegram !== "object")
+            if (!telegram || typeof telegram !== "object") {
                 return;
+            }
             const requireMention = telegram.requireMention;
-            if (requireMention === undefined)
+            if (requireMention === undefined) {
                 return;
-            const groups = telegram.groups &&
-                typeof telegram.groups === "object"
-                ? telegram.groups
-                : {};
+            }
+            const { groups, entry } = ensureDefaultGroupEntry(telegram);
             const defaultKey = "*";
-            const entry = groups[defaultKey] && typeof groups[defaultKey] === "object"
-                ? groups[defaultKey]
-                : {};
             if (entry.requireMention === undefined) {
                 entry.requireMention = requireMention;
                 groups[defaultKey] = entry;

package/dist/config/legacy.shared.js

@@ -1,3 +1,4 @@
+import { isBlockedObjectKey } from "./prototype-keys.js";
 export const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
 export const getRecord = (value) => isRecord(value) ? value : null;
 export const ensureRecord = (root, key) => {
@@ -10,8 +11,9 @@ export const ensureRecord = (root, key) => {
 };
 export const mergeMissing = (target, source) => {
     for (const [key, value] of Object.entries(source)) {
-        if (value === undefined)
+        if (value === undefined || isBlockedObjectKey(key)) {
             continue;
+        }
         const existing = target[key];
         if (existing === undefined) {
             target[key] = value;

package/dist/config/merge-patch.js

@@ -1,19 +1,69 @@
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+import { isPlainObject } from "../utils.js";
+import { isBlockedObjectKey } from "./prototype-keys.js";
+function isObjectWithStringId(value) {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return typeof value.id === "string" && value.id.length > 0;
 }
-export function applyMergePatch(base, patch) {
+/**
+ * Merge arrays of object-like entries keyed by `id`.
+ *
+ * Contract:
+ * - Base array must be fully id-keyed; otherwise return undefined (caller should replace).
+ * - Patch entries with valid id merge by id (or append when the id is new).
+ * - Patch entries without valid id append as-is, avoiding destructive full-array replacement.
+ */
+function mergeObjectArraysById(base, patch, options) {
+    if (!base.every(isObjectWithStringId)) {
+        return undefined;
+    }
+    const merged = [...base];
+    const indexById = new Map();
+    for (const [index, entry] of merged.entries()) {
+        if (!isObjectWithStringId(entry)) {
+            return undefined;
+        }
+        indexById.set(entry.id, index);
+    }
+    for (const patchEntry of patch) {
+        if (!isObjectWithStringId(patchEntry)) {
+            merged.push(structuredClone(patchEntry));
+            continue;
+        }
+        const existingIndex = indexById.get(patchEntry.id);
+        if (existingIndex === undefined) {
+            merged.push(structuredClone(patchEntry));
+            indexById.set(patchEntry.id, merged.length - 1);
+            continue;
+        }
+        merged[existingIndex] = applyMergePatch(merged[existingIndex], patchEntry, options);
+    }
+    return merged;
+}
+export function applyMergePatch(base, patch, options = {}) {
     if (!isPlainObject(patch)) {
         return patch;
     }
     const result = isPlainObject(base) ? { ...base } : {};
     for (const [key, value] of Object.entries(patch)) {
+        if (isBlockedObjectKey(key)) {
+            continue;
+        }
         if (value === null) {
             delete result[key];
             continue;
         }
+        if (options.mergeObjectArraysById && Array.isArray(result[key]) && Array.isArray(value)) {
+            const mergedArray = mergeObjectArraysById(result[key], value, options);
+            if (mergedArray) {
+                result[key] = mergedArray;
+                continue;
+            }
+        }
         if (isPlainObject(value)) {
             const baseValue = result[key];
-            result[key] = applyMergePatch(isPlainObject(baseValue) ? baseValue : {}, value);
+            result[key] = applyMergePatch(isPlainObject(baseValue) ? baseValue : {}, value, options);
             continue;
         }
         result[key] = value;

package/dist/config/prototype-keys.js

@@ -0,0 +1,4 @@
+const BLOCKED_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+export function isBlockedObjectKey(key) {
+    return BLOCKED_OBJECT_KEYS.has(key);
+}