@omnizap-system/omnizap 2.5.12

package/app/services/sticker/stickerFocusService.test.js

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveStickerFocusMessageClassification } from './stickerFocusService.js';
+
+test('resolveStickerFocusMessageClassification nao conta album como mensagem limitada', () => {
+  const classification = resolveStickerFocusMessageClassification({
+    messageInfo: { message: {} },
+    extractedText: '[Álbum]',
+    mediaEntries: [{ mediaType: 'album' }],
+  });
+
+  assert.equal(classification.isThrottleCandidate, false);
+  assert.equal(classification.messageType, 'album');
+  assert.equal(classification.reason, 'sticker_flow_media');
+});
+
+test('resolveStickerFocusMessageClassification nao conta albumImage como mensagem limitada', () => {
+  const classification = resolveStickerFocusMessageClassification({
+    messageInfo: { message: {} },
+    extractedText: '[Álbum]',
+    mediaEntries: [{ mediaType: 'albumImage' }],
+  });
+
+  assert.equal(classification.isThrottleCandidate, false);
+  assert.equal(classification.messageType, 'albumimage');
+  assert.equal(classification.reason, 'sticker_flow_media');
+});
+
+test('resolveStickerFocusMessageClassification continua limitando texto comum', () => {
+  const classification = resolveStickerFocusMessageClassification({
+    messageInfo: {
+      message: {
+        conversation: 'mensagem de texto',
+      },
+    },
+    extractedText: 'mensagem de texto',
+    mediaEntries: [],
+  });
+
+  assert.equal(classification.isThrottleCandidate, true);
+  assert.equal(classification.messageType, 'text');
+  assert.equal(classification.reason, 'explicit_text_payload');
+});

package/app/store/aiPromptStore.js

@@ -0,0 +1,38 @@
+import groupConfigStore from './groupConfigStore.js';
+
+const PROMPT_CONFIG_ID = 'system:ai_prompts';
+
+const normalizeMap = (map) => (map && typeof map === 'object' ? map : {});
+
+const aiPromptStore = {
+  getAllPrompts: async function () {
+    const config = await groupConfigStore.getGroupConfig(PROMPT_CONFIG_ID);
+    return normalizeMap(config.prompts);
+  },
+
+  getPrompt: async function (jid) {
+    if (!jid) return null;
+    const prompts = await this.getAllPrompts();
+    return prompts[jid] || null;
+  },
+
+  setPrompt: async function (jid, prompt) {
+    if (!jid) return null;
+    const prompts = await this.getAllPrompts();
+    prompts[jid] = prompt;
+    await groupConfigStore.updateGroupConfig(PROMPT_CONFIG_ID, { prompts });
+    return prompt;
+  },
+
+  clearPrompt: async function (jid) {
+    if (!jid) return null;
+    const prompts = await this.getAllPrompts();
+    if (prompts[jid]) {
+      delete prompts[jid];
+      await groupConfigStore.updateGroupConfig(PROMPT_CONFIG_ID, { prompts });
+    }
+    return true;
+  },
+};
+
+export default aiPromptStore;

package/app/store/conversationSessionStore.js

@@ -0,0 +1,131 @@
+const DEFAULT_SESSION_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_HISTORY_LIMIT = 8;
+
+const sessions = new Map();
+
+const toFinitePositiveInt = (value, fallback, min = 1) => {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(parsed) || parsed < min) return fallback;
+  return parsed;
+};
+
+const normalizeToken = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase();
+
+const buildSessionKey = ({ chatId, userId, scope = 'private' } = {}) => {
+  const safeScope = normalizeToken(scope) || 'private';
+  const safeChatId = String(chatId || '').trim();
+  const safeUserId = String(userId || '').trim();
+  if (!safeChatId || !safeUserId) return '';
+  return `${safeScope}:${safeChatId}:${safeUserId}`;
+};
+
+const pruneExpiredSessions = (nowMs = Date.now()) => {
+  for (const [key, session] of sessions.entries()) {
+    if (!session || !Number.isFinite(session.expiresAt) || session.expiresAt <= nowMs) {
+      sessions.delete(key);
+    }
+  }
+};
+
+const cloneSession = (session) => ({
+  key: session.key,
+  scope: session.scope,
+  chatId: session.chatId,
+  userId: session.userId,
+  createdAt: session.createdAt,
+  updatedAt: session.updatedAt,
+  expiresAt: session.expiresAt,
+  lastIntent: session.lastIntent ? { ...session.lastIntent } : null,
+  history: Array.isArray(session.history) ? session.history.map((item) => ({ ...item })) : [],
+});
+
+const getOrCreateSession = ({ chatId, userId, scope = 'private', ttlMs }) => {
+  pruneExpiredSessions();
+  const key = buildSessionKey({ chatId, userId, scope });
+  if (!key) return null;
+
+  const nowMs = Date.now();
+  const safeTtlMs = toFinitePositiveInt(ttlMs, DEFAULT_SESSION_TTL_MS, 1_000);
+  const existing = sessions.get(key);
+
+  if (existing && Number.isFinite(existing.expiresAt) && existing.expiresAt > nowMs) {
+    existing.updatedAt = new Date(nowMs).toISOString();
+    existing.expiresAt = nowMs + safeTtlMs;
+    return existing;
+  }
+
+  const created = {
+    key,
+    scope: normalizeToken(scope) || 'private',
+    chatId: String(chatId || '').trim(),
+    userId: String(userId || '').trim(),
+    createdAt: new Date(nowMs).toISOString(),
+    updatedAt: new Date(nowMs).toISOString(),
+    expiresAt: nowMs + safeTtlMs,
+    lastIntent: null,
+    history: [],
+  };
+
+  sessions.set(key, created);
+  return created;
+};
+
+export const getConversationSession = ({ chatId, userId, scope = 'private', ttlMs } = {}) => {
+  const session = getOrCreateSession({ chatId, userId, scope, ttlMs });
+  if (!session) return null;
+  return cloneSession(session);
+};
+
+export const appendConversationSessionMessage = ({ chatId, userId, scope = 'private', role = 'user', text = '', metadata = null, ttlMs, historyLimit = DEFAULT_HISTORY_LIMIT } = {}) => {
+  const session = getOrCreateSession({ chatId, userId, scope, ttlMs });
+  if (!session) return null;
+
+  const safeText = String(text || '').trim();
+  if (safeText) {
+    const safeRole = normalizeToken(role) || 'user';
+    session.history.push({
+      role: safeRole,
+      text: safeText,
+      metadata: metadata && typeof metadata === 'object' ? { ...metadata } : null,
+      createdAt: new Date().toISOString(),
+    });
+    const maxHistory = toFinitePositiveInt(historyLimit, DEFAULT_HISTORY_LIMIT, 1);
+    if (session.history.length > maxHistory) {
+      session.history = session.history.slice(-maxHistory);
+    }
+  }
+
+  session.updatedAt = new Date().toISOString();
+  return cloneSession(session);
+};
+
+export const setConversationSessionIntent = ({ chatId, userId, scope = 'private', intent = null, ttlMs } = {}) => {
+  const session = getOrCreateSession({ chatId, userId, scope, ttlMs });
+  if (!session) return null;
+
+  session.lastIntent =
+    intent && typeof intent === 'object'
+      ? {
+          ...intent,
+          updatedAt: new Date().toISOString(),
+        }
+      : null;
+  session.updatedAt = new Date().toISOString();
+  return cloneSession(session);
+};
+
+export const clearConversationSession = ({ chatId, userId, scope = 'private' } = {}) => {
+  const key = buildSessionKey({ chatId, userId, scope });
+  if (!key) return false;
+  return sessions.delete(key);
+};
+
+export const getConversationSessionStoreStats = () => {
+  pruneExpiredSessions();
+  return {
+    activeSessions: sessions.size,
+  };
+};

package/app/store/groupConfigStore.js

@@ -0,0 +1,58 @@
+import logger from '#logger';
+import { findById, upsert } from '../../database/index.js';
+
+const groupConfigStore = {
+  /**
+   * Recupera a configuracao de um grupo especifico.
+   * @param {string} groupId - O JID do grupo.
+   * @returns {object} A configuracao do grupo, ou um objeto vazio se nao encontrado.
+   */
+  getGroupConfig: async function (groupId) {
+    try {
+      const record = await findById('group_configs', groupId);
+      if (!record || record.config === null || record.config === undefined) {
+        return {};
+      }
+      if (Buffer.isBuffer(record.config)) {
+        return JSON.parse(record.config.toString('utf8'));
+      }
+      if (typeof record.config === 'string') {
+        return JSON.parse(record.config);
+      }
+      return record.config || {};
+    } catch (error) {
+      logger.error('Error loading group configuration from DB:', {
+        error: error.message,
+        groupId,
+      });
+      return {};
+    }
+  },
+
+  /**
+   * Atualiza a configuracao de um grupo especifico.
+   * @param {string} groupId - O JID do grupo.
+   * @param {object} newConfig - O novo objeto de configuracao para mesclar.
+   * @param {string} [newConfig.welcomeMedia] - Caminho opcional para midia de boas-vindas.
+   * @param {string} [newConfig.farewellMedia] - Caminho opcional para midia de despedida.
+   */
+  updateGroupConfig: async function (groupId, newConfig) {
+    const currentConfig = await this.getGroupConfig(groupId);
+    const updatedConfig = { ...currentConfig, ...newConfig };
+    try {
+      await upsert('group_configs', {
+        id: groupId,
+        config: JSON.stringify(updatedConfig),
+      });
+      return updatedConfig;
+    } catch (error) {
+      logger.error('Error updating group configuration in DB:', {
+        error: error.message,
+        groupId,
+      });
+      throw error;
+    }
+  },
+};
+
+export default groupConfigStore;

package/app/store/premiumUserStore.js

@@ -0,0 +1,54 @@
+import groupConfigStore from './groupConfigStore.js';
+import { isSameJidUser, normalizeJid } from '../config/index.js';
+
+const PREMIUM_CONFIG_ID = 'system:premium_users';
+
+const normalizePremiumEntry = (value) => {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+  return normalizeJid(raw) || raw;
+};
+
+const normalizeList = (list) => {
+  const normalizedList = [];
+  const values = Array.isArray(list) ? list : [];
+
+  for (const value of values) {
+    const normalized = normalizePremiumEntry(value);
+    if (!normalized) continue;
+    if (normalizedList.some((entry) => entry === normalized || isSameJidUser(entry, normalized))) continue;
+    normalizedList.push(normalized);
+  }
+
+  return normalizedList;
+};
+
+const premiumUserStore = {
+  getPremiumUsers: async function () {
+    const config = await groupConfigStore.getGroupConfig(PREMIUM_CONFIG_ID);
+    return normalizeList(config.premiumUsers);
+  },
+
+  setPremiumUsers: async function (premiumUsers) {
+    const normalized = normalizeList(premiumUsers);
+    await groupConfigStore.updateGroupConfig(PREMIUM_CONFIG_ID, { premiumUsers: normalized });
+    return normalized;
+  },
+
+  addPremiumUsers: async function (usersToAdd) {
+    const current = await this.getPremiumUsers();
+    const updated = normalizeList([...current, ...usersToAdd]);
+    await groupConfigStore.updateGroupConfig(PREMIUM_CONFIG_ID, { premiumUsers: updated });
+    return updated;
+  },
+
+  removePremiumUsers: async function (usersToRemove) {
+    const current = await this.getPremiumUsers();
+    const normalizedTargets = normalizeList(usersToRemove);
+    const updated = current.filter((jid) => !normalizedTargets.some((target) => target === jid || isSameJidUser(target, jid)));
+    await groupConfigStore.updateGroupConfig(PREMIUM_CONFIG_ID, { premiumUsers: updated });
+    return updated;
+  },
+};
+
+export default premiumUserStore;