@dongdev/fca-unofficial 0.0.7 → 0.0.8

package/README.md

@@ -1,38 +1,74 @@
-This repo is a fork from main repo and will usually have new features bundled faster than main repo (and maybe bundle some bugs, too).
+<div align="center">
 
-# Unofficial Facebook Chat API
-<img alt="version" src="https://img.shields.io/github/package-json/v/miraiPr0ject/fca-unofficial?label=github&style=flat-square">
+![20241210_183831](https://files.catbox.moe/4rl0za.webp)
 
-Facebook now has an official API for chat bots [here](https://developers.facebook.com/docs/messenger-platform).
+<h2 align="center"><b>Unoffcial Facebook Chat API</b></h2><br>This package is created by <b>DongDev</b>
 
-This API is the only way to automate chat functionalities on a user account. We do this by emulating the browser. This means doing the exact same GET/POST requests and tricking Facebook into thinking we're accessing the website normally. Because we're doing it this way, this API won't work with an auth token but requires the credentials of a Facebook account.
+![Image](https://i.imgur.com/nFCeYmQ.jpeg)
 
 _Disclaimer_: We are not responsible if your account gets banned for spammy activities such as sending lots of messages to people you don't know, sending messages very quickly, sending spammy looking URLs, logging in and out very quickly... Be responsible Facebook citizens.
 
 See [below](#projects-using-this-api) for projects using this API.
 
-See the [full changelog](/CHANGELOG.md) for release details.
+# 🤖 Features:
+
+- [X] Once the error is detected it will automatically relogin the appstate.
+- [X] If the appstate itself is logged out it will automatically logged out and you can resubmit it again, But aside of that, if it has an automated behavior, it will relogin then it will dismiss automatically and refreshes the login.
+
+![Image](https://i.imgur.com/Pt6oCS0.jpeg)
+
+- [X] Added a feature where if the account is locked/suspended, it will stop the login process and shows the information and why it was locked/suspended.
+
+![Image](https://i.imgur.com/R0lzR6R.jpeg)
+![Image](https://i.imgur.com/PPE3fB5.jpeg)
+
+- [X] Added api.stopListenMqtt()
+- [X] Added api.getRegion()
+- [X] Added api.setProfileGuard()
+- [X] Added api.addFunctions()
+- [X] Added api.getBotInitialData()
+- [X] Added refreshFb_dtsg (*Facebook's dynamic token security generation*): This will automatically refresh every 12:00 AM in GMT+8 PH time.
+- [X] Added a detection if it's locked or suspended (*will show the information about the lock/suspension*)
+- [X] Added randomUserAgent on setOptions (*experimental*)
+- [X] Added bypassRegion on setOptions (*choose between PRN, PNB, HKG, SYD, VLL, LLA, SIN..., experimental*)
+- [X] Added a userAgent that has a possibility for less logout on accounts (*contributor to jonellcc*)
+- [X] Tested on Mirai/Autobot (*try on Xavia or Goat*)
+
+> You can use cookies editor available in kiwi browser, edge and chrome extension for PC.
+> We the @dongdev/fca-unofficiala team/contributors are recommending you to use the Firefox app for less logout, or use this website if you have no access on these browsers specially iOS user.
+
+If you encounter errors on fca, you can contact me [here](https://www.facebook.com/minhdong.dev)
+
+`</div>`
+
+Facebook now has an official API for chat bots [here](https://developers.facebook.com/docs/messenger-platform).
+
+This API is the only way to automate chat functionalities on a user account. We do this by emulating the browser. This means doing the exact same GET/POST requests and tricking Facebook into thinking we're accessing the website normally. Because we're doing it this way, this API won't work with an auth token but requires the credentials of a Facebook account.
 
 ## Install
-If you just want to use fca-unofficial, you should use this command:
+
+If you just want to use ws3-fca, you should use this command:
+
 ```bash
-npm install @miraipr0ject/fca-unofficial
+npm install @dongdev/fca-unofficial@latest
 ```
-It will download `fca-unofficial` from NPM repositories
 
-## Testing your bots
-If you want to test your bots without creating another account on Facebook, you can use [Facebook Whitehat Accounts](https://www.facebook.com/whitehat/accounts/).
+It will download @dongdev/fca-unofficial from NPM repositories
 
 ## Example Usage
+
 ```javascript
-const login = require("fca-unofficial");
+const login = require("@dongdev/fca-unofficial");
 
 // Create simple echo bot
-login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
-    if(err) return console.error(err);
-
-    api.listen((err, message) => {
-        api.sendMessage(message.body, message.threadID);
+login({
+  appState: []
+}, {
+    //setOptions will be here
+} (err, api) => {
+    if (err) return utils.error(err);
+    api.listenMqtt((err, event) => {
+        api.sendMessage(event.body, event.threadID);
     });
 });
 ```
@@ -41,17 +77,14 @@ Result:
 
 <img width="517" alt="screen shot 2016-11-04 at 14 36 00" src="https://cloud.githubusercontent.com/assets/4534692/20023545/f8c24130-a29d-11e6-9ef7-47568bdbc1f2.png">
 
-
-## Documentation
-
-You can see it [here](DOCS.md).
-
 ## Main Functionality
 
 ### Sending a message
+
 #### api.sendMessage(message, threadID[, callback][, messageID])
 
 Various types of message can be sent:
+
 * *Regular:* set field `body` to the desired message as a string.
 * *Sticker:* set a field `sticker` to the desired sticker ID.
 * *File or image:* Set field `attachment` to a readable stream or an array of readable streams.
@@ -63,10 +96,13 @@ Note that a message can only be a regular message (which can be empty) and optio
 __Tip__: to find your own ID, you can look inside the cookies. The `userID` is under the name `c_user`.
 
 __Example (Basic Message)__
+
 ```js
-const login = require("fca-unofficial");
+const login = require("@dongdev/fca-unofficial");
 
-login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
+login({ 
+    appState: []
+}, (err, api) => {
     if(err) return console.error(err);
 
     var yourID = "000000000000000";
@@ -76,10 +112,13 @@ login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
 ```
 
 __Example (File upload)__
+
 ```js
-const login = require("fca-unofficial");
+const login = require("@dongdev/fca-unofficial");
 
-login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
+login({ 
+    appState: []
+}, (err, api) => {
     if(err) return console.error(err);
 
     // Note this example uploads an image called image.jpg
@@ -92,7 +131,8 @@ login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
 });
 ```
 
-------------------------------------
+---
+
 ### Saving session.
 
 To avoid logging in every time you should save AppState (cookies etc.) to a file, then you can use it without having password in your scripts.
@@ -101,9 +141,11 @@ __Example__
 
 ```js
 const fs = require("fs");
-const login = require("fca-unofficial");
+const login = require("@dongdev/fca-unofficial");
 
-var credentials = {email: "FB_EMAIL", password: "FB_PASSWORD"};
+var credentials = { 
+    appState: []
+};
 
 login(credentials, (err, api) => {
     if(err) return console.error(err);
@@ -114,10 +156,11 @@ login(credentials, (err, api) => {
 
 Alternative: Use [c3c-fbstate](https://github.com/c3cbot/c3c-fbstate) to get fbstate.json (appstate.json)
 
-------------------------------------
+---
 
 ### Listening to a chat
-#### api.listen(callback)
+
+#### api.listenMqtt(callback)
 
 Listen watches for messages sent in a chat. By default this won't receive events (joining/leaving a chat, title change etc…) but it can be activated with `api.setOptions({listenEvents: true})`. This will by default ignore messages sent by the current account, you can enable listening to your own messages with `api.setOptions({selfListen: true})`.
 
@@ -125,7 +168,7 @@ __Example__
 
 ```js
 const fs = require("fs");
-const login = require("fca-unofficial");
+const login = require("@dongdev/fca-unofficial");
 
 // Simple echo bot. It will repeat everything that you say.
 // Will stop when you say '/stop'
@@ -135,7 +178,7 @@ login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, ap
     api.setOptions({listenEvents: true});
 
     var stopListening = api.listenMqtt((err, event) => {
-        if(err) return console.error(err);
+        if( err) return console.error(err);
 
         api.markAsRead(event.threadID, (err) => {
             if(err) console.error(err);
@@ -157,38 +200,8 @@ login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, ap
 });
 ```
 
-## FAQS
-
-1. How do I run tests?
-> For tests, create a `test-config.json` file that resembles `example-config.json` and put it in the `test` directory. From the root >directory, run `npm test`.
-
-2. Why doesn't `sendMessage` always work when I'm logged in as a page?
-> Pages can't start conversations with users directly; this is to prevent pages from spamming users.
-
-3. What do I do when `login` doesn't work?
-> First check that you can login to Facebook using the website. If login approvals are enabled, you might be logging in incorrectly. For how to handle login approvals, read our docs on [`login`](DOCS.md#login).
-
-4. How can I avoid logging in every time?  Can I log into a previous session?
-> We support caching everything relevant for you to bypass login. `api.getAppState()` returns an object that you can save and pass into login as `{appState: mySavedAppState}` instead of the credentials object.  If this fails, your session has expired.
-
-5. Do you support sending messages as a page?
-> Yes, set the pageID option on login (this doesn't work if you set it using api.setOptions, it affects the login process).
-> ```js
-> login(credentials, {pageID: "000000000000000"}, (err, api) => { … }
-> ```
-
-6. I'm getting some crazy weird syntax error like `SyntaxError: Unexpected token [`!!!
-> Please try to update your version of node.js before submitting an issue of this nature.  We like to use new language features.
-
-7. I don't want all of these logging messages!
-> You can use `api.setOptions` to silence the logging. You get the `api` object from `login` (see example above). Do
-> ```js
-> api.setOptions({
->     logLevel: "silent"
-> });
-> ```
+`<a name="projects-using-this-api"></a>`
 
-<a name="projects-using-this-api"></a>
 ## Projects using this API:
 
 - [c3c](https://github.com/lequanglam/c3c) - A bot that can be customizable using plugins. Support Facebook & Discord.

package/index.js

@@ -1,13 +1,68 @@
 "use strict";
-
 const utils = require("./utils");
 const log = require("npmlog");
+const axios = require("axios");
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const models = require("./lib/database/models");
+const logger = require("./lib/logger");
 let checkVerified = null;
 const defaultLogRecordSize = 100;
 log.maxRecordSize = defaultLogRecordSize;
+const defaultConfig = {
+  autoUpdate: true,
+  mqtt: {
+    enabled: true,
+    reconnectInterval: 3600,
+  }
+};
+const configPath = path.join(process.cwd(), "fca-config.json");
+let config;
+if (!fs.existsSync(configPath)) {
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+  config = defaultConfig;
+} else {
+  try {
+    const fileContent = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(fileContent);
+    config = { ...defaultConfig, ...config };
+  } catch (err) {
+    logger("Error reading config file, using defaults", "error");
+    config = defaultConfig;
+  }
+}
+global.fca = {
+  config: config
+};
+async function checkForUpdates() {
+  if (!global.fca.config.autoUpdate) {
+    logger("Auto update is disabled", "info");
+  }
+  try {
+    const response = await axios.get("https://raw.githubusercontent.com/DongDev-VN/fca-unofficial/refs/heads/main/package.json");
+    const remoteVersion = response.data.version;
+    const localPackage = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"));
+    const localVersion = localPackage.version;
+    if (remoteVersion !== localVersion) {
+      logger(`New version available: ${remoteVersion}`, "FCA-UPDATE");
+      logger("Installing latest version...", "FCA-UPDATE");
+      execSync(`npm i ${localPackage.name}@latest`);
+      logger("Update completed! Please restart your application", "FCA-UPDATE");
+      process.exit(1);
+    } else {
+      logger(`You are using the latest version: ${localVersion}`, 'info');
+    }
+  } catch (err) {
+    logger("Failed to check for updates:", err, "error");
+  }
+}
+if (global.fca.config.autoUpdate) {
+  checkForUpdates();
+}
 const Boolean_Option = [
   "online",
-  "selfListen",
+  "selfListen", 
   "listenEvents",
   "updatePresence",
   "forceLogin",
@@ -92,18 +147,17 @@ function buildAPI(globalOptions, html, jar) {
         "Error retrieving userID. This can be caused by a lot of things, including getting blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify.",
     };
   }
-  if (html.indexOf("/checkpoint/block/?next") > -1) {
-    log.warn(
-      "login",
-      "Checkpoint detected. Please log in with a browser to verify."
-    );
+  if (html.indexOf("/checkpoint/block/?next") > -1 || html.indexOf("/checkpoint/?next") > -1) {
+    throw {
+      error: "Checkpoint detected. Please log in with a browser to verify.", 
+    }
   }
   const userID = maybeCookie[0]
     .cookieString()
     .split("=")[1]
     .toString();
   const i_userID = objCookie.i_user || null;
-  log.info("login", `Logged in as ${userID}`);
+  logger(`Logged in as ${userID}`, 'info');
   try {
     clearInterval(checkVerified);
   } catch (_) {}
@@ -116,7 +170,7 @@ function buildAPI(globalOptions, html, jar) {
       const url = new URL(mqttEndpoint);
       region = url.searchParams.get("region")?.toUpperCase() || "PRN";
     }
-    log.info("login", `Sever region ${region}`);
+    logger(`Sever region ${region}`, 'info');
   } catch (e) {
     log.warning("login", "Not MQTT endpoint");
   }
@@ -124,6 +178,16 @@ function buildAPI(globalOptions, html, jar) {
   if (tokenMatch) {
     fb_dtsg = tokenMatch[1];
   }
+  (async () => {
+    try {
+      await models.sequelize.authenticate();
+      await models.syncAll();
+    } catch (error) {
+      console.error(error);
+      console.error('Database connection failed:', error.message);
+    }
+  })();
+  logger(`FCA fix by DongDev`, 'info');
   const ctx = {
     userID: userID,
     i_userID: i_userID,
@@ -161,16 +225,17 @@ function buildAPI(globalOptions, html, jar) {
       api[v.replace(".js", "")] = require("./src/" + v)(defaultFuncs, api, ctx);
     });
   api.listen = api.listenMqtt;
+  setInterval(checkForUpdates, 1000 * 60 * 60 * 24);
   setInterval(async () => {
     api
       .refreshFb_dtsg()
       .then(() => {
-        console.log("Successfully refreshed fb_dtsg");
+        logger("Successfully refreshed fb_dtsg", 'info');
       })
       .catch((err) => {
         console.error("An error occurred while refreshing fb_dtsg", err);
       });
-  }, 1000 * 60 * 60 * 48);
+  }, 1000 * 60 * 60 * 24);
   return [ctx, defaultFuncs, api];
 }
 function loginHelper(
@@ -248,12 +313,6 @@ function loginHelper(
       return res;
     })
     .then(function(res) {
-      if (res.body.indexOf("checkpoint") > -1) {
-        log.warn(
-          "login",
-          "Checkpoint detected. Please log in with a browser to verify."
-        );
-      }
       const html = res.body;
       const stuff = buildAPI(globalOptions, html, jar);
       ctx = stuff[0];
@@ -293,7 +352,7 @@ function loginHelper(
   }
   mainPromise
     .then(function() {
-      log.info("login", "Done logging in.");
+      logger("Done logging in", 'info');
       return callback(null, api);
     })
     .catch(function(e) {
@@ -355,4 +414,5 @@ function login(loginData, options, callback) {
   );
   return returnPromise;
 }
-module.exports = login;
+
+module.exports = login;

package/lib/database/models/index.js

@@ -0,0 +1,47 @@
+const { Sequelize } = require('sequelize');
+const fs = require('fs');
+const path = require('path');
+const databasePath = path.join(process.cwd(), 'Fca_Database');
+if (!fs.existsSync(databasePath)) {
+  fs.mkdirSync(databasePath, { recursive: true });
+}
+const 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
+});
+const models = {};
+fs.readdirSync(__dirname).filter(file => file.endsWith('.js') && file !== 'index.js').forEach(file => {
+    const model = require(path.join(__dirname, file))(sequelize);
+    models[model.name] = model;
+  });
+Object.keys(models).forEach(modelName => {
+  if (models[modelName].associate) {
+    models[modelName].associate(models);
+  }
+});
+models.sequelize = sequelize;
+models.Sequelize = Sequelize;
+models.syncAll = async () => {
+  try {
+    await sequelize.sync({ force: false }); 
+  } catch (error) {
+    console.error('Failed to synchronize models:', error);
+    throw error;
+  }
+};
+
+module.exports = models;

package/lib/database/models/thread.js

@@ -0,0 +1,31 @@
+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,
+      },
+      data: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+      }
+    },
+    {
+      sequelize,
+      modelName: "Thread",
+      timestamps: true,
+    }
+  );
+  return Thread;
+};

package/lib/database/threadData.js

@@ -0,0 +1,93 @@
+const { Thread } = require('./models');
+
+const validateThreadID = (threadID) => {
+  if (typeof threadID !== 'string' && typeof threadID !== 'number') {
+    throw new Error('Invalid threadID: must be a string or number.');
+  }
+  return String(threadID);
+};
+const validateData = (data) => {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error('Invalid data: must be a non-empty object.');
+  }
+};
+
+module.exports = function (bot) {
+  return {
+    async create(threadID, data) {
+      try {
+        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 (error) {
+        throw new Error(`Failed to create thread: ${error.message}`);
+      }
+    },
+
+    async get(threadID) {
+      try {
+        threadID = validateThreadID(threadID);
+        const thread = await Thread.findOne({ where: { threadID } });
+        return thread ? thread.get() : null;
+      } catch (error) {
+        throw new Error(`Failed to get thread: ${error.message}`);
+      }
+    },
+
+    async update(threadID, data) {
+      try {
+        threadID = validateThreadID(threadID);
+        validateData(data);
+        const thread = await Thread.findOne({ where: { threadID } });
+
+        if (thread) {
+          await thread.update(data);
+          return { thread: thread.get(), created: false };
+        } else {
+          const newThread = await Thread.create({ ...data, threadID });
+          return { thread: newThread.get(), created: true };
+        }
+      } catch (error) {
+        throw new Error(`Failed to update thread: ${error.message}`);
+      }
+    },
+
+    async del(threadID) {
+      try {
+        if (!threadID) {
+          throw new Error('threadID is required and cannot be undefined');
+        }
+        threadID = validateThreadID(threadID);
+        if (!threadID) {
+          throw new Error('Invalid threadID');
+        }
+        const result = await Thread.destroy({ where: { threadID } });
+        if (result === 0) {
+          throw new Error('No thread found with the specified threadID');
+        }
+        return result;
+      } catch (error) {
+        throw new Error(`Failed to delete thread: ${error.message}`);
+      }
+    },
+    async delAll() {
+      try {
+        return await Thread.destroy({ where: {} });
+      } catch (error) {
+        throw new Error(`Failed to delete all threads: ${error.message}`);
+      }
+    },
+    async getAll(keys = null) {
+      try {
+        const attributes = typeof keys === 'string' ? [keys] : Array.isArray(keys) ? keys : undefined;
+        const threads = await Thread.findAll({ attributes });
+        return threads.map(thread => thread.get());
+      } catch (error) {
+        throw new Error(`Failed to get all threads: ${error.message}`);
+      }
+    },
+  };
+};

package/lib/logger.js

@@ -0,0 +1,96 @@
+const chalk = require('chalk');
+const gradient = require("gradient-string");
+const themes = [
+  'blue',
+  'dream2',
+  'dream',
+  'test',
+  'fiery',
+  'rainbow',
+  'pastel',
+  'cristal',
+  'red',
+  'aqua',
+  'pink',
+  'retro',
+  'sunlight',
+  'teen',
+  'summer',
+  'flower',
+  'ghost',
+  'hacker'
+];
+const theme = themes[Math.floor(Math.random() * themes.length)];
+let co;
+let error;
+if (theme.toLowerCase() === 'blue') {
+  co = gradient([{ color: "#1affa3", pos: 0.2 }, { color: "cyan", pos: 0.4 }, { color: "pink", pos: 0.6 }, { color: "cyan", pos: 0.8 }, { color: '#1affa3', pos: 1 }]);
+  error = chalk.red.bold;
+} else if (theme == "dream2") {
+  cra = gradient("blue", "pink")
+  co = gradient("#a200ff", "#21b5ff", "#a200ff")
+} else if (theme.toLowerCase() === 'dream') {
+  co = gradient([{ color: "blue", pos: 0.2 }, { color: "pink", pos: 0.3 }, { color: "gold", pos: 0.6 }, { color: "pink", pos: 0.8 }, { color: "blue", pos: 1 }]);
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'fiery') {
+  co = gradient("#fc2803", "#fc6f03", "#fcba03");
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'rainbow') {
+  co = gradient.rainbow
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'pastel') {
+  co = gradient.pastel
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'cristal') {
+  co = gradient.cristal
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'red') {
+  co = gradient("red", "orange");
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'aqua') {
+  co = gradient("#0030ff", "#4e6cf2");
+  error = chalk.blueBright;
+} else if (theme.toLowerCase() === 'pink') {
+  cra = gradient('purple', 'pink');
+  co = gradient("#d94fff", "purple");
+} else if (theme.toLowerCase() === 'retro') {
+  cra = gradient("#d94fff", "purple");
+  co = gradient.retro;
+} else if (theme.toLowerCase() === 'sunlight') {
+  cra = gradient("#f5bd31", "#f5e131");
+  co = gradient("orange", "#ffff00", "#ffe600");
+} else if (theme.toLowerCase() === 'teen') {
+  cra = gradient("#00a9c7", "#853858", "#853858", "#00a9c7");
+  co = gradient.teen;
+} else if (theme.toLowerCase() === 'summer') {
+  cra = gradient("#fcff4d", "#4de1ff");
+  co = gradient.summer;
+} else if (theme.toLowerCase() === 'flower') {
+  cra = gradient("blue", "purple", "yellow", "#81ff6e");
+  co = gradient.pastel;
+} else if (theme.toLowerCase() === 'ghost') {
+  cra = gradient("#0a658a", "#0a7f8a", "#0db5aa");
+  co = gradient.mind;
+} else if (theme === 'hacker') {
+  cra = chalk.hex('#4be813');
+  co = gradient('#47a127', '#0eed19', '#27f231');
+} else {
+  co = gradient("#243aff", "#4687f0", "#5800d4");
+  error = chalk.red.bold;
+}
+module.exports = (text, type) => {
+  switch (type) {
+    case "warn":
+      process.stderr.write(co(`\r[ FCA-WARN ] > ${text}`) + '\n');
+      break;
+    case "error":
+      process.stderr.write(chalk.bold.hex("#ff0000").bold(`\r[ FCA-ERROR ]`) + ` > ${text}` + '\n');
+      break;
+    case "info":
+      process.stderr.write(chalk.bold(co(`\r[ FCA-UNO ] > ${text}`) + '\n'));
+      break;
+    default:
+      process.stderr.write(chalk.bold(co(`\r${String(type).toUpperCase()} ${text}`) + '\n'));
+      break;
+  }
+};