levix-bot 2.0.0

package/src/utils/recentMessageCache.esm.js

@@ -0,0 +1,70 @@
+// In-memory store for messages the bot itself sent.
+//
+// Sole purpose: back Baileys' getMessage callback so retries succeed. When a
+// recipient can't decrypt something we sent, Baileys asks for it again through
+// getMessage; rc10's enableAutoSessionRecreation needs this to recover from
+// "this message can take a while".
+//
+// Nothing is written to disk and nothing other people send is kept here.
+//
+// Eviction: time-based + size-cap, both small — a retry request arrives within
+// minutes or not at all.
+
+const DEFAULT_TTL_MS = 1000 * 60 * 60; // 1 hour
+const DEFAULT_MAX_ITEMS = 500;
+
+const recent = new Map(); // id -> { value, expiresAt }
+let ttlMs = DEFAULT_TTL_MS;
+let maxItems = DEFAULT_MAX_ITEMS;
+
+function gc(now = Date.now()) {
+  // Drop expired entries first.
+  for (const [id, entry] of recent) {
+    if (entry.expiresAt <= now) recent.delete(id);
+  }
+  // If still over the cap, drop oldest insertions (Map preserves order).
+  while (recent.size > maxItems) {
+    const oldest = recent.keys().next().value;
+    if (oldest === undefined) break;
+    recent.delete(oldest);
+  }
+}
+
+export function configureRecentCache({ ttlMs: nextTtl, maxItems: nextMax } = {}) {
+  if (Number.isFinite(nextTtl) && nextTtl > 0) ttlMs = nextTtl;
+  if (Number.isFinite(nextMax) && nextMax > 0) maxItems = nextMax;
+}
+
+export function rememberMessage(id, value) {
+  if (!id) return;
+  const expiresAt = Date.now() + ttlMs;
+  recent.set(id, { value, expiresAt });
+  if (recent.size > maxItems) gc();
+}
+
+export function recallMessage(id) {
+  if (!id) return null;
+  const entry = recent.get(id);
+  if (!entry) return null;
+  if (entry.expiresAt <= Date.now()) {
+    recent.delete(id);
+    return null;
+  }
+  return entry.value;
+}
+
+export function forgetMessage(id) {
+  if (!id) return;
+  recent.delete(id);
+}
+
+// Used by Baileys getMessage; expects a `proto.IMessage` (or undefined).
+export async function getMessageFromRecent(key) {
+  if (!key?.id) return undefined;
+  const stored = recallMessage(key.id);
+  if (!stored) return undefined;
+  // Stored archive uses { message, ... } shape -- we only need .message
+  return stored.message || stored.rawMessage || undefined;
+}
+
+setInterval(() => gc(), 1000 * 60 * 5).unref?.();

package/src/utils/requestOrigin.cjs

@@ -0,0 +1,102 @@
+// Who is really on the other end of this request.
+//
+// WHY THIS IS NOT `req.ip`
+// ------------------------
+// Express's `req.ip` honours `X-Forwarded-For` as soon as `trust proxy` is set
+// — including a hop count like `1`, which is exactly what the panel tells an
+// nginx user to configure. From a non-loopback address:
+//
+//   trust proxy = 1, header "X-Forwarded-For: 127.0.0.1"  ->  req.ip = 127.0.0.1
+//
+// So a stranger could have made an unclaimed bot believe they were sitting at
+// its keyboard, and claim it without the setup code. `req.ip` is the right
+// answer for logging and for "who is this user"; it is the wrong answer for
+// "is this physically the same machine".
+//
+// The socket address on its own isn't enough either: a reverse proxy on the
+// same host connects from 127.0.0.1, so every remote visitor through it would
+// look local.
+//
+// THE RULE
+// --------
+// A request counts as local only when all three hold:
+//
+//   1. the operator has NOT configured a proxy (`trust_proxy` is empty) —
+//      if they told us something is in front, anything could have come through it
+//   2. no forwarding header is present — anything that sets one is a proxy,
+//      declared or not
+//   3. the TCP peer is a loopback address — the only part of this that a
+//      remote client cannot influence
+//
+// A reverse-proxy deployment therefore always uses the setup code, which is
+// what we want: the code is printed on the server's own console, so having it
+// proves access to the machine. `levix` on a laptop stays code-free.
+
+// Headers that mean "a proxy handled this". Any of them present is enough to
+// stop calling the request local, whether or not we trust the value.
+const FORWARDING_HEADERS = [
+  "x-forwarded-for",
+  "x-real-ip",
+  "forwarded",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-client-ip",
+  "cf-connecting-ip",
+  "true-client-ip",
+];
+
+/** 127.0.0.0/8, ::1, and the IPv4-mapped forms of both. */
+function isLoopbackAddress(address) {
+  if (typeof address !== "string" || !address) return false;
+
+  // Strip a zone id ("fe80::1%eth0") and any IPv4-mapped IPv6 prefix.
+  let value = address.trim().toLowerCase().split("%")[0];
+  if (value.startsWith("[") && value.endsWith("]")) value = value.slice(1, -1);
+  if (value.startsWith("::ffff:")) value = value.slice("::ffff:".length);
+
+  if (value === "::1" || value === "0:0:0:0:0:0:0:1") return true;
+
+  // 127.0.0.0/8 — and only that: "127.0.0.1.evil.com" or "1270.0.1" must not pass.
+  const octets = value.split(".");
+  if (octets.length !== 4) return false;
+  if (!octets.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)) {
+    return false;
+  }
+  return octets[0] === "127";
+}
+
+function hasForwardingHeader(headers = {}) {
+  return FORWARDING_HEADERS.some((name) => {
+    const value = headers[name];
+    return typeof value === "string" && value.trim() !== "";
+  });
+}
+
+/**
+ * The address of the machine that actually opened the TCP connection.
+ * Never derived from a header, so it can't be forged — which is what makes it
+ * the right key for rate limiting a password or setup-code guess.
+ */
+function clientAddress(req) {
+  return req?.socket?.remoteAddress || req?.connection?.remoteAddress || "";
+}
+
+/**
+ * Is this request coming straight from this machine, with nothing in between?
+ *
+ * @param {object} req
+ * @param {{ proxyConfigured?: boolean }} [options]
+ */
+function isDirectLocalRequest(req, { proxyConfigured = false } = {}) {
+  if (proxyConfigured) return false;
+  if (hasForwardingHeader(req?.headers)) return false;
+  return isLoopbackAddress(clientAddress(req));
+}
+
+module.exports = {
+  FORWARDING_HEADERS,
+  isLoopbackAddress,
+  hasForwardingHeader,
+  clientAddress,
+  isDirectLocalRequest,
+};

package/src/utils/sendBotMessage.cjs

@@ -0,0 +1,43 @@
+// CommonJS shim around sendBotMessage.esm.js so .cjs commands can use it.
+// We lazy-import the ESM module on first call and cache the resolved exports.
+
+const logger = require("./logger.cjs");
+
+let cached = null;
+
+async function getModule() {
+  if (cached) return cached;
+  cached = await import("./sendBotMessage.esm.js");
+  return cached;
+}
+
+async function sendBotMessage(sock, jid, content, options = {}) {
+  try {
+    const mod = await getModule();
+    return await mod.sendBotMessage(sock, jid, content, options);
+  } catch (err) {
+    logger.error({ err }, "[sendBotMessage.cjs] fell back to raw sendMessage");
+    const opts = {};
+    if (options?.quote !== false) {
+      const quoted = options?.quoted || options?.replyTo;
+      if (quoted) opts.quoted = quoted;
+    }
+    return sock.sendMessage(jid, content, opts);
+  }
+}
+
+async function sendBotError(sock, jid, err, arabicLead = "حدث خطأ", options = {}) {
+  try {
+    const mod = await getModule();
+    return await mod.sendBotError(sock, jid, err, arabicLead, options);
+  } catch (innerErr) {
+    logger.error({ err: innerErr }, "[sendBotMessage.cjs] error helper failed");
+    const name = err?.name || "Error";
+    const message = err?.message || String(err);
+    return sock.sendMessage(jid, {
+      text: `❌ *${arabicLead}*\n\n*النوع:* \`${name}\`\n*التفاصيل:* ${message}`,
+    });
+  }
+}
+
+module.exports = { sendBotMessage, sendBotError };

package/src/utils/sendBotMessage.esm.js

@@ -0,0 +1,139 @@
+// Unified outbound message helper.
+//
+// Every command / handler in the bot should send replies through
+// sendBotMessage(...) instead of calling sock.sendMessage directly. It does:
+//
+//   * typing simulation ("composing") before sending, with realistic delay
+//     proportional to text length (capped 300-3000ms).
+//   * a randomized inter-message delay per chat so several messages from the
+//     same handler don't arrive bunched in the same second.
+//   * automatic `quoted: msg` so the bot's reply is threaded under the
+//     command. Pass `{ quote: false }` to opt out (e.g. status broadcasts).
+//   * tracks the last bot-sent message per chat for follow-up updates.
+//
+// The helper is resilient: if presence updates fail (rare on Baileys v7) the
+// message itself is still sent.
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const logger = require("./logger.cjs");
+const settings = require("../config/settings.cjs");
+
+const lastSendTime = new Map(); // chatJid -> timestamp ms
+
+// Read per send: both are editable from the dashboard.
+function sendGap() {
+  const min = Math.max(0, settings.get("bot_min_delay_ms"));
+  return { min, max: Math.max(min, settings.get("bot_max_delay_ms")) };
+}
+
+function jitter(min, max) {
+  if (max <= min) return min;
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function sleep(ms) {
+  if (!ms || ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function typingDelayFor(content) {
+  const text = content?.text || content?.caption || "";
+  if (!text) return jitter(300, 700);
+  // ~40 chars/sec typing rhythm, clamped to [400, 2500] ms
+  const base = Math.min(2500, Math.max(400, (text.length / 40) * 1000));
+  return Math.floor(base * (0.85 + Math.random() * 0.3));
+}
+
+async function safePresence(sock, jid, presence) {
+  try {
+    await sock.sendPresenceUpdate(presence, jid);
+  } catch (err) {
+    logger.debug({ err: err?.message, jid, presence }, "[sendBotMessage] presence failed");
+  }
+}
+
+/**
+ * Send a message with typing simulation, inter-message delay, and quoted reply.
+ *
+ * @param {object} sock - Baileys socket
+ * @param {string} jid  - Chat JID
+ * @param {object} content - Message content (passed to sock.sendMessage)
+ * @param {object} options
+ * @param {object} [options.quoted]  - Message to quote. Defaults to options.replyTo.
+ * @param {object} [options.replyTo] - Original incoming message (auto-quoted).
+ * @param {boolean} [options.quote=true]  - Set false to skip auto-quoting.
+ * @param {boolean} [options.typing=true] - Set false to skip typing presence.
+ * @param {number}  [options.delayMs]     - Override the inter-message gap.
+ * @returns {Promise<object>} Baileys send result
+ */
+export async function sendBotMessage(sock, jid, content, options = {}) {
+  const {
+    replyTo = null,
+    quoted = null,
+    quote = true,
+    typing = true,
+    delayMs,
+  } = options;
+
+  // Respect the per-chat cooldown so multiple replies don't pile up instantly.
+  const now = Date.now();
+  const lastAt = lastSendTime.get(jid) || 0;
+  const elapsed = now - lastAt;
+  let targetGap;
+  if (typeof delayMs === "number") {
+    targetGap = Math.max(0, delayMs);
+  } else {
+    const { min, max } = sendGap();
+    targetGap = jitter(min, max);
+  }
+  if (elapsed < targetGap) await sleep(targetGap - elapsed);
+
+  if (typing) {
+    await safePresence(sock, jid, "composing");
+    await sleep(typingDelayFor(content));
+    await safePresence(sock, jid, "paused");
+  }
+
+  const opts = {};
+  if (quote) {
+    const quotedMsg = quoted || replyTo;
+    if (quotedMsg) opts.quoted = quotedMsg;
+  }
+
+  try {
+    const sent = await sock.sendMessage(jid, content, opts);
+    lastSendTime.set(jid, Date.now());
+    return sent;
+  } catch (err) {
+    logger.error(
+      { err, jid, contentKeys: Object.keys(content || {}) },
+      "[sendBotMessage] sock.sendMessage failed"
+    );
+    throw err;
+  }
+}
+
+/**
+ * Helper: send a textual error message that includes the actual error name +
+ * a concise reason, so we don't smear the user with "حدث خطأ" alone.
+ *
+ * @param {object} sock
+ * @param {string} jid
+ * @param {Error|string} err
+ * @param {string} [arabicLead] - optional Arabic prefix ("معرفتش أعمل كذا")
+ * @param {object} [options]    - forwarded to sendBotMessage
+ */
+export async function sendBotError(sock, jid, err, arabicLead = "حدث خطأ", options = {}) {
+  const name = err?.name || (typeof err === "string" ? "Error" : "Error");
+  const message =
+    err?.message || (typeof err === "string" ? err : JSON.stringify(err));
+  const text = `❌ *${arabicLead}*\n\n*النوع:* \`${name}\`\n*التفاصيل:* ${message}`.slice(
+    0,
+    1500
+  );
+  return sendBotMessage(sock, jid, { text }, options);
+}
+
+export default sendBotMessage;

package/src/utils/statusMessage.cjs

@@ -0,0 +1,179 @@
+// One live message per command, edited in place.
+//
+// Commands used to narrate their work with a stream of separate messages
+// ("🔍 جاري التحليل...", "🎬 جاري التحميل...", "📦 الملف كبير..."), which buries
+// the chat. WhatsApp supports editing a message you sent, so a command can
+// instead post ONE line and rewrite it as it progresses:
+//
+//   const status = await createStatus(sock, jid, "🔍 بحلل الرابط...", { replyTo: msg });
+//   await status.update("🎬 بنزّل الفيديو...");
+//   await status.finish("✅ اتبعت — 12.3 MB");
+//
+// Everything here is best-effort: a failed edit never breaks the command. If
+// the message is too old to edit (WhatsApp only allows it for a while) or the
+// edit is rejected, we fall back to a normal send and keep going.
+
+const logger = require("./logger.cjs");
+const { sendBotMessage } = require("./sendBotMessage.cjs");
+
+// WhatsApp tolerates a few edits per message; spacing them out keeps the
+// server happy and the animation readable.
+const MIN_EDIT_GAP_MS = 600;
+
+function sleep(ms) {
+  if (!ms || ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class StatusMessage {
+  constructor(sock, jid, options = {}) {
+    this.sock = sock;
+    this.jid = jid;
+    this.replyTo = options.replyTo || null;
+    this.quote = options.quote !== false;
+    this.key = null;
+    this.text = "";
+    this.lastEditAt = 0;
+    this.closed = false;
+  }
+
+  async start(text) {
+    this.text = text;
+    try {
+      const sent = await sendBotMessage(
+        this.sock,
+        this.jid,
+        { text },
+        { replyTo: this.replyTo, quote: this.quote, typing: false, delayMs: 0 }
+      );
+      this.key = sent?.key || null;
+      this.lastEditAt = Date.now();
+    } catch (err) {
+      logger.warn({ err: err?.message }, "[status] initial send failed");
+      this.key = null;
+    }
+    return this;
+  }
+
+  /** Rewrite the line. Identical text is skipped so we don't burn an edit. */
+  async update(text, { force = false } = {}) {
+    if (this.closed && !force) return false;
+    const next = String(text || "").trim();
+    if (!next || next === this.text) return false;
+
+    // No message to edit (initial send failed) — send one and adopt it.
+    if (!this.key) return this._sendFresh(next);
+
+    const wait = MIN_EDIT_GAP_MS - (Date.now() - this.lastEditAt);
+    if (wait > 0) await sleep(wait);
+
+    try {
+      // `quoted: null` on purpose: the command handler wraps sock.sendMessage
+      // and auto-quotes anything that doesn't set it, and an edit/delete is a
+      // protocolMessage — there is nowhere to hang a contextInfo.
+      await this.sock.sendMessage(
+        this.jid,
+        { text: next, edit: this.key },
+        { quoted: null }
+      );
+      this.text = next;
+      this.lastEditAt = Date.now();
+      return true;
+    } catch (err) {
+      logger.debug({ err: err?.message }, "[status] edit failed — sending instead");
+      return this._sendFresh(next);
+    }
+  }
+
+  async _sendFresh(text) {
+    try {
+      const sent = await sendBotMessage(
+        this.sock,
+        this.jid,
+        { text },
+        { replyTo: this.replyTo, quote: this.quote, typing: false, delayMs: 0 }
+      );
+      this.key = sent?.key || null;
+      this.text = text;
+      this.lastEditAt = Date.now();
+      return true;
+    } catch (err) {
+      logger.warn({ err: err?.message }, "[status] fallback send failed");
+      return false;
+    }
+  }
+
+  /** Last update for this run. Always delivered, even if an edit is refused. */
+  async finish(text) {
+    const ok = await this.update(text, { force: true });
+    this.closed = true;
+    return ok;
+  }
+
+  /** Turn the line into the standard error card. */
+  async fail(err, arabicLead = "حصلت مشكلة") {
+    const name = err?.name || "Error";
+    const message = err?.message || String(err || "غير معروف");
+    return this.finish(
+      `❌ *${arabicLead}*\n\n*النوع:* \`${name}\`\n*التفاصيل:* ${message}`.slice(0, 1500)
+    );
+  }
+
+  /** Remove the status line entirely (used when the result speaks for itself). */
+  async remove() {
+    this.closed = true;
+    if (!this.key) return false;
+    try {
+      await this.sock.sendMessage(
+        this.jid,
+        { delete: this.key },
+        { quoted: null }
+      );
+      this.key = null;
+      return true;
+    } catch (err) {
+      logger.debug({ err: err?.message }, "[status] delete failed");
+      return false;
+    }
+  }
+}
+
+/**
+ * Post the first status line and hand back the handle used to rewrite it.
+ *
+ * @param {object} sock
+ * @param {string} jid
+ * @param {string} text                initial line
+ * @param {object} [options]
+ * @param {object} [options.replyTo]   message to quote
+ * @param {boolean}[options.quote]     set false to not quote anything
+ * @returns {Promise<StatusMessage>}
+ */
+async function createStatus(sock, jid, text, options = {}) {
+  return new StatusMessage(sock, jid, options).start(text);
+}
+
+/**
+ * A status handle that does nothing — lets helpers take an optional status
+ * without every call site guarding for null.
+ */
+function nullStatus() {
+  return {
+    key: null,
+    text: "",
+    async update() {
+      return false;
+    },
+    async finish() {
+      return false;
+    },
+    async fail() {
+      return false;
+    },
+    async remove() {
+      return false;
+    },
+  };
+}
+
+module.exports = { createStatus, nullStatus, StatusMessage };

package/src/utils/storage-hub.cjs

@@ -0,0 +1,49 @@
+// CommonJS face of storage-hub.esm.js — the AI conversation history.
+//
+// Both halves are the same SQLite store, so this one can require it directly
+// instead of lazy-importing the ESM module the way it had to when the history
+// lived in a separate async database. The signatures stay async for callers.
+
+const logger = require("./logger.cjs");
+const store = require("../db/store.cjs");
+
+async function getChatHistoryAsync(chatId) {
+  try {
+    return store.getChatHistory(chatId);
+  } catch (err) {
+    logger.error({ err }, "[storage-hub] getChatHistoryAsync failed");
+    return [];
+  }
+}
+
+async function saveChatHistoryAsync(chatId, historyArray) {
+  try {
+    store.saveChatHistory(chatId, historyArray);
+  } catch (err) {
+    logger.error({ err }, "[storage-hub] saveChatHistoryAsync failed");
+  }
+}
+
+async function deleteChatHistoryAsync(chatId) {
+  try {
+    return store.deleteChatHistory(chatId);
+  } catch (err) {
+    logger.error({ err }, "[storage-hub] deleteChatHistoryAsync failed");
+    return false;
+  }
+}
+
+async function deleteAllChatHistoriesAsync() {
+  try {
+    store.deleteAllChatHistories();
+  } catch (err) {
+    logger.error({ err }, "[storage-hub] deleteAllChatHistoriesAsync failed");
+  }
+}
+
+module.exports = {
+  getChatHistoryAsync,
+  saveChatHistoryAsync,
+  deleteChatHistoryAsync,
+  deleteAllChatHistoriesAsync,
+};

package/src/utils/storage-hub.esm.js

@@ -0,0 +1,24 @@
+// Gemini conversation history.
+//
+// It lives in the same SQLite file as everything else, so these are ordinary
+// synchronous queries. The functions stay `async` because every caller already
+// awaits them (they date from when this was a separate database), and changing
+// forty call sites to save a microtask buys nothing.
+
+import store from "../db/store.esm.js";
+
+export async function getChatHistoryAsync(chatId) {
+  return store.getChatHistory(chatId);
+}
+
+export async function saveChatHistoryAsync(chatId, historyArray) {
+  store.saveChatHistory(chatId, historyArray);
+}
+
+export async function deleteChatHistoryAsync(chatId) {
+  return store.deleteChatHistory(chatId);
+}
+
+export async function deleteAllChatHistoriesAsync() {
+  store.deleteAllChatHistories();
+}

package/src/utils/storage.cjs

@@ -0,0 +1,80 @@
+// The CommonJS door onto storage.
+//
+// Everything lives in one SQLite file (src/db/db.cjs); src/db/store.cjs holds
+// the queries. This module just re-exports them under the names the commands
+// have always used — and yes, the API is synchronous, because SQLite is.
+//
+// The ESM half is src/utils/storage.esm.js; both point at the same singleton.
+
+const store = require("../db/store.cjs");
+
+module.exports = {
+  // Bot Settings
+  getBotSetting: store.getBotSetting,
+  saveBotSetting: store.saveBotSetting,
+  deleteBotSetting: store.deleteBotSetting,
+  // Group Settings
+  getGroupSettings: store.getGroupSettings,
+  saveGroupSettings: store.saveGroupSettings,
+  getAllGroupSettings: store.getAllGroupSettings,
+  // Warnings
+  getUserWarnings: store.getUserWarnings,
+  saveUserWarnings: store.saveUserWarnings,
+  clearUserWarnings: store.clearUserWarnings,
+  getAllWarnings: store.getAllWarnings,
+  // Todos
+  getUserTodos: store.getUserTodos,
+  saveUserTodos: store.saveUserTodos,
+  // Notes
+  saveNote: store.saveNote,
+  getNote: store.getNote,
+  getAllNotes: store.getAllNotes,
+  deleteNote: store.deleteNote,
+  getAllNotesFlat: store.getAllNotesFlat,
+  // QR Code
+  saveQrCode: store.saveQrCode,
+  getQrCode: store.getQrCode,
+  deleteQrCode: store.deleteQrCode,
+  // Forward Scores
+  incrementForwardScore: store.incrementForwardScore,
+  getForwardScore: store.getForwardScore,
+  getTopForwardedMessages: store.getTopForwardedMessages,
+  // User Metadata
+  saveUserMetadata: store.saveUserMetadata,
+  getUserMetadata: store.getUserMetadata,
+  isUserOwner: store.isUserOwner,
+  isUserBotAdmin: store.isUserBotAdmin,
+  getAllOwners: store.getAllOwners,
+  getAllBotAdmins: store.getAllBotAdmins,
+  setUserRole: store.setUserRole,
+  updateUserLastSeen: store.updateUserLastSeen,
+  // LID Mapping (Baileys v7)
+  storeLidPnMapping: store.storeLidPnMapping,
+  storeLidPnMappings: store.storeLidPnMappings,
+  getLidForPn: store.getLidForPn,
+  getLidsForPns: store.getLidsForPns,
+  getPnForLid: store.getPnForLid,
+  getAllLidMappings: store.getAllLidMappings,
+  // Debts
+  addDebt: store.addDebt,
+  getDebt: store.getDebt,
+  deleteDebt: store.deleteDebt,
+  listDebts: store.listDebts,
+  getRecentDebts: store.getRecentDebts,
+  countDebts: store.countDebts,
+  // Dashboard counters + listings
+  countGroups: store.countGroups,
+  countWarnings: store.countWarnings,
+  countTodos: store.countTodos,
+  countNotes: store.countNotes,
+  getAllTodos: store.getAllTodos,
+  getAllUsers: store.getAllUsers,
+  countUsers: store.countUsers,
+  // Scheduled messages
+  getSchedules: store.getSchedules,
+  getSchedule: store.getSchedule,
+  saveSchedule: store.saveSchedule,
+  setScheduleStatus: store.setScheduleStatus,
+  deleteSchedule: store.deleteSchedule,
+  countSchedules: store.countSchedules,
+};