Upload 56 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,49 +1,49 @@
-FROM nvidia/cuda:11.3.1-base-ubuntu20.04
-
-ENV DEBIAN_FRONTEND=noninteractive \
-	TZ=Europe/Paris
-
-# Remove any third-party apt sources to avoid issues with expiring keys.
-# Install some basic utilities
-RUN rm -f /etc/apt/sources.list.d/*.list && \
-    apt-get update && apt-get install -y --no-install-recommends \
-    curl \
-    ca-certificates \
-    sudo \
-    git \
-    wget \
-    procps \
-    git-lfs \
-    zip \
-    unzip \
-    htop \
-    vim \
-    nano \
-    bzip2 \
-    libx11-6 \
-    build-essential \
-    libsndfile-dev \
-    software-properties-common \
- && rm -rf /var/lib/apt/lists/*
-
- RUN curl -sL https://deb.nodesource.com/setup_18.x  | bash - && \
-    apt-get install -y nodejs && \
-    npm install -g configurable-http-proxy
-
-# Tạo thư mục làm việc trong container
-WORKDIR /app
-
-# Clone repository từ GitHub
-RUN git clone https://github.com/pedguedes090/mira-bot-v1.git .
-
-# Cài đặt các phụ thuộc
-RUN npm install
-
-# Cấp quyền đọc/ghi cho thư mục
-RUN chmod -R 755 /app
-
-# Expose port mà ứng dụng sẽ chạy
-EXPOSE 25645
-
-# Lệnh để chạy ứng dụng
-CMD ["npm", "start"]
+FROM nvidia/cuda:11.3.1-base-ubuntu20.04
+
+ENV DEBIAN_FRONTEND=noninteractive \
+	TZ=Europe/Paris
+
+# Remove any third-party apt sources to avoid issues with expiring keys.
+# Install some basic utilities
+RUN rm -f /etc/apt/sources.list.d/*.list && \
+    apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    ca-certificates \
+    sudo \
+    git \
+    wget \
+    procps \
+    git-lfs \
+    zip \
+    unzip \
+    htop \
+    vim \
+    nano \
+    bzip2 \
+    libx11-6 \
+    build-essential \
+    libsndfile-dev \
+    software-properties-common \
+ && rm -rf /var/lib/apt/lists/*
+
+ RUN curl -sL https://deb.nodesource.com/setup_18.x  | bash - && \
+    apt-get install -y nodejs && \
+    npm install -g configurable-http-proxy
+
+# Tạo thư mục làm việc trong container
+WORKDIR /app
+COPY package*.json ./
+COPY package-lock*.json ./
+COPY . .
+
+# Cài đặt các phụ thuộc
+RUN npm install
+
+# Cấp quyền đọc/ghi cho thư mục
+RUN chmod -R 755 /app
+
+# Expose port mà ứng dụng sẽ chạy
+EXPOSE 25645
+
+# Lệnh để chạy ứng dụng
+CMD ["npm", "start"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024, GiaKhang1810
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,12 @@
----
-title: Dunbot
-emoji: 🐢
-colorFrom: indigo
-colorTo: gray
-sdk: docker
-app_port: 25645
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Dunbot
+emoji: 🐢
+colorFrom: indigo
+colorTo: gray
+sdk: docker
+app_port: 25645
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

changelog.json

@@ -0,0 +1,33 @@
+{
+    "beta-1.0.1": {
+        "source/database/index.js": [],
+        "source/database/model/thread.mongodb.js": [],
+        "source/database/model/thread.sqlite3.js": [],
+        "source/database/model/user.mongodb.js": [],
+        "source/database/model/user.sqlite3.js": [],
+        "source/languages/en-US.json": [],
+        "source/languages/vi-VN.json": [],
+        "source/lib/log.js": [],
+        "source/lib/utils.js": [],
+        "source/control/index.js": [],
+        "source/control/model.js": [],
+        "source/mira.js": [],
+        "source/apis/utils.js": [],
+        "source/apis/lib/changeAvatar.js": [],
+        "source/apis/lib/changeBio.js": [],
+        "source/apis/lib/changeCover.js": [],
+        "source/apis/lib/Client.js": [],
+        "source/apis/lib/getAccessToken.js": [],
+        "source/apis/lib/getCurrentUserID.js": [],
+        "source/apis/lib/getThreadInfo.js": [],
+        "source/apis/lib/getUserID.js": [],
+        "source/apis/lib/logout.js": [],
+        "source/apis/lib/markAsDelivered.js": [],
+        "source/apis/lib/markAsRead.js": [],
+        "source/apis/lib/Messenger.js": [],
+        "source/apis/lib/muteThread.js": [],
+        "source/apis/lib/post.js": [],
+        "source/apis/lib/resolvePhotoUrl.js": [],
+        "source/apis/lib/screenshot.js": []
+    }
+}

config.json

@@ -0,0 +1,62 @@
+{
+    "facebookAccountOptions": {
+        "email": "",
+        "password": "",
+        "whiteID": "",
+        "pageID": "",
+        "proxy": null,
+        "cookies": "",
+        "facebookState": "fbstate.json"
+    },
+    "dashboardOptions": {
+        "port": 25645,
+        "user": "zpNJSxhCuG@mira.com",
+        "password": "ZU2pXI93sDCT5mIy",
+        "resetAccount": false
+    },
+    "botOptions": {
+        "adminOnly": false,
+        "name": "Mira",
+        "prefix": ",",
+        "adminIDs": [
+            100036947774673,
+            100035731083424
+        ]
+    },
+    "facebookAPIsOptions": {
+        "autoReconnect": true,
+        "listenSelf": true,
+        "listenNotif": true,
+        "listenEventsSelf": true,
+        "listenEvents": true,
+        "forceLogin": true,
+        "autoRefreshState": true,
+        "online": true,
+        "updatePresence": true,
+        "autoMarkDelivery": true
+    },
+    "systemOptions": {
+        "time_zone": "Asia/Ho_Chi_Minh",
+        "language": "en-US",
+        "autoUpdate": {
+            "enable": true,
+            "releaseOnly": true
+        },
+        "autoRestart": {
+            "enable": true,
+            "timeMS": 3600000
+        },
+        "autoLoadPlugins": {
+            "enable": true,
+            "ignore": []
+        },
+        "autoReloadPlugins": {
+            "enable": true,
+            "ignore": []
+        },
+        "DataBase": {
+            "type": "sqlite",
+            "mongoURI": "mongodb+srv://GiaKhang1810:Promaxcapdo123@mira.kcuhmnf.mongodb.net/?retryWrites=true&w=majority&appName=Mira"
+        }
+    }
+}

configCommands.json

@@ -0,0 +1,4 @@
+{
+    "fb": {},
+    "facebook": {}
+}

package.json

@@ -0,0 +1,44 @@
+{
+  "name": "mira-bot-v1",
+  "version": "beta-1.0.1",
+  "description": "Simple Chatbot Messenger",
+  "main": "source/mira.js",
+  "scripts": {
+    "start": "node source/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GiaKhang1810/mira-bot-v1.git"
+  },
+  "keywords": [],
+  "author": "Khang",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/GiaKhang1810/mira-bot-v1/issues"
+  },
+  "homepage": "https://github.com/GiaKhang1810/mira-bot-v1#readme",
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "dependencies": {
+    "axios": "^1.7.2",
+    "cheerio": "^1.0.0",
+    "ejs": "^3.1.10",
+    "express": "^4.19.2",
+    "express-session": "^1.18.0",
+    "express-ws": "^5.0.2",
+    "https-proxy-agent": "^7.0.5",
+    "moment-timezone": "^0.5.45",
+    "mongodb": "^6.8.0",
+    "mongoose": "^8.5.2",
+    "mqtt": "^5.9.1",
+    "mqtt-packet": "^9.0.0",
+    "puppeteer": "^22.14.0",
+    "request": "^2.88.2",
+    "sequelize": "^6.37.3",
+    "sqlite3": "^5.1.7",
+    "websocket-stream": "^5.5.2"
+  }
+}

plugins/fb.js

@@ -0,0 +1,63 @@
+class facebook {
+    get Options() {
+        return {
+            name: "fb",
+            version: "1.0.0",
+            role: 0,
+            author: [
+                {
+                    info: "Khang",
+                    contact: "m.me/100036947774673"
+                }
+            ],
+            category: "Tools",
+            description: {
+                "vi-VN": "Công cụ giúp bạn thực hiện các thao tác không cho phép trên facebook.",
+                "en-US": "Tool to help you perform actions that are not allowed on Facebook."
+            },
+            delay: 2000,
+            guides: {
+                "vi-VN":
+                    "{p}{n}dl reel {url} - Tải video từ reel.\n" +
+                    "{p}{n}dl watch {url} - Tải video từ watch.\n" +
+                    "{p}{n}token {cookie} - Lấy token từ cookie.\n" +
+                    "{p}{n}info user {uid} - Lấy thông tin người dùng.\n" +
+                    "{p}{n}info thread {tid} - Lấy thông tin nhóm.\n" +
+                    "{p}{n}screen {uid} {userAgent} - Chụp màn hình người dùng.",
+                "en-US":
+                    "{p}{n}help - Sends a list of instructions for use.\n" +
+                    "{p}{n}dl reel {url} - Download video from reel.\n" + 
+                    "{p}{n}dl watch {url} - Download videos from watch.\n" +
+                    "{p}{n}token {cookie} - Get token from cookie.\n" +
+                    "{p}{n}info user {uid} - Get user information.\n" +
+                    "{p}{n}info thread {tid} - Get group information.\n" +
+                    "{p}{n}screen {uid} {userAgent} - Capture user screen."
+            },
+            dependencies: ["fs"],
+            envConfig: {}
+        }
+    }
+
+    get Langs() {
+        return {
+            "vi-VN": {
+
+            },
+            "en-US": {
+                
+            }
+        }
+    }
+
+    async Reply({ Messenger, User, Thread, events, apis }) {}
+
+    async React({ Messenger, User, Thread, events, apis }) {}
+
+    async Schedule({ Messenger, User, Thread, events, apis }) {}
+
+    async Main({ Messenger, User, Thread, events, apis , args}) {
+
+    }
+}
+
+module.exports = facebook;

source/apis/index.js

@@ -0,0 +1,272 @@
+var log = require("../lib/log");
+var utils = require("./utils");
+var fs = require("fs");
+var globalOptions = global.mira.config.facebookAPIsOptions;
+
+function buildAPIs(body, jar, whiteID, proxy, loginCount) {
+    var infoCookies = jar
+        .getCookies("https://www.facebook.com")
+        .reduce(function (form, cookies) {
+            var [name, value] = cookies.cookieString().split("=");
+            form[name] = value;
+            return form;
+        }, {});
+
+    if (!infoCookies.i_user && !infoCookies.c_user) {
+        log.warn("facebook.login.notUser");
+        if (globalOptions.forceLogin) {
+            log.warn("facebook.relogin.force");
+            return Login(false, loginCount += 1);
+        } else
+            process.exit(1);
+    }
+
+    var userID = whiteID === infoCookies.i_user ? infoCookies.i_user : infoCookies.c_user;
+    log.info("facebook.login.user", userID);
+    var clientID = (Math.random() * 2147483648 | 0).toString(16);
+    var apis = {
+        getAppState: function getAppState() {
+            return jar
+                .getCookies("https://www.facebook.com")
+                .concat(jar.getCookies("https://www.messenger.com"));
+        }
+    }
+
+    var endpoint, region, syncToken;
+    var endpointExec = /"appID":219994525426954,"endpoint":"(.+?)"/g.exec(body);
+    if (endpointExec) {
+        endpoint = endpointExec[1].replace(/\\\//g, "/");
+        region = new URL(endpoint).searchParams.get("region").toUpperCase();
+        log.info("facebook.login.region", region);
+    } else
+        log.warn("facebook.login.notRegion");
+
+    var ctx = {
+        userID,
+        region,
+        endpoint,
+        clientID,
+        jar,
+        get globalOptions() {
+            return global.mira.config.facebookAPIsOptions;
+        },
+        isLogin: true,
+        lastSeqID: null,
+        clientMutationID: 0,
+        proxy
+    }
+
+    var http = utils.makeDefaults(body, userID, ctx);
+    fs.readdirSync(__dirname + "/lib")
+        .filter(item => item.endsWith(".js"))
+        .map(function (item) {
+            apis[item.replace(".js", "")] = require("./lib/" + item)(http, apis, ctx);
+        });
+    log.info("facebook.apis", Object.keys(apis).length);
+    global.mira.apis = apis;
+
+    var checkLogin = setInterval(function () {
+        if (ctx.isLogin)
+            return;
+
+        log.warn("facebook.login.logout");
+        if (globalOptions.autoReconnect) {
+            log.warn("facebook.login.reconnect");
+            clearInterval(checkLogin);
+            return Login(false, loginCount += 1);
+        }
+    }, 5000);
+
+    return utils
+        .post("https://www.facebook.com/v1.0/dialog/oauth/confirm", ctx.jar, {
+            fb_dtsg: /\["DTSGInitData",\[],{"token":"(\S+)","async_get_token"/g.exec(body)[1],
+            app_id: "124024574287414",
+            redirect_uri: "fbconnect://success",
+            display: "popup",
+            return_format: "access_token",
+        })
+        .then(function (res) {
+            var body = res.body;
+            var token = body.match(/access_token=(.+?)&/);
+            if (token && token[1]) {
+                ctx.token = token[1];
+                log.info("facebook.access.token", token[1]);
+            } else
+                throw new Error("Token is undefined.");
+        })
+        .catch(function (error) {
+            log.warn("facebook.access.error", error.message);
+            console.log(error);
+        });
+}
+
+async function makeLogin(email, password, proxy) {
+    var Browser;
+    var Pup = require("puppeteer");
+    var Proxy = utils.parseProxy(proxy);
+
+    if (Proxy && Proxy.length > 0) {
+        Browser = await Pup.launch({ headless: true, args: ["--proxy-server=" + proxy] });
+    } else
+        Browser = await Pup.launch({ headless: false });
+
+    var Page = await Browser.newPage();
+
+    if (Proxy && Proxy[0] && Proxy[1])
+        await Page.authenticate({
+            username: Proxy[0],
+            password: Proxy[1]
+        });
+
+    await Page.setUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36");
+    await Page.goto("https://www.facebook.com");
+    await Page.type("input[name=\"email\"]", email);
+    await Page.type("input[name=\"pass\"]", password);
+    await Page.click("button[name=\"login\"]");
+    var waitForLoad = Page.waitForNavigation({ waitUntil: "networkidle0" });
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    var currentUrl = Page.url();
+
+    if (currentUrl.indexOf("/two_step_verification/two_factor/") > -1 || currentUrl.indexOf("/checkpoint/465803052217681") > -1) {
+        log.warn("facebook.login.checkpoint");
+        var timeoutCheckpoint = setTimeout(function () {
+            log.warn("facebook.login.missTimeCheckpoint");
+            process.exit(1);
+        }, 2 * 60 * 1000);
+        if (await Page.evaluate(_ => document.querySelectorAll("input").length) === 1) {
+            async function waitForCheckpointSMS(length) {
+                var NotChangeURL = _ => currentUrl === Page.url();
+                var ReClick = _ => Page.click("span[class=\"x1lliihq x193iq5w x6ikm8r x10wlt62 xlyipyv xuxw1ft\"]");
+                var GetCodeSMS = _ => log.input("facebook.access.codeSMS", "yellow", 60 * 1000);
+                var EnterCodeSMS = SMS => length === 0 ? Page.type("input[dir=\"ltr\"", SMS) : Page.evaluate(SMS => {
+                    var input = document.querySelector("input[dir=\"ltr\"");
+                    if (input) {
+                        input.value = SMS;
+                        input.dispatchEvent(new Event("input", { bubbles: true }));
+                    }
+                }, SMS);
+
+                if (length > 2)
+                    throw new Error("Cant Authenticated With CodeSMS.");
+                var SMS = await GetCodeSMS();
+                if (SMS) {
+                    await EnterCodeSMS(SMS);
+                    await ReClick();
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    if (NotChangeURL()) {
+                        log.warn("facebook.access.wrongSMS");
+                        return waitForCheckpointSMS(length + 1);
+                    }
+                } else
+                    throw new Error("CodeSMS is undefined.");
+            }
+
+            await waitForCheckpointSMS(0);
+        } else {
+            var intervalCheckURL;
+            var waitForCheckpoint = new Promise(resolve => {
+                intervalCheckURL = setInterval(function () {
+                    var currentURL = Page.url();
+                    if (currentURL.indexOf("/two_factor/remember_browser/") > -1)
+                        resolve();
+                }, 5000);
+            });
+            await waitForCheckpoint;
+            clearInterval(intervalCheckURL);
+        }
+        clearTimeout(timeoutCheckpoint);
+        await Page.click("div[class=\"x1n2onr6 x1ja2u2z x78zum5 x2lah0s xl56j7k x6s0dn4 xozqiw3 x1q0g3np x9f619 xi112ho x17zwfj4 x585lrc x1403ito x1qhmfi1 x1s9qjmn x39innc x7gj0x1 x1mpseq2 x13fuv20 xu3j5b3 x1q0q8m5 x26u7qi x178xt8z xm81vs4 xso031l xy80clv x1fq8qgq x1ghtduv x1oktzhs\"");
+    }
+    
+    if (currentUrl.indexOf("/two_step_verification/authentication/") > -1) {
+        log.warn("facebook.login.checkpointImage");
+        process.exit(1);
+    }
+
+    if (currentUrl.indexOf("/login/") > -1) {
+        log.warn("facebook.login.wrong");
+        process.exit(1);
+    }
+
+    await waitForLoad;
+    var appState = await Page.cookies();
+    await Browser.close();
+    return appState;
+}
+
+function LoginHelper(appState, email, password, proxy, whiteID, loginCount) {
+    if (appState) {
+        var jar = utils.getJar();
+
+        if (typeof appState === "string") {
+            appState = decodeURIComponent(appState).split("; ").map(item => {
+                var [key, value] = item.split("=");
+                return {
+                    key,
+                    value,
+                    domain: "facebook.com",
+                    path: "/",
+                    expires: new Date().getTime() + 1000 * 60 * 60 * 24 * 365
+                }
+            });
+        }
+        appState.map(item => {
+            var string = [
+                (item.key || item.name) + "=" + item.value,
+                "expires=" + item.expires,
+                "domain=" + item.domain,
+                "path=" + item.path
+            ].join("; ");
+            jar.setCookie(utils.cookie(string), "http://" + item.domain);
+        });
+
+        return utils
+            .get("https://www.facebook.com", jar, null, null, { noRef: true })
+            .then(function (res) {
+                var reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+                var redirect = reg.exec(res.body);
+                if (redirect && redirect[1]) {
+                    return utils
+                        .get(redirect[1], jar);
+                }
+                return res;
+            })
+            .then(res => buildAPIs(res.body, jar, whiteID, proxy, loginCount))
+            .catch(function (error) {
+                log.error("facebook.login.error");
+                console.log(error);
+                process.exit(1);
+            });
+    } else if (email && email.length > 0 && password && password.length > 0) {
+        return makeLogin(email, password, proxy)
+            .then(fbState => LoginHelper(fbState, email, password, proxy, whiteID, loginCount));
+    } else {
+        log.warn("facebook.missing");
+        process.exit(1);
+    }
+}
+
+function Login(firstLogin = true, loginCount = 1) {
+    if (loginCount >= 3) {
+        log.warn("facebook.relogin.error");
+        process.exit(1);
+    }
+
+    var appState;
+    var { email, password, cookies, facebookState, proxy, whiteID } = global.mira.config.facebookAccountOptions;
+    var path = __dirname + "/../../" + facebookState;
+
+    if (facebookState && facebookState.length > 0 && fs.existsSync(path))
+        appState = require(path);
+    else if (cookies && cookies.length > 0)
+        appState = cookies;
+
+    if (proxy && proxy.length > 0)
+        utils.setProxy(proxy);
+
+    proxy = proxy || "";
+    appState = firstLogin ? appState : null;
+    return LoginHelper(appState, email, password, proxy, whiteID, loginCount);
+}
+
+module.exports = Login;

source/apis/lib/Client.js

@@ -0,0 +1,1132 @@
+var utils = require("../utils");
+var mqtt = require("mqtt");
+var websocket = require("websocket-stream");
+var HttpsProxyAgent = require("https-proxy-agent");
+var EventEmitter = require("events");
+var topics = [
+    "/legacy_web",
+    "/webrtc",
+    "/rtc_multi",
+    "/onevc",
+    "/br_sr",
+    "/sr_res",
+    "/t_ms",
+    "/thread_typing",
+    "/orca_typing_notifications",
+    "/notify_disconnect",
+    "/orca_presence",
+    "/legacy_web_mtouch",
+    "/t_rtc_multi",
+    "/ls_foreground_state",
+    "/ls_resp",
+    "/inbox",
+    "/mercury",
+    "/messaging_events",
+    "/orca_message_notifications",
+    "/pp",
+    "/webrtc_response"
+];
+
+function notificationConnect(ctx) {
+    var next = true;
+    return utils
+        .get("https://www.facebook.com/notifications", ctx.jar)
+        .catch(function (error) {
+            if (error.type === "logout.")
+                ctx.isLogin = false;
+
+            next = false;
+            console.log(error);
+        })
+        .finally(function () {
+            if (next && ctx.listenNotif)
+                return setTimeout(notificationConnect, 1000, ctx);
+        });
+}
+
+function markDelivery(apis, threadID, messageID) {
+    if (threadID && messageID)
+        apis.markAsDelivered(threadID, messageID, error => !error ? apis.markAsRead(threadID) : null);
+}
+
+function parseAndReCallback(http, apis, ctx, globalCallback, deltails) {
+    function getExtension(original_extension, fullFileName = "") {
+        if (original_extension)
+            return original_extension;
+        else {
+            var extension = fullFileName.split(".").pop();
+            if (extension === fullFileName)
+                return "";
+            else
+                return extension;
+        }
+    }
+
+    function formatAttachment(attachment1, attachment2) {
+        var fullFileName = attachment1.filename;
+        var fileSize = Number(attachment1.fileSize || 0);
+        var durationVideo = attachment1.genericMetadata ? Number(attachment1.genericMetadata.videoLength) : undefined;
+        var durationAudio = attachment1.genericMetadata ? Number(attachment1.genericMetadata.duration) : undefined;
+        var mimeType = attachment1.mimeType;
+
+        attachment2 = attachment2 || { id: "", image_data: {} };
+        attachment1 = attachment1.mercury || attachment1;
+        var blob = attachment1.blob_attachment || attachment1.sticker_attachment;
+        var type = blob && blob.__typename ? blob.__typename : attachment1.attach_type;
+        if (!type && attachment1.sticker_attachment) {
+            type = "StickerAttachment";
+            blob = attachment1.sticker_attachment;
+        } else if (!type && attachment1.extensible_attachment) {
+            if (attachment1.extensible_attachment.story_attachment && attachment1.extensible_attachment.story_attachment.target && attachment1.extensible_attachment.story_attachment.target.__typename && attachment1.extensible_attachment.story_attachment.target.__typename === "MessageLocation")
+                type = "MessageLocation";
+            else
+                type = "ExtensibleAttachment";
+            blob = attachment1.extensible_attachment;
+        }
+        switch (type) {
+            case "sticker":
+                return {
+                    type: "sticker",
+                    ID: attachment1.metadata.stickerID.toString(),
+                    url: attachment1.url,
+                    packID: attachment1.metadata.packID.toString(),
+                    spriteUrl: attachment1.metadata.spriteURI,
+                    spriteUrl2x: attachment1.metadata.spriteURI2x,
+                    width: attachment1.metadata.width,
+                    height: attachment1.metadata.height,
+                    caption: attachment2.caption,
+                    description: attachment2.description,
+                    frameCount: attachment1.metadata.frameCount,
+                    frameRate: attachment1.metadata.frameRate,
+                    framesPerRow: attachment1.metadata.framesPerRow,
+                    framesPerCol: attachment1.metadata.framesPerCol,
+                    stickerID: attachment1.metadata.stickerID.toString(),
+                    spriteURI: attachment1.metadata.spriteURI,
+                    spriteURI2x: attachment1.metadata.spriteURI2x
+                }
+            case "file":
+                return {
+                    type: "file",
+                    ID: attachment2.id.toString(),
+                    fullFileName,
+                    filename: attachment1.name,
+                    fileSize,
+                    original_extension: getExtension(attachment1.original_extension, fullFileName),
+                    mimeType,
+                    url: attachment1.url,
+                    isMalicious: attachment2.is_malicious,
+                    contentType: attachment2.mime_type,
+                    name: attachment1.name
+                }
+            case "photo":
+                return {
+                    type: "photo",
+                    ID: attachment1.metadata.fbid.toString(),
+                    filename: attachment1.fileName,
+                    fullFileName,
+                    fileSize,
+                    original_extension: getExtension(attachment1.original_extension, fullFileName),
+                    mimeType,
+                    thumbnailUrl: attachment1.thumbnail_url,
+                    previewUrl: attachment1.preview_url,
+                    previewWidth: attachment1.preview_width,
+                    previewHeight: attachment1.preview_height,
+                    largePreviewUrl: attachment1.large_preview_url,
+                    largePreviewWidth: attachment1.large_preview_width,
+                    largePreviewHeight: attachment1.large_preview_height,
+                    url: attachment1.metadata.url,
+                    width: attachment1.metadata.dimensions.split(",")[0],
+                    height: attachment1.metadata.dimensions.split(",")[1],
+                    name: fullFileName
+                }
+            case "animated_image":
+                return {
+                    type: "animated_image",
+                    ID: attachment2.id.toString(),
+                    filename: attachment2.filename,
+                    fullFileName: fullFileName,
+                    original_extension: getExtension(attachment2.original_extension, fullFileName),
+                    mimeType,
+                    previewUrl: attachment1.preview_url,
+                    previewWidth: attachment1.preview_width,
+                    previewHeight: attachment1.preview_height,
+                    url: attachment2.image_data.url,
+                    width: attachment2.image_data.width,
+                    height: attachment2.image_data.height,
+                    name: attachment1.name,
+                    facebookUrl: attachment1.url,
+                    thumbnailUrl: attachment1.thumbnail_url,
+                    rawGifImage: attachment2.image_data.raw_gif_image,
+                    rawWebpImage: attachment2.image_data.raw_webp_image,
+                    animatedGifUrl: attachment2.image_data.animated_gif_url,
+                    animatedGifPreviewUrl: attachment2.image_data.animated_gif_preview_url,
+                    animatedWebpUrl: attachment2.image_data.animated_webp_url,
+                    animatedWebpPreviewUrl: attachment2.image_data.animated_webp_preview_url
+                }
+            case "share":
+                return {
+                    type: "share",
+                    ID: attachment1.share.share_id.toString(),
+                    url: attachment2.href,
+                    title: attachment1.share.title,
+                    description: attachment1.share.description,
+                    source: attachment1.share.source,
+                    image: attachment1.share.media.image,
+                    width: attachment1.share.media.image_size.width,
+                    height: attachment1.share.media.image_size.height,
+                    playable: attachment1.share.media.playable,
+                    duration: attachment1.share.media.duration,
+                    subattachments: attachment1.share.subattachments,
+                    properties: {},
+                    animatedImageSize: attachment1.share.media.animated_image_size,
+                    facebookUrl: attachment1.share.uri,
+                    target: attachment1.share.target,
+                    styleList: attachment1.share.style_list
+                }
+            case "video":
+                return {
+                    type: "video",
+                    ID: attachment1.metadata.fbid.toString(),
+                    filename: attachment1.name,
+                    fullFileName: fullFileName,
+                    original_extension: getExtension(attachment1.original_extension, fullFileName),
+                    mimeType,
+                    duration: durationVideo,
+                    previewUrl: attachment1.preview_url,
+                    previewWidth: attachment1.preview_width,
+                    previewHeight: attachment1.preview_height,
+                    url: attachment1.url,
+                    width: attachment1.metadata.dimensions.width,
+                    height: attachment1.metadata.dimensions.height,
+                    videoType: "unknown",
+                    thumbnailUrl: attachment1.thumbnail_url
+                }
+            case "error":
+                return {
+                    type: "error",
+                    attachment1: attachment1,
+                    attachment2: attachment2
+                }
+            case "MessageImage":
+                return {
+                    type: "photo",
+                    ID: blob.legacy_attachment_id,
+                    filename: blob.filename,
+                    fullFileName,
+                    fileSize,
+                    original_extension: getExtension(blob.original_extension, fullFileName),
+                    mimeType,
+                    thumbnailUrl: blob.thumbnail.uri,
+                    previewUrl: blob.preview.uri,
+                    previewWidth: blob.preview.width,
+                    previewHeight: blob.preview.height,
+                    largePreviewUrl: blob.large_preview.uri,
+                    largePreviewWidth: blob.large_preview.width,
+                    largePreviewHeight: blob.large_preview.height,
+                    url: blob.large_preview.uri,
+                    width: blob.original_dimensions.x,
+                    height: blob.original_dimensions.y,
+                    name: blob.filename
+                }
+            case "MessageAnimatedImage":
+                return {
+                    type: "animated_image",
+                    ID: blob.legacy_attachment_id,
+                    filename: blob.filename,
+                    fullFileName,
+                    original_extension: getExtension(blob.original_extension, fullFileName),
+                    mimeType,
+                    previewUrl: blob.preview_image.uri,
+                    previewWidth: blob.preview_image.width,
+                    previewHeight: blob.preview_image.height,
+                    url: blob.animated_image.uri,
+                    width: blob.animated_image.width,
+                    height: blob.animated_image.height,
+                    thumbnailUrl: blob.preview_image.uri,
+                    name: blob.filename,
+                    facebookUrl: blob.animated_image.uri,
+                    rawGifImage: blob.animated_image.uri,
+                    animatedGifUrl: blob.animated_image.uri,
+                    animatedGifPreviewUrl: blob.preview_image.uri,
+                    animatedWebpUrl: blob.animated_image.uri,
+                    animatedWebpPreviewUrl: blob.preview_image.uri
+                }
+            case "MessageVideo":
+                return {
+                    type: "video",
+                    ID: blob.legacy_attachment_id,
+                    filename: blob.filename,
+                    fullFileName,
+                    original_extension: getExtension(blob.original_extension, fullFileName),
+                    fileSize: fileSize,
+                    duration: durationVideo,
+                    mimeType,
+                    previewUrl: blob.large_image.uri,
+                    previewWidth: blob.large_image.width,
+                    previewHeight: blob.large_image.height,
+                    url: blob.playable_url,
+                    width: blob.original_dimensions.x,
+                    height: blob.original_dimensions.y,
+                    videoType: blob.video_type.toLowerCase(),
+                    thumbnailUrl: blob.large_image.uri
+                }
+            case "MessageAudio":
+                return {
+                    type: "audio",
+                    ID: blob.url_shimhash,
+                    filename: blob.filename,
+                    fullFileName,
+                    fileSize,
+                    duration: durationAudio,
+                    original_extension: getExtension(blob.original_extension, fullFileName),
+                    mimeType,
+                    audioType: blob.audio_type,
+                    url: blob.playable_url,
+                    isVoiceMail: blob.is_voicemail
+                }
+            case "StickerAttachment":
+            case "Sticker":
+                return {
+                    type: "sticker",
+                    ID: blob.id,
+                    url: blob.url,
+                    packID: blob.pack ? blob.pack.id : null,
+                    spriteUrl: blob.sprite_image,
+                    spriteUrl2x: blob.sprite_image_2x,
+                    width: blob.width,
+                    height: blob.height,
+                    caption: blob.label,
+                    description: blob.label,
+                    frameCount: blob.frame_count,
+                    frameRate: blob.frame_rate,
+                    framesPerRow: blob.frames_per_row,
+                    framesPerCol: blob.frames_per_column,
+                    stickerID: blob.id,
+                    spriteURI: blob.sprite_image,
+                    spriteURI2x: blob.sprite_image_2x
+                }
+            case "MessageLocation":
+                var urlAttach = blob.story_attachment.url;
+                var mediaAttach = blob.story_attachment.media;
+                var u = querystring.parse(url.parse(urlAttach).query).u;
+                var where1 = querystring.parse(url.parse(u).query).where1;
+                var address = where1.split(", ");
+                var latitude;
+                var longitude;
+
+                try {
+                    latitude = Number.parseFloat(address[0]);
+                    longitude = Number.parseFloat(address[1]);
+                } finally { }
+
+                var imageUrl;
+                var width;
+                var height;
+                if (mediaAttach && mediaAttach.image) {
+                    imageUrl = mediaAttach.image.uri;
+                    width = mediaAttach.image.width;
+                    height = mediaAttach.image.height;
+                }
+
+                return {
+                    type: "location",
+                    ID: blob.legacy_attachment_id,
+                    latitude,
+                    longitude,
+                    image: imageUrl,
+                    width,
+                    height,
+                    url: u || urlAttach,
+                    address: where1,
+                    facebookUrl: blob.story_attachment.url,
+                    target: blob.story_attachment.target,
+                    styleList: blob.story_attachment.style_list
+                }
+            case "ExtensibleAttachment":
+                return {
+                    type: "share",
+                    ID: blob.legacy_attachment_id,
+                    url: blob.story_attachment.url,
+                    title: blob.story_attachment.title_with_entities.text,
+                    description: blob.story_attachment.description && blob.story_attachment.description.text,
+                    source: blob.story_attachment.source ? blob.story_attachment.source.text : null,
+                    image: blob.story_attachment.media && blob.story_attachment.media.image && blob.story_attachment.media.image.uri,
+                    width: blob.story_attachment.media && blob.story_attachment.media.image && blob.story_attachment.media.image.width,
+                    height: blob.story_attachment.media && blob.story_attachment.media.image && blob.story_attachment.media.image.height,
+                    playable: blob.story_attachment.media && blob.story_attachment.media.is_playable,
+                    duration: blob.story_attachment.media && blob.story_attachment.media.playable_duration_in_ms,
+                    playableUrl: !blob.story_attachment.media ? null : blob.story_attachment.media.playable_url,
+                    subattachments: blob.story_attachment.subattachments,
+                    properties: blob.story_attachment.properties.reduce(function (obj, cur) {
+                        obj[cur.key] = cur.value.text;
+                        return obj;
+                    }, {}),
+                    facebookUrl: blob.story_attachment.url,
+                    target: blob.story_attachment.target,
+                    styleList: blob.story_attachment.style_list
+                }
+            case "MessageFile":
+                return {
+                    type: "file",
+                    ID: blob.message_file_fbid,
+                    fullFileName,
+                    filename: blob.filename,
+                    fileSize,
+                    mimeType: blob.mimetype,
+                    original_extension: blob.original_extension || fullFileName.split(".").pop(),
+                    url: blob.url,
+                    isMalicious: blob.is_malicious,
+                    contentType: blob.content_type,
+                    name: blob.filename
+                }
+            default:
+                throw new Error("unrecognized attach_file of type " + type + "`" + JSON.stringify(attachment1, null, 4) + " attachment2: " + JSON.stringify(attachment2, null, 4) + "`");
+        }
+    }
+
+    if (deltails.class === "NewMessage") {
+        function formatMessage() {
+            var md = deltails.messageMetadata;
+            var mdata = !deltails.data ? [] : !deltails.data.prng ? [] : JSON.parse(deltails.data.prng);
+            var m_id = mdata.map(u => u.i);
+            var m_offset = mdata.map(u => u.o);
+            var m_length = mdata.map(u => u.l);
+            var mentions = {};
+            for (var i = 0; i < m_id.length; i++)
+                mentions[m_id[i]] = deltails.body.substring(m_offset[i], m_offset[i] + m_length[i]);
+
+            return {
+                type: "message",
+                senderID: utils.formatID(md.actorFbId.toString()),
+                body: deltails.body || "",
+                threadID: utils.formatID((md.threadKey.threadFbId || md.threadKey.otherUserFbId).toString()),
+                messageID: md.messageId,
+                attachments: (deltails.attachments || []).map(v => formatAttachment(v)),
+                mentions,
+                timestamp: md.timestamp,
+                isGroup: !!md.threadKey.threadFbId,
+                participantIDs: deltails.participants || []
+            }
+        }
+
+        (function resolveAttachmentUrl(i) {
+            if (i === (deltails.attachments || []).length) {
+                try {
+                    var message = formatMessage();
+                    (message.senderID !== ctx.userID || ctx.globalOptions.listenSelf) ? globalCallback(null, message) : null;
+                    if (ctx.globalOptions.autoMarkDelivery)
+                        markDelivery(apis, message.threadID, message.messageID);
+                } catch (error) {
+                    error = {
+                        error: "Problem parsing message object. Please open an issue at https://github.com/GiaKhang1810/mira-bot-v1/issues.",
+                        detail: error,
+                        response: deltails,
+                        type: "parse_error"
+                    }
+                    globalCallback(error);
+                }
+            } else {
+                if (deltails.attachments[i].mercury.attach_type === "photo") {
+                    apis.resolvePhotoUrl(deltails.attachments[i].fbid, (e, u) => e ? deltails.attachments[i].mercury.metadata.url = u : null, resolveAttachmentUrl(i + 1));
+                } else {
+                    return resolveAttachmentUrl(i + 1);
+                }
+            }
+        })(0);
+    }
+
+    if (deltails.class === "ClientPayload") {
+        var ClientPayload = JSON.parse(String.fromCharCode.apply(null, deltails.payload));
+        if (ClientPayload && ClientPayload.deltas) {
+            for (var i in ClientPayload.deltas) {
+                var delta = ClientPayload.deltas[i];
+
+                if (delta.deltaMessageReaction && ctx.globalOptions.listenEvents) {
+                    var reaction = {
+                        type: "message_reaction",
+                        threadID: (delta.deltaMessageReaction.threadKey.threadFbId ? delta.deltaMessageReaction.threadKey.threadFbId : delta.deltaMessageReaction.threadKey.otherUserFbId).toString(),
+                        messageID: delta.deltaMessageReaction.messageId,
+                        reaction: delta.deltaMessageReaction.reaction,
+                        senderID: delta.deltaMessageReaction.senderId.toString(),
+                        userID: (delta.deltaMessageReaction.userId || delta.deltaMessageReaction.senderId).toString()
+                    }
+                    globalCallback(null, reaction);
+                } else if (delta.deltaRecallMessageData && ctx.globalOptions.listenEvents) {
+                    var unsend = {
+                        type: "message_unsend",
+                        threadID: (delta.deltaRecallMessageData.threadKey.threadFbId ? delta.deltaRecallMessageData.threadKey.threadFbId : delta.deltaRecallMessageData.threadKey.otherUserFbId).toString(),
+                        messageID: delta.deltaRecallMessageData.messageID,
+                        senderID: delta.deltaRecallMessageData.senderID.toString(),
+                        deletionTimestamp: delta.deltaRecallMessageData.deletionTimestamp,
+                        timestamp: delta.deltaRecallMessageData.timestamp
+                    }
+                    globalCallback(null, unsend);
+                } else if (delta.deltaRemoveMessage && ctx.globalOptions.listenEvents) {
+                    var del = {
+                        type: "message_self_delete",
+                        threadID: (delta.deltaRemoveMessage.threadKey.threadFbId ? delta.deltaRemoveMessage.threadKey.threadFbId : delta.deltaRemoveMessage.threadKey.otherUserFbId).toString(),
+                        messageID: delta.deltaRemoveMessage.messageIds.length === 1 ? delta.deltaRemoveMessage.messageIds[0] : delta.deltaRemoveMessage.messageIds,
+                        senderID: ctx.userID,
+                        deletionTimestamp: delta.deltaRemoveMessage.deletionTimestamp,
+                        timestamp: delta.deltaRemoveMessage.timestamp
+                    }
+                    globalCallback(null, del);
+                } else if (delta.deltaMessageReply) {
+                    var mdata = !delta.deltaMessageReply.message ? [] : !delta.deltaMessageReply.message.data ? [] : !delta.deltaMessageReply.message.data.prng ? [] : JSON.parse(delta.deltaMessageReply.message.data.prng);
+                    var m_id = mdata.map(u => u.i);
+                    var m_offset = mdata.map(u => u.o);
+                    var m_length = mdata.map(u => u.l);
+                    var mentions = {}
+
+                    for (var i = 0; i < m_id.length; i++)
+                        mentions[m_id[i]] = (delta.deltaMessageReply.message.body || "").substring(m_offset[i], m_offset[i] + m_length[i]);
+
+                    var callbackToReturn = {
+                        type: "message_reply",
+                        threadID: (delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId ? delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId : delta.deltaMessageReply.message.messageMetadata.threadKey.otherUserFbId).toString(),
+                        messageID: delta.deltaMessageReply.message.messageMetadata.messageId,
+                        senderID: delta.deltaMessageReply.message.messageMetadata.actorFbId.toString(),
+                        attachments: (delta.deltaMessageReply.message.attachments || []).map(att => {
+                            var mercury = JSON.parse(att.mercuryJSON);
+                            Object.assign(att, mercury);
+                            return att;
+                        }).map(att => {
+                            var x;
+                            try {
+                                x = formatAttachment(att);
+                            } catch (ex) {
+                                x = att;
+                                x.error = ex;
+                                x.type = "unknown";
+                            }
+                            return x;
+                        }),
+                        body: delta.deltaMessageReply.message.body || "",
+                        isGroup: !!delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId,
+                        mentions,
+                        timestamp: delta.deltaMessageReply.message.messageMetadata.timestamp,
+                        participantIDs: (delta.deltaMessageReply.message.messageMetadata.cid.canonicalParticipantFbids || delta.deltaMessageReply.message.participants || []).map(e => e.toString())
+                    }
+
+                    if (delta.deltaMessageReply.repliedToMessage) {
+                        mdata = !delta.deltaMessageReply.repliedToMessage ? [] : !delta.deltaMessageReply.repliedToMessage.data ? [] : !delta.deltaMessageReply.repliedToMessage.data.prng ? [] : JSON.parse(delta.deltaMessageReply.repliedToMessage.data.prng);
+                        m_id = mdata.map(u => u.i);
+                        m_offset = mdata.map(u => u.o);
+                        m_length = mdata.map(u => u.l);
+                        var rmentions = {}
+
+                        for (var i = 0; i < m_id.length; i++)
+                            rmentions[m_id[i]] = (delta.deltaMessageReply.repliedToMessage.body || "").substring(m_offset[i], m_offset[i] + m_length[i]);
+
+                        callbackToReturn.messageReply = {
+                            threadID: (delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId ? delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId : delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.otherUserFbId).toString(),
+                            messageID: delta.deltaMessageReply.repliedToMessage.messageMetadata.messageId,
+                            senderID: delta.deltaMessageReply.repliedToMessage.messageMetadata.actorFbId.toString(),
+                            attachments: delta.deltaMessageReply.repliedToMessage.attachments.map(att => {
+                                var mercury = JSON.parse(att.mercuryJSON);
+                                Object.assign(att, mercury);
+                                return att;
+                            }).map(att => {
+                                var x;
+                                try {
+                                    x = formatAttachment(att);
+                                } catch (ex) {
+                                    x = att;
+                                    x.error = ex;
+                                    x.type = "unknown";
+                                }
+                                return x;
+                            }),
+                            body: delta.deltaMessageReply.repliedToMessage.body || "",
+                            isGroup: !!delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId,
+                            mentions: rmentions,
+                            timestamp: delta.deltaMessageReply.repliedToMessage.messageMetadata.timestamp
+                        };
+                    } else if (delta.deltaMessageReply.replyToMessageId) {
+                        return http
+                            .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, {
+                                queries: JSON.stringify({
+                                    o0: {
+                                        doc_id: "2848441488556444",
+                                        query_params: {
+                                            thread_and_message_id: {
+                                                thread_id: callbackToReturn.threadID,
+                                                message_id: delta.deltaMessageReply.replyToMessageId.id
+                                            }
+                                        }
+                                    }
+                                })
+                            })
+                            .then(utils.parseAndCheckLogin(ctx, http))
+                            .then(resData => {
+                                if (resData[resData.length - 1].error_results > 0)
+                                    throw resData[0].o0.errors;
+
+
+                                if (resData[resData.length - 1].successful_results === 0)
+                                    throw { error: "forcedFetch: there was no successful_results", response: resData };
+
+                                var fetchData = resData[0].o0.data.message;
+                                var mobj = {}
+                                for (var n in fetchData.message.ranges)
+                                    mobj[fetchData.message.ranges[n].entity.id] = (fetchData.message.text || "").substr(fetchData.message.ranges[n].offset, fetchData.message.ranges[n].length);
+
+
+                                callbackToReturn.messageReply = {
+                                    threadID: callbackToReturn.threadID,
+                                    messageID: fetchData.message_id,
+                                    senderID: fetchData.message_sender.id.toString(),
+                                    attachments: fetchData.message.blob_attachment.map(att => {
+                                        var x;
+                                        try {
+                                            x = formatAttachment({ blob_attachment: att });
+                                        } catch (ex) {
+                                            x = att;
+                                            x.error = ex;
+                                            x.type = "unknown";
+                                        }
+                                        return x;
+                                    }),
+                                    body: fetchData.message.text || "",
+                                    isGroup: callbackToReturn.isGroup,
+                                    mentions: mobj,
+                                    timestamp: parseInt(fetchData.timestamp_precise)
+                                };
+                            })
+                            .catch(console.log)
+                            .finally(function () {
+                                if (ctx.globalOptions.autoMarkDelivery)
+                                    markDelivery(apis, callbackToReturn.threadID, callbackToReturn.messageID);
+
+                                (callbackToReturn.senderID !== ctx.userID || ctx.globalOptions.listenSelf) ? globalCallback(null, callbackToReturn) : null;
+                            });
+                    } else
+                        callbackToReturn.delta = delta;
+
+                    if (ctx.globalOptions.autoMarkDelivery)
+                        markDelivery(apis, callbackToReturn.threadID, callbackToReturn.messageID);
+
+                    return (callbackToReturn.senderID !== ctx.userID || ctx.globalOptions.listenSelf) ? globalCallback(null, callbackToReturn) : null;
+                }
+            }
+            return;
+        }
+    }
+
+    if (deltails.class !== "NewMessage" && !ctx.globalOptions.listenEvents)
+        return;
+
+    function getAdminTextMessageType(type) {
+        switch (type) {
+            case 'unpin_messages_v2':
+                return 'log:unpin-message';
+            case 'pin_messages_v2':
+                return 'log:pin-message';
+            case "change_thread_theme":
+                return "log:thread-color";
+            case "change_thread_icon":
+                return "log:thread-icon";
+            case "change_thread_nickname":
+                return "log:user-nickname";
+            case "change_thread_admins":
+                return "log:thread-admins";
+            case "group_poll":
+                return "log:thread-poll";
+            case "change_thread_approval_mode":
+                return "log:thread-approval-mode";
+            case "messenger_call_log":
+            case "participant_joined_group_call":
+                return "log:thread-call";
+            default:
+                return type;
+        }
+    }
+    function formatDeltaEvent() {
+        var logMessageType;
+        var logMessageData;
+        switch (deltails.class) {
+            case "AdminTextMessage":
+                logMessageData = deltails.untypedData;
+                logMessageType = getAdminTextMessageType(deltails.type);
+                break;
+            case "ThreadName":
+                logMessageType = "log:thread-name";
+                logMessageData = { name: deltails.name };
+                break;
+            case "ParticipantsAddedToGroupThread":
+                logMessageType = "log:subscribe";
+                logMessageData = { addedParticipants: deltails.addedParticipants };
+                break;
+            case "ParticipantLeftGroupThread":
+                logMessageType = "log:unsubscribe";
+                logMessageData = { leftParticipantFbId: deltails.leftParticipantFbId };
+                break;
+            case "ApprovalQueue":
+                logMessageType = "log:approval-queue";
+                logMessageData = {
+                    approvalQueue: {
+                        action: deltails.action,
+                        recipientFbId: deltails.recipientFbId,
+                        requestSource: deltails.requestSource,
+                        ...deltails.messageMetadata
+                    }
+                }
+        }
+
+        return {
+            type: "event",
+            threadID: utils.formatID((deltails.messageMetadata.threadKey.threadFbId || deltails.messageMetadata.threadKey.otherUserFbId).toString()),
+            messageID: deltails.messageMetadata.messageId.toString(),
+            logMessageType: logMessageType,
+            logMessageData: logMessageData,
+            logMessageBody: deltails.messageMetadata.adminText,
+            timestamp: deltails.messageMetadata.timestamp,
+            author: deltails.messageMetadata.actorFbId,
+            participantIDs: deltails.participants
+        }
+    }
+
+    function getAdminTextMessageType(type) {
+        switch (type) {
+            case 'unpin_messages_v2':
+                return 'log:unpin-message';
+            case 'pin_messages_v2':
+                return 'log:pin-message';
+            case "change_thread_theme":
+                return "log:thread-color";
+            case "change_thread_icon":
+                return "log:thread-icon";
+            case "change_thread_nickname":
+                return "log:user-nickname";
+            case "change_thread_admins":
+                return "log:thread-admins";
+            case "group_poll":
+                return "log:thread-poll";
+            case "change_thread_approval_mode":
+                return "log:thread-approval-mode";
+            case "messenger_call_log":
+            case "participant_joined_group_call":
+                return "log:thread-call";
+            default:
+                return type;
+        }
+    }
+    function formatDeltaEvent() {
+        var logMessageType;
+        var logMessageData;
+        switch (deltails.class) {
+            case "AdminTextMessage":
+                logMessageData = deltails.untypedData;
+                logMessageType = getAdminTextMessageType(deltails.type);
+                break;
+            case "ThreadName":
+                logMessageType = "log:thread-name";
+                logMessageData = { name: deltails.name };
+                break;
+            case "ParticipantsAddedToGroupThread":
+                logMessageType = "log:subscribe";
+                logMessageData = { addedParticipants: deltails.addedParticipants };
+                break;
+            case "ParticipantLeftGroupThread":
+                logMessageType = "log:unsubscribe";
+                logMessageData = { leftParticipantFbId: deltails.leftParticipantFbId };
+                break;
+            case "ApprovalQueue":
+                logMessageType = "log:approval-queue";
+                logMessageData = {
+                    approvalQueue: {
+                        action: deltails.action,
+                        recipientFbId: deltails.recipientFbId,
+                        requestSource: deltails.requestSource,
+                        ...deltails.messageMetadata
+                    }
+                }
+        }
+
+        return {
+            type: "event",
+            threadID: utils.formatID((deltails.messageMetadata.threadKey.threadFbId || deltails.messageMetadata.threadKey.otherUserFbId).toString()),
+            messageID: deltails.messageMetadata.messageId.toString(),
+            logMessageType: logMessageType,
+            logMessageData: logMessageData,
+            logMessageBody: deltails.messageMetadata.adminText,
+            timestamp: deltails.messageMetadata.timestamp,
+            author: deltails.messageMetadata.actorFbId,
+            participantIDs: deltails.participants
+        }
+    }
+    switch (deltails.class) {
+        case "ReadReceipt":
+            try {
+                var readReceipt = {
+                    reader: (deltails.threadKey.otherUserFbId || deltails.actorFbId).toString(),
+                    time: deltails.actionTimestampMs,
+                    threadID: utils.formatID((deltails.threadKey.otherUserFbId || deltails.threadKey.threadFbId).toString()),
+                    type: "read_receipt"
+                }
+                globalCallback(null, readReceipt);
+            } catch (error) {
+                error = {
+                    error: "Problem parsing message object. Please open an issue at https://github.com/GiaKhang1810/mira-bot-v1/issues.",
+                    detail: error,
+                    response: deltails,
+                    type: "parse_error"
+                }
+                globalCallback(error);
+            }
+            break;
+        case "AdminTextMessage":
+            switch (deltails.type) {
+                case "change_thread_theme":
+                case "change_thread_nickname":
+                case "change_thread_icon":
+                case "change_thread_quick_reaction":
+                case "change_thread_admins":
+                case "group_poll":
+                case "joinable_group_link_mode_change":
+                case "magic_words":
+                case "change_thread_approval_mode":
+                case "messenger_call_log":
+                case "participant_joined_group_call":
+                    try {
+                        var detailsEvent = formatDeltaEvent();
+                        globalCallback(null, detailsEvent);
+                    } catch (error) {
+                        error = {
+                            error: "Problem parsing message object. Please open an issue at https://github.com/GiaKhang1810/mira-bot-v1/issues.",
+                            detail: error,
+                            response: deltails,
+                            type: "parse_error"
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case "ForcedFetch":
+            if (!deltails.threadKey)
+                return;
+            var mid = deltails.messageId;
+            var tid = deltails.threadKey.threadFbId;
+            if (mid && tid) {
+                var form = {
+                    queries: JSON.stringify({
+                        o0: {
+                            doc_id: "2848441488556444",
+                            query_params: {
+                                thread_and_message_id: {
+                                    thread_id: tid.toString(),
+                                    message_id: mid
+                                }
+                            }
+                        }
+                    })
+                }
+
+                http
+                    .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+                    .then(utils.parseAndCheckLogin(ctx, http))
+                    .then(resData => {
+                        if (resData[resData.length - 1].error_results > 0)
+                            throw resData[0].o0.errors;
+                        if (resData[resData.length - 1].successful_results === 0)
+                            throw { error: "forcedFetch: there was no successful_results", response: resData }
+
+                        var fetchData = resData[0].o0.data.message;
+                        if (utils.getType(fetchData) !== "Object")
+                            return;
+
+                        switch (fetchData.__typename) {
+                            case "ThreadImageMessage":
+                                (fetchData.message_sender.id.toString() !== ctx.userID || ctx.globalOptions.listenEventsSelf) ? globalCallback(null, {
+                                    type: "event",
+                                    threadID: utils.formatID(tid.toString()),
+                                    messageID: fetchData.message_id,
+                                    logMessageType: "log:thread-image",
+                                    logMessageData: {
+                                        attachmentID: fetchData.image_with_metadata && fetchData.image_with_metadata.legacy_attachment_id,
+                                        width: fetchData.image_with_metadata && fetchData.image_with_metadata.original_dimensions.x,
+                                        height: fetchData.image_with_metadata && fetchData.image_with_metadata.original_dimensions.y,
+                                        url: fetchData.image_with_metadata && fetchData.image_with_metadata.preview.uri
+                                    },
+                                    logMessageBody: fetchData.snippet,
+                                    timestamp: fetchData.timestamp_precise,
+                                    author: fetchData.message_sender.id
+                                }) : null;
+                                break;
+                            case "UserMessage":
+                                globalCallback(null, {
+                                    type: "message",
+                                    senderID: utils.formatID(fetchData.message_sender.id),
+                                    body: fetchData.message.text || "",
+                                    threadID: utils.formatID(tid.toString()),
+                                    messageID: fetchData.message_id,
+                                    attachments: [{
+                                        type: "share",
+                                        ID: fetchData.extensible_attachment.legacy_attachment_id,
+                                        url: fetchData.extensible_attachment.story_attachment.url,
+
+                                        title: fetchData.extensible_attachment.story_attachment.title_with_entities.text,
+                                        description: fetchData.extensible_attachment.story_attachment.description.text,
+                                        source: fetchData.extensible_attachment.story_attachment.source,
+
+                                        image: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).uri,
+                                        width: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).width,
+                                        height: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).height,
+                                        playable: (fetchData.extensible_attachment.story_attachment.media || {}).is_playable || false,
+                                        duration: (fetchData.extensible_attachment.story_attachment.media || {}).playable_duration_in_ms || 0,
+
+                                        subattachments: fetchData.extensible_attachment.subattachments,
+                                        properties: fetchData.extensible_attachment.story_attachment.properties
+                                    }],
+                                    mentions: {},
+                                    timestamp: parseInt(fetchData.timestamp_precise),
+                                    participantIDs: (fetchData.participants || (fetchData.messageMetadata ? fetchData.messageMetadata.cid ? fetchData.messageMetadata.cid.canonicalParticipantFbids : fetchData.messageMetadata.participantIds : []) || []),
+                                    isGroup: (fetchData.message_sender.id != tid.toString())
+                                });
+                                break;
+                        }
+                    })
+                    .catch(console.log);
+            }
+            break;
+        case "ThreadName":
+        case "ParticipantsAddedToGroupThread":
+        case "ParticipantLeftGroupThread":
+        case "ApprovalQueue":
+            try {
+                var detailsEvent = formatDeltaEvent();
+                globalCallback(null, detailsEvent);
+            } catch (error) {
+                error = {
+                    error: "Problem parsing message object. Please open an issue at https://github.com/ntkhang03/fb-chat-api/issues.",
+                    detail: error,
+                    response: deltails,
+                    type: "parse_error"
+                }
+                globalCallback(error);
+            }
+            break;
+    }
+}
+
+function connectClientWs(http, apis, ctx, globalCallback) {
+    var chatOn = ctx.globalOptions.online;
+    var foreground = false;
+    var sessionID = Math.floor(Math.random() * 9007199254740991) + 1;
+    var username = JSON.stringify({
+        u: ctx.userID,
+        s: sessionID,
+        chat_on: chatOn,
+        fg: foreground,
+        d: utils.getGUID(),
+        ct: "websocket",
+        aid: "219994525426954",
+        mqtt_sid: "",
+        cp: 3,
+        ecp: 10,
+        st: [],
+        pm: [],
+        dc: "",
+        no_auto_fg: true,
+        gas: null,
+        pack: [],
+        a: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (Kbody, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+        aids: null
+    });
+    var host = ctx.endpoint ? ctx.endpoint + "&sid=" + sessionID : ctx.region ? "wss://edge-chat.facebook.com/chat?region=" + ctx.region.toLocaleLowerCase() + "&sid=" + sessionID : "wss://edge-chat.facebook.com/chat?sid=" + sessionID;
+    var options = {
+        clientId: "mqttwsclient",
+        protocolId: "MQIsdp",
+        protocolVersion: 3,
+        username,
+        clean: true,
+        wsOptions: {
+            headers: {
+                "Cookie": ctx.jar.getCookies("https://www.facebook.com").join("; "),
+                "Origin": "https://www.facebook.com",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (Kbody, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+                "Referer": "https://www.facebook.com/",
+                "Host": new URL(host).hostname
+            },
+            origin: "https://www.facebook.com",
+            protocolVersion: 13
+        },
+        keepalive: 10,
+        reschedulePings: true
+    }
+
+    if (ctx.proxy) {
+        var agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+        options.wsOptions.agent = agent;
+    }
+
+    ctx.Client = new mqtt.Client(_ => websocket(host, options.wsOptions), options);
+    var Client = ctx.Client;
+    Client
+        .on("error", function (error) {
+            if (error.message === "Invalid header flag bits, must be 0x0 for puback packet")
+                return;
+            if (ctx.Client)
+                ctx.Client.end(false, _ => ctx.Client = null);
+            if (ctx.globalOptions.autoReconnect) {
+                return getSeqID(http, apis, ctx, globalCallback);
+            }
+            error = {
+                type: "disconnect",
+                message: "Connection refused: Server unavailable",
+                error
+            }
+            globalCallback(error);
+        })
+        .on("close", _ => { })
+        .on("connect", function () {
+            topics.map(topic => Client.subscribe(topic));
+
+            var topic;
+            var queue = {
+                sync_api_version: 10,
+                max_deltas_able_to_process: 1000,
+                delta_batch_size: 500,
+                encoding: "JSON",
+                entity_fbid: ctx.userID
+            }
+
+            if (ctx.syncToken) {
+                topic = "/messenger_sync_get_diffs";
+                queue.last_seq_id = ctx.lastSeqID;
+                queue.sync_token = ctx.syncToken;
+            } else {
+                topic = "/messenger_sync_create_queue";
+                queue.initial_titan_sequence_id = ctx.lastSeqID;
+                queue.device_params = null;
+            }
+
+            Client.publish(topic, JSON.stringify(queue), { qos: 1, retain: false });
+            Client.publish("/foreground_state", JSON.stringify({ foreground: chatOn }), { qos: 1 });
+            Client.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
+            ctx.listenNotif ? notificationConnect(ctx) : null;
+        })
+        .on("message", function (topic, message) {
+            var Message = JSON.parse(Buffer.from(message).toString());
+            if (Message.type === "jewel_requests_add") {
+                globalCallback(null, {
+                    type: "friend_request_received",
+                    actorFbId: Message.frodeltails.toString(),
+                    timestamp: Date.now().toString()
+                });
+            }
+            else if (Message.type === "jewel_requests_remove_old") {
+                globalCallback(null, {
+                    type: "friend_request_cancel",
+                    actorFbId: Message.frodeltails.toString(),
+                    timestamp: Date.now().toString()
+                });
+            }
+            else if (topic === "/t_ms") {
+                if (Message.firstDeltaSeqId && Message.syncToken) {
+                    ctx.lastSeqID = Message.firstDeltaSeqId;
+                    ctx.syncToken = Message.syncToken;
+                }
+
+                if (Message.lastIssuedSeqId) {
+                    ctx.lastSeqID = parseInt(Message.lastIssuedSeqId);
+                }
+
+                for (var i in Message.deltas) {
+                    var deltails = Message.deltas[i];
+                    parseAndReCallback(http, apis, ctx, globalCallback, deltails);
+                }
+            } else if (topic === "/thread_typing" || topic === "/orca_typing_notifications") {
+                var typ = {
+                    type: "typ",
+                    isTyping: !!Message.state,
+                    from: Message.sender_fbid.toString(),
+                    threadID: utils.formatID((Message.thread || Message.sender_fbid).toString())
+                };
+                globalCallback(null, typ);
+            } else if (topic === "/orca_presence") {
+                if (!ctx.globalOptions.updatePresence) {
+                    for (var i in Message.list) {
+                        var data = Message.list[i];
+                        var userID = data["u"];
+
+                        var presence = {
+                            type: "presence",
+                            userID: userID.toString(),
+                            timestamp: data["l"] * 1000,
+                            statuses: data["p"]
+                        }
+                        globalCallback(null, presence);
+                    }
+                }
+            } else if (Message.type === "notifications_seen") {
+                var notif = {
+                    type: "notification",
+                    alertIDs: Message.alert_ids,
+                    graphQLIDs: Message.graphql_ids,
+                    notiGraphQLIDs: Message.notif_graphql_ids,
+                    timestamp: Date.now().toString()
+                }
+                globalCallback(null, notif);
+            } else {
+                console.log(topic, Message);
+            }
+        });
+}
+
+function getSeqID(http, apis, ctx, globalCallback) {
+    var headers = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/600.3.18 (KHTML, like Gecko) Version/8.0.3 Safari/600.3.18"
+    }
+    utils
+        .get("https://www.facebook.com/", ctx.jar, null, null, headers)
+        .then(function (res) {
+            var reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+            var redirect = reg.exec(res.body);
+            if (redirect && redirect[1]) {
+                delete headers.noRef;
+                return utils
+                    .get(redirect[1], ctx.jar, null, null, headers);
+            }
+
+            return res;
+        })
+        .then(function (res) {
+            var seqRegex = /irisSeqID:"(\d+)"/.exec(res.body);
+            if (seqRegex && seqRegex[1]) {
+                ctx.lastSeqID = seqRegex[1];
+                connectClientWs(http, apis, ctx, globalCallback);
+            } else {
+                var error = new Error("seqID is undefined.");
+                error.type = "logout.";
+                throw error;
+            }
+        })
+        .catch(function (error) {
+            if (error.type === "logout.")
+                ctx.isLogin = false;
+            console.log(error);
+            return globalCallback(error);
+        });
+}
+
+module.exports = function (http, apis, ctx) {
+    var globalCallback;
+    return class Client extends EventEmitter {
+        constructor() {
+            super();
+
+            globalCallback = (error, message) => error ? this.emit("error", error) : this.emit("message", message);
+            getSeqID(http, apis, ctx, globalCallback);
+            return this;
+        }
+
+        disconnect() {
+            globalCallback = () => { }
+            if (ctx.Client)
+                ctx.Client.end(false, _ => ctx.Client = null);
+        }
+    }
+}

source/apis/lib/Messenger.js

@@ -0,0 +1,464 @@
+/*
+    Origin Source: https://github.com/ntkhang03/Goat-Bot-V2/blob/main/fb-chat-api/
+    Converter: Khang
+*/
+
+var utils = require("../utils");
+var allowedProperties = {
+    attachments: true,
+    url: true,
+    sticker: true,
+    emoji: true,
+    emojiSize: true,
+    body: true,
+    mentions: true,
+    location: true
+}
+
+function removeSpecialChar(inputString) {
+    if (typeof inputString !== "string")
+        return inputString;
+    var buffer = Buffer.from(inputString, "utf8");
+    let filteredBuffer = Buffer.alloc(0);
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] === 0xEF && buffer[i + 1] === 0xB8 && buffer[i + 2] === 0x8F)
+            i += 2;
+        else
+            filteredBuffer = Buffer.concat([filteredBuffer, buffer.slice(i, i + 1)]);
+
+    }
+
+    var convertedString = filteredBuffer.toString("utf8");
+    return convertedString;
+}
+
+module.exports = function (http, apis, ctx) {
+    function edit(message, messageID, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof message === "function") {
+            callback = message;
+            message = "";
+        }
+        if (typeof messageID === "function") {
+            callback = messageID;
+            messageID = null;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+        if (typeof messageID !== "string")
+            callback(new Error("messageID must be an string"));
+        else if (!ctx.Client)
+            callback(new Error("You must connect mqtt first"));
+        else {
+            var queryPayload = {
+                message_id: messageID,
+                text: message
+            }
+            var query = {
+                failure_count: null,
+                label: "742",
+                payload: JSON.stringify(queryPayload),
+                queue_name: "edit_message",
+                task_id: Math.round(Math.random() * 312312721413).toString()
+            }
+
+            var context = {
+                app_id: "2220391788200892",
+                payload: JSON.stringify({
+                    data_trace_id: null,
+                    epoch_id: 0,
+                    tasks: [query],
+                    version_id: "6903494529735864"
+                }),
+                request_id: Math.round(Math.random() * 312312721413).toString(),
+                type: 3
+            }
+            ctx.Client.publish("/ls_req", JSON.stringify(context), { qos: 1, retain: false });
+            callback();
+        }
+
+        return returnPromise;
+    }
+
+    function react(reaction, messageID, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof reaction === "function") {
+            callback = reaction;
+            reaction = "";
+        }
+        if (typeof messageID === "function") {
+            callback = messageID;
+            messageID = null;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+        if (typeof messageID !== "string")
+            callback(new Error("messageID must be an string"));
+        else {
+            var variables = {
+                data: {
+                    client_mutation_id: Math.round(Math.random() * 312312721413).toString(),
+                    actor_id: ctx.userID,
+                    action: reaction === "" ? "REMOVE_REACTION" : "ADD_REACTION",
+                    message_id: messageID,
+                    reaction
+                }
+            }
+            var qs = {
+                doc_id: "1491398900900362",
+                variables: JSON.stringify(variables),
+                dpr: 1
+            }
+
+            http
+                .postData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {}, qs)
+                .then(utils.parseAndCheckLogin(ctx.jar, http))
+                .then(function (res) {
+                    if (res.error || res.errors)
+                        throw res;
+                    return callback();
+                })
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+
+    function unsend(messageID, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof messageID === "function") {
+            callback = messageID;
+            messageID = null;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+        if (typeof messageID !== "string")
+            callback(new Error("messageID must be an string"));
+        else {
+            http
+                .post("https://www.facebook.com/messaging/unsend_message/", ctx.jar, { message_id: messageID })
+                .then(utils.parseAndCheckLogin(ctx, http))
+                .then(function (res) {
+                    if (res.error || res.errors)
+                        throw res;
+
+                    return callback();
+                })
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+
+    function send(message, threadID, messageID, callback, isGroup) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof message === "function") {
+            callback = message;
+            message = null;
+        }
+        if (typeof threadID === "function") {
+            callback = threadID;
+            threadID = null;
+        }
+        if (typeof messageID === "function") {
+            callback = messageID;
+            messageID = null;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        var messageType = utils.getType(message);
+        var threadIDType = utils.getType(threadID);
+        var messageIDType = utils.getType(messageID);
+
+        var error;
+        if (messageType !== "String" && messageType !== "Object")
+            error = new Error("Message should be of type string or object and not " + messageType + ".");
+        if (threadIDType !== "Array" && threadIDType !== "Number" && threadIDType !== "String")
+            error = new Error("ThreadID should be of type number, string, or array and not " + threadIDType + ".");
+        if (messageID && messageIDType !== "String")
+            error = new Error("MessageID should be of type string and not " + messageIDType + ".");
+        if (messageType === "String")
+            message = {
+                body: message
+            }
+        if (utils.getType(message.body) === "String")
+            message.body = removeSpecialChar(message.body);
+
+        var disallowedProperties = Object.keys(message).filter(prop => !allowedProperties[prop]);
+        if (disallowedProperties.length > 0)
+            error = new Error("Dissallowed props: `" + disallowedProperties.join(", ") + "`");
+        if (error)
+            callback(error);
+        else {
+            var messageAndOTID = utils.generateOfflineThreadingID();
+            var form = {
+                client: "mercury",
+                action_type: "ma-type:user-generated-message",
+                author: "fbid:" + ctx.userID,
+                timestamp: Date.now(),
+                timestamp_absolute: "Today",
+                timestamp_relative: utils.generateTimestampRelative(),
+                timestamp_time_passed: "0",
+                is_unread: false,
+                is_cleared: false,
+                is_forward: false,
+                is_filtered_content: false,
+                is_filtered_content_bh: false,
+                is_filtered_content_account: false,
+                is_filtered_content_quasar: false,
+                is_filtered_content_invalid_app: false,
+                is_spoof_warning: false,
+                source: "source:chat:web",
+                "source_tags[0]": "source:chat",
+                body: message.body ? message.body.toString() : "",
+                html_body: false,
+                ui_push_phase: "V3",
+                status: "0",
+                offline_threading_id: messageAndOTID,
+                message_id: messageAndOTID,
+                threading_id: utils.generateThreadingID(ctx.clientID),
+                "ephemeral_ttl_mode:": "0",
+                manual_retry_cnt: "0",
+                has_attachment: !!(message.attachments || message.url || message.sticker),
+                signatureID: utils.getSignatureID(),
+                replied_to_message_id: messageID
+            }
+            handleLocation(message, form, threadID, messageAndOTID, callback, isGroup)
+                .then(handleSticker)
+                .then(handleAttachment)
+                .then(handleURL)
+                .then(handleEmoji)
+                .then(handleMention)
+                .then(function (input) {
+                    if (utils.getType(input[2]) === "Array")
+                        input[5] = false;
+                    else {
+                        if (utils.getType(input[5]) !== "Boolean")
+                            input[5] = input[2].toString().length < 16;
+                        else
+                            input[5] = !input[5];
+                    }
+
+                    return input;
+                })
+                .then(sendContent)
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+
+    function handleLocation(...input) {
+        if (input[0].location) {
+            if (input[0].location.latitude === null || input[0].location.longitude === null)
+                return Promise.reject(new Error("location property needs both latitude and longitude"));
+
+            input[1]["location_attachment[coordinates][latitude]"] = input[0].location.latitude;
+            input[1]["location_attachment[coordinates][longitude]"] = input[0].location.longitude;
+            input[1]["location_attachment[is_current_location]"] = !!input[0].location.current;
+        }
+        return Promise.resolve(input);
+    }
+
+    function handleEmoji(input) {
+        if (input[0].emojiSize !== null && input[0].emoji === null)
+            return Promise.reject(new Error("emoji property is empty"));
+        if (input[0].emoji) {
+            if (input[0].emojiSize == null)
+                input[0].emojiSize = "medium";
+            if (input[0].emojiSize !== "small" && input[0].emojiSize !== "medium" && input[0].emojiSize !== "large")
+                return Promise.reject(new Error("emojiSize property is invalid"));
+            if (input[1].body !== null && input[1].body !== "")
+                return Promise.reject(new Error("body is not empty"));
+            input[1].body = input[0].emoji;
+            input[1]["tags[0]"] = "hot_emoji_size:" + input[0].emojiSize;
+        }
+
+        return Promise.resolve(input);
+    }
+
+    function handleSticker(input) {
+        if (input[0].sticker)
+            input[1].sticker_id = input[0].sticker;
+        return Promise.resolve(input);
+    }
+
+    function handleAttachment(input) {
+        if (input[0].attachments) {
+            input[1].image_ids = [];
+            input[1].gif_ids = [];
+            input[1].file_ids = [];
+            input[1].video_ids = [];
+            input[1].audio_ids = [];
+
+            input[0].attachments = Array.isArray(input[0].attachments) ? input[0].attachments : [input[0].attachments];
+
+            return handleUpload(input[0].attachments)
+                .then(function (files) {
+                    files.forEach(function (file) {
+                        var key = Object.keys(file);
+                        var type = key[0];
+                        input[1][type + "s"].push(file[type]);
+                    });
+                    return input;
+                });
+        }
+
+        return Promise.resolve(input);
+    }
+
+    function handleUpload(attachments) {
+        var uploads = [];
+
+        for (var i = 0; i < attachments.length; i++) {
+            if (!utils.isReadableStream(attachments[i]))
+                throw new Error("Attachment should be a readable stream and not " + utils.getType(attachments[i]) + ".");
+
+            var form = {
+                upload_1024: attachments[i],
+                voice_clip: "true"
+            }
+
+            uploads.push(
+                http
+                    .postData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form)
+                    .then(utils.parseAndCheckLogin(ctx, http))
+                    .then(function (res) {
+                        if (res.error || res.errors)
+                            throw res;
+                        return res.payload.metadata[0];
+                    })
+            );
+        }
+
+        return Promise.all(uploads);
+    }
+
+    function handleURL(input) {
+        if (input[0].url) {
+            input[1]["shareable_attachment[share_type]"] = "100";
+
+            return getURL()
+                .then(function (params) {
+                    input[1]["shareable_attachment[share_params]"] = params;
+                    return input;
+                });
+        }
+
+        return Promise.resolve(input);
+    }
+
+    function getURL(url) {
+        var form = {
+            image_height: 960,
+            image_width: 960,
+            uri: url
+        }
+
+        return http
+            .post("https://www.facebook.com/message_share_attachment/fromURI/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                if (res.error || res.errors || !res.payload)
+                    throw res;
+
+                return res.payload.share_data.share_params;
+            });
+    }
+
+    function handleMention(input) {
+        if (input[0].mentions) {
+            for (var i = 0; i < input[0].mentions.length; i++) {
+                var mention = input[0].mentions[i];
+
+                var tag = mention.tag;
+                if (typeof tag !== "string")
+                    return Promise.reject(new Error("Mention tags must be strings."));
+
+                var offset = input[0].body.indexOf(tag, mention.fromIndex || 0);
+
+                var id = mention.id || 0;
+                input[1]["profile_xmd[" + i + "][offset]"] = offset;
+                input[1]["profile_xmd[" + i + "][length]"] = tag.length;
+                input[1]["profile_xmd[" + i + "][id]"] = id;
+                input[1]["profile_xmd[" + i + "][type]"] = "p";
+            }
+        }
+
+        return Promise.resolve(input);
+    }
+
+    function sendContent(input) {
+        if (utils.getType(input[2]) === "Array") {
+            for (var i = 0; i < input[2].length; i++)
+                input[1]["specific_to_list[" + i + "]"] = "fbid:" + input[2][i];
+
+            input[1]["specific_to_list[" + input[2].length + "]"] = "fbid:" + ctx.userID;
+            input[1]["client_thread_id"] = "root:" + input[3];
+        } else {
+            if (input[5]) {
+                input[1]["specific_to_list[0]"] = "fbid:" + input[2];
+                input[1]["specific_to_list[1]"] = "fbid:" + ctx.userID;
+                input[1]["other_user_fbid"] = input[2];
+            } else
+                input[1]["thread_fbid"] = input[2];
+        }
+
+        return http
+            .post("https://www.facebook.com/messaging/send/", ctx.jar, input[1])
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                if (!res || res.error || res.errors)
+                    throw res
+
+                var messageInfo = res.payload.actions.reduce(function (p, v) {
+                    return {
+                        threadID: v.thread_fbid || v.other_user_fbid,
+                        messageID: v.message_id,
+                        timestamp: v.timestamp
+                    }
+                }, null);
+
+                return input[4](null, messageInfo);
+            });
+    }
+
+    return {
+        send,
+        edit,
+        react,
+        unsend
+    }
+}

source/apis/lib/changeAvatar.js

@@ -0,0 +1,103 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    function handleUpload(image) {
+        var callback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            callback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (!utils.isReadableStream(image))
+            callback(new Error("image is not a readable stream"));
+
+        var form = {
+            profile_id: ctx.userID,
+            photo_source: 57,
+            av: ctx.userID,
+            file: image
+        }
+
+        http
+            .postData("https://www.facebook.com/profile/picture/upload/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                if (res.error || res.errors)
+                    throw res;
+
+                return callback(null, res);
+            })
+            .catch(callback);
+
+        return returnPromise;
+    }
+
+    return function changeAvatar(image, caption = "", timestamp = null, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (typeof caption === "number") {
+            timestamp = caption;
+            caption = "";
+        }
+        if (typeof caption === "function") {
+            callback = caption;
+            caption = "";
+        }
+        if (typeof timestamp === "function") {
+            callback = timestamp;
+            timestamp = null;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        handleUpload(image)
+            .then(res => ({
+                fb_api_req_friendly_name: "ProfileCometProfilePictureSetMutation",
+                doc_id: "5066134240065849",
+                variables: JSON.stringify({
+                    input: {
+                        caption,
+                        existing_photo_id: res.payload.fbid,
+                        expiration_time: timestamp,
+                        profile_id: ctx.userID,
+                        profile_pic_method: "EXISTING",
+                        profile_pic_source: "TIMELINE",
+                        scaled_crop_rect: {
+                            height: 1,
+                            width: 1,
+                            x: 0,
+                            y: 0
+                        },
+                        skip_cropping: true,
+                        actor_id: ctx.userID,
+                        client_mutation_id: Math.round(Math.random() * 19).toString()
+                    },
+                    isPage: false,
+                    isProfile: true,
+                    scale: 3
+                }),
+                fb_api_caller_class: "RelayModern"
+            }))
+            .then(form => http.post("https://www.facebook.com/api/graphql", ctx.jar, form))
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                if (res.error || res.errors)
+                    throw res;
+
+                return callback(null, {
+                    url: res.data.user_update_cover_photo.user.cover_photo.photo.url
+                });
+            })
+            .catch(function (error) {
+                if (error.type === "logout.")
+                    ctx.isLogin = false;
+
+                console.log(error);
+                return callback(error);
+            });
+
+        return returnPromise;
+    }
+}

source/apis/lib/changeBio.js

@@ -0,0 +1,61 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+  return function changeBio(bio, publish, callback) {
+    var pCallback;
+    var returnPromise = new Promise(function (resolve, reject) {
+      pCallback = error => error ? reject(error) : resolve();
+    });
+
+    if (typeof bio === "function") {
+      callback = bio;
+      bio = "";
+    }
+    if (typeof bio === "boolean") {
+      publish = bio;
+      bio = "";
+    }
+    if (typeof publish === "function") {
+      callback = publish;
+      publish = false;
+    }
+    if (typeof publish !== "boolean") 
+        publish = false;
+    if (typeof callback !== "function") 
+        callback = pCallback;
+
+    var form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "ProfileCometSetBioMutation",
+      doc_id: "2725043627607610",
+      variables: JSON.stringify({
+        input: {
+          bio,
+          publish_bio_feed_story: publish,
+          actor_id: ctx.userID,
+          client_mutation_id: Math.round(Math.random() * 1024).toString()
+        },
+        hasProfileTileViewID: false,
+        profileTileViewID: null,
+        scale: 1
+      })
+    }
+
+    http
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, http))
+      .then(function (res) {
+        if (res.error || res.errors) 
+            throw res;
+        return callback();
+      })
+      .catch(function (error) {
+        if (error.type === "logout.") 
+            ctx.isLogin = false;
+
+        return callback(error);
+      });
+
+    return returnPromise;
+  }
+}

source/apis/lib/changeCover.js

@@ -0,0 +1,84 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    function handleUpload(image) {
+        var callback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            callback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (!utils.isReadableStream(image))
+            callback(new Error("image is not a readable stream"));
+
+        var form = {
+            profile_id: ctx.userID,
+            photo_source: 57,
+            av: ctx.userID,
+            file: image
+        }
+
+        http
+            .postData("https://www.facebook.com/profile/picture/upload/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                if (res.error || res.errors)
+                    throw res;
+
+                return callback(null, res);
+            })
+            .catch(callback);
+
+        return returnPromise;
+    }
+
+    return function changeCover(image, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        handleUpload(image)
+            .then(res => ({
+                fb_api_caller_class: "RelayModern",
+                fb_api_req_friendly_name: "ProfileCometCoverPhotoUpdateMutation",
+                variables: JSON.stringify({
+                    input: {
+                        attribution_id_v2: `ProfileCometCollectionRoot.react,comet.profile.collection.photos_by,unexpected,${Date.now()},770083,,;ProfileCometCollectionRoot.react,comet.profile.collection.photos_albums,unexpected,${Date.now()},470774,,;ProfileCometCollectionRoot.react,comet.profile.collection.photos,unexpected,${Date.now()},94740,,;ProfileCometCollectionRoot.react,comet.profile.collection.saved_reels_on_profile,unexpected,${Date.now()},89669,,;ProfileCometCollectionRoot.react,comet.profile.collection.reels_tab,unexpected,${Date.now()},152201,,`,
+                        cover_photo_id: res.payload.fbid,
+                        focus: {
+                            x: 0.5,
+                            y: 1
+                        },
+                        target_user_id: ctx.userID,
+                        actor_id: ctx.userID,
+                        client_mutation_id: Math.round(Math.random() * 19).toString()
+                    },
+                    scale: 1,
+                    contextualProfileContext: null
+                }),
+                doc_id: "8247793861913071"
+            }))
+            .then(form => http.post("https://www.facebook.com/api/graphql", ctx.jar, form))
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                if (res.error || res.errors)
+                    throw res;
+
+                return callback(null, {
+                    url: res.data.profile_picture_set
+                });
+            })
+            .catch(function (error) {
+                if (error.type === "logout.")
+                    ctx.isLogin = false;
+
+                console.log(error);
+                return callback(error);
+            });
+
+        return returnPromise;
+    }
+}

source/apis/lib/getAccessToken.js

@@ -0,0 +1,81 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    return function getAccessToken(callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = (error, token) => error ? reject(error) : resolve(token);
+        });
+
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        if (ctx.token) {
+            var qs = {
+                access_token: ctx.token
+            }
+            utils
+                .get("https://graph.facebook.com/me/permissions", ctx.jar, qs)
+                .then(function () {
+                    return callback(null, ctx.token);
+                })
+                .catch(function () {
+                    return utils
+                        .getDTSGInitData(ctx)
+                        .then(function () {
+                            return utils
+                                .post("https://www.facebook.com/v1.0/dialog/oauth/confirm", ctx.jar, {
+                                    fb_dtsg: ctx.fb_dtsg,
+                                    app_id: "124024574287414",
+                                    redirect_uri: "fbconnect://success",
+                                    display: "popup",
+                                    return_format: "access_token",
+                                });
+                        })
+                        .then(function (res) {
+                            var body = res.body;
+                            var token = body.match(/access_token=(.*?)&/);
+                            if (token && token[1])
+                                ctx.token = token[1];
+                            else
+                                throw new Error("Token is undefined.");
+
+                            return callback(null, ctx.token);
+                        })
+                        .catch(function (error) {
+                            console.log(error);
+                            return callback(error);
+                        });
+                });
+        } else {
+            utils
+                .getDTSGInitData(ctx)
+                .then(function () {
+                    return utils
+                        .post("https://www.facebook.com/v1.0/dialog/oauth/confirm", ctx.jar, {
+                            fb_dtsg: ctx.fb_dtsg,
+                            app_id: "124024574287414",
+                            redirect_uri: "fbconnect://success",
+                            display: "popup",
+                            return_format: "access_token",
+                        });
+                })
+                .then(function (res) {
+                    var body = res.body;
+                    var token = body.match(/access_token=(.*?)&/);
+                    if (token && token[1])
+                        ctx.token = token[1];
+                    else
+                        throw new Error("Token is undefined.");
+
+                    return callback(null, ctx.token);
+                })
+                .catch(function (error) {
+                    console.log(error);
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+}

source/apis/lib/getCurrentUserID.js

@@ -0,0 +1,5 @@
+module.exports = function (http, apis, ctx) {
+    return function getCurrentUserID() {
+        return ctx.userID;
+    }
+}

source/apis/lib/getThreadInfo.js

@@ -0,0 +1,163 @@
+var utils = require("../utils");
+
+function formatEventReminders(reminder) {
+    return {
+        reminderID: reminder.id,
+        eventCreatorID: reminder.lightweight_event_creator.id,
+        time: reminder.time,
+        eventType: reminder.lightweight_event_type.toLowerCase(),
+        locationName: reminder.location_name,
+        locationCoordinates: reminder.location_coordinates,
+        locationPage: reminder.location_page,
+        eventStatus: reminder.lightweight_event_status.toLowerCase(),
+        note: reminder.note,
+        repeatMode: reminder.repeat_mode.toLowerCase(),
+        eventTitle: reminder.event_title,
+        triggerMessage: reminder.trigger_message,
+        secondsToNotifyBefore: reminder.seconds_to_notify_before,
+        allowsRsvp: reminder.allows_rsvp,
+        relatedEvent: reminder.related_event,
+        members: reminder.event_reminder_members.edges.map(member => ({
+            memberID: member.node.id,
+            state: member.guest_list_state.toLowerCase()
+        }))
+    }
+}
+
+function formatThreadGraphQLResponse(data) {
+    var messageThread = data.message_thread;
+    if (!messageThread) return {}
+
+    var threadID = messageThread.thread_key.thread_fbid || messageThread.thread_key.other_user_id;
+
+    var lastM = messageThread.last_message;
+    var snippetID = lastM && lastM.nodes && lastM.nodes[0] && lastM.nodes[0].message_sender && lastM.nodes[0].message_sender.messaging_actor ? lastM.nodes[0].message_sender.messaging_actor.id : null;
+    var snippetText = lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+    var lastR = messageThread.last_read_receipt;
+    var lastReadTimestamp = lastR && lastR.nodes && lastR.nodes[0] && lastR.nodes[0].timestamp_precise ? lastR.nodes[0].timestamp_precise : null;
+
+    return {
+        threadID: threadID,
+        threadName: messageThread.name,
+        participantIDs: messageThread.all_participants.edges.map(d => d.node.messaging_actor.id),
+        userInfo: messageThread.all_participants.edges.map(d => ({
+            id: d.node.messaging_actor.id,
+            name: d.node.messaging_actor.name,
+            firstName: d.node.messaging_actor.short_name,
+            vanity: d.node.messaging_actor.username,
+            thumbSrc: d.node.messaging_actor.big_image_src.uri,
+            profileUrl: d.node.messaging_actor.big_image_src.uri,
+            gender: d.node.messaging_actor.gender,
+            type: d.node.messaging_actor.__typename,
+            isFriend: d.node.messaging_actor.is_viewer_friend,
+            isBirthday: !!d.node.messaging_actor.is_birthday
+        })),
+        unreadCount: messageThread.unread_count,
+        messageCount: messageThread.messages_count,
+        timestamp: messageThread.updated_time_precise,
+        muteUntil: messageThread.mute_until,
+        isGroup: messageThread.thread_type == "GROUP",
+        isSubscribed: messageThread.is_viewer_subscribed,
+        isArchived: messageThread.has_viewer_archived,
+        folder: messageThread.folder,
+        cannotReplyReason: messageThread.cannot_reply_reason,
+        eventReminders: messageThread.event_reminders ? messageThread.event_reminders.nodes.map(formatEventReminders) : null,
+        emoji: messageThread.customization_info ? messageThread.customization_info.emoji : null,
+        color: messageThread.customization_info && messageThread.customization_info.outgoing_bubble_color ? messageThread.customization_info.outgoing_bubble_color.slice(2) : null,
+        nicknames:
+            messageThread.customization_info &&
+                messageThread.customization_info.participant_customizations
+                ? messageThread.customization_info.participant_customizations.reduce(function (res, val) {
+                    if (val.nickname) res[val.participant_id] = val.nickname;
+                    return res;
+                }, {})
+                : {},
+        adminIDs: messageThread.thread_admins,
+        approvalMode: Boolean(messageThread.approval_mode),
+        approvalQueue: messageThread.group_approval_queue.nodes.map(a => ({
+            inviterID: a.inviter.id,
+            requesterID: a.requester.id,
+            timestamp: a.request_timestamp,
+            request_source: a.request_source
+        })),
+        reactionsMuteMode: messageThread.reactions_mute_mode.toLowerCase(),
+        mentionsMuteMode: messageThread.mentions_mute_mode.toLowerCase(),
+        isPinProtected: messageThread.is_pin_protected,
+        relatedPageThread: messageThread.related_page_thread,
+        name: messageThread.name,
+        snippet: snippetText,
+        snippetSender: snippetID,
+        snippetAttachments: [],
+        serverTimestamp: messageThread.updated_time_precise,
+        imageSrc: messageThread.image ? messageThread.image.uri : null,
+        isCanonicalUser: messageThread.is_canonical_neo_user,
+        isCanonical: messageThread.thread_type != "GROUP",
+        recipientsLoadable: true,
+        hasEmailParticipant: false,
+        readOnly: false,
+        canReply: messageThread.cannot_reply_reason == null,
+        lastMessageTimestamp: messageThread.last_message ? messageThread.last_message.timestamp_precise : null,
+        lastMessageType: "message",
+        lastReadTimestamp: lastReadTimestamp,
+        threadType: messageThread.thread_type == "GROUP" ? 2 : 1,
+        inviteLink: {
+            enable: messageThread.joinable_mode ? messageThread.joinable_mode.mode == 1 : false,
+            link: messageThread.joinable_mode ? messageThread.joinable_mode.link : null
+        }
+    }
+}
+
+module.exports = function (http, apis, ctx) {
+    return function getThreadInfo(threadIDs, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (typeof callback !== "function") callback = pCallback;
+        if (!Array.isArray(threadIDs)) threadIDs = [threadIDs];
+
+        var form = {}
+        threadIDs.map((id, i) => form["o" + i] = {
+            doc_id: "3449967031715030",
+            query_params: {
+                id,
+                message_limit: 0,
+                load_messages: false,
+                load_read_receipts: false,
+                before: null
+            }
+        });
+
+        form = {
+            queries: JSON.stringify(form),
+            batch_name: "MessengerGraphQLThreadFetcher"
+        }
+
+        http
+            .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (resData) {
+                if (resData.error) throw resData;
+                var threadInfos = {}
+                for (let i = resData.length - 2; i >= 0; i--) {
+                    var threadInfo = formatThreadGraphQLResponse(resData[i][Object.keys(resData[i])[0]].data);
+                    threadInfos[threadInfo.threadID] = threadInfo;
+                }
+                if (Object.values(threadInfos).length === 1) {
+                    callback(null, Object.values(threadInfos)[0]);
+                }
+                else {
+                    callback(null, threadInfos);
+                }
+            })
+            .catch(function (error) {
+                if (error.type === "logout.")
+                    ctx.isLogin = false;
+                console.log(error);
+                return callback(error);
+            });
+
+        return returnPromise;
+    }
+}

source/apis/lib/getUserID.js

@@ -0,0 +1,91 @@
+var utils = require("../utils");
+
+function format(res) {
+    var res = res.relay_rendering_strategy.view_model.profile;
+    return {
+        userID: res.id,
+        name: res.name,
+        isVerified: res.is_verified,
+        profileUrl: res.url,
+        photoUrl: res.profile_picture.uri
+    }
+}
+
+module.exports = function (http, apis, ctx) {
+    return function getUserID(name, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (typeof name === "function") {
+            callback = name;
+            name = null;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        if (typeof name !== "string")
+            callback(new Error("name must be an string"));
+        else {
+            var form = {
+                fb_api_caller_class: "RelayModern",
+                fb_api_req_friendly_name: "SearchCometResultsInitialResultsQuery",
+                variables: JSON.stringify({
+                    count: 5,
+                    allow_streaming: false,
+                    args: {
+                        callsite: "COMET_GLOBAL_SEARCH",
+                        config: {
+                            exact_match: false,
+                            high_confidence_config: null,
+                            intercept_config: null,
+                            sts_disambiguation: null,
+                            watch_config: null
+                        },
+                        context: {
+                            bsid: utils.getGUID(),
+                            tsid: null
+                        },
+                        experience: {
+                            encoded_server_defined_params: null,
+                            fbid: null,
+                            type: "PEOPLE_TAB"
+                        },
+                        filters: [],
+                        text: name.toLowerCase()
+                    },
+                    cursor: null,
+                    feedbackSource: 23,
+                    fetch_filters: true,
+                    renderLocation: "search_results_page",
+                    scale: 1,
+                    stream_initial_count: 0,
+                    useDefaultActor: false,
+                    __relay_internal__pv__IsWorkUserrelayprovider: false,
+                    __relay_internal__pv__IsMergQAPollsrelayprovider: false,
+                    __relay_internal__pv__StoriesArmadilloReplyEnabledrelayprovider: false,
+                    __relay_internal__pv__StoriesRingrelayprovider: false
+                }),
+                doc_id: "9946783172059974"
+            }
+
+            http
+                .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, http))
+                .then(function (res) {
+                    if (res.error || res.errors) 
+                        throw res;
+                    return callback(null, res.data.serpResponse.results.edges.map(format));
+                })
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+}

source/apis/lib/getUserInfo.js

@@ -0,0 +1,144 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    function parseData(data) {
+        var retObj = {}
+
+        for (var prop in data) {
+            if (data.hasOwnProperty(prop)) {
+                var innerObj = data[prop];
+                retObj[prop] = {
+                    name: innerObj.name,
+                    firstName: innerObj.firstName,
+                    vanity: innerObj.vanity,
+                    thumbSrc: innerObj.thumbSrc,
+                    profileUrl: innerObj.uri,
+                    gender: innerObj.gender,
+                    type: innerObj.type,
+                    isFriend: innerObj.is_friend,
+                    isBirthday: !!innerObj.is_birthday,
+                    searchTokens: innerObj.searchTokens,
+                    alternateName: innerObj.alternateName,
+                }
+            }
+        }
+
+        return retObj;
+    }
+
+    function parseDataHighLevel(userIDs, data) {
+        var retObj = {}
+
+        for (var index in userIDs) {
+            var res = data[index];
+            if (Object.keys(res).length > 0) {
+                retObj[res.id] = {
+                    id: res.id,
+                    name: res.name,
+                    shortName: res.short_name || null,
+                    verified: res.verified != false ? true : false,
+                    email: res.email || null,
+                    website: res.website || null,
+                    follower: !!res.subscribers == true ? res.subscribers.summary.total_count : null,
+                    lover: res.significant_other || null,
+                    cover: !!res.cover == true ? res.cover.source : null,
+                    first_name: res.first_name || null,
+                    middle_name: res.middle_name || null,
+                    last_name: res.last_name || null,
+                    about: res.about || null,
+                    birthday: res.birthday || null,
+                    languages: res.languages || [],
+                    gender: res.gender || null,
+                    hometown: !!res.hometown == true ? res.hometown.name : null,
+                    profileUrl: res.link || null,
+                    location: !!res.location == true ? res.location.name : null,
+                    username: res.username || null,
+                    avatar: !!res.picture == true ? res.picture.data.url : null,
+                    relationship_status: !!res.relationship_status == true ? res.relationship_status : null,
+                    subscribers: !!res.subscribers == true ? res.subscribers.data : null,
+                    favorite_athletes: !!res.favorite_athletes == false ? [] : res.favorite_athletes.map(v => ({
+                        name: v.name
+                    })),
+                    education: !!res.education == true ? res.education.map(v => ({
+                        type: v.type,
+                        school: v.school.name
+                    })) : [],
+                    work: !!res.work == true ? res.work : []
+                }
+            } else
+                retObj[userIDs[index]] = {}
+        }
+
+        return retObj;
+    }
+
+    function requestData(userID) {
+        var qs = {
+            fields: "id,name,verified,cover,first_name,email,about,birthday,gender,website,hometown,link,location,quotes,relationship_status,significant_other,username,subscribers.limite(0),short_name,last_name,middle_name,education,picture,work,languages,favorite_athletes",
+            access_token: ctx.token
+        }
+        return utils
+            .get("https://graph.facebook.com/v1.0/" + userID, ctx.jar, qs)
+            .then(function (res) {
+                return JSON.parse(res.body);
+            })
+            .catch(function (error) {
+                console.log(error);
+                return {}
+            });
+    }
+
+    return function getUserInfo(userIDs, deprecated = false, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = (error, data) => error ? reject(error) : resolve(data);
+        });
+
+        if (typeof deprecated === "function") {
+            callback = deprecated;
+            deprecated = false;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+        if (!Array.isArray(userIDs))
+            userIDs = [userIDs];
+        if (!deprecated) {
+            var form = [];
+            apis
+                .getAccessToken()
+                .then(function () {
+                    userIDs.map(userID => form.push(requestData(userID)));
+                    return Promise.all(form);
+                })
+                .then(function (res) {
+                    return callback(null, parseDataHighLevel(userIDs, res));
+                })
+                .catch(function (error) {
+                if (error.type === "logout.")
+                    ctx.isLogin = false;
+                console.log(error);
+                return callback(error);
+            });
+        } else {
+            var form = {}
+            userIDs.map((value, index) => form["ids[" + index + "]"] = value);
+            http
+                .post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, http))
+                .then(function (res) {
+                    if (res.error || res.errors)
+                        throw new Error(res);
+
+                    return callback(null, parseData(res.payload.profiles));
+                })
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+                    console.log(error);
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+}

source/apis/lib/logout.js

@@ -0,0 +1,53 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    return function logout(callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof callback !== "function")
+            callback = pCallback
+
+        var form = {
+            pmid: "0"
+        }
+
+        http
+            .post("https://www.facebook.com/bluebar/modern_settings_menu/?help_type=364455653583099&show_contextual_help=1", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function (res) {
+                var elem = res.jsmods.instances[0][2][0].filter(item => item.value === "logout")[0];
+                var body = res.jsmods.markup.filter(item => item[0] === elem.markup.__m)[0][1].__html;
+                var match = [...body.matchAll(/<input[^>]*name="([^"]+)"[^>]*value="([^"]+)"[^>]*>/g)].map(item => item[2]);
+                var form = {
+                    jazoest: match[0],
+                    fb_dtsg: match[1],
+                    ref: match[2],
+                    h: match[3]
+                }
+
+                return http.post("https://www.facebook.com/logout.php", ctx.jar, form);
+            })
+            .then(function (res) {
+                if (!res.headers)
+                    throw {
+                        error: "An error occurred when logging out."
+                    }
+
+                return http.get(res.headers.location, ctx.jar);
+            })
+            .then(function () {
+                ctx.isLogin = false;
+                return callback();
+            })
+            .catch(function (error) {
+                if (error.type === "logout.")
+                    ctx.isLogin = false;
+                return callback(error);
+            });
+
+        return returnPromise;
+    }
+}

source/apis/lib/markAsDelivered.js

@@ -0,0 +1,35 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    return function markAsDelivered(threadID, messageID, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof callback !== "function") callback = pCallback;
+        if (threadID && messageID) {
+            var form = {}
+            form["message_ids[0]"] = messageID;
+            form["thread_ids[" + threadID + "][0]"] = messageID;
+
+            http
+                .post("https://www.facebook.com/ajax/mercury/delivery_receipts.php", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, http))
+                .then(function (resData) {
+                    if (resData.error)
+                        throw resData;
+
+                    return callback();
+                })
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+                    return callback(error);
+                });
+        } else
+            callback("Error: messageID or threadID is not defined");
+
+        return returnPromise;
+    }
+}

source/apis/lib/markAsRead.js

@@ -0,0 +1,41 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    return function markAsRead(threadID, read = true, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof read === "function") {
+            callback = read;
+            read = true;
+        }
+
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        var form = {}
+        form["source"] = "PagesManagerMessagesInterface";
+        form["request_user_id"] = ctx.userID;
+        form["ids[" + threadID + "]"] = read;
+        form["watermarkTimestamp"] = new Date().getTime();
+        form["shouldSendReadReceipt"] = true;
+        form["commerce_last_message_type"] = "";
+
+        http
+            .post("https://www.facebook.com/ajax/mercury/change_read_status.php", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, http))
+            .then(function () {
+                return callback();
+            })
+            .catch(function (error) {
+                if (error.type === "logout.") 
+                    ctx.isLogin = false;
+
+                return callback(error);
+            })
+
+        return returnPromise;
+    }
+}

source/apis/lib/muteThread.js

@@ -0,0 +1,49 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    return function muteThread(threadID, muteSeconds = 0, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof threadID === "function") {
+            callback = threadID;
+            threadID = null;
+        }
+        if (typeof muteSeconds === "function") {
+            callback = muteSeconds;
+            muteSeconds = 0;
+        }
+        if (typeof callback !== "function")
+            callback = pCallback;
+        if (utils.getType(threadID) !== "String" || utils.getType(threadID) !== "Number")
+            callback(new Error("threadID must be an string number"));
+        else if (utils.getType(muteSeconds) !== "String" || utils.getType(muteSeconds) !== "Number")
+            callback(new Error("muteSeconds must be an string number"));
+        else {
+            var form = {
+                thread_fbid: threadID,
+                mute_settings: muteSeconds
+            }
+    
+            http
+                .post("https://www.facebook.com/ajax/mercury/change_mute_thread.php", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, http))
+                .then(function (res) {
+                    if (res.error || res.errors)
+                        throw res; 
+    
+                    return callback();
+                })
+                .catch(function (error) {
+                    if (error.type === "logout.")
+                        ctx.isLogin = false;
+    
+                    return callback(error);
+                });
+        }
+
+        return returnPromise;
+    }
+}

source/apis/lib/post.js

@@ -0,0 +1,12 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+    return function HttpClientPostData(url, form, parse = false, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        return returnPromise;
+    }
+}

source/apis/lib/resolvePhotoUrl.js

@@ -0,0 +1,63 @@
+var utils = require("../utils");
+
+module.exports = function (http, apis, ctx) {
+  function getPhotoUrls(photoIDs) {
+    var callback;
+    var uploads = [];
+    var returnPromise = new Promise(function (resolve, reject) {
+      callback = (error, photoUrl) => photoUrl ? resolve(photoUrl) : reject(error);
+    });
+
+    photoIDs.map(function (id) {
+      var httpPromise = http
+        .get("https://www.facebook.com/mercury/attachments/photo", ctx.jar, {
+          photo_id: id
+        })
+        .then(utils.parseAndCheckLogin(ctx, http))
+        .then(function (res) {
+          if (res.error) throw res;
+          return res.jsmods.require[0][3][0]
+        })
+        .catch(function (error) {
+          return callback(error);
+        });
+      uploads.push(httpPromise);
+    });
+
+    Promise
+      .all(uploads)
+      .then(function (res) {
+        return callback(null, res.reduce(function (form, v, i) {
+          form[photoIDs[i]] = v;
+          return form;
+        }, {}));
+      })
+
+    return returnPromise;
+  }
+  
+  return function resolvePhotoUrl(photoIDs, callback) {
+    var pCallback;
+    var returnPromise = new Promise(function (resolve, reject) {
+      pCallback = (error, photoUrl) => photoUrl ? resolve(photoUrl) : reject(error);
+    });
+
+    if (!Array.isArray(photoIDs)) photoIDs = [photoIDs];
+    if (typeof callback !== 'function') callback = pCallback;
+
+    getPhotoUrls(photoIDs)
+      .then(function (photoUrl) {
+        if (Object.keys(photoUrl).length == 1) {
+          callback(null, photoUrl[photoIDs[0]]);
+        } else callback(null, photoUrl);
+      })
+      .catch(function (error) {
+        if (error.type === "logout.") 
+            ctx.isLogin = false;
+        console.log(error);
+        return callback(error);
+      }); 
+
+    return returnPromise;
+  }
+}

source/apis/lib/screenshot.js

@@ -0,0 +1,77 @@
+var utils = require("../utils");
+var Pup = require("puppeteer");
+
+module.exports = function (http, apis, ctx) {
+    return async function ScreenShotChromium(url, path, Options, callback) {
+        var pCallback;
+        var returnPromise = new Promise(function (resolve, reject) {
+            pCallback = error => error ? reject(error) : resolve();
+        });
+
+        if (typeof url === "function") {
+            callback = url;
+            url = null;
+        }
+        if (typeof path === "function") {
+            callback = path;
+            path = null;
+        }
+        if (typeof Options === "function") {
+            callback = Options;
+            Options = {}
+        }
+        if (typeof Options !== "object") 
+            Options = {}
+        if (typeof callback !== "function")
+            callback = pCallback;
+
+        Options.userAgent = Options.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36";
+        Options.width = Options.width || 1920;
+        Options.height = Options.height || 1080;
+        Options.fullPage = Options.fullPage || false;
+
+        if (!utils.isURL(url))
+            callback(new Error("url is invalid"));
+        else if (!utils.isPath(path))
+            callback(new Error("path is invalid"));
+        else {
+            var Browser;
+            var Proxy = utils.parseProxy(ctx.proxy);
+
+            if (Proxy && Proxy.length > 0) {
+                Browser = await Pup.launch({ headless: true, args: ["--proxy-server=" + ctx.proxy] });
+            } else
+                Browser = await Pup.launch({ headless: true });
+
+            var Page = await Browser.newPage();
+
+            if (Proxy && Proxy[0] && Proxy[1])
+                await Page.authenticate({
+                    username: Proxy[0],
+                    password: Proxy[1]
+                });
+
+            var Cookies = apis.getAppState().map(item => ({
+                name: item.key,
+                value: item.value,
+                domain: ".facebook.com",
+                path: "/",
+                secure: true,
+                httpOnly: true
+            }));
+
+            await Page.setViewport({
+                width: Options.width, 
+                height: Options.height 
+            });
+            await Page.setUserAgent(Options.userAgent);
+            await Page.setCookie(...Cookies);
+            await Page.goto(url, { waitUntil: "networkidle0" });
+            await Page.screenshot({ path, fullPage: Options.fullPage });
+            await Browser.close();
+            callback();
+        }
+
+        return returnPromise;
+    }
+}

source/apis/utils.js

@@ -0,0 +1,372 @@
+var request = require("request").defaults({ jar: true });
+var parseProxy = proxy => (proxy.match(/^(?:http:\/\/)?(?:(\S+):(\S+)@)?([A-Za-z0-9.-]+):(\d{2,5})$/) || []).slice(1);
+var utilsLib = require("../lib/utils");
+var log = require("../lib/log");
+var stream = require("stream");
+
+function setProxy(proxy) {
+    var proxyArray = parseProxy(proxy);
+
+    if (proxyArray)
+        request = require("request").defaults({ jar: true, proxy });
+    else
+        request = require("request").defaults({ jar: true });
+}
+
+function setHeaders(url, ctx, customHeaders) {
+    var headers = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Referer: "https://www.facebook.com/",
+        Host: new URL(url).hostname,
+        Origin: "https://www.facebook.com",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (Kbody, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+        Connection: "keep-alive",
+        "sec-fetch-site": "same-origin"
+    }
+    if (customHeaders)
+        Object.assign(headers, customHeaders);
+    if (customHeaders && customHeaders.noRef) {
+        delete headers.Referer;
+        delete headers.noRef;
+    }
+    if (ctx && ctx.region)
+        headers["X-MSGR-Region"] = ctx.region;
+
+    return headers;
+}
+
+function get(url, jar, qs, ctx, customHeaders) {
+    if (utilsLib.getType(qs) === "Object") {
+        for (var prop in qs) {
+            if (qs.hasOwnProperty(prop) && utilsLib.getType(qs[prop]) === "Object") {
+                qs[prop] = JSON.stringify(qs[prop]);
+            }
+        }
+    }
+    var options = {
+        headers: setHeaders(url, ctx, customHeaders),
+        timeout: 60000,
+        qs,
+        url,
+        method: "GET",
+        jar,
+        gzip: true
+    }
+
+    var callback;
+    var returnPromise = new Promise(function (resolve, reject) {
+        callback = (error, response) => error ? reject(error) : resolve(response);
+    });
+    request(options, callback);
+
+    return returnPromise;
+}
+
+function post(url, jar, form, ctx, customHeaders) {
+    var options = {
+        headers: setHeaders(url, ctx, customHeaders),
+        timeout: 60000,
+        url,
+        method: "POST",
+        form,
+        jar,
+        gzip: true
+    }
+
+    var callback;
+    var returnPromise = new Promise(function (resolve, reject) {
+        callback = (error, response) => error ? reject(error) : resolve(response);
+    });
+    request(options, callback);
+
+    return returnPromise;
+}
+
+function postData(url, jar, formData, qs, ctx, customHeaders) {
+    if (utilsLib.getType(qs) === "Object") {
+        for (var prop in qs) {
+            if (qs.hasOwnProperty(prop) && utilsLib.getType(qs[prop]) === "Object") {
+                qs[prop] = JSON.stringify(qs[prop]);
+            }
+        }
+    }
+    var headers = setHeaders(url, ctx, customHeaders);
+    headers["Content-Type"] = "multipart/form-data";
+    var options = {
+        headers,
+        timeout: 60000,
+        url,
+        method: "POST",
+        formData,
+        qs,
+        jar,
+        gzip: true
+    }
+
+    var callback;
+    var returnPromise = new Promise(function (resolve, reject) {
+        callback = (error, response) => error ? reject(error) : resolve(response);
+    });
+    request(options, callback);
+
+    return returnPromise;
+}
+
+function isReadableStream(maybeStream) {
+    return (maybeStream instanceof stream.Stream && typeof maybeStream._read === "function" && utilsLib.getType(maybeStream._readableState) === "Object");
+}
+
+function getGUID() {
+    var sectionLength = Date.now();
+    var id = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+        var r = Math.floor((sectionLength + Math.random() * 16) % 16);
+        sectionLength = Math.floor(sectionLength / 16);
+        var _guid = (c === "x" ? r : (r & 7) | 8).toString(16);
+        return _guid;
+    });
+    return id;
+}
+
+function getSignatureID() {
+    return Math.floor(Math.random() * 2147483648).toString(16);
+}
+
+function makeDefaults(body, userID, ctx) {
+    var reqCounter = 1;
+    var fb_dtsg = /\["DTSGInitData",\[],{"token":"(\S+)","async_get_token"/g.exec(body)[1];
+    var revision = /"server_revision":(\d+)/g.exec(body)[1];
+
+    function mergeWithDefaults(Obj) {
+        fb_dtsg = ctx.fb_dtsg ? ctx.fb_dtsg : fb_dtsg
+        var ttstamp = "2";
+        for (var i = 0; i < fb_dtsg.length; i++) {
+            ttstamp += fb_dtsg.charCodeAt(i);
+        }
+        var newObj = {
+            av: userID,
+            __user: userID,
+            __req: (reqCounter++).toString(36),
+            __rev: revision,
+            __a: 1,
+            fb_dtsg,
+            jazoest: ctx.ttstamp ? ctx.ttstamp : ttstamp
+        }
+        if (!Obj)
+            return newObj;
+
+        for (var prop in Obj)
+            if (Obj.hasOwnProperty(prop))
+                if (!newObj[prop])
+                    newObj[prop] = Obj[prop];
+
+        return newObj;
+    }
+
+    function postWithDefaults(url, jar, form, ctxx = ctx, customHeaders) {
+        return post(url, jar, mergeWithDefaults(form), ctxx, customHeaders);
+    }
+
+    function getWithDefaults(url, jar, qs, ctxx = ctx, customHeaders) {
+        return get(url, jar, mergeWithDefaults(qs), ctxx, customHeaders);
+    }
+
+    function postDataWithDefault(url, jar, form, qs, ctxx = ctx, customHeaders) {
+        return postData(url, jar, mergeWithDefaults(form), mergeWithDefaults(qs), ctxx, customHeaders);
+    }
+
+    return {
+        get: getWithDefaults,
+        post: postWithDefaults,
+        postData: postDataWithDefault
+    }
+}
+
+function makeParsable(body) {
+    var withoutForLoop = body.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*/, "");
+    var maybeMultipleObjects = withoutForLoop.split(/\}\r\n *\{/);
+    if (maybeMultipleObjects.length === 1)
+        return maybeMultipleObjects;
+    return "[" + maybeMultipleObjects.join("},{") + "]";
+}
+
+function parseAndCheckLogin(ctx, http, retryCount) {
+    var delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+    var _try = tryData => new Promise(function (resolve, reject) {
+        try {
+            resolve(tryData());
+        } catch (error) {
+            reject(error);
+        }
+    });
+    if (retryCount === undefined) retryCount = 0;
+
+    return function (data) {
+        function any() {
+            if (data.statusCode >= 500 && data.statusCode < 600) {
+                if (retryCount >= 5) {
+                    var err = new Error("Request retry failed. Check the `res` and `statusCode` property on this error.");
+                    err.statusCode = data.statusCode;
+                    err.res = data.body;
+                    err.error = "Request retry failed. Check the `res` and `statusCode` property on this error.";
+                    throw err;
+                }
+                retryCount++;
+                var retryTime = Math.floor(Math.random() * 5000);
+                var url = data.request.uri.protocol + "//" + data.request.uri.hostname + data.request.uri.pathname;
+                if (data.request.headers["Content-Type"].split(";")[0] === "multipart/form-data") {
+                    return delay(retryTime)
+                        .then(function () {
+                            return http
+                                .postData(url, ctx.jar, data.request.formData);
+                        })
+                        .then(parseAndCheckLogin(ctx, http, retryCount));
+                }
+                else {
+                    return delay(retryTime)
+                        .then(function () {
+                            return http
+                                .post(url, ctx.jar, data.request.formData);
+                        })
+                        .then(parseAndCheckLogin(ctx, http, retryCount));
+                }
+            }
+            if (data.statusCode !== 200)
+                throw new Error("parseAndCheckLogin got status code: " + data.statusCode + ". Bailing out of trying to parse response.");
+
+            var res = null;
+            try {
+                res = JSON.parse(makeParsable(data.body));
+            } catch (e) {
+                var err = new Error("JSON.parse error. Check the `detail` property on this error.");
+                err.error = "JSON.parse error. Check the `detail` property on this error.";
+                err.detail = e;
+                err.res = data.body;
+                throw err;
+            }
+
+            if (res.redirect && data.request.method === "GET") {
+                return http
+                    .get(res.redirect, ctx.jar)
+                    .then(parseAndCheckLogin(ctx, http));
+            }
+
+            if (res.jsmods && res.jsmods.require && Array.isArray(res.jsmods.require[0]) && res.jsmods.require[0][0] === "Cookie") {
+                res.jsmods.require[0][3][0] = res.jsmods.require[0][3][0].replace("_js_", "");
+                var cookie = formatCookie(res.jsmods.require[0][3], "facebook");
+                var cookie2 = formatCookie(res.jsmods.require[0][3], "messenger");
+                ctx.jar.setCookie(request.cookie(cookie), "https://www.facebook.com");
+                ctx.jar.setCookie(request.cookie(cookie2), "https://www.messenger.com");
+            }
+
+            if (res.jsmods && Array.isArray(res.jsmods.require)) {
+                var arr = res.jsmods.require;
+                for (var i in arr) {
+                    if (arr[i][0] === "DTSG" && arr[i][1] === "setToken") {
+                        ctx.fb_dtsg = arr[i][3][0];
+
+                        ctx.ttstamp = "2";
+                        for (var j = 0; j < ctx.fb_dtsg.length; j++) {
+                            ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
+                        }
+                    }
+                }
+            }
+
+            if (res.error === 1357001) {
+                var err = new Error('Facebook blocked login. Please visit https://facebook.com and check your account.');
+                err.type = "Logout.";
+                throw err;
+            }
+            return res;
+        }
+        return _try(any);
+    }
+}
+
+function formatID(id) {
+    if (id != undefined && id != null) {
+        return id.replace(/(fb)?id[:.]/, "");
+    }
+    else {
+        return id;
+    }
+}
+
+function getDTSGInitData(ctx) {
+    return get("https://www.facebook.com", ctx.jar)
+        .then(function (res) {
+            var body = res.body;
+            ctx.fb_dtsg = /\["DTSGInitData",\[],{"token":"(.+?)"/g.exec(body)[1];
+        });
+}
+
+function binaryToDecimal(data) {
+    var ret = "";
+    while (data !== "0") {
+        var end = 0;
+        var fullName = "";
+        var i = 0;
+        for (; i < data.length; i++) {
+            end = 2 * end + parseInt(data[i], 10);
+            if (end >= 10) {
+                fullName += "1";
+                end -= 10;
+            } else
+                fullName += "0";
+        }
+        ret = end.toString() + ret;
+        data = fullName.slice(fullName.indexOf("1"));
+    }
+    return ret;
+}
+
+function generateOfflineThreadingID() {
+    var ret = Date.now();
+    var value = Math.floor(Math.random() * 4294967295);
+    var str = ("0000000000000000000000" + value.toString(2)).slice(-22);
+    var message = ret.toString(2) + str;
+    return binaryToDecimal(message);
+}
+
+function generateTimestampRelative() {
+    var d = new Date();
+    return d.getHours() + ":" + padZeros(d.getMinutes());
+}
+
+function padZeros(val, len) {
+    val = String(val);
+    len = len || 2;
+    while (val.length < len) val = "0" + val;
+    return val;
+}
+
+function generateThreadingID(clientID) {
+	var k = Date.now();
+	var l = Math.floor(Math.random() * 4294967295);
+	var m = clientID;
+	return "<" + k + ":" + l + "-" + m + "@mail.projektitan.com>";
+}
+
+var utils = {
+    getJar: request.jar,
+    cookie: request.cookie,
+    setProxy,
+    parseProxy,
+    get,
+    post,
+    postData,
+    isReadableStream,
+    getGUID,
+    getSignatureID,
+    makeDefaults,
+    parseAndCheckLogin,
+    formatID,
+    getDTSGInitData,
+    generateOfflineThreadingID,
+    generateTimestampRelative,
+    generateThreadingID
+}
+
+Object.assign(utils, utilsLib);
+
+module.exports = utils;

source/control/events/cache.json

@@ -0,0 +1 @@
+{}

source/control/index.js

@@ -0,0 +1,204 @@
+var utils = require("../lib/utils");
+var log = require("../lib/log");
+var fs = require("fs");
+var Child = require("child_process");
+
+var requiredOptions = {
+    name: [
+        "String",
+        true
+    ],
+    version: [
+        "String",
+        true
+    ],
+    role: [
+        "Number",
+        true
+    ],
+    author: [
+        "Array",
+        true
+    ],
+    category: [
+        "String",
+        true
+    ],
+    description: [
+        "Object",
+        true
+    ],
+    delay: [
+        "Number",
+        true
+    ],
+    guides: [
+        "Object",
+        true
+    ],
+    dependencies: [
+        "Array",
+        false
+    ],
+    envConfig: [
+        "Object",
+        false
+    ]
+}
+
+module.exports = function () {
+    var apis = global.mira.apis;
+    var { systemOptions } = global.mira.config;
+
+    if (systemOptions.autoLoadPlugins.enable) {
+        var path = require("path");
+        var fs = require("fs");
+        var dir = path.resolve(global.mira.dir, "plugins");
+        var plugins = fs.readdirSync(dir).filter(item => item.endsWith(".js") && !systemOptions.autoLoadPlugins.ignore.includes(item));
+
+        function LoadPlugin(pluginPath) {
+            delete require.cache[pluginPath];
+            function error(message) {
+                var error = new Error(message);
+                error.at = pluginPath;
+                return error;
+            }
+            try {
+                var pl = new (require(pluginPath))();
+                var Options = pl.Options;
+                var Langs = pl.Langs;
+                var Reply = pl.Reply;
+                var React = pl.React;
+                var Schedule = pl.Schedule;
+                var Events = pl.Events;
+                var Main = pl.Main;
+                if (utils.getType(Options) !== "Object")
+                    throw error("Object is required in Options");
+
+                for (var item of Object.entries(requiredOptions)) {
+                    if (item[1][1] && !Options[item[0]].toString() || utils.getType(Options[item[0]]) !== item[1][0])
+                        throw error(item[0] + " is not accepted.");
+                }
+
+                if (typeof Main !== "function")
+                    throw error("function is required in Main.");
+
+                if (utils.getType(Langs) !== "Object")
+                    throw error("Object is required in " + lang);
+
+                for (var lang in Langs) {
+                    if (utils.getType(Langs[lang]) !== "Object")
+                        throw error("Object is required in " + lang);
+
+                    for (var content in Langs[lang]) {
+                        if (utils.getType(Langs[lang][content]) !== "String")
+                            throw error("String is required in " + content);
+                    }
+                }
+
+                if (Reply && typeof Reply !== "function")
+                    throw error("Reply must be function");
+                if (React && typeof React !== "function")
+                    throw error("React must be function");
+                if (Schedule && typeof Schedule !== "function")
+                    throw error("Schedule must be function");
+                if (Events && typeof Events !== "function")
+                    throw error("Events must be function");
+
+                if (Options.dependencies) {
+                    pl.dependencies = {}
+                    var execOptions = {
+                        cwd: dir,
+                        stdio: "inherit",
+                        shell: true
+                    }
+                    for (var dependencie of Options.dependencies) {
+                        try {
+                            pl.dependencies[dependencie] = require(dependencie);
+                        } catch (error) {
+                            Child.execSync("npm install " + dependencie, execOptions);
+                            pl.dependencies[dependencie] = require(dependencie);
+                        }
+                    }
+                }
+
+                if (Options.envConfig) {
+                    var envConfig = {}
+                    envConfig[Options.name] = {}
+                    for (var env in Options.envConfig) {
+                        envConfig[Options.name][env] = Options.envConfig[env];
+                    }
+                    global.mira.configCommands = envConfig;
+                }
+
+                global.modules.cmds = global.modules.cmds.filter(item => item[0] !== Options.name);
+                global.modules.cmds.push([Options.name, pl]);
+            } catch (error) {
+                console.log(error);
+            }
+        }
+
+        plugins.forEach(plugin => {
+            var pluginPath = path.resolve(dir, plugin);
+            LoadPlugin(pluginPath);
+            if (systemOptions.autoReloadPlugins.enable && !systemOptions.autoReloadPlugins.ignore.includes(plugin)) {
+                var lastReload = fs.statSync(pluginPath).mtimeMs;
+                var reloading = false;
+
+                function reload() {
+                    if (reloading)
+                        return;
+                    reloading = true;
+                    setTimeout(function () {
+                        reloading = false;
+                        if (lastReload === fs.statSync(pluginPath).mtimeMs)
+                            return;
+
+                        try {
+                            LoadPlugin(pluginPath);
+                            log.info("control.modules.reload", plugin);
+                        } finally {}
+                    }, 2000);
+                }
+                fs.watch(pluginPath, type => {
+                    if (type === "change")
+                        reload();
+                });
+            }
+        });
+
+        log.info("control.modules.len", global.modules.cmds.length);
+    }
+
+    var Client = new apis.Client();
+    var model = require("./model");
+    log.info("control.model.connect");
+    log.info("control.Client.connect");
+    log.wall();
+    global.mira.Client = Client;
+    return Client
+        .on("message", message => {
+            switch (message.type) {
+                case "message":
+                    model.Main(message);
+                case "message_reply":
+                case "message_unsend":
+                    model.db.createDataBase(message);
+                    model.Events(message);
+                    break;
+                case "event":
+                    break;
+                case "message_reaction":
+                    break;
+                default:
+                    break;
+            }
+        })
+        .on("error", function (error) {
+            if (error.type === "disconnect")
+                Client.disconnect();
+
+            log.error("control.Client.error", error.message || error);
+            console.log(error);
+        });
+}

source/control/model.js

@@ -0,0 +1,267 @@
+var utils = require("../lib/utils");
+var log = require("../lib/log");
+var { apis } = global.mira;
+var { model } = global.database;
+var ScheduleInterval;
+
+var bannedAPIs = [
+    "Messenger",
+    "Client",
+    "markAsDelivered",
+    "markAsRead",
+    "getUserInfo"
+];
+
+async function createDataBase(message) {
+    var { User, Thread } = model;
+    var { threadID, participantIDs, isGroup } = message;
+
+    if (isGroup) {
+        try {
+            await Thread.findOne(threadID);
+        } catch (error) {
+            log.error("database.create.fail", threadID, error.message);
+            console.log(error);
+        }
+    } else {
+        try {
+            await User.findOne(threadID);
+        } catch (error) {
+            log.error("database.create.fail", threadID, error.message);
+            console.log(error);
+        }
+    }
+
+    for (var userID of participantIDs || []) {
+        try {
+            await User.findOne(userID);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        } catch (error) {
+            log.error("database.create.fail", userID, error.message);
+            console.log(error);
+        }
+    }
+}
+
+async function updateDataBase(message) {
+
+}
+
+function levenshteinDistance(str1, str2) {
+    var len1 = str1.length;
+    var len2 = str2.length;
+    var dp = [];
+
+    for (var i = 0; i <= len1; i++)
+        dp[i] = [i];
+    for (var j = 0; j <= len2; j++)
+        dp[0][j] = j;
+    for (var i = 1; i <= len1; i++) {
+        for (var j = 1; j <= len2; j++) {
+            var cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+
+    return dp[len1][len2];
+}
+
+function similarityScore(str1, str2) {
+    var maxLength = Math.max(str1.length, str2.length);
+    if (maxLength === 0)
+        return 1.0;
+    var distance = levenshteinDistance(str1, str2);
+    return (maxLength - distance) / maxLength;
+}
+
+function findBestMatch(target, possibleMatches) {
+    var bestMatch = "";
+    var bestScore = 0;
+
+    for (var match of possibleMatches) {
+        var score = similarityScore(target, match);
+        if (score > bestScore) {
+            bestScore = score;
+            bestMatch = match;
+        }
+    }
+
+    return {
+        target: bestMatch,
+        rating: bestScore
+    }
+}
+
+async function Main(info) {
+    var allCMD = [...global.modules.cmds];
+    var { prefix, adminOnly, adminIDs } = global.mira.config.botOptions;
+    var { language } = require("../../config.json").systemOptions;
+    var { senderID, threadID, isGroup } = info;
+    var { User, Thread } = model;
+    var escapedPrefix = prefix.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+    var prefixRegex = new RegExp("^" + escapedPrefix, "i");
+    var isCalled = prefixRegex.test(info.body);
+    if (!isCalled)
+        return;
+
+    var [namePlg, ...args] = info.body.replace(prefixRegex, "").trim().split(/\s+/);
+    var cmd = allCMD.find(item => item[0] === namePlg);
+    var Messenger = utils.createMessenger(apis, info);
+    var userData = await User.findOne(senderID);
+    var userID = parseInt(senderID);
+
+    if (adminOnly && !adminIDs.includes(userID))
+        return;
+
+    if (isGroup) {
+        var threadData = await Thread.findOne(threadID);
+        if (threadData.banAt > 0 && !adminIDs.includes(userID))
+            return Messenger.reply(log.parseDir("control.model.threadBanned", [threadData.reason, utils.getTime(null, threadData.banAt)]));
+    }
+
+    if (userData.banAt > 0 && !adminIDs.includes(userID))
+        return Messenger.reply(log.parseDir("control.model.userBanned", [userData.reason, utils.getTime(null, userData.banAt)]));
+
+    if (namePlg.length === 0)
+        return Messenger.reply(log.parseDir("control.model.noPluginCalled", prefix));
+
+    if (!cmd) {
+        var allPlugins = allCMD.map(item => item[0]);
+        var bestMatch = findBestMatch(namePlg, allPlugins);
+        var content = log.parseDir("control.model.notExist", [namePlg, bestMatch.target]);
+        return Messenger.reply(content);
+    }
+
+    var pl = cmd[1];
+    var Langs = pl.Langs[language] || pl.Langs[Object.keys(pl.Langs)[0]];
+
+    function getText(dir, inputs) {
+        try {
+            if (Langs.hasOwnProperty(dir)) {
+                var content = Langs[dir];
+
+                if (inputs.length > 0) {
+                    for (var index = 1; index <= inputs.length; index++)
+                        content = content.replace("%" + index, inputs[index - 1]);
+                }
+
+                content = content.replace(/{p}|{n}/g, match => match === "{p}" ? prefix : namePlg);
+                return content;
+            }
+            return dir;
+        } catch (error) {
+            console.log(error);
+            return dir;
+        }
+    }
+
+    var subAPIs = { ...apis }
+
+    for (var api of bannedAPIs)
+        delete subAPIs[api];
+
+    Messenger.getText = getText;
+
+    var util = {
+        args,
+        Messenger,
+        events: info,
+        ...model,
+        apis: subAPIs
+    }
+
+    try {
+        pl.Main(util);
+    } catch (error) {
+        console.log(error);
+    }
+}
+
+async function Events(info) {
+    var allCMD = [...global.modules.cmds];
+    var { prefix, adminOnly, adminIDs } = global.mira.config.botOptions;
+    var { language } = require("../../config.json").systemOptions;
+    var { senderID, threadID, isGroup } = info;
+    var { User, Thread } = model;
+    var escapedPrefix = prefix.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+    var prefixRegex = new RegExp("^" + escapedPrefix, "i");
+    var isCalled = prefixRegex.test(info.body);
+    if (isCalled || senderID === apis.getCurrentUserID())
+        return;
+
+    var args = info.body.trim().split(/\s+/);
+    var Messenger = utils.createMessenger(apis, info);
+    var userData = await User.findOne(senderID);
+    var userID = parseInt(senderID);
+
+    if (adminOnly && !adminIDs.includes(userID))
+        return;
+
+    if (isGroup) {
+        var threadData = await Thread.findOne(threadID);
+        if (threadData.banAt > 0 && !adminIDs.includes(userID))
+            return;
+    }
+
+    if (userData.banAt > 0 && !adminIDs.includes(userID))
+        return;
+
+    for (var item of allCMD.filter(item => !!item[1].Events)) {
+        var pl = item[1];
+        var Langs = pl.Langs[language] || pl.Langs[Object.keys(pl.Langs)[0]];
+
+        function getText(dir, inputs) {
+            try {
+                if (Langs.hasOwnProperty(dir)) {
+                    var content = Langs[dir];
+
+                    if (inputs.length > 0) {
+                        for (var index = 1; index <= inputs.length; index++)
+                            content = content.replace("%" + index, inputs[index - 1]);
+                    }
+
+                    content = content.replace(/{p}|{n}/g, match => match === "{p}" ? prefix : namePlg);
+                    return content;
+                }
+                return dir;
+            } catch (error) {
+                console.log(error);
+                return dir;
+            }
+        }
+
+        var subAPIs = { ...apis }
+
+        for (var api of bannedAPIs)
+            delete subAPIs[api];
+
+        Messenger.getText = getText;
+
+        var util = {
+            args,
+            Messenger,
+            events: info,
+            ...model,
+            apis: subAPIs
+        }
+
+        try {
+            pl.Events(util);
+        } catch (error) {
+            console.log(error);
+        }
+    }
+}
+
+async function Reply(info) {
+    
+}
+
+module.exports = {
+    db: {
+        createDataBase,
+        updateDataBase
+    },
+    Main,
+    Events
+}

source/dashboard/assets/css/404.css

@@ -0,0 +1,113 @@
+* {
+    margin: 0;
+    padding: 0;
+    font-family: "Montserrat", sans-serif;
+}
+
+body {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100vh;
+
+}
+
+main {
+    display: flex;
+    flex-direction: row;
+    padding: 0 10%;
+    gap: 40px;
+}
+
+.main-text {
+    width: 50%;
+    text-align: start;
+    padding: 10px;
+    margin-right: 10px;
+}
+
+.main-text h3 {
+    font-size: 15px;
+    color: #ABB0B3;
+    text-transform: capitalize;
+    letter-spacing: 2px;
+    margin-bottom: 16px;
+}
+
+.main-text h1 {
+    font-size: 57px;
+    color: #121212;
+    font-weight: bold;
+    margin-top: 12px;
+}
+
+.main-text h2 {
+    font-size: 33px;
+    color: #121212;
+    font-weight: 400;
+    margin-bottom: 40px;
+    line-height: 48px;
+
+
+}
+
+.main-text a {
+    padding: 10px 20px;
+    background: linear-gradient(90deg, #fef506, #ff6575, #ae4df9, #029aff);
+    background-size: 500%;
+    color: white;
+    text-decoration: none;
+    border-radius: 5px;
+    animation: color 5s infinite alternate;
+
+}
+
+@keyframes color {
+    0% {
+        background-position: left;
+    }
+
+    100% {
+        background-position: right;
+    }
+
+}
+
+.main-text a:hover {
+    animation: color 1s infinite alternate;
+}
+
+.main-image {
+    display: flex;
+    justify-content: center;
+    width: 50%;
+    background-color: transparent;
+
+}
+
+@keyframes move {
+    0% {
+        transform: translateY(-10px);
+    }
+
+    25% {
+        transform: translateX(10px);
+    }
+
+    50% {
+        transform: translateY(10px);
+    }
+
+    75% {
+        transform: translateX(-10px);
+    }
+
+    100% {
+        transform: translateY(-10px);
+    }
+}
+
+.main-image img {
+    width: 720px;
+    animation: move 10s infinite linear;
+}

source/dashboard/assets/css/login.css

@@ -0,0 +1,176 @@
+* {
+  margin: 0;
+  padding: 0;
+  font-family: "Montserrat", sans-serif;
+}
+
+body {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100vh;
+}
+
+main {
+  display: flex;
+  flex-direction: row;
+  padding: 0 10%;
+  gap: 40px;
+}
+
+.main-text {
+  width: 50%;
+  text-align: start;
+  padding: 10px;
+  margin-right: 10px;
+  justify-content: right;
+}
+
+.text {
+  font-size: 33px;
+  font-weight: 600;
+  margin-bottom: 35px;
+  color: #595959;
+  text-align: center;
+}
+
+@keyframes color {
+  0% {
+      background-position: left;
+  }
+
+  100% {
+      background-position: right;
+  }
+}
+
+.main-image {
+  display: flex;
+  justify-content: left;
+  width: 50%;
+  background-color: transparent;
+}
+
+@keyframes move {
+  0% {
+      transform: translateY(-10px);
+  }
+
+  25% {
+      transform: translateX(10px);
+  }
+
+  50% {
+      transform: translateY(10px);
+  }
+
+  75% {
+      transform: translateX(-10px);
+  }
+
+  100% {
+      transform: translateY(-10px);
+  }
+}
+
+.main-image img {
+  width: 720px;
+  animation: move 10s infinite linear;
+}
+
+.field {
+  height: 50px;
+  width: 100%;
+  display: flex;
+  position: relative;
+}
+
+.field:nth-child(2) {
+  margin-top: 20px;
+}
+
+.field input {
+  height: 100%;
+  width: 100%;
+  padding-left: 45px;
+  outline: none;
+  border: none;
+  font-size: 18px;
+  background: #dde1e7;
+  color: #595959;
+  border-radius: 25px;
+  box-shadow: inset 2px 2px 5px #BABECC,
+      inset -5px -5px 10px #ffffff73;
+}
+
+.field input:focus {
+  box-shadow: inset 1px 1px 2px #BABECC,
+      inset -1px -1px 2px #ffffff73;
+}
+
+.field span {
+  position: absolute;
+  left: 15px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: #595959;
+  width: 50px;
+  line-height: 50px;
+}
+
+.field label {
+  position: absolute;
+  top: 50%;
+  transform: translateY(-50%);
+  left: 45px;
+  pointer-events: none;
+  color: #666666;
+}
+
+.field input:valid~label {
+  opacity: 0;
+}
+
+button {
+  margin: 15px 0;
+  width: 100%;
+  height: 50px;
+  font-size: 18px;
+  line-height: 50px;
+  font-weight: 600;
+  background: #dde1e7;
+  border-radius: 25px;
+  border: none;
+  outline: none;
+  cursor: pointer;
+  color: #595959;
+  box-shadow: 2px 2px 5px #BABECC,
+      -5px -5px 10px #ffffff73;
+}
+
+button:focus {
+  color: #3498db;
+  box-shadow: inset 2px 2px 5px #BABECC,
+      inset -5px -5px 10px #ffffff73;
+}
+
+.remember {
+  text-align: left;
+  margin: 10px 0 10px 5px;
+  text-transform: capitalize;
+}
+
+#remember {
+  accent-color: #fff;
+}
+
+.remember label {
+  display: flex;
+  align-items: center;
+  font-size: 16px;
+  text-decoration: none;
+}
+
+.remember label p {
+  margin-left: 8px;
+}

source/dashboard/assets/js/lockkey.js

@@ -0,0 +1,89 @@
+(function () {
+    function detectDevTools() {
+        var threshold = 160;
+        var devToolsOpen = false;
+
+        function checkDevTools() {
+            if (window.outerWidth - window.innerWidth > threshold ||
+                window.outerHeight - window.innerHeight > threshold) {
+                devToolsOpen = true;
+                alert("Developer tools are open!");
+            }
+        }
+        setInterval(checkDevTools, 1000);
+
+        document.addEventListener("keydown", function (event) {
+            if (event.key === "F12") {
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        });
+
+        document.addEventListener("keydown", function (event) {
+            if (
+                (event.ctrlKey && event.shiftKey && event.key === "I") ||
+                (event.ctrlKey && event.shiftKey && event.key === "C") ||
+                (event.ctrlKey && event.shiftKey && event.key === "J") ||
+                (event.ctrlKey && event.key === "U")
+            ) {
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        });
+
+        document.addEventListener("contextmenu", function (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        });
+
+        document.addEventListener("copy", function (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        });
+
+        document.addEventListener("cut", function (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        });
+        document.body.style.userSelect = "none";
+        document.body.style.webkitUserSelect = "none";
+        document.body.style.mozUserSelect = "none";
+        document.body.style.msUserSelect = "none";
+    }
+
+    document.addEventListener("DOMContentLoaded", detectDevTools);
+
+    window.onload = function () {
+        document.addEventListener("contextmenu", function (event) {
+            event.preventDefault();
+        }, false);
+
+        document.addEventListener("keydown", function (event) {
+            if (event.ctrlKey && event.shiftKey && event.keyCode === 73) { // Ctrl+Shift+I
+                disabledEvent(event);
+            }
+            if (event.ctrlKey && event.shiftKey && event.keyCode === 74) { // Ctrl+Shift+J
+                disabledEvent(event);
+            }
+            if (event.keyCode === 83 && (navigator.platform.match("Mac") ? event.metaKey : event.ctrlKey)) { // Ctrl+S or Cmd+S
+                disabledEvent(event);
+            }
+            if (event.ctrlKey && event.keyCode === 85) { // Ctrl+U
+                disabledEvent(event);
+            }
+            if (event.keyCode === 123) { // F12
+                disabledEvent(event);
+            }
+        }, false);
+
+        function disabledEvent(event) {
+            if (event.stopPropagation) {
+                event.stopPropagation();
+            } else if (window.event) {
+                window.event.cancelBubble = true;
+            }
+            event.preventDefault();
+            return false;
+        }
+    }
+})();

source/dashboard/assets/js/login.js

@@ -0,0 +1,46 @@
+function DOMContentLoaded() {
+    var formLogin = document.querySelector("form");
+    var isSubmitting = false;
+
+    async function formLoginSubmit(event) {
+        event.preventDefault();
+        
+        if (isSubmitting)
+            return;
+
+        isSubmitting = true;
+
+        var formData = new FormData(formLogin);
+        var formDataObject = Object.fromEntries(formData.entries());
+        formDataObject.url = "/login";
+        formDataObject.remember = formLogin.querySelector("#remember").checked;
+
+        var submitButton = formLogin.querySelector("button");
+        submitButton.disabled = true;
+
+        try {
+            var response = await fetch("/", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(formDataObject)
+            });
+            
+            response = await response.json();
+            if (response.isLogin)
+                window.location.href = "/dashboard";
+            else 
+                alert(response.message);
+        } catch (error) {
+            console.error(error);
+            formLogin.reset();
+            alert(error.message);
+        } finally {
+            submitButton.disabled = false;
+            isSubmitting = false;
+        }
+    }
+    formLogin.addEventListener("submit", formLoginSubmit);
+}
+document.addEventListener("DOMContentLoaded", DOMContentLoaded);

source/dashboard/index.js

@@ -0,0 +1,123 @@
+var log = require("../lib/log");
+var utils = require("../lib/utils");
+
+var path = require("path");
+var Express = require("express");
+var ExpressWs = require("express-ws");
+var ExpressSession = require("express-session")({
+    secret: "không có gì là bí mật.",
+    resave: false,
+    saveUninitialized: true,
+    cookie: {
+        secure: true
+    }
+});
+var Os = require("os");
+var fs = require("fs");
+
+var App = Express();
+
+ExpressWs(App);
+App.set("view engine", "ejs");
+App.set("views", path.resolve(__dirname, "views"));
+App.use("/assets", utils.requestChecked, Express.static(path.resolve(__dirname, "assets")));
+App.use(Express.urlencoded({ extended: true }));
+App.use(Express.json());
+App.use(ExpressSession);
+
+if (global.mira.config.dashboardOptions.resetAccount) {
+    var { Messenger } = global.mira.apis;
+    var { adminIDs } = global.mira.config.botOptions;
+    var templMail = utils.randomStr({ length: 10, letter: true, number: false }) + "@mira.com";
+    var templPass = utils.randomStr({ length: 16 });
+    global.mira.config = {
+        dashboardOptions: {
+            user: templMail,
+            password: templPass
+        }
+    }
+
+    var message =
+        "==========================" +
+        "\n• Email: " + templMail +
+        "\n• Password: " + templPass +
+        "\n• Timestamp: " + Date.now() +
+        "\n==========================";
+    adminIDs.map(id => Messenger.send(message, id, _ => {}));
+}
+
+App.post("/", function (req, res) {
+    var { dashboardOptions } = global.mira.config;
+    var body = req.body;
+    var status, resData;
+
+    if (body.url === "/login") {
+        var { username, password, remember } = body;
+        if (username === dashboardOptions.user && password === dashboardOptions.password) {
+            req.session.loggedIn = true;
+            req.session.username = username;
+
+            req.session.cookie.maxAge = remember ? 7 * 24 * 60 * 60 * 1000 : 3 * 60 * 60 * 1000;
+            req.session.cookie.secure = req.secure || req.headers["x-forwarded-proto"] === "https";
+            req.session.cookie.httpOnly = true;
+
+            status = 200;
+            resData = {
+                isLogin: true
+            }
+        } else {
+            status = 401;
+            resData = {
+                message: "Wrong Username/Password."
+            }
+        }
+    } else if (body.url === "/logout") {
+        req.session.destroy();
+        status = 200;
+        resData = {
+            isLogin: false
+        }
+    }
+
+    res.status(status || 404);
+    res.json(resData || {});
+});
+
+App.get("/login", function (req, res) {
+    if (utils.isAuthenticated(req))
+        res.redirect("/dashboard");
+    else
+        res.render("login");
+});
+
+App.get("/", function (req, res) {
+    if (utils.isAuthenticated(req))
+        res.redirect("/dashboard");
+    else
+        res.redirect("/login");
+});
+
+App.use(function (req, res) {
+    res.status(404);
+    res.render("404");
+});
+
+var interfaces = Os.networkInterfaces();
+var info;
+
+for (var network in interfaces) {
+    if (info)
+        break;
+
+    info = interfaces[network].find(item => !item.internal && item.family === "IPv4");
+}
+
+var Server = App.listen(global.mira.config.dashboardOptions.port, _ => {
+    var port = Server.address().port;
+
+    log.info("dashboard.port", port);
+    log.info("dashboard.ip", info.address);
+    log.info("dashboard.host", "http://" + info.address + ":" + port);
+    log.wall();
+});
+

source/dashboard/views/403.ejs

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <meta name="author" content="Khang">
+    <meta name="keywords" content="mira, bot">
+    <title>Sorry, This Page Can't Be Accessed | Mira</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@300;400;500;600;700&display=swap"
+        rel="stylesheet">
+    <link rel="stylesheet" href="/assets/css/404.css">
+    <script src="/assets/js/lockkey.js"></script>
+    <script>
+        function GoBack() {
+            if (document.referrer)
+                history.back();
+            else
+                window.location.href = "https://google.com/";
+        }
+    </script>
+</head>
+
+<body>
+    <main>
+        <div class="main-text">
+            <h3>ERROR CODE: 403</h3>
+            <h1>OOOPS!!</h1>
+            <h2>Please go back to the previous page to continue browsing.</h2>
+            <a onclick="GoBack()">Go Back</a>
+        </div>
+        <div class="main-image">
+            <img src="/assets/image/403.png" alt="">
+        </div>
+    </main>
+</body>
+
+</html>

source/dashboard/views/404.ejs

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <meta name="author" content="Khang">
+    <meta name="keywords" content="mira, bot">
+    <title>Sorry, This Page Can't Be Found | Mira</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@300;400;500;600;700&display=swap"
+        rel="stylesheet">
+    <link rel="stylesheet" href="/assets/css/404.css">
+    <script src="/assets/js/lockkey.js"></script>
+</head>
+
+<body>
+    <main>
+        <div class="main-text">
+            <h3>ERROR CODE: 404</h3>
+            <h1>OOOPS!!</h1>
+            <h2>This page may have been moved, deleted, or may never have existed.</h2>
+            <a href="/">Go Home</a>
+        </div>
+        <div class="main-image">
+            <img src="/assets/image/404.png" alt="">
+        </div>
+    </main>
+</body>
+
+</html>

source/dashboard/views/login.ejs

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+  <meta name="author" content="Khang">
+  <meta name="keywords" content="mira, bot">
+  <title>Login | Mira</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@300;400;500;600;700&display=swap"
+    rel="stylesheet">
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css" />
+  <link rel="stylesheet" href="/assets/css/login.css">
+  <script src="/assets/js/login.js"></script>
+  <script src="/assets/js/lockkey.js"></script>
+</head>
+
+<body>
+  <main>
+    <div class="main-text">
+      <div class="text">Login</div>
+      <form>
+        <div class="field">
+          <input type="text" name="username" required>
+          <span class="fas fa-user"></span>
+          <label>Email</label>
+        </div>
+        <div class="field">
+          <input type="password" name="password" required>
+          <span class="fas fa-lock"></span>
+          <label>Password</label>
+        </div>
+        <div class="remember">
+          <label for="remember">
+            <input type="checkbox" id="remember">
+            <p>Remember me</p>
+          </label>
+        </div>
+        <button type="submit">Sign in</button>
+      </form>
+    </div>
+    <div class="main-image">
+      <img src="/assets/image/login.png" alt="">
+    </div>
+  </main>
+</body>
+
+</html>

source/database/index.js

@@ -0,0 +1,93 @@
+var { DataBase } = global.mira.config.systemOptions;
+var log = require("../lib/log");
+
+async function SQLiteDataBase(firstConnect = true) {
+    var sql = require("sequelize");
+    var SQL = new sql({
+        dialect: "sqlite",
+        storage: __dirname + "/database.sqlite",
+        pool: {
+            max: 20,
+            min: 0,
+            acquire: 60000,
+            idle: 20000
+        },
+        retry: {
+            match: [
+                /SQLITE_BUSY/,
+            ],
+            name: "query",
+            max: 20
+        },
+        logging: false,
+        transactionType: "IMMEDIATE",
+        define: {
+            underscored: false,
+            freezeTableName: true,
+            charset: "utf8",
+            dialectOptions: {
+                collate: "utf8_general_ci"
+            },
+            timestamps: true
+        },
+        sync: {
+            force: false
+        }
+    });
+
+    try {
+        await SQL.authenticate();
+        log.info("database.authenticate.type", "SQLite");
+        await require("./model/user.sqlite3.js")(SQL, sql);
+        await require("./model/thread.sqlite3.js")(SQL, sql);
+        return log.wall();
+    } catch (error) {
+        log.error("database.authenticate.error", "SQLite", error.message);
+        console.log(error);
+        if (firstConnect) {
+            log.warn("database.reAuthenticated", "MongoDB");
+            var newConfig = global.mira.config;
+            newConfig.systemOptions.DataBase.type = "mongodb";
+            global.mira.config = newConfig;
+            return MongoDataBase(false);
+        } else
+            process.exit(1);
+    }
+}
+
+async function MongoDataBase(firstConnect = true) {
+    var { mongoURI } = DataBase;
+    var Mongo = require("mongoose");
+    var mongoRegex = /^(mongodb:\/\/|mongodb+srv:\/\/)[\w.-]+(:\d{2,5})?(\/[\w.-]*)?(\?.*)?$/;
+
+    try {
+        if (!mongoRegex.test(mongoURI))
+            throw new Error("mongoURI is invalid.");
+        await Mongo.connect(mongoURI);
+        log.info("database.authenticate.type", "MongoDB");
+        await require("./model/user.mongodb.js")(Mongo);
+        await require("./model/thread.mongodb.js")(Mongo);
+        return log.wall();
+    } catch (error) {
+        log.error("database.authenticate.error", "MongoDB", error.message);
+        console.log(error);
+        if (firstConnect) {
+            log.warn("database.reAuthenticated", "SQLite");
+            var newConfig = global.mira.config;
+            newConfig.systemOptions.DataBase.type = "sqlite";
+            global.mira.config = newConfig;
+            return SQLiteDataBase(false);
+        } else
+            process.exit(1);
+    }
+}
+
+if (DataBase.type !== "sqlite" && DataBase.type !== "mongodb") {
+    log.warn("database.notSupport", DataBase.type);
+    log.warn("database.defaultType");
+    var newConfig = global.mira.config;
+    newConfig.systemOptions.DataBase.type = "sqlite";
+    global.mira.config = newConfig;
+}
+
+module.exports = DataBase.type.toLowerCase() === "sqlite" ? SQLiteDataBase : MongoDataBase;

source/database/model/thread.mongodb.js

@@ -0,0 +1,159 @@
+var { apis } = global.mira;
+var log = require("../../lib/log");
+var { getType } = require("../../lib/utils");
+
+module.exports = async function ThreadDataBase(Client) {
+    var ThreadShema = new Client.Schema({
+        threadID: {
+            type: Client.Schema.Types.Decimal128,
+            unique: true,
+            required: true
+        },
+        name: {
+            type: String,
+            required: true,
+            validate: {
+                validator: v => v && v.trim().length > 0,
+                message: "Name must not be empty"
+            }
+        },
+        info: {
+            type: Client.Schema.Types.Mixed,
+            validate: {
+                validator: function (v) {
+                    try {
+                        JSON.stringify(v);
+                        return true;
+                    } catch (e) {
+                        return false;
+                    }
+                },
+                message: "Info must be a valid JSON object"
+            }
+        },
+        data: {
+            type: Client.Schema.Types.Mixed,
+            validate: {
+                validator: function (v) {
+                    try {
+                        JSON.stringify(v);
+                        return true;
+                    } catch (e) {
+                        return false;
+                    }
+                },
+                message: "Data must be a valid JSON object"
+            }
+        },
+        banAt: {
+            type: Number,
+            default: 0,
+            validate: {
+                validator: v => Number.isInteger(v) && v >= 0,
+                message: "banAt must be a non-negative integer"
+            }
+        },
+        reason: {
+            type: String,
+            required: false,
+            validate: {
+                validator: v => (!v || v.trim().length > 0),
+                message: "Reason must not be empty if providedy"
+            }
+        }
+    }, {
+        timestamps: true
+    });
+
+    ThreadShema.pre("save", function (next) {
+        this.updatedAt = Date.now();
+        next();
+    });
+    var Thread = Client.model("Thread", ThreadShema);
+
+    function getAll() {
+        return Thread.find();
+    }
+
+    function find(conditions = {}) {
+        if (getType(conditions) !== "Object")
+            throw new Error("conditions must be an JSON Object.");
+
+        return Thread.find(conditions);
+    }
+
+    async function getInfo(threadID) {
+        if (isNaN(parseInt(threadID)))
+            throw new Error("threadID must be a string number.");
+
+        var infoObj = await apis.getThreadInfo(threadID);
+        return infoObj;
+    }
+
+    async function findOne(threadID) {
+        if (isNaN(parseInt(threadID)))
+            throw new Error("threadID must be a string number.");
+
+        var thread = await Thread.findOne({ threadID });
+        if (!thread) {
+            await createData(threadID);
+            thread = await findOne(threadID);
+        }
+
+        return thread;
+    }
+
+    async function createData(threadID) {
+        var info = await getInfo(threadID);
+        var infoObj = {
+            threadID,
+            name: info.name,
+            money: 0,
+            info,
+            data: {},
+            banAt: 0,
+            reason: null
+        }
+        delete infoObj.info.name;
+        await Thread.findOneAndUpdate({ threadID }, infoObj, { upsert: true, new: true });
+        log.info("database.create.success", threadID);
+        return;
+    }
+
+    async function setData(threadID, data) {
+        if (isNaN(parseInt(threadID)))
+            throw new Error("threadID must be a string number.");
+        if (getType(data) !== "Object")
+            throw new Error("data must be an JSON Object.");
+
+        await Thread.updateOne({ threadID }, { $set: data });
+        return;
+    }
+
+    async function setDataAll(data, conditions = {}) {
+        if (getType(conditions) !== "Object")
+            throw new Error("conditions must be an JSON Object.");
+        if (getType(data) !== "Object")
+            throw new Error("data must be an JSON Object.");
+
+        await Thread.updateMany(conditions, { $set: data });
+        return;
+    }
+
+    async function deleteThread(threadID) {
+        if (isNaN(parseInt(threadID)))
+            throw new Error("threadID must be a string number.");
+        await Thread.deleteOne({ threadID });
+        return;
+    }
+
+    log.info("database.model", "Thread.mongodb");
+    return global.database.model.Thread = {
+        getAll,
+        find,
+        findOne,
+        setData,
+        setDataAll,
+        deleteThread
+    }
+}

source/database/model/thread.sqlite3.js

@@ -0,0 +1,132 @@
+var { apis } = global.mira;
+var log = require("../../lib/log");
+var { getType } = require("../../lib/utils");
+
+module.exports = async function ThreadDataBase(SQL, sql) {
+    var Thread = SQL.define("Thread", {
+        threadID: {
+            type: sql.BIGINT,
+            unique: true
+        },
+        name: {
+            type: sql.STRING,
+            allowNull: false,
+            validate: {
+                notEmpty: true
+            }
+        },
+        info: {
+            type: sql.JSON,
+            validate: {
+                isJSON: value => JSON.stringify(value)
+            }
+        },
+        data: {
+            type: sql.JSON,
+            validate: {
+                isJSON: value => JSON.stringify(value)
+            }
+        },
+        banAt: {
+            type: sql.BIGINT,
+            defaultValue: 0,
+            validate: {
+                isInt: true,
+                min: 0
+            }
+        },
+        reason: {
+            type: sql.STRING,
+            allowNull: true,
+            validate: {
+                notEmpty: true
+            }
+        }
+    });
+
+    Thread.sync({ force: false });
+
+    function getAll() {
+        return Thread.findAll();
+    }
+
+    function find(conditions = {}) {
+        if (getType(conditions) !== "Object") 
+            throw new Error("conditions must be an JSON Object.");
+
+        return Thread.findAll({ where: conditions });
+    }
+
+    async function getInfo(threadID) {
+        if (isNaN(parseInt(threadID))) 
+            throw new Error("ThreadID must be a string number.");
+
+        var infoObj = await apis.getThreadInfo(threadID);
+        return infoObj;
+    }
+
+    async function findOne(threadID) {
+        if (isNaN(parseInt(threadID))) 
+            throw new Error("ThreadID must be a string number.");
+
+        var threadData = await Thread.findOne({ where: { threadID } });
+        if (!threadData) {
+            await createData(threadID);
+            return await findOne(threadID);
+        }
+
+        return threadData.get({ plain: true });
+    }
+
+    async function createData(threadID) {
+        var info = await getInfo(threadID);
+        var infoObj = {
+            threadID,
+            name: info.name,
+            money: 0,
+            info,
+            data: {}
+        }
+        delete infoObj.info.name;
+        await Thread.findOrCreate({ where: { threadID }, defaults: infoObj });
+        log.info("database.create.success", threadID);
+        return;
+    }
+
+    async function setData(threadID, data) {
+        if (isNaN(parseInt(threadID))) 
+            throw new Error("ThreadID must be a string number.");
+        if (getType(data) !== "Object") 
+            throw new Error("data must be an JSON Object.");
+
+        await Thread.update(data, { where: { threadID } });
+        return;
+    }
+
+    async function setDataAll(data, conditions = {}) {
+        if (getType(conditions) !== "Object") 
+            throw new Error("conditions must be an JSON Object.");
+        if (getType(data) !== "Object") 
+            throw new Error("data must be an JSON Object.");
+
+        await Thread.update(data, { where: conditions });
+        return;
+    }
+
+    async function deleteThread(threadID) {
+        if (isNaN(parseInt(threadID))) 
+            throw new Error("threadID must be a string number.");
+        await Thread.destroy({ where: { threadID } });
+        return;
+    }
+
+    log.info("database.model", "Thread.sqlite3");
+    return global.database.model.Thread = {
+        getAll,
+        find,
+        findOne,
+        setData,
+        setDataAll,
+        deleteThread
+    }
+}

source/database/model/user.mongodb.js

@@ -0,0 +1,167 @@
+var { apis } = global.mira;
+var log = require("../../lib/log");
+var { getType } = require("../../lib/utils");
+
+module.exports = async function UserDataBase(Client) {
+    var UserShema = new Client.Schema({
+        userID: {
+            type: Client.Schema.Types.Decimal128,
+            unique: true,
+            required: true
+        },
+        name: {
+            type: String,
+            required: true,
+            validate: {
+                validator: v => v && v.trim().length > 0,
+                message: "Name must not be empty"
+            }
+        },
+        money: {
+            type: Client.Schema.Types.Decimal128,
+            default: 0,
+            validate: {
+                validator: v => Number.isInteger(v) && v >= 0,
+                message: "Money must be a non-negative integer"
+            }
+        },
+        info: {
+            type: Client.Schema.Types.Mixed,
+            validate: {
+                validator: function (v) {
+                    try {
+                        JSON.stringify(v);
+                        return true;
+                    } catch (e) {
+                        return false;
+                    }
+                },
+                message: "Info must be a valid JSON object"
+            }
+        },
+        data: {
+            type: Client.Schema.Types.Mixed,
+            validate: {
+                validator: function (v) {
+                    try {
+                        JSON.stringify(v);
+                        return true;
+                    } catch (e) {
+                        return false;
+                    }
+                },
+                message: "Data must be a valid JSON object"
+            }
+        },
+        banAt: {
+            type: Number,
+            default: 0,
+            validate: {
+                validator: v => Number.isInteger(v) && v >= 0,
+                message: "banAt must be a non-negative integer"
+            }
+        },
+        reason: {
+            type: String,
+            required: false,
+            validate: {
+                validator: v => (!v || v.trim().length > 0),
+                message: "Reason must not be empty if providedy"
+            }
+        }
+    }, {
+        timestamps: true
+    });
+
+    UserShema.pre("save", function (next) {
+        this.updatedAt = Date.now();
+        next();
+    });
+    var User = Client.model("User", UserShema);
+
+    function getAll() {
+        return User.find();
+    }
+
+    function find(conditions = {}) {
+        if (getType(conditions) !== "Object")
+            throw new Error("conditions must be an JSON Object.");
+
+        return User.find(conditions);
+    }
+
+    async function getInfo(userID) {
+        if (isNaN(parseInt(userID)))
+            throw new Error("userID must be a string number.");
+
+        var infoObj = await apis.getUserInfo(userID);
+        return infoObj[userID] || {}
+    }
+
+    async function findOne(userID) {
+        if (isNaN(parseInt(userID)))
+            throw new Error("userID must be a string number.");
+
+        var user = await User.findOne({ userID });
+        if (!user) {
+            await createData(userID);
+            user = await findOne(userID);
+        }
+
+        return user;
+    }
+
+    async function createData(userID) {
+        var info = await getInfo(userID);
+        var infoObj = {
+            userID,
+            name: info.name || "User",
+            money: 0,
+            info,
+            data: {},
+            banAt: 0,
+            reason: null
+        }
+        delete infoObj.info.name;
+        await User.findOneAndUpdate({ userID }, infoObj, { upsert: true, new: true });
+        log.info("database.create.success", userID);
+        return;
+    }
+
+    async function setData(userID, data) {
+        if (isNaN(parseInt(userID)))
+            throw new Error("userID must be a string number.");
+        if (getType(data) !== "Object")
+            throw new Error("data must be an JSON Object.");
+
+        await User.updateOne({ userID }, { $set: data });
+        return;
+    }
+
+    async function setDataAll(data, conditions = {}) {
+        if (getType(conditions) !== "Object")
+            throw new Error("conditions must be an JSON Object.");
+        if (getType(data) !== "Object")
+            throw new Error("data must be an JSON Object.");
+
+        await User.updateMany(conditions, { $set: data });
+        return;
+    }
+
+    async function deleteUser(userID) {
+        if (isNaN(parseInt(userID)))
+            throw new Error("userID must be a string number.");
+        await User.deleteOne({ userID });
+        return;
+    }
+
+    log.info("database.model", "User.mongodb");
+    return global.database.model.User = {
+        getAll,
+        find,
+        findOne,
+        setData,
+        setDataAll,
+        deleteUser
+    }
+}

source/database/model/user.sqlite3.js

@@ -0,0 +1,142 @@
+var { apis } = global.mira;
+var log = require("../../lib/log");
+var { getType } = require("../../lib/utils");
+
+module.exports = async function UserDataBase(SQL, sql) {
+    var User = SQL.define("User", {
+        userID: {
+            type: sql.BIGINT,
+            unique: true
+        },
+        name: {
+            type: sql.STRING,
+            allowNull: false,
+            validate: {
+                notEmpty: true
+            }
+        },
+        money: {
+            type: sql.BIGINT,
+            defaultValue: 0,
+            validate: {
+                isInt: true,
+                min: 0
+            }
+        },
+        info: {
+            type: sql.JSON,
+            validate: {
+                isJSON: value => JSON.stringify(value)
+            }
+        },
+        data: {
+            type: sql.JSON,
+            validate: {
+                isJSON: value => JSON.stringify(value)
+            }
+        },
+        banAt: {
+            type: sql.BIGINT,
+            defaultValue: 0,
+            validate: {
+                isInt: true,
+                min: 0
+            }
+        },
+        reason: {
+            type: sql.STRING,
+            allowNull: true,
+            validate: {
+                notEmpty: true
+            }
+        }
+    });
+
+    User.sync({ force: false });
+
+    function getAll() {
+        return User.findAll();
+    }
+
+    function find(conditions = {}) {
+        if (getType(conditions) !== "Object") 
+            throw new Error("conditions must be an JSON Object.");
+
+        return User.findAll({ where: conditions });
+    }
+
+    async function getInfo(userID) {
+        if (isNaN(parseInt(userID))) 
+            throw new Error("userID must be a string number.");
+
+        var infoObj = await apis.getUserInfo(userID);
+        return infoObj[userID] || {}
+    }
+
+    async function findOne(userID) {
+        if (isNaN(parseInt(userID))) 
+            throw new Error("userID must be a string number.");
+
+        var userData = await User.findOne({ where: { userID } });
+        if (!userData) {
+            await createData(userID);
+            return await findOne(userID);
+        }
+
+        return userData.get({ plain: true });
+    }
+
+    async function createData(userID) {
+        var info = await getInfo(userID);
+        var infoObj = {
+            userID,
+            name: info.name || "User",
+            money: 0,
+            info,
+            data: {},
+            banAt: 0,
+            reason: null
+        }
+        delete infoObj.info.name;
+        await User.findOrCreate({ where: { userID }, defaults: infoObj });
+        log.info("database.create.success", userID);
+        return;
+    }
+
+    async function setData(userID, data) {
+        if (isNaN(parseInt(userID))) 
+            throw new Error("userID must be a string number.");
+        if (getType(data) !== "Object") 
+            throw new Error("data must be an JSON Object.");
+
+        await User.update(data, { where: { userID } });
+        return;
+    }
+
+    async function setDataAll(data, conditions = {}) {
+        if (getType(conditions) !== "Object") 
+            throw new Error("conditions must be an JSON Object.");
+        if (getType(data) !== "Object") 
+            throw new Error("data must be an JSON Object.");
+
+        await User.update(data, { where: conditions });
+        return;
+    }
+
+    async function deleteUser(userID) {
+        if (isNaN(parseInt(userID))) 
+            throw new Error("userID must be a string number.");
+        await User.destroy({ where: { userID } });
+        return;
+    }
+
+    log.info("database.model", "User.sqlite3");
+    return global.database.model.User = {
+        getAll,
+        find,
+        findOne,
+        setData,
+        setDataAll,
+        deleteUser
+    }
+}

source/index.js

@@ -0,0 +1,27 @@
+var { spawn } = require("child_process");
+var { version, name } = require("../package.json");
+var log = require("./lib/log");
+
+function RunSystem() {
+    log.wall();
+    log.info("process.name", name);
+    log.info("process.version", version);
+    var Mira = spawn("node", ["mira.js"], {
+        cwd: __dirname,
+        stdio: "inherit",
+        shell: true
+    });
+
+    Mira.on("close", exitCode => {
+        if (exitCode === 2) {
+            log.info("process.restarting");
+            setTimeout(_ => {
+                console.clear();
+                RunSystem();
+            }, 5000);
+        } else {
+            log.info("process.exit", exitCode);
+        }
+    });
+}
+RunSystem();