fca-riyad 37.0.0

package/src/core/sendReqMqtt.js

@@ -0,0 +1,96 @@
+"use strict";
+
+function sendReqMqtt(ctx, payload, options, callback) {
+  return new Promise((resolve, reject) => {
+    const cb = typeof options === "function" ? options : callback;
+    const opts = typeof options === "object" && options ? options : {};
+    if (!ctx || !ctx.mqttClient) {
+      const err = new Error("Not connected to MQTT");
+      if (cb) cb(err);
+      return reject(err);
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = typeof opts.request_id === "number" ? opts.request_id : ++ctx.wsReqNumber;
+    const timeoutMs = typeof opts.timeout === "number" ? opts.timeout : 20000;
+    const qos = typeof opts.qos === "number" ? opts.qos : 1;
+    const retain = !!opts.retain;
+    const reqTopic = "/ls_req";
+    const respTopic = opts.respTopic || "/ls_resp";
+    const form = JSON.stringify({
+      app_id: opts.app_id || "",
+      payload: typeof payload === "string" ? payload : JSON.stringify(payload),
+      request_id: reqID,
+      type: opts.type == null ? 3 : opts.type
+    });
+    let timer = null;
+    let cleaned = false;
+
+    // Cleanup function to ensure listeners and timers are always removed
+    const cleanup = () => {
+      if (cleaned) return;
+      cleaned = true;
+      try {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        if (ctx.mqttClient && typeof ctx.mqttClient.removeListener === "function") {
+          ctx.mqttClient.removeListener("message", handleRes);
+        }
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    };
+
+    const handleRes = (topic, message) => {
+      if (topic !== respTopic) return;
+      let msg;
+      try {
+        msg = JSON.parse(message.toString());
+      } catch {
+        return;
+      }
+      if (msg.request_id !== reqID) return;
+      if (typeof opts.filter === "function" && !opts.filter(msg)) return;
+      cleanup();
+      try {
+        msg.payload = typeof msg.payload === "string" ? JSON.parse(msg.payload) : msg.payload;
+      } catch { }
+      const out = { success: true, response: msg.payload, raw: msg };
+      if (cb) cb(null, out);
+      resolve(out);
+    };
+
+    try {
+      ctx.mqttClient.on("message", handleRes);
+    } catch (err) {
+      cleanup();
+      const error = new Error("Failed to attach message listener");
+      if (cb) cb(error);
+      return reject(error);
+    }
+
+    timer = setTimeout(() => {
+      cleanup();
+      const err = new Error("MQTT response timeout");
+      if (cb) cb(err);
+      reject(err);
+    }, timeoutMs);
+
+    try {
+      ctx.mqttClient.publish(reqTopic, form, { qos, retain }, (err) => {
+        if (err) {
+          cleanup();
+          if (cb) cb(err);
+          reject(err);
+        }
+      });
+    } catch (err) {
+      cleanup();
+      if (cb) cb(err);
+      reject(err);
+    }
+  });
+}
+
+module.exports = sendReqMqtt;

package/src/database/helpers.js

@@ -0,0 +1,53 @@
+"use strict";
+
+/**
+ * Shared helpers for database layer (userData, threadData).
+ * Keeps validation and payload normalization in one place.
+ */
+
+const DB_NOT_INIT = "Database not initialized";
+
+function validateId(value, fieldName = "id") {
+  if (value == null) {
+    throw new Error(`${fieldName} is required and cannot be undefined`);
+  }
+  if (typeof value !== "string" && typeof value !== "number") {
+    throw new Error(`Invalid ${fieldName}: must be a string or number`);
+  }
+  return String(value);
+}
+
+function validateData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object");
+  }
+}
+
+/**
+ * @param {string|string[]|null} keys - "userID" | ["userID","data"] | null
+ * @returns {string[]|undefined}
+ */
+function normalizeAttributes(keys) {
+  if (keys == null) return undefined;
+  return typeof keys === "string" ? [keys] : Array.isArray(keys) ? keys : undefined;
+}
+
+/**
+ * Normalize payload: accept either { data } or raw object.
+ */
+function normalizePayload(data, key = "data") {
+  return Object.prototype.hasOwnProperty.call(data, key) ? data : { [key]: data };
+}
+
+function wrapError(message, cause) {
+  return new Error(`${message}: ${cause && cause.message ? cause.message : cause}`);
+}
+
+module.exports = {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  normalizePayload,
+  wrapError
+};

package/src/database/models/index.js

@@ -0,0 +1,88 @@
+const { Sequelize } = require("sequelize");
+const fs = require("fs");
+const path = require("path");
+
+let sequelize = null;
+let models = {};
+
+try {
+  const databasePath = path.join(process.cwd(), "Fca_Database");
+  if (!fs.existsSync(databasePath)) {
+    fs.mkdirSync(databasePath, { recursive: true });
+  }
+
+  sequelize = new Sequelize({
+    dialect: "sqlite",
+    storage: path.join(databasePath, "database.sqlite"),
+    logging: false,
+    pool: {
+      max: 5,
+      min: 0,
+      acquire: 30000,
+      idle: 10000
+    },
+    retry: {
+      max: 3
+    },
+    dialectOptions: {
+      timeout: 5000
+    },
+    isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
+  });
+
+  // Load models with error handling
+  try {
+    const modelFiles = fs.readdirSync(__dirname)
+      .filter(file => file.endsWith(".js") && file !== "index.js");
+
+    for (const file of modelFiles) {
+      try {
+        const model = require(path.join(__dirname, file))(sequelize);
+        if (model && model.name) {
+          models[model.name] = model;
+        }
+      } catch (modelError) {
+        // Log but continue loading other models
+        console.error(`Failed to load model ${file}:`, modelError && modelError.message ? modelError.message : String(modelError));
+      }
+    }
+
+    // Associate models
+    Object.keys(models).forEach(modelName => {
+      try {
+        if (models[modelName].associate) {
+          models[modelName].associate(models);
+        }
+      } catch (assocError) {
+        console.error(`Failed to associate model ${modelName}:`, assocError && assocError.message ? assocError.message : String(assocError));
+      }
+    });
+  } catch (loadError) {
+    console.error("Failed to load models:", loadError && loadError.message ? loadError.message : String(loadError));
+  }
+
+  models.sequelize = sequelize;
+  models.Sequelize = Sequelize;
+  models.isReady = true;
+  models.syncAll = async () => {
+    try {
+      if (!sequelize) {
+        throw new Error("Sequelize instance not initialized");
+      }
+      await sequelize.sync({ force: false });
+    } catch (error) {
+      console.error("Failed to synchronize models:", error && error.message ? error.message : String(error));
+      throw error;
+    }
+  };
+} catch (initError) {
+  console.error("Database initialization error:", initError && initError.message ? initError.message : String(initError));
+  models.sequelize = null;
+  models.Sequelize = Sequelize;
+  models.isReady = false;
+  models.syncAll = async () => {
+    throw new Error("Database not initialized");
+  };
+}
+
+module.exports = models;

package/src/database/models/thread.js

@@ -0,0 +1,50 @@
+module.exports = function(sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class Thread extends Model {}
+
+  Thread.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      threadID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      messageCount: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      data: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        get() {
+          const value = this.getDataValue('data');
+          if (typeof value === 'string') {
+            try {
+              return JSON.parse(value);
+            } catch {
+              return value;
+            }
+          }
+          return value;
+        },
+        set(value) {
+          this.setDataValue('data', typeof value === 'string' ? value : JSON.stringify(value));
+        }
+      }
+    },
+    {
+      sequelize,
+      modelName: "Thread",
+      timestamps: true
+    }
+  );
+  return Thread;
+};

package/src/database/models/user.js

@@ -0,0 +1,46 @@
+module.exports = function (sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class User extends Model { }
+
+  User.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      userID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      data: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        get() {
+          const value = this.getDataValue('data');
+          if (typeof value === 'string') {
+            try {
+              return JSON.parse(value);
+            } catch {
+              return value;
+            }
+          }
+          return value;
+        },
+        set(value) {
+          this.setDataValue('data', typeof value === 'string' ? value : JSON.stringify(value));
+        }
+      }
+    },
+    {
+      sequelize,
+      modelName: "User",
+      timestamps: true
+    }
+  );
+
+  return User;
+};

package/src/database/threadData.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const models = require("./models");
+const {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  wrapError
+} = require("./helpers");
+
+const Thread = models.Thread;
+const ID_FIELD = "threadID";
+
+module.exports = function (bot) {
+  return {
+    async create(threadID, data) {
+      if (!Thread) {
+        return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: true };
+      }
+      try {
+        threadID = validateId(threadID, ID_FIELD);
+        let thread = await Thread.findOne({ where: { threadID } });
+        if (thread) return { thread: thread.get(), created: false };
+        thread = await Thread.create({ threadID, ...(data || {}) });
+        return { thread: thread.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to create thread", err);
+      }
+    },
+
+    async get(threadID) {
+      if (!Thread) return null;
+      try {
+        threadID = validateId(threadID, ID_FIELD);
+        const thread = await Thread.findOne({ where: { threadID } });
+        return thread ? thread.get() : null;
+      } catch (err) {
+        throw wrapError("Failed to get thread", err);
+      }
+    },
+
+    async update(threadID, data) {
+      if (!Thread) {
+        return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: false };
+      }
+      try {
+        threadID = validateId(threadID, ID_FIELD);
+        validateData(data);
+        const thread = await Thread.findOne({ where: { threadID } });
+        if (thread) {
+          await thread.update(data);
+          return { thread: thread.get(), created: false };
+        }
+        const newThread = await Thread.create({ ...data, threadID });
+        return { thread: newThread.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to update thread", err);
+      }
+    },
+
+    async del(threadID) {
+      if (!Thread) throw new Error(DB_NOT_INIT);
+      try {
+        threadID = validateId(threadID, ID_FIELD);
+        const result = await Thread.destroy({ where: { threadID } });
+        if (result === 0) throw new Error("No thread found with the specified threadID");
+        return result;
+      } catch (err) {
+        throw wrapError("Failed to delete thread", err);
+      }
+    },
+
+    async delAll() {
+      if (!Thread) return 0;
+      try {
+        return await Thread.destroy({ where: {} });
+      } catch (err) {
+        throw wrapError("Failed to delete all threads", err);
+      }
+    },
+
+    async getAll(keys = null) {
+      if (!Thread) return [];
+      try {
+        const attributes = normalizeAttributes(keys);
+        const rows = await Thread.findAll({ attributes });
+        return rows.map((t) => t.get());
+      } catch (err) {
+        throw wrapError("Failed to get all threads", err);
+      }
+    }
+  };
+};

package/src/database/userData.js

@@ -0,0 +1,98 @@
+"use strict";
+
+const models = require("./models");
+const {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  normalizePayload,
+  wrapError
+} = require("./helpers");
+
+const User = models.User;
+const ID_FIELD = "userID";
+
+function stubUser(userID, data) {
+  return { user: { userID, ...normalizePayload(data || {}, "data") }, created: true };
+}
+
+module.exports = function (bot) {
+  return {
+    async create(userID, data) {
+      if (!User) return stubUser(validateId(userID, ID_FIELD), data);
+      try {
+        userID = validateId(userID, ID_FIELD);
+        validateData(data);
+        const payload = normalizePayload(data, "data");
+        let user = await User.findOne({ where: { userID } });
+        if (user) return { user: user.get(), created: false };
+        user = await User.create({ userID, ...payload });
+        return { user: user.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to create user", err);
+      }
+    },
+
+    async get(userID) {
+      if (!User) return null;
+      try {
+        userID = validateId(userID, ID_FIELD);
+        const user = await User.findOne({ where: { userID } });
+        return user ? user.get() : null;
+      } catch (err) {
+        throw wrapError("Failed to get user", err);
+      }
+    },
+
+    async update(userID, data) {
+      if (!User) return { user: { userID: validateId(userID, ID_FIELD), ...normalizePayload(data || {}, "data") }, created: false };
+      try {
+        userID = validateId(userID, ID_FIELD);
+        validateData(data);
+        const payload = normalizePayload(data, "data");
+        const user = await User.findOne({ where: { userID } });
+        if (user) {
+          await user.update(payload);
+          return { user: user.get(), created: false };
+        }
+        const newUser = await User.create({ userID, ...payload });
+        return { user: newUser.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to update user", err);
+      }
+    },
+
+    async del(userID) {
+      if (!User) throw new Error(DB_NOT_INIT);
+      try {
+        userID = validateId(userID, ID_FIELD);
+        const result = await User.destroy({ where: { userID } });
+        if (result === 0) throw new Error("No user found with the specified userID");
+        return result;
+      } catch (err) {
+        throw wrapError("Failed to delete user", err);
+      }
+    },
+
+    async delAll() {
+      if (!User) return 0;
+      try {
+        return await User.destroy({ where: {} });
+      } catch (err) {
+        throw wrapError("Failed to delete all users", err);
+      }
+    },
+
+    async getAll(keys = null) {
+      if (!User) return [];
+      try {
+        const attributes = normalizeAttributes(keys);
+        const rows = await User.findAll({ attributes });
+        return rows.map((u) => u.get());
+      } catch (err) {
+        throw wrapError("Failed to get all users", err);
+      }
+    }
+  };
+};

package/src/remote/remoteClient.js

@@ -0,0 +1,123 @@
+"use strict";
+
+const WebSocket = require("ws");
+const logger = require("../../func/logger");
+
+function createRemoteClient(api, ctx, cfg) {
+  if (!cfg || !cfg.enabled || !cfg.url) return null;
+
+  const url = String(cfg.url);
+  const token = cfg.token ? String(cfg.token) : null;
+  const autoReconnect = cfg.autoReconnect !== false;
+  const emitter = ctx && ctx._emitter;
+
+  let ws = null;
+  let closed = false;
+  let reconnectTimer = null;
+
+  function log(message, level = "info") {
+    logger(`[remote] ${message}`, level);
+  }
+
+  function scheduleReconnect() {
+    if (!autoReconnect || closed) return;
+    if (reconnectTimer) return;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      if (!closed) connect();
+    }, 5000);
+  }
+
+  function safeEmit(event, payload) {
+    try {
+      if (emitter && typeof emitter.emit === "function") {
+        emitter.emit(event, payload);
+      }
+    } catch { }
+  }
+
+  function connect() {
+    try {
+      ws = new WebSocket(url, {
+        headers: token ? { Authorization: `Bearer ${token}` } : undefined
+      });
+    } catch (e) {
+      log(`connect error: ${e && e.message ? e.message : String(e)}`, "warn");
+      scheduleReconnect();
+      return;
+    }
+
+    ws.on("open", () => {
+      log("connected", "info");
+      const payload = {
+        type: "hello",
+        userID: ctx && ctx.userID,
+        region: ctx && ctx.region,
+        version: require("../../package.json").version
+      };
+      try {
+        ws.send(JSON.stringify(payload));
+      } catch { }
+      safeEmit("remoteConnected", payload);
+    });
+
+    ws.on("message", data => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (!msg || typeof msg !== "object") return;
+
+      switch (msg.type) {
+        case "ping":
+          try {
+            ws.send(JSON.stringify({ type: "pong" }));
+          } catch { }
+          break;
+        case "stop":
+          safeEmit("remoteStop", msg);
+          break;
+        case "broadcast":
+          safeEmit("remoteBroadcast", msg.payload || {});
+          break;
+        default:
+          safeEmit("remoteMessage", msg);
+          break;
+      }
+    });
+
+    ws.on("close", () => {
+      log("disconnected", "warn");
+      safeEmit("remoteDisconnected");
+      if (!closed) scheduleReconnect();
+    });
+
+    ws.on("error", err => {
+      log(`error: ${err && err.message ? err.message : String(err)}`, "warn");
+    });
+  }
+
+  connect();
+
+  return {
+    close() {
+      closed = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      try {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.close();
+        }
+      } catch { }
+    }
+  };
+}
+
+module.exports = {
+  createRemoteClient
+};
+

package/src/utils/broadcast.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const logger = require("../../func/logger");
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function broadcast(api, threadIDs, message, options) {
+  const opts = options || {};
+  const delayMs = typeof opts.delayMs === "number" ? opts.delayMs : 1000;
+  const skipBlocked = opts.skipBlocked !== false;
+  const onResult = typeof opts.onResult === "function" ? opts.onResult : null;
+
+  if (!api || typeof api.sendMessage !== "function") {
+    throw new Error("broadcast: api.sendMessage is required.");
+  }
+
+  const ids = Array.isArray(threadIDs) ? threadIDs : [threadIDs];
+  const results = [];
+
+  for (const id of ids) {
+    try {
+      const res = await api.sendMessage(message, id);
+      const item = { threadID: id, ok: true, res };
+      results.push(item);
+      if (onResult) onResult(null, item);
+    } catch (e) {
+      const msg = e && e.error ? e.error : e && e.message ? e.message : String(e);
+      logger(`broadcast: failed for ${id}: ${msg}`, "warn");
+      const item = { threadID: id, ok: false, error: e };
+      results.push(item);
+      if (onResult) onResult(e, item);
+
+      if (
+        skipBlocked &&
+        /permission|blocked|not allowed|cannot send message|not authorized/i.test(msg)
+      ) {
+        // Skip only this target, continue with others
+      }
+    }
+    if (delayMs > 0) {
+      await delay(delayMs);
+    }
+  }
+
+  return results;
+}
+
+module.exports = broadcast;
+