@cexy/hoonfca 1.0.4 → 1.0.6

package/module/config.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+const logger = require("../func/logger");
+
+const defaultConfig = {
+  autoUpdate: false,
+  mqtt: {
+    enabled: true,
+    reconnectInterval: 3600
+  },
+  autoLogin: true,
+  credentials: {
+    email: "",
+    password: "",
+    twofactor: ""
+  }
+};
+
+function loadConfig() {
+  const configPath = path.join(process.cwd(), "fca-config.json");
+  let config = {};
+
+  try {
+    if (!fs.existsSync(configPath)) {
+      config = { ...defaultConfig };
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    } else {
+      const fileContent = fs.readFileSync(configPath, "utf8");
+      config = JSON.parse(fileContent);
+
+      // Merge with defaults
+      config = {
+        ...defaultConfig,
+        ...config,
+        mqtt: {
+          ...defaultConfig.mqtt,
+          ...(config.mqtt || {})
+        },
+        credentials: {
+          ...defaultConfig.credentials,
+          ...(config.credentials || {})
+        }
+      };
+
+      // Save updated config if new keys were added
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+  } catch (err) {
+    logger(`Config error: ${err.message}`, "error");
+
+    config = { ...defaultConfig };
+
+    try {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    } catch (_) {}
+  }
+
+  return {
+    config,
+    configPath
+  };
+}
+
+module.exports = {
+  loadConfig,
+  defaultConfig
+};

package/module/login.js

@@ -0,0 +1,154 @@
+const { getType } = require("../src/utils/format");
+const { setOptions } = require("./options");
+const { loadConfig } = require("./config");
+const { checkAndUpdateVersion } = require("../func/checkUpdate");
+const loginHelper = require("./loginHelper");
+const logger = require("../func/logger");
+
+const { config } = loadConfig();
+global.fca = { config };
+
+// Global error handlers to prevent bot crashes
+// Handle unhandled promise rejections (e.g., fetch timeouts, network errors)
+if (!global.fca._errorHandlersInstalled) {
+  global.fca._errorHandlersInstalled = true;
+
+  process.on("unhandledRejection", (reason, promise) => {
+    try {
+      // Check if it's a fetch/network timeout error
+      if (reason && typeof reason === "object") {
+        const errorCode = reason.code || reason.cause?.code;
+        const errorMessage = reason.message || String(reason);
+
+        // Suppress Sequelize instance errors (handled gracefully in getBackupModel)
+        if (errorMessage.includes("No Sequelize instance passed")) {
+          return; // Silently ignore - already handled
+        }
+
+        // Handle fetch timeout errors gracefully
+        if (errorCode === "UND_ERR_CONNECT_TIMEOUT" ||
+            errorCode === "ETIMEDOUT" ||
+            errorMessage.includes("Connect Timeout") ||
+            errorMessage.includes("fetch failed")) {
+          logger(`Network timeout error caught (non-fatal): ${errorMessage}`, "warn");
+          return; // Don't crash, just log
+        }
+
+        // Handle other network errors
+        if (errorCode === "ECONNREFUSED" ||
+            errorCode === "ENOTFOUND" ||
+            errorCode === "ECONNRESET" ||
+            errorMessage.includes("ECONNREFUSED") ||
+            errorMessage.includes("ENOTFOUND")) {
+          logger(`Network connection error caught (non-fatal): ${errorMessage}`, "warn");
+          return; // Don't crash, just log
+        }
+      }
+
+      // For other unhandled rejections, log but don't crash
+      logger(`Unhandled promise rejection (non-fatal): ${reason && reason.message ? reason.message : String(reason)}`, "error");
+    } catch (e) {
+      // Fallback if logger fails
+      console.error("[FCA-ERROR] Unhandled promise rejection:", reason);
+    }
+  });
+
+  // Handle uncaught exceptions (last resort)
+  process.on("uncaughtException", (error) => {
+    try {
+      const errorMessage = error.message || String(error);
+      const errorCode = error.code;
+
+      // Suppress Sequelize instance errors (handled gracefully in getBackupModel)
+      if (errorMessage.includes("No Sequelize instance passed")) {
+        return; // Silently ignore - already handled
+      }
+
+      // Handle fetch/network errors
+      if (errorCode === "UND_ERR_CONNECT_TIMEOUT" ||
+          errorCode === "ETIMEDOUT" ||
+          errorMessage.includes("Connect Timeout") ||
+          errorMessage.includes("fetch failed")) {
+        logger(`Uncaught network timeout error (non-fatal): ${errorMessage}`, "warn");
+        return; // Don't crash
+      }
+
+      // For other uncaught exceptions, log but try to continue
+      logger(`Uncaught exception (attempting to continue): ${errorMessage}`, "error");
+      // Note: We don't exit here to allow bot to continue running
+      // In production, you might want to restart the process instead
+    } catch (e) {
+      // Fallback if logger fails
+      console.error("[FCA-ERROR] Uncaught exception:", error);
+    }
+  });
+}
+
+function login(loginData, options, callback) {
+  if (getType(options) === "Function" || getType(options) === "AsyncFunction") {
+    callback = options;
+    options = {};
+  }
+  const globalOptions = {
+    selfListen: false,
+    selfListenEvent: false,
+    listenEvents: false,
+    listenTyping: false,
+    updatePresence: false,
+    forceLogin: false,
+    autoMarkDelivery: true,
+    autoMarkRead: false,
+    autoReconnect: true,
+    online: true,
+    emitReady: false,
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+  };
+  setOptions(globalOptions, options);
+  let prCallback = null;
+  let rejectFunc = null;
+  let resolveFunc = null;
+  let returnPromise = null;
+  if (getType(callback) !== "Function" && getType(callback) !== "AsyncFunction") {
+    returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    prCallback = function (error, api) {
+      if (error) return rejectFunc(error);
+      return resolveFunc(api);
+    };
+    callback = prCallback;
+  }
+
+
+const proceed = () =>
+  loginHelper(
+    loginData.appState,
+    loginData.Cookie,
+    loginData.email,
+    loginData.password,
+    globalOptions,
+    callback,
+    prCallback
+  );
+
+// Login immediately
+proceed();
+
+// Run update check in background (never block login)
+if (config && config.autoUpdate) {
+  setImmediate(async () => {
+    try {
+      await checkAndUpdateVersion();
+    } catch (err) {
+      logger(
+        `Background update check failed: ${err.message || err}`,
+        "warn"
+      );
+    }
+  });
+} 
+ return returnPromise;
+}
+
+module.exports = login;