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.
@@ -38,8 +38,11 @@ import {
38
38
  getRecentDebts,
39
39
  getSchedules,
40
40
  rememberSavedName,
41
+ resolveUserPhone,
41
42
  saveGroupSettings,
42
43
  } from "../utils/storage.esm.js";
44
+ import normalizeJid, { isLidJid } from "../utils/normalizeJid.esm.js";
45
+ import { fileToBuffer, MultipartError, readMultipartForm } from "../utils/multipart.esm.js";
43
46
 
44
47
  const require = createRequire(import.meta.url);
45
48
  const logger = require("../utils/logger.cjs");
@@ -50,6 +53,7 @@ const secrets = require("../config/secrets.cjs");
50
53
  const { clientAddress } = require("../utils/requestOrigin.cjs");
51
54
  const { blockedFor, recordFailure, clearAttempts } = require("../panel/login-throttle.cjs");
52
55
  const {
56
+ ATTACHMENT_MAX: FEEDBACK_ATTACHMENT_MAX,
53
57
  TOPICS: FEEDBACK_TOPICS,
54
58
  MESSAGE_MAX: FEEDBACK_MESSAGE_MAX,
55
59
  MESSAGE_MIN: FEEDBACK_MESSAGE_MIN,
@@ -62,8 +66,10 @@ const { stampPanelSession } = require("../panel/session-auth.cjs");
62
66
  const { DATA_DIR } = require("../config/paths.cjs");
63
67
  const { PERSONA_FILE, activeProviderKeySetting } = require("../services/aiAgent.cjs");
64
68
  const {
69
+ SCHEDULE_MEDIA_MAX_BYTES,
65
70
  deleteScheduledJob,
66
71
  retryScheduledJob,
72
+ scheduleMediaPath,
67
73
  scheduleNewJob,
68
74
  saveScheduledJob,
69
75
  } = require("../../scheduler.cjs");
@@ -74,6 +80,7 @@ const {
74
80
  } = require("../utils/recurrence.cjs");
75
81
  const { discoverProviderModels, DiscoveryError } = require("../services/llmDiscovery.cjs");
76
82
  const settingsTransfer = require("../services/settingsTransfer.cjs");
83
+ const autoDelete = require("../services/autoDelete.cjs");
77
84
  const cron = require("node-cron");
78
85
 
79
86
  const router = Router();
@@ -412,6 +419,7 @@ router.post(
412
419
  apiKey,
413
420
  baseUrl,
414
421
  refresh = false,
422
+ cacheOnly = false,
415
423
  } = req.body || {};
416
424
 
417
425
  const provKey = String(provider || "gemini").toLowerCase();
@@ -438,6 +446,7 @@ router.post(
438
446
  apiKey: effectiveKey,
439
447
  baseUrl: effectiveBaseUrl,
440
448
  refresh: Boolean(refresh),
449
+ cacheOnly: Boolean(cacheOnly),
441
450
  });
442
451
 
443
452
  return res.json(result);
@@ -1008,16 +1017,22 @@ router.get("/recipients", (req, res) => {
1008
1017
  const users = getAllUsers() || [];
1009
1018
  users.sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0));
1010
1019
  for (const u of users.slice(0, 80)) {
1011
- const jid = u.jid;
1012
- if (!jid || seen.has(jid) || String(jid).endsWith("@g.us")) continue;
1013
- const peer = describePeer(jid);
1014
- const personKey = peer.phone || u.lid || jid;
1020
+ if (!u.jid || seen.has(u.jid) || String(u.jid).endsWith("@g.us")) continue;
1021
+ const peer = describePeer(u.jid);
1022
+ const personKey = peer.phone || u.lid || u.jid;
1015
1023
  if (seen.has(personKey)) continue;
1016
- seen.add(jid);
1024
+ // The phone-number JID wins when one is known: it is the stable
1025
+ // identity to schedule against, and it keeps an @lid row from ever
1026
+ // reaching the picker as a raw id.
1027
+ // peer.phone is the "+<digits>" display label; a JID wants the digits.
1028
+ const digits = peer.phone ? peer.phone.replace(/\D/g, "") : "";
1029
+ const id = digits ? `${digits}@s.whatsapp.net` : u.jid;
1030
+ seen.add(u.jid);
1031
+ seen.add(id);
1017
1032
  seen.add(personKey);
1018
1033
  if (u.lid) seen.add(u.lid);
1019
1034
  recipients.push({
1020
- id: jid,
1035
+ id,
1021
1036
  name: peer.label,
1022
1037
  phone: peer.phone,
1023
1038
  savedName: peer.savedName ?? null,
@@ -1032,6 +1047,32 @@ router.get("/recipients", (req, res) => {
1032
1047
  }
1033
1048
  });
1034
1049
 
1050
+ // The formats WhatsApp renders inline. Anything else (SVG, HEIC, MKV, WAV…)
1051
+ // would arrive as a broken image/video/voice bubble, so it goes as a document.
1052
+ const INLINE_IMAGE = new Set(["image/jpeg", "image/png", "image/webp"]);
1053
+ const INLINE_VIDEO = new Set(["video/mp4", "video/3gpp"]);
1054
+ const INLINE_AUDIO = new Set([
1055
+ "audio/mpeg",
1056
+ "audio/mp4",
1057
+ "audio/x-m4a",
1058
+ "audio/aac",
1059
+ "audio/ogg",
1060
+ "audio/opus",
1061
+ "audio/amr",
1062
+ ]);
1063
+
1064
+ /** Which WhatsApp shape an uploaded file is delivered as. */
1065
+ function scheduleMediaKind(mime) {
1066
+ const base = String(mime || "")
1067
+ .split(";")[0]
1068
+ .trim()
1069
+ .toLowerCase();
1070
+ if (INLINE_IMAGE.has(base)) return "image";
1071
+ if (INLINE_VIDEO.has(base)) return "video";
1072
+ if (INLINE_AUDIO.has(base)) return "audio";
1073
+ return "document";
1074
+ }
1075
+
1035
1076
  router.post(
1036
1077
  "/schedules",
1037
1078
  asyncRoute(async (req, res) => {
@@ -1040,18 +1081,57 @@ router.post(
1040
1081
  return badRequest(res, "Maximum 3 scheduled messages reached");
1041
1082
  }
1042
1083
 
1043
- const { targetJid, message, type, cronString, scheduledTime, recurrence, targetName } =
1044
- req.body || {};
1045
- if (!targetJid || !message) {
1046
- return badRequest(res, "Recipient and message are required");
1084
+ // The panel sends JSON; a scheduled message with media arrives as
1085
+ // multipart/form-data (browser FormData or the Android host bridge), with
1086
+ // the same fields as text parts plus one file part.
1087
+ let body = req.body || {};
1088
+ let file = null;
1089
+ if (
1090
+ String(req.headers["content-type"] || "")
1091
+ .toLowerCase()
1092
+ .startsWith("multipart/form-data")
1093
+ ) {
1094
+ try {
1095
+ const parsed = await readMultipartForm(req, { maxFileSize: SCHEDULE_MEDIA_MAX_BYTES });
1096
+ body = parsed.fields;
1097
+ file = parsed.file;
1098
+ } catch (error) {
1099
+ if (error instanceof MultipartError) return badRequest(res, error.message);
1100
+ throw error;
1101
+ }
1102
+ }
1103
+
1104
+ let recurrence = body.recurrence;
1105
+ if (recurrence && typeof recurrence === "string") {
1106
+ try {
1107
+ recurrence = JSON.parse(recurrence);
1108
+ } catch {
1109
+ recurrence = null;
1110
+ }
1111
+ }
1112
+
1113
+ const { targetJid, message, type, cronString, scheduledTime, targetName } = body;
1114
+ if (!targetJid || (!message && !file)) {
1115
+ return badRequest(res, "Recipient and a message or a file are required");
1047
1116
  }
1048
1117
 
1049
1118
  const id = Date.now().toString();
1119
+
1120
+ // An @lid target is resolved to its phone-number JID while the mapping is
1121
+ // fresh, so delivery and the label never depend on the LID still being
1122
+ // mapped months later. Unresolvable LIDs are kept as they are.
1123
+ // A phone JID never carries the "+" of the display label.
1124
+ let target = normalizeJid(String(targetJid).trim().replace(/^\+/, ""));
1125
+ if (isLidJid(target)) {
1126
+ const phone = resolveUserPhone(target);
1127
+ if (phone) target = `${phone}@s.whatsapp.net`;
1128
+ }
1129
+
1050
1130
  const job = {
1051
1131
  id,
1052
1132
  type: type === "once" ? "once" : "recurring",
1053
- targetJid: String(targetJid).trim(),
1054
- message: String(message).trim(),
1133
+ targetJid: target,
1134
+ message: String(message ?? "").trim(),
1055
1135
  creatorJid: "dashboard@levix",
1056
1136
  status: "active",
1057
1137
  };
@@ -1079,7 +1159,20 @@ router.post(
1079
1159
  job.date = new Date(timeMs).toISOString();
1080
1160
  }
1081
1161
 
1082
- if (targetName && !String(job.targetJid).endsWith("@g.us")) {
1162
+ // Written only once the job is known to be valid, so a refused request
1163
+ // never leaves a file behind with no row to delete it.
1164
+ if (file) {
1165
+ const mediaPath = scheduleMediaPath(id);
1166
+ fs.mkdirSync(path.dirname(mediaPath), { recursive: true });
1167
+ fs.writeFileSync(mediaPath, await fileToBuffer(file));
1168
+ job.media = {
1169
+ kind: scheduleMediaKind(file.type),
1170
+ mimeType: file.type || "application/octet-stream",
1171
+ fileName: file.name || null,
1172
+ };
1173
+ }
1174
+
1175
+ if (targetName && !job.targetJid.endsWith("@g.us")) {
1083
1176
  rememberSavedName(job.targetJid, targetName);
1084
1177
  }
1085
1178
 
@@ -1210,6 +1303,7 @@ router.get("/feedback/meta", (req, res) => {
1210
1303
  topics: FEEDBACK_TOPICS,
1211
1304
  messageMin: FEEDBACK_MESSAGE_MIN,
1212
1305
  messageMax: FEEDBACK_MESSAGE_MAX,
1306
+ attachmentMax: FEEDBACK_ATTACHMENT_MAX,
1213
1307
  // Shown next to the form so the operator can see what travels with it.
1214
1308
  runtime: { version: runtime.version, platform: runtime.platform },
1215
1309
  });
@@ -1217,10 +1311,36 @@ router.get("/feedback/meta", (req, res) => {
1217
1311
 
1218
1312
  // Leaves this machine only when the operator presses Send, and carries nothing
1219
1313
  // but the form's own fields plus the version and platform — see feedback.cjs.
1314
+ // An optional attachment (a screenshot, a log) rides along as multipart and is
1315
+ // forwarded to the same endpoint, which delivers it to Telegram as a file.
1220
1316
  router.post(
1221
1317
  "/feedback",
1222
1318
  asyncRoute(async (req, res) => {
1223
- const parsed = validateFeedback(req.body || {});
1319
+ let body = req.body || {};
1320
+ let attachment = null;
1321
+ if (
1322
+ String(req.headers["content-type"] || "")
1323
+ .toLowerCase()
1324
+ .startsWith("multipart/form-data")
1325
+ ) {
1326
+ try {
1327
+ const parsed = await readMultipartForm(req, { maxFileSize: FEEDBACK_ATTACHMENT_MAX });
1328
+ body = parsed.fields;
1329
+ if (parsed.file) {
1330
+ attachment = {
1331
+ buffer: await fileToBuffer(parsed.file),
1332
+ name: parsed.file.name || "attachment",
1333
+ type: parsed.file.type || "application/octet-stream",
1334
+ size: parsed.file.size,
1335
+ };
1336
+ }
1337
+ } catch (error) {
1338
+ if (error instanceof MultipartError) return badRequest(res, error.message);
1339
+ throw error;
1340
+ }
1341
+ }
1342
+
1343
+ const parsed = validateFeedback(body);
1224
1344
  if (!parsed.ok) return badRequest(res, parsed.error);
1225
1345
 
1226
1346
  const retryAfter = feedbackRetryAfter();
@@ -1232,7 +1352,7 @@ router.post(
1232
1352
  });
1233
1353
  }
1234
1354
 
1235
- const result = await submitFeedback(parsed.value);
1355
+ const result = await submitFeedback(parsed.value, attachment);
1236
1356
  if (!result.ok) {
1237
1357
  return res.status(result.status).json({ success: false, error: result.error });
1238
1358
  }
@@ -1423,4 +1543,81 @@ router.post("/session/restart", (req, res, next) => {
1423
1543
  router.handle(req, res, next);
1424
1544
  });
1425
1545
 
1546
+ // ===========================================================================
1547
+ // Keyword auto-delete
1548
+ // ===========================================================================
1549
+
1550
+ function autoDeleteFail(res, error, label) {
1551
+ if (error?.status === 400 || error?.status === 404 || error?.name === "AutoDeleteError") {
1552
+ return res.status(error.status || 400).json({ success: false, error: error.message });
1553
+ }
1554
+ return fail(res, error, label);
1555
+ }
1556
+
1557
+ router.get("/auto-delete/rules", (_req, res) => {
1558
+ try {
1559
+ res.json({ success: true, rules: autoDelete.listRules() });
1560
+ } catch (error) {
1561
+ autoDeleteFail(res, error, "Error listing auto-delete rules");
1562
+ }
1563
+ });
1564
+
1565
+ router.post("/auto-delete/rules", (req, res) => {
1566
+ try {
1567
+ const rule = autoDelete.createRule(req.body || {});
1568
+ res.json({ success: true, rule });
1569
+ } catch (error) {
1570
+ autoDeleteFail(res, error, "Error creating an auto-delete rule");
1571
+ }
1572
+ });
1573
+
1574
+ router.patch("/auto-delete/rules/:id", (req, res) => {
1575
+ try {
1576
+ const rule = autoDelete.updateRule(req.params.id, req.body || {});
1577
+ res.json({ success: true, rule });
1578
+ } catch (error) {
1579
+ autoDeleteFail(res, error, "Error updating an auto-delete rule");
1580
+ }
1581
+ });
1582
+
1583
+ router.delete("/auto-delete/rules/:id", (req, res) => {
1584
+ try {
1585
+ autoDelete.deleteRule(req.params.id);
1586
+ res.json({ success: true });
1587
+ } catch (error) {
1588
+ autoDeleteFail(res, error, "Error deleting an auto-delete rule");
1589
+ }
1590
+ });
1591
+
1592
+ router.post("/auto-delete/rules/:id/reset", (req, res) => {
1593
+ try {
1594
+ const rule = autoDelete.resetCounter(req.params.id);
1595
+ res.json({ success: true, rule });
1596
+ } catch (error) {
1597
+ autoDeleteFail(res, error, "Error resetting an auto-delete counter");
1598
+ }
1599
+ });
1600
+
1601
+ router.get("/auto-delete/log", (req, res) => {
1602
+ try {
1603
+ const log = autoDelete.listLog({
1604
+ ruleId: req.query.ruleId,
1605
+ limit: req.query.limit,
1606
+ offset: req.query.offset,
1607
+ });
1608
+ res.json({ success: true, log });
1609
+ } catch (error) {
1610
+ autoDeleteFail(res, error, "Error listing auto-delete copies");
1611
+ }
1612
+ });
1613
+
1614
+ router.delete("/auto-delete/log", (req, res) => {
1615
+ try {
1616
+ const cleared = autoDelete.clearLog(req.query.ruleId);
1617
+ res.json({ success: true, cleared });
1618
+ } catch (error) {
1619
+ autoDeleteFail(res, error, "Error clearing auto-delete copies");
1620
+ }
1621
+ });
1622
+
1426
1623
  export default router;