levix-bot 4.4.0 → 4.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +3 -2
- package/package.json +1 -1
- package/public/dashboard/assets/index-Con1xdhN.js +515 -0
- package/public/dashboard/assets/index-De78KNvv.css +2 -0
- package/public/dashboard/index.html +2 -2
- package/scheduler.cjs +66 -7
- package/src/commands/autodelete.cjs +213 -0
- package/src/commands/pack.cjs +46 -25
- package/src/commands/packs.cjs +4 -1
- package/src/commands/shortlink.cjs +273 -66
- package/src/commands/stickers.cjs +26 -8
- package/src/config/defaults.cjs +1 -0
- package/src/config/settings.cjs +10 -0
- package/src/core/session.js +9 -1
- package/src/db/db.cjs +63 -0
- package/src/db/store.cjs +259 -3
- package/src/handlers/command.handler.js +1 -0
- package/src/handlers/message.handler.js +15 -0
- package/src/panel/feedback.cjs +43 -14
- package/src/routes/dashboard.api.esm.js +212 -15
- package/src/services/autoDelete.cjs +576 -0
- package/src/services/llmDiscovery.cjs +32 -10
- package/src/stickers/errors.cjs +7 -6
- package/src/stickers/library.cjs +118 -13
- package/src/utils/bidi.cjs +21 -0
- package/src/utils/multipart.esm.js +81 -0
- package/src/utils/storage.cjs +13 -0
- package/src/utils/storage.esm.js +14 -0
- package/public/dashboard/assets/index-5P8GnKLg.css +0 -2
- package/public/dashboard/assets/index-DXzno3X6.js +0 -515
|
@@ -0,0 +1,576 @@
|
|
|
1
|
+
// Keyword auto-delete: rules, matching, and the per-message delete hook.
|
|
2
|
+
//
|
|
3
|
+
// Keywords are stored and returned as entered: trimmed, NFC, internal
|
|
4
|
+
// whitespace collapsed. Matching uses a normalized form (NFKC, Arabic
|
|
5
|
+
// diacritics/alef/ya, lowercase, collapsed whitespace), derived on first
|
|
6
|
+
// match and memoized per cached rule object, next to the compiled word
|
|
7
|
+
// patterns. The store drops those objects on any write.
|
|
8
|
+
// De-duplication uses that normalized form and keeps the first spelling.
|
|
9
|
+
// Rows saved before this split are already normalized; normalization is
|
|
10
|
+
// idempotent, so they keep matching without a migration.
|
|
11
|
+
//
|
|
12
|
+
// The first enabled rule that matches wins. A message that invokes this
|
|
13
|
+
// command is exempt only when the sender may run it right now, so
|
|
14
|
+
// `!autodelete add x` cannot delete itself while a member writing
|
|
15
|
+
// `!autodelete <keyword>` still matches.
|
|
16
|
+
|
|
17
|
+
const logger = require("../utils/logger.cjs");
|
|
18
|
+
const normalizeJid = require("../utils/normalizeJid.cjs");
|
|
19
|
+
const { resolveGroupMetadata } = require("../utils/groupMetadataCache.cjs");
|
|
20
|
+
const { mediaType } = require("../utils/messageContent.cjs");
|
|
21
|
+
const store = require("../db/store.cjs");
|
|
22
|
+
|
|
23
|
+
const MAX_RULES = 100;
|
|
24
|
+
const MAX_KEYWORDS = 50;
|
|
25
|
+
const MAX_KEYWORD_CHARS = 100;
|
|
26
|
+
const MAX_NAME_CHARS = 60;
|
|
27
|
+
const MAX_SENDERS = 200;
|
|
28
|
+
const LOG_TEXT_MAX = 8000;
|
|
29
|
+
const DECLARED_ALIASES = ["ad", "حذف_تلقائي"];
|
|
30
|
+
|
|
31
|
+
const MATCH_MODES = new Set(["contains", "word", "exact"]);
|
|
32
|
+
const CHAT_SCOPES = new Set(["all", "groups", "private"]);
|
|
33
|
+
const SENDER_MODES = new Set(["everyone", "selected"]);
|
|
34
|
+
|
|
35
|
+
const TASHKEEL = /[\u064B-\u065F\u0670\u0640]/g;
|
|
36
|
+
const ALEF_VARIANTS = /[\u0622\u0623\u0625\u0671]/g;
|
|
37
|
+
const ALEF_MAKSURA = /\u0649/g;
|
|
38
|
+
const REGEX_ESCAPE = /[.*+?^${}()|[\]\\]/g;
|
|
39
|
+
|
|
40
|
+
class AutoDeleteError extends Error {
|
|
41
|
+
constructor(message, status = 400) {
|
|
42
|
+
super(message);
|
|
43
|
+
this.name = "AutoDeleteError";
|
|
44
|
+
this.status = status;
|
|
45
|
+
}
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
function asBool(value, field) {
|
|
49
|
+
if (typeof value === "boolean") return value;
|
|
50
|
+
throw new AutoDeleteError(`${field} must be true or false`);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
function escapeRegex(value) {
|
|
54
|
+
return String(value).replace(REGEX_ESCAPE, "\\$&");
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
function wordPattern(keyword) {
|
|
58
|
+
return new RegExp(
|
|
59
|
+
`(?<![\\p{L}\\p{N}\\p{M}])${escapeRegex(keyword)}(?![\\p{L}\\p{N}\\p{M}])`,
|
|
60
|
+
"u",
|
|
61
|
+
);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
// Normalized keywords and word-mode regexes, one entry per cached rule object.
|
|
65
|
+
// The store drops those objects when the rule cache is rebuilt (any write).
|
|
66
|
+
const matchIndexByRule = new WeakMap();
|
|
67
|
+
|
|
68
|
+
function compileWordPatterns(keywords) {
|
|
69
|
+
return (keywords || []).map((keyword) => {
|
|
70
|
+
try {
|
|
71
|
+
return wordPattern(keyword);
|
|
72
|
+
} catch {
|
|
73
|
+
return null;
|
|
74
|
+
}
|
|
75
|
+
});
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
function indexRuleForMatch(rule) {
|
|
79
|
+
const matchKeywords = (rule?.keywords || []).map((keyword) => normalizeMatchText(keyword));
|
|
80
|
+
const patterns = rule?.match === "word" ? compileWordPatterns(matchKeywords) : null;
|
|
81
|
+
const index = { matchKeywords, patterns };
|
|
82
|
+
if (rule && typeof rule === "object") matchIndexByRule.set(rule, index);
|
|
83
|
+
return index;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
function matchIndexFor(rule) {
|
|
87
|
+
if (rule && typeof rule === "object") {
|
|
88
|
+
const cached = matchIndexByRule.get(rule);
|
|
89
|
+
if (cached) return cached;
|
|
90
|
+
}
|
|
91
|
+
return indexRuleForMatch(rule);
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
/** Visible text ready to compare: NFKC, tashkeel/tatweel stripped, alef/ya unified. */
|
|
95
|
+
function normalizeMatchText(input) {
|
|
96
|
+
let text = String(input ?? "");
|
|
97
|
+
text = text.normalize("NFKC");
|
|
98
|
+
text = text.replace(TASHKEEL, "");
|
|
99
|
+
text = text.replace(ALEF_VARIANTS, "\u0627");
|
|
100
|
+
text = text.replace(ALEF_MAKSURA, "\u064A");
|
|
101
|
+
text = text.toLowerCase();
|
|
102
|
+
text = text.replace(/\s+/g, " ").trim();
|
|
103
|
+
return text;
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
/** Spelling we store and show. Matching goes through normalizeMatchText. */
|
|
107
|
+
function displayKeyword(input) {
|
|
108
|
+
return String(input ?? "")
|
|
109
|
+
.normalize("NFC")
|
|
110
|
+
.replace(/\s+/g, " ")
|
|
111
|
+
.trim();
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
function keywordMatches(normalizedText, keyword, mode, compiledPattern) {
|
|
115
|
+
if (!normalizedText || !keyword) return false;
|
|
116
|
+
if (mode === "exact") return normalizedText === keyword;
|
|
117
|
+
if (mode === "word") {
|
|
118
|
+
try {
|
|
119
|
+
const re = compiledPattern || wordPattern(keyword);
|
|
120
|
+
return re.test(normalizedText);
|
|
121
|
+
} catch {
|
|
122
|
+
return false;
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
return normalizedText.includes(keyword);
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
function senderListMatches(list, candidates, sameUser) {
|
|
129
|
+
if (!Array.isArray(list) || !list.length || !candidates?.length) return false;
|
|
130
|
+
for (const candidate of candidates) {
|
|
131
|
+
for (const entry of list) {
|
|
132
|
+
if (sameUser(entry, candidate)) return true;
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
return false;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
function ruleMatches(rule, ctx) {
|
|
139
|
+
if (!rule?.enabled) return false;
|
|
140
|
+
if (ctx.fromMe && !rule.includeOwn) return false;
|
|
141
|
+
if (rule.chatScope === "groups" && !ctx.isGroup) return false;
|
|
142
|
+
if (rule.chatScope === "private" && ctx.isGroup) return false;
|
|
143
|
+
if (rule.senders?.mode === "selected") {
|
|
144
|
+
if (!senderListMatches(rule.senders.list, ctx.senderCandidates, ctx.sameUser)) return false;
|
|
145
|
+
}
|
|
146
|
+
const { matchKeywords, patterns } = matchIndexFor(rule);
|
|
147
|
+
return matchKeywords.some((keyword, i) =>
|
|
148
|
+
keywordMatches(ctx.normalizedText, keyword, rule.match, patterns ? patterns[i] : undefined),
|
|
149
|
+
);
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
function chooseDeleteMode({ forEveryone, fromMe, isGroup, botIsAdmin }) {
|
|
153
|
+
if (!forEveryone) return "deleteForMe";
|
|
154
|
+
if (fromMe) return "revoke";
|
|
155
|
+
if (isGroup && botIsAdmin) return "revoke";
|
|
156
|
+
return "deleteForMe";
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
function looksLikeManagementCommand(body) {
|
|
160
|
+
if (!body) return false;
|
|
161
|
+
const runtimeConfig = require("../config/runtime-config.cjs");
|
|
162
|
+
const prefix = runtimeConfig.getPrefix();
|
|
163
|
+
if (!body.startsWith(prefix)) return false;
|
|
164
|
+
const token = body.slice(prefix.length).trim().split(/\s+/)[0];
|
|
165
|
+
if (!token) return false;
|
|
166
|
+
const name = token.toLowerCase();
|
|
167
|
+
if (name === "autodelete") return true;
|
|
168
|
+
const aliases = runtimeConfig.getAliases("autodelete", DECLARED_ALIASES);
|
|
169
|
+
return aliases.some((alias) => String(alias).toLowerCase() === name);
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
let resolveSenderFn = null;
|
|
173
|
+
|
|
174
|
+
async function loadResolveSender() {
|
|
175
|
+
if (!resolveSenderFn) {
|
|
176
|
+
const mod = await import("../middleware/permissions.middleware.js");
|
|
177
|
+
resolveSenderFn = mod.resolveSender;
|
|
178
|
+
}
|
|
179
|
+
return resolveSenderFn;
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
/**
|
|
183
|
+
* Exempt only when the sender may actually run !autodelete right now: the
|
|
184
|
+
* command is not disabled, and they pass its live permission level the same
|
|
185
|
+
* way the dispatcher does (fromMe counts as the owner). Prefix+name/alias is
|
|
186
|
+
* the cheap gate; permission work runs only after that hits.
|
|
187
|
+
*/
|
|
188
|
+
async function isManagementCommand(body, msg, sock) {
|
|
189
|
+
if (!looksLikeManagementCommand(body)) return false;
|
|
190
|
+
try {
|
|
191
|
+
const runtimeConfig = require("../config/runtime-config.cjs");
|
|
192
|
+
if (runtimeConfig.isDisabled("autodelete")) return false;
|
|
193
|
+
const { evaluatePermissionLevel } = require("../utils/permissionLevel.cjs");
|
|
194
|
+
const resolveSender = await loadResolveSender();
|
|
195
|
+
const isGroup = Boolean(msg?.key?.remoteJid?.endsWith("@g.us"));
|
|
196
|
+
const groupMetadata = isGroup ? await resolveGroupMetadata(sock, msg.key.remoteJid) : null;
|
|
197
|
+
const sender = resolveSender(msg, groupMetadata, sock);
|
|
198
|
+
const level = runtimeConfig.getPermission("autodelete");
|
|
199
|
+
return Boolean(evaluatePermissionLevel(level, sender).hasPermission);
|
|
200
|
+
} catch (error) {
|
|
201
|
+
logger.debug({ err: error }, "[auto-delete] management-command auth failed");
|
|
202
|
+
return false;
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
function normalizeKeywords(raw) {
|
|
207
|
+
if (!Array.isArray(raw)) throw new AutoDeleteError("keywords must be a list of strings");
|
|
208
|
+
if (raw.length < 1 || raw.length > MAX_KEYWORDS) {
|
|
209
|
+
throw new AutoDeleteError("A rule needs 1 to 50 keywords");
|
|
210
|
+
}
|
|
211
|
+
const seen = new Set();
|
|
212
|
+
const out = [];
|
|
213
|
+
for (const item of raw) {
|
|
214
|
+
if (typeof item !== "string" && typeof item !== "number") {
|
|
215
|
+
throw new AutoDeleteError("Each keyword must be a string");
|
|
216
|
+
}
|
|
217
|
+
const displayed = displayKeyword(item);
|
|
218
|
+
if (displayed.length < 1 || displayed.length > MAX_KEYWORD_CHARS) {
|
|
219
|
+
throw new AutoDeleteError("Each keyword must be 1 to 100 characters");
|
|
220
|
+
}
|
|
221
|
+
const normalized = normalizeMatchText(displayed);
|
|
222
|
+
if (!normalized) throw new AutoDeleteError("Keyword is empty after normalization");
|
|
223
|
+
if (seen.has(normalized)) continue;
|
|
224
|
+
seen.add(normalized);
|
|
225
|
+
out.push(displayed);
|
|
226
|
+
}
|
|
227
|
+
if (!out.length) throw new AutoDeleteError("A rule needs 1 to 50 keywords");
|
|
228
|
+
return out;
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
function normalizeSenderEntry(value) {
|
|
232
|
+
const raw = String(value ?? "").trim();
|
|
233
|
+
if (!raw) return null;
|
|
234
|
+
const lower = raw.toLowerCase();
|
|
235
|
+
if (lower.endsWith("@g.us") || lower.endsWith("@broadcast") || lower.endsWith("@newsletter")) {
|
|
236
|
+
throw new AutoDeleteError("Senders must be contacts, not groups");
|
|
237
|
+
}
|
|
238
|
+
if (raw.includes("@")) return normalizeJid(raw);
|
|
239
|
+
const digits = raw.replace(/\D/g, "");
|
|
240
|
+
if (digits.length >= 8 && digits.length <= 15) return `${digits}@s.whatsapp.net`;
|
|
241
|
+
throw new AutoDeleteError(`Invalid sender: ${raw}`);
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
function normalizeSenders(senders) {
|
|
245
|
+
if (senders == null) return { mode: "everyone", list: [] };
|
|
246
|
+
if (typeof senders !== "object" || Array.isArray(senders)) {
|
|
247
|
+
throw new AutoDeleteError("senders must be { mode, list }");
|
|
248
|
+
}
|
|
249
|
+
const mode = senders.mode == null ? "everyone" : String(senders.mode);
|
|
250
|
+
if (!SENDER_MODES.has(mode)) {
|
|
251
|
+
throw new AutoDeleteError('senders.mode must be "everyone" or "selected"');
|
|
252
|
+
}
|
|
253
|
+
const list = senders.list == null ? [] : senders.list;
|
|
254
|
+
if (!Array.isArray(list)) throw new AutoDeleteError("senders.list must be a list");
|
|
255
|
+
if (list.length > MAX_SENDERS) throw new AutoDeleteError("Too many senders (max 200)");
|
|
256
|
+
const seen = new Set();
|
|
257
|
+
const normalized = [];
|
|
258
|
+
for (const entry of list) {
|
|
259
|
+
const jid = normalizeSenderEntry(entry);
|
|
260
|
+
if (!jid || seen.has(jid)) continue;
|
|
261
|
+
seen.add(jid);
|
|
262
|
+
normalized.push(jid);
|
|
263
|
+
}
|
|
264
|
+
if (mode === "selected" && !normalized.length) {
|
|
265
|
+
throw new AutoDeleteError("Select at least one sender");
|
|
266
|
+
}
|
|
267
|
+
return { mode, list: mode === "everyone" ? [] : normalized };
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
function validateRuleInput(input = {}, { partial = false } = {}) {
|
|
271
|
+
if (input == null || typeof input !== "object" || Array.isArray(input)) {
|
|
272
|
+
throw new AutoDeleteError("Invalid rule");
|
|
273
|
+
}
|
|
274
|
+
const out = {};
|
|
275
|
+
|
|
276
|
+
if (!partial || input.name !== undefined) {
|
|
277
|
+
if (input.name == null || input.name === "") {
|
|
278
|
+
out.name = null;
|
|
279
|
+
} else {
|
|
280
|
+
const name = String(input.name).trim();
|
|
281
|
+
if (name.length > MAX_NAME_CHARS) {
|
|
282
|
+
throw new AutoDeleteError("Name must be 60 characters or fewer");
|
|
283
|
+
}
|
|
284
|
+
out.name = name || null;
|
|
285
|
+
}
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
if (!partial || input.enabled !== undefined) {
|
|
289
|
+
out.enabled = input.enabled === undefined ? true : asBool(input.enabled, "enabled");
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
if (!partial || input.keywords !== undefined) {
|
|
293
|
+
out.keywords = normalizeKeywords(input.keywords);
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
if (!partial || input.match !== undefined) {
|
|
297
|
+
const match = input.match === undefined ? "contains" : String(input.match);
|
|
298
|
+
if (!MATCH_MODES.has(match)) {
|
|
299
|
+
throw new AutoDeleteError('match must be "contains", "word", or "exact"');
|
|
300
|
+
}
|
|
301
|
+
out.match = match;
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
if (!partial || input.chatScope !== undefined) {
|
|
305
|
+
const chatScope = input.chatScope === undefined ? "all" : String(input.chatScope);
|
|
306
|
+
if (!CHAT_SCOPES.has(chatScope)) {
|
|
307
|
+
throw new AutoDeleteError('chatScope must be "all", "groups", or "private"');
|
|
308
|
+
}
|
|
309
|
+
out.chatScope = chatScope;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
if (!partial) {
|
|
313
|
+
out.senders = normalizeSenders(input.senders);
|
|
314
|
+
} else if (input.senders !== undefined) {
|
|
315
|
+
out.senders = input.senders;
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
if (!partial || input.includeOwn !== undefined) {
|
|
319
|
+
out.includeOwn =
|
|
320
|
+
input.includeOwn === undefined ? false : asBool(input.includeOwn, "includeOwn");
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
if (!partial || input.forEveryone !== undefined) {
|
|
324
|
+
out.forEveryone =
|
|
325
|
+
input.forEveryone === undefined ? true : asBool(input.forEveryone, "forEveryone");
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
if (!partial || input.keepCopy !== undefined) {
|
|
329
|
+
out.keepCopy = input.keepCopy === undefined ? false : asBool(input.keepCopy, "keepCopy");
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
return out;
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
function parseRuleId(value) {
|
|
336
|
+
const id = Number(value);
|
|
337
|
+
if (!Number.isInteger(id) || id <= 0) throw new AutoDeleteError("Invalid rule id");
|
|
338
|
+
return id;
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
function requireRule(id) {
|
|
342
|
+
const rule = store.getAutoDeleteRule(id);
|
|
343
|
+
if (!rule) throw new AutoDeleteError("Rule not found", 404);
|
|
344
|
+
return rule;
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
function listRules() {
|
|
348
|
+
return store.listAutoDeleteRules();
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
function getRule(id) {
|
|
352
|
+
return requireRule(parseRuleId(id));
|
|
353
|
+
}
|
|
354
|
+
|
|
355
|
+
function createRule(input) {
|
|
356
|
+
if (store.countAutoDeleteRules() >= MAX_RULES) {
|
|
357
|
+
throw new AutoDeleteError("You can keep at most 100 auto-delete rules");
|
|
358
|
+
}
|
|
359
|
+
const fields = validateRuleInput(input, { partial: false });
|
|
360
|
+
if (!fields.keywords?.length) throw new AutoDeleteError("A rule needs 1 to 50 keywords");
|
|
361
|
+
return store.insertAutoDeleteRule(fields);
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
function updateRule(id, input) {
|
|
365
|
+
const ruleId = parseRuleId(id);
|
|
366
|
+
const existing = requireRule(ruleId);
|
|
367
|
+
const fields = validateRuleInput(input, { partial: true });
|
|
368
|
+
if (input?.senders !== undefined) {
|
|
369
|
+
const merged = {
|
|
370
|
+
mode: input.senders?.mode ?? existing.senders.mode,
|
|
371
|
+
list: input.senders?.list ?? existing.senders.list,
|
|
372
|
+
};
|
|
373
|
+
fields.senders = normalizeSenders(merged);
|
|
374
|
+
}
|
|
375
|
+
return store.updateAutoDeleteRule(ruleId, fields);
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
function deleteRule(id) {
|
|
379
|
+
const ruleId = parseRuleId(id);
|
|
380
|
+
requireRule(ruleId);
|
|
381
|
+
store.deleteAutoDeleteRule(ruleId);
|
|
382
|
+
return true;
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
function resetCounter(id) {
|
|
386
|
+
const ruleId = parseRuleId(id);
|
|
387
|
+
requireRule(ruleId);
|
|
388
|
+
return store.resetAutoDeleteCounter(ruleId);
|
|
389
|
+
}
|
|
390
|
+
|
|
391
|
+
function listLog({ ruleId, limit, offset } = {}) {
|
|
392
|
+
let parsedRuleId;
|
|
393
|
+
if (ruleId !== undefined && ruleId !== null && ruleId !== "") {
|
|
394
|
+
parsedRuleId = parseRuleId(ruleId);
|
|
395
|
+
}
|
|
396
|
+
let parsedLimit = 50;
|
|
397
|
+
if (limit !== undefined && limit !== null && limit !== "") {
|
|
398
|
+
parsedLimit = Number(limit);
|
|
399
|
+
if (!Number.isInteger(parsedLimit) || parsedLimit < 1) {
|
|
400
|
+
throw new AutoDeleteError("limit must be a positive integer");
|
|
401
|
+
}
|
|
402
|
+
}
|
|
403
|
+
if (parsedLimit > 200) parsedLimit = 200;
|
|
404
|
+
let parsedOffset = 0;
|
|
405
|
+
if (offset !== undefined && offset !== null && offset !== "") {
|
|
406
|
+
parsedOffset = Number(offset);
|
|
407
|
+
if (!Number.isInteger(parsedOffset) || parsedOffset < 0) {
|
|
408
|
+
throw new AutoDeleteError("offset must be a non-negative integer");
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
return store.listAutoDeleteLog({
|
|
412
|
+
ruleId: parsedRuleId,
|
|
413
|
+
limit: parsedLimit,
|
|
414
|
+
offset: parsedOffset,
|
|
415
|
+
});
|
|
416
|
+
}
|
|
417
|
+
|
|
418
|
+
function clearLog(ruleId) {
|
|
419
|
+
let parsed;
|
|
420
|
+
if (ruleId !== undefined && ruleId !== null && ruleId !== "") {
|
|
421
|
+
parsed = parseRuleId(ruleId);
|
|
422
|
+
requireRule(parsed);
|
|
423
|
+
}
|
|
424
|
+
return store.clearAutoDeleteLog(parsed);
|
|
425
|
+
}
|
|
426
|
+
|
|
427
|
+
function messageTimestampOf(msg) {
|
|
428
|
+
const n = Number(msg?.messageTimestamp);
|
|
429
|
+
return Number.isFinite(n) ? n : 0;
|
|
430
|
+
}
|
|
431
|
+
|
|
432
|
+
async function performDelete(sock, msg, mode) {
|
|
433
|
+
const jid = msg.key.remoteJid;
|
|
434
|
+
if (mode === "revoke") {
|
|
435
|
+
try {
|
|
436
|
+
await sock.sendMessage(jid, { delete: msg.key });
|
|
437
|
+
return "revoke";
|
|
438
|
+
} catch (error) {
|
|
439
|
+
logger.warn({ err: error }, "[auto-delete] revoke failed, falling back to delete-for-me");
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
await sock.chatModify(
|
|
443
|
+
{
|
|
444
|
+
deleteForMe: {
|
|
445
|
+
deleteMedia: false,
|
|
446
|
+
key: msg.key,
|
|
447
|
+
timestamp: messageTimestampOf(msg),
|
|
448
|
+
},
|
|
449
|
+
},
|
|
450
|
+
jid,
|
|
451
|
+
);
|
|
452
|
+
return "deleteForMe";
|
|
453
|
+
}
|
|
454
|
+
|
|
455
|
+
async function identityHelpers(passed = {}) {
|
|
456
|
+
if (passed.sameUser && passed.getSenderCandidates && passed.isBotAdminInGroup) {
|
|
457
|
+
return passed;
|
|
458
|
+
}
|
|
459
|
+
const mod = await import("../utils/permissions.esm.js");
|
|
460
|
+
return {
|
|
461
|
+
sameUser: passed.sameUser || mod.sameUser,
|
|
462
|
+
getSenderCandidates: passed.getSenderCandidates || mod.getSenderCandidates,
|
|
463
|
+
isBotAdminInGroup: passed.isBotAdminInGroup || mod.isBotAdminInGroup,
|
|
464
|
+
};
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
function keepCopyText(body) {
|
|
468
|
+
const text = String(body ?? "");
|
|
469
|
+
if (text.length <= LOG_TEXT_MAX) return text;
|
|
470
|
+
return text.slice(0, LOG_TEXT_MAX);
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
/**
|
|
474
|
+
* Per-message hook. Returns true when a rule successfully deleted the message
|
|
475
|
+
* (caller must stop the rest of the pipeline). Never throws.
|
|
476
|
+
*/
|
|
477
|
+
async function handleIncoming(sock, msg, body, helpers) {
|
|
478
|
+
try {
|
|
479
|
+
const enabled = store.listEnabledAutoDeleteRules();
|
|
480
|
+
if (!enabled.length) return false;
|
|
481
|
+
if (await isManagementCommand(body, msg, sock)) return false;
|
|
482
|
+
const normalizedText = normalizeMatchText(body);
|
|
483
|
+
if (!normalizedText) return false;
|
|
484
|
+
|
|
485
|
+
const ident = await identityHelpers(helpers);
|
|
486
|
+
const isGroup = Boolean(msg.key?.remoteJid?.endsWith("@g.us"));
|
|
487
|
+
const fromMe = Boolean(msg.key?.fromMe);
|
|
488
|
+
const senderCandidates = ident.getSenderCandidates(msg, sock);
|
|
489
|
+
|
|
490
|
+
let matched = null;
|
|
491
|
+
for (const rule of enabled) {
|
|
492
|
+
if (
|
|
493
|
+
ruleMatches(rule, {
|
|
494
|
+
normalizedText,
|
|
495
|
+
isGroup,
|
|
496
|
+
fromMe,
|
|
497
|
+
senderCandidates,
|
|
498
|
+
sameUser: ident.sameUser,
|
|
499
|
+
})
|
|
500
|
+
) {
|
|
501
|
+
matched = rule;
|
|
502
|
+
break;
|
|
503
|
+
}
|
|
504
|
+
}
|
|
505
|
+
if (!matched) return false;
|
|
506
|
+
|
|
507
|
+
let botIsAdmin = false;
|
|
508
|
+
if (matched.forEveryone && !fromMe && isGroup) {
|
|
509
|
+
const meta = await resolveGroupMetadata(sock, msg.key.remoteJid);
|
|
510
|
+
botIsAdmin = ident.isBotAdminInGroup(meta, sock);
|
|
511
|
+
}
|
|
512
|
+
const intended = chooseDeleteMode({
|
|
513
|
+
forEveryone: matched.forEveryone,
|
|
514
|
+
fromMe,
|
|
515
|
+
isGroup,
|
|
516
|
+
botIsAdmin,
|
|
517
|
+
});
|
|
518
|
+
|
|
519
|
+
let used;
|
|
520
|
+
try {
|
|
521
|
+
used = await performDelete(sock, msg, intended);
|
|
522
|
+
} catch (error) {
|
|
523
|
+
logger.error({ err: error, ruleId: matched.id }, "[auto-delete] delete failed");
|
|
524
|
+
return false;
|
|
525
|
+
}
|
|
526
|
+
|
|
527
|
+
store.incrementAutoDeleteCounter(matched.id);
|
|
528
|
+
if (matched.keepCopy) {
|
|
529
|
+
try {
|
|
530
|
+
store.insertAutoDeleteLog({
|
|
531
|
+
ruleId: matched.id,
|
|
532
|
+
chatJid: msg.key.remoteJid,
|
|
533
|
+
sender: senderCandidates[0] || null,
|
|
534
|
+
text: keepCopyText(body),
|
|
535
|
+
mediaType: mediaType(msg.message) || "",
|
|
536
|
+
mode: used,
|
|
537
|
+
});
|
|
538
|
+
} catch (error) {
|
|
539
|
+
logger.error({ err: error, ruleId: matched.id }, "[auto-delete] keepCopy failed");
|
|
540
|
+
}
|
|
541
|
+
}
|
|
542
|
+
logger.debug({ ruleId: matched.id, mode: used }, "[auto-delete] deleted a message");
|
|
543
|
+
return true;
|
|
544
|
+
} catch (error) {
|
|
545
|
+
logger.error({ err: error }, "[auto-delete] hook failed");
|
|
546
|
+
return false;
|
|
547
|
+
}
|
|
548
|
+
}
|
|
549
|
+
|
|
550
|
+
module.exports = {
|
|
551
|
+
AutoDeleteError,
|
|
552
|
+
MAX_RULES,
|
|
553
|
+
MAX_KEYWORDS,
|
|
554
|
+
MAX_KEYWORD_CHARS,
|
|
555
|
+
MAX_NAME_CHARS,
|
|
556
|
+
DECLARED_ALIASES,
|
|
557
|
+
MATCH_MODES,
|
|
558
|
+
CHAT_SCOPES,
|
|
559
|
+
normalizeMatchText,
|
|
560
|
+
keywordMatches,
|
|
561
|
+
ruleMatches,
|
|
562
|
+
chooseDeleteMode,
|
|
563
|
+
isManagementCommand,
|
|
564
|
+
validateRuleInput,
|
|
565
|
+
parseRuleId,
|
|
566
|
+
listRules,
|
|
567
|
+
getRule,
|
|
568
|
+
createRule,
|
|
569
|
+
updateRule,
|
|
570
|
+
deleteRule,
|
|
571
|
+
resetCounter,
|
|
572
|
+
listLog,
|
|
573
|
+
clearLog,
|
|
574
|
+
handleIncoming,
|
|
575
|
+
performDelete,
|
|
576
|
+
};
|
|
@@ -49,11 +49,15 @@ async function requestJson(url, { headers, timeoutMs = REQUEST_TIMEOUT_MS } = {}
|
|
|
49
49
|
const controller = new AbortController();
|
|
50
50
|
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
51
51
|
try {
|
|
52
|
-
const resp = await safeProviderFetch(
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
52
|
+
const resp = await safeProviderFetch(
|
|
53
|
+
url,
|
|
54
|
+
{
|
|
55
|
+
method: "GET",
|
|
56
|
+
headers: { Accept: "application/json", ...headers },
|
|
57
|
+
signal: controller.signal,
|
|
58
|
+
},
|
|
59
|
+
{ allowLoopback: true },
|
|
60
|
+
);
|
|
57
61
|
return resp;
|
|
58
62
|
} catch (err) {
|
|
59
63
|
if (err && err.name === "AbortError") {
|
|
@@ -306,10 +310,9 @@ class GeminiDiscoveryAdapter extends BaseDiscoveryAdapter {
|
|
|
306
310
|
|
|
307
311
|
async discover({ apiKey, baseUrl = "https://generativelanguage.googleapis.com" }) {
|
|
308
312
|
const key = this.validateCredentials(apiKey);
|
|
309
|
-
const rootUrl = assertProviderBaseUrl(
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
);
|
|
313
|
+
const rootUrl = assertProviderBaseUrl(baseUrl || "https://generativelanguage.googleapis.com", {
|
|
314
|
+
allowLoopback: true,
|
|
315
|
+
});
|
|
313
316
|
|
|
314
317
|
const rawList = [];
|
|
315
318
|
let pageToken = "";
|
|
@@ -386,7 +389,13 @@ async function discoverProviderModels(optionsOrProvider = "gemini", maybeOptions
|
|
|
386
389
|
options = optionsOrProvider;
|
|
387
390
|
}
|
|
388
391
|
|
|
389
|
-
const {
|
|
392
|
+
const {
|
|
393
|
+
provider = "gemini",
|
|
394
|
+
apiKey = "",
|
|
395
|
+
baseUrl = "",
|
|
396
|
+
refresh = false,
|
|
397
|
+
cacheOnly = false,
|
|
398
|
+
} = options;
|
|
390
399
|
const provKey = String(provider || "gemini").toLowerCase();
|
|
391
400
|
const adapter = ADAPTERS[provKey];
|
|
392
401
|
|
|
@@ -430,6 +439,19 @@ async function discoverProviderModels(optionsOrProvider = "gemini", maybeOptions
|
|
|
430
439
|
}
|
|
431
440
|
}
|
|
432
441
|
|
|
442
|
+
// Opening the panel must not spend a request on the operator's key: with
|
|
443
|
+
// nothing cached it gets the recommended list, and Refresh goes live.
|
|
444
|
+
if (cacheOnly && !refresh) {
|
|
445
|
+
return {
|
|
446
|
+
success: true,
|
|
447
|
+
live: false,
|
|
448
|
+
requiresApiKey: false,
|
|
449
|
+
fallback: true,
|
|
450
|
+
provider: provKey,
|
|
451
|
+
models: getSeedModels(provKey),
|
|
452
|
+
};
|
|
453
|
+
}
|
|
454
|
+
|
|
433
455
|
try {
|
|
434
456
|
const liveModels = await adapter.discover({
|
|
435
457
|
apiKey: cleanKey,
|
package/src/stickers/errors.cjs
CHANGED
|
@@ -8,6 +8,7 @@
|
|
|
8
8
|
// in `message` or `details`.
|
|
9
9
|
|
|
10
10
|
const { tr } = require("../utils/i18n.cjs");
|
|
11
|
+
const { isolate } = require("../utils/bidi.cjs");
|
|
11
12
|
|
|
12
13
|
const CODES = Object.freeze({
|
|
13
14
|
NO_MEDIA: "NO_MEDIA",
|
|
@@ -166,18 +167,18 @@ function message(pick, error) {
|
|
|
166
167
|
return pick("That sticker is not in your library.", "هذا الملصق غير موجود في مكتبتك.");
|
|
167
168
|
case "PACK_NOT_FOUND":
|
|
168
169
|
return pick(
|
|
169
|
-
`There is no pack named "${d.name || ""}".`,
|
|
170
|
-
`لا توجد حزمة باسم "${d.name || ""}".`,
|
|
170
|
+
`There is no pack named "${isolate(d.name || "")}".`,
|
|
171
|
+
`لا توجد حزمة باسم "${isolate(d.name || "")}".`,
|
|
171
172
|
);
|
|
172
173
|
case "PACK_EXISTS":
|
|
173
174
|
return pick(
|
|
174
|
-
`A pack named "${d.name || ""}" already exists.`,
|
|
175
|
-
`توجد حزمة باسم "${d.name || ""}" بالفعل.`,
|
|
175
|
+
`A pack named "${isolate(d.name || "")}" already exists.`,
|
|
176
|
+
`توجد حزمة باسم "${isolate(d.name || "")}" بالفعل.`,
|
|
176
177
|
);
|
|
177
178
|
case "INVALID_NAME":
|
|
178
179
|
return pick(
|
|
179
|
-
"Pack names are 1–40 letters, digits, spaces, - or
|
|
180
|
-
"اسم الحزمة من 1 إلى 40
|
|
180
|
+
"Pack names are 1–40 characters: letters, digits, spaces, - _ ' . & , or emoji, and can't be a command word.",
|
|
181
|
+
"اسم الحزمة من 1 إلى 40 حرفًا: حروف أو أرقام أو مسافات أو - _ ' . & , أو رموز تعبيرية، ولا يجوز أن يكون كلمة أمر.",
|
|
181
182
|
);
|
|
182
183
|
case "INVALID_OPTIONS":
|
|
183
184
|
return pick("Those sticker options are not valid.", "خيارات الملصق هذه غير صالحة.");
|