levix-bot 4.5.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/src/db/store.cjs CHANGED
@@ -1601,6 +1601,231 @@ function stickerPackItemCount(packId) {
1601
1601
  return q("SELECT COUNT(*) AS n FROM sticker_pack_items WHERE pack_id = ?").get(packId).n;
1602
1602
  }
1603
1603
 
1604
+ // ===================================================================
1605
+ // --- Keyword auto-delete ---
1606
+ // ===================================================================
1607
+ //
1608
+ // Rules are operator configuration. The per-message matcher reads an in-memory
1609
+ // copy so it does not JSON-parse every rule on every incoming message. Any
1610
+ // write invalidates that copy. Kept copies (keepCopy) are account-scoped and
1611
+ // wiped on unlink; the rules themselves stay.
1612
+
1613
+ const AUTO_DELETE_LOG_CAP = 5000;
1614
+
1615
+ let autoDeleteRuleCache = null;
1616
+
1617
+ function invalidateAutoDeleteRuleCache() {
1618
+ autoDeleteRuleCache = null;
1619
+ }
1620
+
1621
+ function autoDeleteRuleRow(row) {
1622
+ if (!row) return null;
1623
+ return {
1624
+ id: row.id,
1625
+ name: row.name || null,
1626
+ enabled: Boolean(row.enabled),
1627
+ keywords: parseJson(row.keywords, []),
1628
+ match: row.match_mode,
1629
+ chatScope: row.chat_scope,
1630
+ senders: {
1631
+ mode: row.senders_mode,
1632
+ list: parseJson(row.senders_list, []),
1633
+ },
1634
+ includeOwn: Boolean(row.include_own),
1635
+ forEveryone: Boolean(row.for_everyone),
1636
+ keepCopy: Boolean(row.keep_copy),
1637
+ deletedCount: row.deleted_count || 0,
1638
+ lastDeletedAt: row.last_deleted_at ?? null,
1639
+ createdAt: row.created_at,
1640
+ updatedAt: row.updated_at,
1641
+ };
1642
+ }
1643
+
1644
+ function listAutoDeleteRules() {
1645
+ if (!autoDeleteRuleCache) {
1646
+ autoDeleteRuleCache = q("SELECT * FROM auto_delete_rules ORDER BY id ASC")
1647
+ .all()
1648
+ .map(autoDeleteRuleRow);
1649
+ }
1650
+ return autoDeleteRuleCache;
1651
+ }
1652
+
1653
+ function listEnabledAutoDeleteRules() {
1654
+ return listAutoDeleteRules().filter((rule) => rule.enabled);
1655
+ }
1656
+
1657
+ function getAutoDeleteRule(id) {
1658
+ return autoDeleteRuleRow(q("SELECT * FROM auto_delete_rules WHERE id = ?").get(Number(id)));
1659
+ }
1660
+
1661
+ function countAutoDeleteRules() {
1662
+ return q("SELECT COUNT(*) AS n FROM auto_delete_rules").get().n;
1663
+ }
1664
+
1665
+ function insertAutoDeleteRule(rule) {
1666
+ const now = Date.now();
1667
+ const { lastInsertRowid } = q(
1668
+ `INSERT INTO auto_delete_rules
1669
+ (name, enabled, keywords, match_mode, chat_scope, senders_mode, senders_list,
1670
+ include_own, for_everyone, keep_copy, deleted_count, last_deleted_at,
1671
+ created_at, updated_at)
1672
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, NULL, ?, ?)`,
1673
+ ).run(
1674
+ rule.name ?? null,
1675
+ bool(rule.enabled !== false),
1676
+ JSON.stringify(rule.keywords || []),
1677
+ rule.match || "contains",
1678
+ rule.chatScope || "all",
1679
+ rule.senders?.mode || "everyone",
1680
+ JSON.stringify(rule.senders?.list || []),
1681
+ bool(rule.includeOwn),
1682
+ bool(rule.forEveryone !== false),
1683
+ bool(rule.keepCopy),
1684
+ now,
1685
+ now,
1686
+ );
1687
+ invalidateAutoDeleteRuleCache();
1688
+ return getAutoDeleteRule(Number(lastInsertRowid));
1689
+ }
1690
+
1691
+ function updateAutoDeleteRule(id, fields) {
1692
+ const current = getAutoDeleteRule(id);
1693
+ if (!current) return null;
1694
+ const next = {
1695
+ name: fields.name !== undefined ? fields.name : current.name,
1696
+ enabled: fields.enabled !== undefined ? fields.enabled : current.enabled,
1697
+ keywords: fields.keywords !== undefined ? fields.keywords : current.keywords,
1698
+ match: fields.match !== undefined ? fields.match : current.match,
1699
+ chatScope: fields.chatScope !== undefined ? fields.chatScope : current.chatScope,
1700
+ senders: fields.senders !== undefined ? fields.senders : current.senders,
1701
+ includeOwn: fields.includeOwn !== undefined ? fields.includeOwn : current.includeOwn,
1702
+ forEveryone: fields.forEveryone !== undefined ? fields.forEveryone : current.forEveryone,
1703
+ keepCopy: fields.keepCopy !== undefined ? fields.keepCopy : current.keepCopy,
1704
+ };
1705
+ q(
1706
+ `UPDATE auto_delete_rules
1707
+ SET name = ?, enabled = ?, keywords = ?, match_mode = ?, chat_scope = ?,
1708
+ senders_mode = ?, senders_list = ?, include_own = ?, for_everyone = ?,
1709
+ keep_copy = ?, updated_at = ?
1710
+ WHERE id = ?`,
1711
+ ).run(
1712
+ next.name ?? null,
1713
+ bool(next.enabled),
1714
+ JSON.stringify(next.keywords || []),
1715
+ next.match,
1716
+ next.chatScope,
1717
+ next.senders?.mode || "everyone",
1718
+ JSON.stringify(next.senders?.list || []),
1719
+ bool(next.includeOwn),
1720
+ bool(next.forEveryone),
1721
+ bool(next.keepCopy),
1722
+ Date.now(),
1723
+ Number(id),
1724
+ );
1725
+ invalidateAutoDeleteRuleCache();
1726
+ return getAutoDeleteRule(id);
1727
+ }
1728
+
1729
+ function deleteAutoDeleteRule(id) {
1730
+ const { changes } = q("DELETE FROM auto_delete_rules WHERE id = ?").run(Number(id));
1731
+ invalidateAutoDeleteRuleCache();
1732
+ return changes > 0;
1733
+ }
1734
+
1735
+ function incrementAutoDeleteCounter(id) {
1736
+ const now = Date.now();
1737
+ const { changes } = q(
1738
+ `UPDATE auto_delete_rules
1739
+ SET deleted_count = deleted_count + 1, last_deleted_at = ?, updated_at = ?
1740
+ WHERE id = ?`,
1741
+ ).run(now, now, Number(id));
1742
+ invalidateAutoDeleteRuleCache();
1743
+ return changes > 0;
1744
+ }
1745
+
1746
+ function resetAutoDeleteCounter(id) {
1747
+ q(
1748
+ `UPDATE auto_delete_rules
1749
+ SET deleted_count = 0, last_deleted_at = NULL, updated_at = ?
1750
+ WHERE id = ?`,
1751
+ ).run(Date.now(), Number(id));
1752
+ invalidateAutoDeleteRuleCache();
1753
+ return getAutoDeleteRule(id);
1754
+ }
1755
+
1756
+ function autoDeleteLogRow(row) {
1757
+ if (!row) return null;
1758
+ return {
1759
+ id: row.id,
1760
+ ruleId: row.rule_id,
1761
+ chatJid: row.chat_jid,
1762
+ sender: row.sender || null,
1763
+ text: row.text || "",
1764
+ mediaType: row.media_type || "",
1765
+ mode: row.mode,
1766
+ createdAt: row.created_at,
1767
+ };
1768
+ }
1769
+
1770
+ function capAutoDeleteLog(max = AUTO_DELETE_LOG_CAP) {
1771
+ const limit = Math.max(0, Number(max) || 0);
1772
+ q(
1773
+ `DELETE FROM auto_delete_log WHERE id NOT IN (
1774
+ SELECT id FROM auto_delete_log ORDER BY created_at DESC, id DESC LIMIT ?
1775
+ )`,
1776
+ ).run(limit);
1777
+ }
1778
+
1779
+ function insertAutoDeleteLog(entry) {
1780
+ const now = entry.createdAt ?? Date.now();
1781
+ const { lastInsertRowid } = q(
1782
+ `INSERT INTO auto_delete_log
1783
+ (rule_id, chat_jid, sender, text, media_type, mode, created_at)
1784
+ VALUES (?, ?, ?, ?, ?, ?, ?)`,
1785
+ ).run(
1786
+ Number(entry.ruleId),
1787
+ entry.chatJid,
1788
+ entry.sender ?? null,
1789
+ entry.text ?? "",
1790
+ entry.mediaType ?? "",
1791
+ entry.mode,
1792
+ now,
1793
+ );
1794
+ capAutoDeleteLog();
1795
+ return autoDeleteLogRow(
1796
+ q("SELECT * FROM auto_delete_log WHERE id = ?").get(Number(lastInsertRowid)),
1797
+ );
1798
+ }
1799
+
1800
+ function listAutoDeleteLog({ ruleId, limit = 50, offset = 0 } = {}) {
1801
+ if (ruleId != null) {
1802
+ return q(
1803
+ `SELECT * FROM auto_delete_log WHERE rule_id = ?
1804
+ ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?`,
1805
+ )
1806
+ .all(Number(ruleId), Number(limit), Number(offset))
1807
+ .map(autoDeleteLogRow);
1808
+ }
1809
+ return q("SELECT * FROM auto_delete_log ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?")
1810
+ .all(Number(limit), Number(offset))
1811
+ .map(autoDeleteLogRow);
1812
+ }
1813
+
1814
+ function clearAutoDeleteLog(ruleId) {
1815
+ if (ruleId != null) {
1816
+ const { changes } = q("DELETE FROM auto_delete_log WHERE rule_id = ?").run(Number(ruleId));
1817
+ return changes;
1818
+ }
1819
+ const { changes } = q("DELETE FROM auto_delete_log").run();
1820
+ return changes;
1821
+ }
1822
+
1823
+ function clearAutoDeleteOnUnlink() {
1824
+ q("DELETE FROM auto_delete_log").run();
1825
+ q("UPDATE auto_delete_rules SET deleted_count = 0, last_deleted_at = NULL").run();
1826
+ invalidateAutoDeleteRuleCache();
1827
+ }
1828
+
1604
1829
  module.exports = {
1605
1830
  // Lifecycle
1606
1831
  initStore,
@@ -1734,4 +1959,21 @@ module.exports = {
1734
1959
  stickerPackReorder,
1735
1960
  stickerPackExclusive,
1736
1961
  stickerPackItemCount,
1962
+ // Keyword auto-delete
1963
+ AUTO_DELETE_LOG_CAP,
1964
+ listAutoDeleteRules,
1965
+ listEnabledAutoDeleteRules,
1966
+ getAutoDeleteRule,
1967
+ countAutoDeleteRules,
1968
+ insertAutoDeleteRule,
1969
+ updateAutoDeleteRule,
1970
+ deleteAutoDeleteRule,
1971
+ incrementAutoDeleteCounter,
1972
+ resetAutoDeleteCounter,
1973
+ insertAutoDeleteLog,
1974
+ listAutoDeleteLog,
1975
+ clearAutoDeleteLog,
1976
+ capAutoDeleteLog,
1977
+ clearAutoDeleteOnUnlink,
1978
+ invalidateAutoDeleteRuleCache,
1737
1979
  };
@@ -53,6 +53,7 @@ const EDIT_IN_PLACE_EXCLUDE = new Set([
53
53
  "toimage",
54
54
  "pack",
55
55
  "stickers",
56
+ "autodelete",
56
57
  ]);
57
58
 
58
59
  // Wrap a socket so commands reply nicely:
@@ -3,6 +3,7 @@ import { handleAntiSpam } from "../middleware/antispam.middleware.js";
3
3
  import { checkBlacklist } from "../middleware/blacklist.middleware.js";
4
4
  import { trackForwardedMessage } from "../middleware/forward-tracking.middleware.js";
5
5
  import normalizeJid from "../utils/normalizeJid.esm.js";
6
+ import { getSenderCandidates, isBotAdminInGroup, sameUser } from "../utils/permissions.esm.js";
6
7
  import { rememberMessage } from "../utils/recentMessageCache.esm.js";
7
8
  import { saveUserMetadata, updateUserLastSeen } from "../utils/storage.esm.js";
8
9
  import { handleCommand } from "./command.handler.js";
@@ -11,6 +12,7 @@ const require = createRequire(import.meta.url);
11
12
  const logger = require("../utils/logger.cjs");
12
13
  const { visibleText } = require("../utils/messageContent.cjs");
13
14
  const { detectLang, withLang } = require("../utils/i18n.cjs");
15
+ const autoDelete = require("../services/autoDelete.cjs");
14
16
 
15
17
  // Envelopes that carry no user-visible content: message revokes and edits
16
18
  // (protocolMessage), reactions, poll votes, the undecrypted edit envelope, and
@@ -78,6 +80,19 @@ export async function handleIncomingMessage(sock, m) {
78
80
  // to the command handler and the user sees nothing happen.
79
81
  const body = visibleText(msg.message);
80
82
 
83
+ // Keyword auto-delete: after content/status skip, before blacklist/commands
84
+ // /moderation. A successful delete stops the rest of the pipeline.
85
+ try {
86
+ const deleted = await autoDelete.handleIncoming(sock, msg, body, {
87
+ sameUser,
88
+ getSenderCandidates,
89
+ isBotAdminInGroup,
90
+ });
91
+ if (deleted) return;
92
+ } catch (error) {
93
+ logger.error({ err: error }, "auto-delete hook failed");
94
+ }
95
+
81
96
  // Everything the bot says about this message — a moderation warning, a
82
97
  // command's reply — goes out in one language (see utils/i18n.cjs). A
83
98
  // command narrows this down to its own arguments.
@@ -80,6 +80,7 @@ const {
80
80
  } = require("../utils/recurrence.cjs");
81
81
  const { discoverProviderModels, DiscoveryError } = require("../services/llmDiscovery.cjs");
82
82
  const settingsTransfer = require("../services/settingsTransfer.cjs");
83
+ const autoDelete = require("../services/autoDelete.cjs");
83
84
  const cron = require("node-cron");
84
85
 
85
86
  const router = Router();
@@ -1542,4 +1543,81 @@ router.post("/session/restart", (req, res, next) => {
1542
1543
  router.handle(req, res, next);
1543
1544
  });
1544
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
+
1545
1623
  export default router;