First commit for siong cm_bot

.gitignore

@@ -0,0 +1,9 @@
+__pycache__
+*/*.txt
+*.png
+node_modules/
+obsolete
+cmd
+*.xlsx
+*.log
+nohup.out

README.md

@@ -0,0 +1 @@
+# cm_bot

index.cjs

@@ -0,0 +1,17 @@
+const { fork } = require('child_process');
+
+// Run telegramBot.cjs
+const telegramBotProcess = fork('src/telegramBot.cjs');
+
+// Run visualWeb.cjs
+const visualWebProcess = fork('src/visualWebApi.cjs');
+
+// Handle exit events
+telegramBotProcess.on('exit', (code) => {
+  console.log(`telegramBot.cjs exited with code ${code}`);
+});
+
+visualWebProcess.on('exit', (code) => {
+  console.log(`visualWeb.cjs exited with code ${code}`);
+});
+

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "cm_bot",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.cjs",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/heng5411/cm_bot.git"
+  },
+  "author": "yiekheng",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/heng5411/cm_bot/issues"
+  },
+  "homepage": "https://github.com/heng5411/cm_bot#readme",
+  "dependencies": {
+    "axios": "^1.8.4",
+    "cors": "^2.8.5",
+    "express": "^4.21.2",
+    "mysql2": "^3.14.0",
+    "node-telegram-bot-api": "^0.66.0",
+    "puppeteer": "^24.4.0",
+    "winston": "^3.17.0",
+    "xlsx": "^0.18.5"
+  }
+}

run.bat

@@ -0,0 +1,3 @@
+@echo off
+del *.log
+node src\transferCommissionBot.cjs

src/bot.cjs

@@ -0,0 +1,43 @@
+const puppeteer = require("puppeteer");
+
+class Bot {
+  constructor() {
+    this.pages = [];
+  }
+
+  async createNewPage() {
+    const browser = await puppeteer.launch({
+      //headless: false,
+      timeout: 0,
+      args: ["--no-sandbox"],
+    });
+    const page = (await browser.pages())[0];
+    this.pages.push({ browser, page });
+    return page;
+  }
+
+  async close(page) {
+    const index = this.pages.findIndex((p) => p.page === page);
+    if (index === -1) return;
+    const { browser } = this.pages[index];
+    await browser.close();
+    this.pages.splice(index, 1);
+  }
+
+  async loadPageAndWaitForElement(page, url, selector, timeout = 3 * 60 * 1000) {
+    if (!url.startsWith("https:")) {
+      url = url.replace(/^http:\/\//, "https://");
+    }
+    await page.goto(url, { waitUntil: "networkidle2" });
+    await page.waitForSelector(selector, { timeout });
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    const bot = new Bot();
+  })();
+}
+
+module.exports = Bot;
+

src/cmBot.cjs

@@ -0,0 +1,177 @@
+const config = require("./config");
+const Bot = require("./bot.cjs");
+
+class cmBot extends Bot {
+  constructor() {
+    super();
+    this.url = "https://www.cm99.net/cm";
+    this.superAgentId = config.cm_config.super_agent_id;
+    this.superAgentPassword = config.cm_config.super_agent_password;
+    this.safePassword = config.cm_config.safe_password;
+  }
+
+  async loadLoginPage(page) {
+    await this.loadPageAndWaitForElement(page, this.url + "/login", "#loginForm");
+  }
+
+  async loadAccountPage(page) {
+    await this.loadPageAndWaitForElement(
+      page, 
+      this.url + "/userMainAction",
+      "#jsonTree"
+    );
+    await page.waitForSelector("a.jstree-loading", { hidden: true });
+  }
+
+  async loadQrPage(page) {
+    await this.loadPageAndWaitForElement(
+      page, 
+      this.url + "/showQrCode",
+      "#qrCodeForm"
+    );
+  }
+
+  async loadTransferPage(page) {
+    await this.loadPageAndWaitForElement(
+      page, 
+      this.url + "/transfer",
+      "#transferForm"
+    );
+  }
+
+  async loadUserProfilePage(page) {
+    await this.loadPageAndWaitForElement(
+      page, 
+      this.url + "/userProfile",
+      ".generalContent"
+    );
+  }
+
+  async loadSecurityPinPage(page) {
+    await this.loadPageAndWaitForElement(
+      page, 
+      this.url + "/setSecurityPin",
+      "#depositTable"
+    );
+  }
+
+  async enterLoginPageUserIdAndPass(page, username, password) {
+    await page.waitForSelector("#j_username");
+    await page.waitForSelector("#j_password");
+    await page.type("#j_username", username);
+    await page.type("#j_password", password);
+  }
+
+  async clickLoginButton(page) {
+    await page.waitForSelector('#loginForm input[type="submit"]');
+    await page.click('#loginForm input[type="submit"]');
+  }
+
+  async login(page, id, password) {
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      await this.loadLoginPage(page);
+      await this.enterLoginPageUserIdAndPass(page, id, password);
+      await this.clickLoginButton(page);
+      try {
+        await page.waitForSelector("#loginForm", { hidden: true, timeout: 3000 });
+        break; // Exit loop if login is successful
+      } catch (error) {
+        if (attempt === 3) {
+          throw new Error(`unable to login`);
+        }
+      }
+    }
+  }
+
+  async logout(page) {
+    await page.click('a[title="Logout"]');
+    await page.waitForSelector("#loginForm", { visible: true });
+  }
+
+  async fillUserForm(page, username, password) {
+    await this.loadAccountPage(page);
+    await page.type("#userAccountForm_user_username", username);
+    await page.type("#userAccountForm_user_name", username);
+    await page.type("#userAccountForm_user_password", password);
+    await page.type("#userAccountForm_user_confirmPassword", password);
+    await page.click("#checkAllPrizePackages");
+    await page.click("#checkAllPrizePackages5D6D");
+    await page.click("#userAccountForm_button_save");
+    await page.waitForSelector("img#indicator", { hidden: true });
+  }
+
+  async superAgentChangeUserPassword(page, username, password) {
+    await this.loadAccountPage(page);
+    const as = await page.$$('a');
+    for (const a of as) {
+      const text = await page.evaluate(el => el.textContent, a);
+      if (text.includes(username)) {
+        await a.click();
+        break;
+      }
+    }
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    await page.waitForSelector("#userAccountForm_user_username", { hidden: true });
+    await page.type("#userAccountForm_user_password", password);
+    await page.type("#userAccountForm_user_confirmPassword", password);
+    await page.waitForSelector("#userAccountForm_button_update", { visible: true });
+    await page.click("#userAccountForm_button_update");
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    await page.waitForSelector("img#indicator", { hidden: true });
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    console.log(`password : ${password} changed for ${username}`);
+  }
+
+  async getRegisterLink(page) {
+    await this.loadQrPage(page);
+    const link = await page.$eval("#qrCodeForm a", (el) => el.href);
+    return link;
+  }
+
+  async setSafePass(page) {
+    await this.loadSecurityPinPage(page);
+    await page.type("#newPin", this.safePassword);
+    await page.type("#confirmNewPin", this.safePassword);
+    await page.click("#button_save");
+  }
+
+  async fillTransferForm(page, t_username, t_password, amount){
+    for(let attempt = 1; attempt <= 3; attempt ++){
+      try{
+        await this.loadTransferPage(page);
+        await page.waitForSelector("#username", { visible: true, timeout: 5000 });
+        await page.type("#username", t_username);
+        await page.click("#search");
+        await page.waitForSelector("#amount", { visible: true, timeout: 5000 });
+        await page.type("#amount", amount);
+        await page.type("#securityPin", t_password);
+        await page.click("#button_transfer");
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        const errorMessages = await page.$("#errorMessages");
+        if (errorMessages) {
+          throw new Error("wrong sec pin");
+        }
+        break;
+      } catch (error) {
+        if (error.message.includes("wrong sec pin")) {
+          throw error;
+        }
+        if (attempt === 3) {
+          throw error;
+        }
+      }
+    }
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    const bot = new cmBot();
+    const page = await bot.createNewPage();
+    await bot.login(page, bot.superAgentId, bot.superAgentPassword);
+    await bot.superAgentChangeUserPassword(page, "13c3829", "test");
+  })();
+}
+
+module.exports = cmBot;
+

src/config.js

@@ -0,0 +1,16 @@
+const config = {
+    db: {
+        host: "192.168.0.210",
+        user: "siong_cm",
+        password: "hengserver",
+        database: "siong_cm",
+        port: 3306
+    },
+    cm_config : {
+        super_agent_id : "13sa0001a",
+        super_agent_password : "Wenwen12345",
+        safe_password : "Wenwen12345"
+    }
+}
+
+module.exports = config;

src/createAccBot.cjs

@@ -0,0 +1,131 @@
+const DB = require("./db");
+const cmBot = require("./cmBot.cjs");
+
+class createAccBot {
+  constructor() {
+    this.db = new DB();
+  }
+
+  async getMaxUsernameFromAcc(prefix) {
+    const rows = await this.db.query(
+      "SELECT username FROM acc WHERE username LIKE ? ORDER BY username DESC LIMIT 1",
+      [`${prefix}%`]
+    );
+    let maxUsername = rows[0] ? rows[0].username : "";
+    let newNum =
+      parseInt(maxUsername.replace(prefix, ""), 10) +
+      (maxUsername[maxUsername.length - 1] === "3" ? 2 : 1);
+    newNum.toString();
+    return prefix + newNum;
+  }
+
+  generatePassword() {
+    const lower = "abcdefghijklmnopqrstuvwxyz";
+    const upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const num = "0123456789";
+    const length = Math.floor(Math.random() * 3) + 6;
+    let password = "";
+    password += lower.charAt(Math.floor(Math.random() * lower.length));
+    password += upper.charAt(Math.floor(Math.random() * upper.length));
+    password += num.charAt(Math.floor(Math.random() * num.length));
+    const chars = [lower, upper, num];
+    for (let i = 3; i < length; i++) {
+      const char = chars[Math.floor(Math.random() * chars.length)];
+      password += char.charAt(Math.floor(Math.random() * char.length));
+    }
+    return password;
+  }
+
+  async insertAccToDB(username, password, link) {
+    const result = await this.db.query(
+      "INSERT INTO acc (username, password, link) VALUES (?, ?, ?)",
+      [username, password, link]
+    );
+    console.log(
+      `Insert ${username} - ${result.affectedRows === 1 ? "success" : "failed"}`
+    );
+  }
+
+  async createAcc(prefix = "13c") {
+    const username = await this.getMaxUsernameFromAcc(prefix);
+    const password = this.generatePassword();
+    let link = "";
+
+    const cmbot = new cmBot();
+    const page = await cmbot.createNewPage();
+    try {
+      await cmbot.login(page, cmbot.superAgentId, cmbot.superAgentPassword);
+      await cmbot.fillUserForm(page, username, password);
+      await cmbot.logout(page);
+      await cmbot.login(page, username, password);
+      link = await cmbot.getRegisterLink(page);
+      await this.insertAccToDB(username, password, link);
+    } catch (error) {
+      console.error("Error creating account:", error);
+    } finally {
+      await cmbot.close(page);
+    }
+
+    return [username, password, link];
+  }
+
+  async updateAccPassword(username) {
+    const [result] = await this.db.query("SELECT * FROM acc WHERE username = ?", [username]);
+    if (!result) {
+      const password = this.generatePassword();
+      let link = "";
+
+      const cmbot = new cmBot();
+      const page = await cmbot.createNewPage();
+      try {
+        await cmbot.login(page, cmbot.superAgentId, cmbot.superAgentPassword);
+        await cmbot.superAgentChangeUserPassword(page, username, password);
+        await cmbot.logout(page);
+        await cmbot.login(page, username, password);
+        link = await cmbot.getRegisterLink(page);
+        await this.insertAccToDB(username, password, link);
+      } catch (error) {
+        console.error("Error creating account:", error);
+      } finally {
+        await cmbot.close(page);
+      }
+
+      return [username, password, link];
+    }
+  }
+
+  async updateAccStatusToWait(username) {
+    await this.db.query(
+      "UPDATE acc SET status = 'wait' WHERE username = ?",
+      [username]
+    );
+  }
+
+  async getAcc() {
+    const [row] = await this.db.query(
+      "SELECT username, password, link FROM acc WHERE status = ? ORDER BY username ASC LIMIT 1",
+      [""]
+    );
+
+    if (row) {
+      await this.updateAccStatusToWait(row.username);
+      return [row.username, row.password, row.link];
+    }
+
+    const [username, password, link] = await this.createAcc();
+    await this.updateAccStatusToWait(username);
+    return [username, password, link];
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    const bot = new createAccBot();
+    for (let i = 3850; i <= 3850; i++) {
+      if (i % 10 === 4) continue;
+      await bot.updateAccPassword(`13c${i.toString().padStart(4, "0")}`);
+    }
+  })();
+}
+
+module.exports = createAccBot;

src/db.js

@@ -0,0 +1,88 @@
+const mysql = require("mysql2");
+const config = require("./config");
+
+class DB {
+  constructor() {
+    this.config = config.db;
+  }
+
+  async query(sql, vals) {
+    const connection = mysql.createConnection(this.config);
+    try {
+      const rows = await new Promise((resolve, reject) => {
+        connection.query(sql, vals, (err, rows) => {
+          connection.end();
+          if (err) {
+            return reject(err);
+          }
+          resolve(rows);
+        });
+      });
+      return rows;
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+}
+async function syncAcc() {
+  const xlsx = require("xlsx");
+  const workbook = xlsx.readFile("./acc.xlsx");
+  const sheets = [workbook.Sheets["cm13a39"]];
+  const db = new DB();
+  for (const worksheet of sheets) {
+    const data = xlsx.utils.sheet_to_json(worksheet);
+    for (const row of data) {
+      const username = row.username === undefined ? "" : row.username;
+      const status = row.status === undefined ? "" : row.status;
+      const password = row.password === undefined ? "" : row.password;
+      const link = row.link === undefined ? "" : row.link;
+      try {
+        await db.query(
+          "INSERT INTO acc (username, status, password, link) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE password=?, link=?",
+          [username, status, password, link, password, link]
+        );
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+}
+
+async function syncUser() {
+  const xlsx = require("xlsx");
+  const workbook = xlsx.readFile("./user.xlsx");
+  const worksheet = workbook.Sheets["Sheet1"];
+  const data = xlsx.utils.sheet_to_json(worksheet);
+  const db = new DB();
+  for (const row of data) {
+    const f_username = row.f_username === undefined ? "" : row.f_username;
+    const f_password = row.f_password === undefined ? "" : row.f_password;
+    const t_username = row.t_username === undefined ? "" : row.t_username;
+    const t_password = row.t_password === undefined ? "" : row.t_password;
+    try {
+      await db.query(
+        "INSERT INTO user (f_username, f_password, t_username, t_password) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE f_password=?, t_username=?, t_password=?",
+        [f_username, f_password, t_username, t_password, f_password, t_username, t_password]
+      );
+    } catch (error) {
+      console.error(error);
+    }
+  }
+}
+
+if (require.main === module) {
+  Promise.all([syncAcc(), syncUser()])
+    .then(() => {
+      console.log("done sync");
+      process.exit();
+    })
+    .catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+}
+
+module.exports = DB;
+
+

src/setSafePassBot.cjs

@@ -0,0 +1,98 @@
+const DB = require("./db");
+const cmBot = require("./cmBot.cjs");
+
+class setSafePassBot {
+  constructor() {
+    this.db = new DB();
+    this.bot = new cmBot();
+  }
+
+  async getPasswordFromAcc(f_username) {
+    const [result] = await this.db.query(
+      "SELECT password FROM acc WHERE username = ?",
+      [f_username]
+    );
+    if (!result) {
+      throw new Error("Account not found");
+    }
+    return result.password;
+  }
+
+  async getUsernameFromWALink(wa_link) {
+    try {
+      const url = new URL(wa_link);
+      if (url.protocol !== "https:" || !url.hostname.includes("whatsapp.com")) {
+        throw new Error("Invalid WhatsApp link");
+      }
+    } catch (error) {
+      throw new Error("Invalid URL format");
+    }
+
+    await this.bot.loadPageAndWaitForElement(this.page, wa_link, "#main_block");
+    const text = await this.page.$eval(
+      "#main_block h3",
+      (el) => el.textContent
+    );
+    return text.replace(/^\*+/g, "").replace(/\s/g, "").split("/");
+  }
+
+  async getUserData(wa_link) {
+    const [t_username, f_username] = await this.getUsernameFromWALink(wa_link);
+    const f_password = await this.getPasswordFromAcc(f_username);
+    const t_password = "Sky533535";
+    return [f_username, f_password, t_username, t_password];
+  }
+
+  async insertUserToDB(f_username, f_password, t_username, t_password) {
+    await this.db.query(
+      "INSERT INTO user (f_username, f_password, t_username, t_password) VALUES (?, ?, ?, ?)",
+      [f_username, f_password, t_username, t_password]
+    );
+  }
+
+  async updateAccDB(f_username) {
+    await this.db.query("UPDATE acc SET status = ? WHERE username = ?", [
+      "done",
+      f_username,
+    ]);
+  }
+
+  async isFUsernameExist(f_username) {
+    const [result] = await this.db.query(
+      "SELECT f_username FROM user WHERE f_username = ?",
+      [f_username]
+    );
+    return !!result;
+  }
+
+  async setSafePass(wa_link) {
+    try {
+      this.page = await this.bot.createNewPage();
+      const [f_username, f_password, t_username, t_password] =
+        await this.getUserData(wa_link);
+      if (await this.isFUsernameExist(f_username)) {
+        throw new Error("account already exists");
+      }
+      await this.bot.login(this.page, f_username, f_password);
+      await this.bot.setSafePass(this.page);
+      await this.insertUserToDB(f_username, f_password, t_username, t_password);
+      await this.updateAccDB(f_username);
+      this.bot.close(this.page);
+      return [f_username, t_username];
+    } catch (error) {
+      console.error(error);
+      this.bot.close(this.page);
+      throw error;
+    }
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    const bot = new setSafePassBot();
+    // console.log(await bot.getPasswordFromAcc("13c3599"));
+    await bot.setSafePass("https://chat.whatsapp.com/Dh6WEaXzt4W6jVIwTZevNC");
+  })();
+}
+
+module.exports = setSafePassBot;

src/telegramBot.cjs

@@ -0,0 +1,93 @@
+console.log("Telegram bot is running");
+
+const TelegramBot = require("node-telegram-bot-api");
+
+const createAccBot = require("./createAccBot.cjs");
+const setSafePassBot = require("./setSafePassBot.cjs");
+
+const token = "7028479329:AAH_UTPoYcaB0iZMXJjO7pKYxyub8ZSXn2E";
+const teleBot = new TelegramBot(token, { polling: true });
+const registeredAcc = {};
+
+async function handleGetAcc(chatId) {
+  teleBot.sendMessage(chatId, "Starting to get account...");
+  const [username, password, link] = await new createAccBot().getAcc();
+  teleBot.sendMessage(
+    chatId,
+    `Username:  ${username}\nPassword: ${password}\nLink: ${link}`
+  );
+}
+
+async function handleInsertUserToDB(chatId) {
+  teleBot.sendMessage(chatId, "Starting to insert user to database...");
+  try {
+    const [f_username, t_username] = await new setSafePassBot().setSafePass(
+      registeredAcc[chatId]
+    );
+    teleBot.sendMessage(
+      chatId,
+      `Done setting safe pass for ${f_username} - ${t_username}`
+    );
+  } catch (error) {
+      teleBot.sendMessage(chatId, `Error: ${error.message}`);
+  } finally {
+    delete registeredAcc[chatId];
+  }
+}
+
+async function handleCreateAcc(chatId) {
+  teleBot.sendMessage(chatId, "Starting to create accounts...");
+  const accBot = new createAccBot();
+  for (let i = 0; i < 10; i++) {
+    await accBot.createAcc();
+  }
+  teleBot.sendMessage(chatId, "10 accounts created.");
+}
+
+async function handleSetRegisteredAcc(chatId, text) {
+  teleBot.sendMessage(chatId, "Starting to set registered account...");
+  registeredAcc[chatId] = text;
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  teleBot.sendMessage(chatId, `Done remember ${text}`);
+}
+
+async function handleGetMenu(chatId) {
+  teleBot.sendMessage(
+    chatId,
+    `Menu:
+  /1 - Get Account
+  /2 - Insert User to Database
+  /3 - Create 10 Accountst`
+  );
+}
+
+teleBot.on("message", async (msg) => {
+  const {
+    chat: { id: chatId },
+    text,
+  } = msg;
+
+  console.log(`${new Date().toISOString()}: chatId: ${chatId}, text: ${text}`);
+
+  const [cmd, ...args] = text.split(" ");
+
+  try {
+    if (cmd === "/menu") {
+      await handleGetMenu(chatId);
+    } else if (cmd === "/1") {
+      await handleGetAcc(chatId);
+    } else if (cmd === "/2") {
+      await handleInsertUserToDB(chatId);
+    } else if (cmd === "/3") {
+      await handleCreateAcc(chatId);
+    } else if (text.startsWith("https://chat.whatsapp.com/")) {
+      await handleSetRegisteredAcc(chatId, text);
+    }
+  } catch (error) {
+    teleBot.sendMessage(chatId, "Error: " + error.message);
+  }
+});
+
+teleBot.on("error", (error) => {
+  console.error("Error:", error);
+});

src/transferCommissionBot.cjs

@@ -0,0 +1,167 @@
+const DB = require("./db");
+const cmBot = require("./cmBot.cjs");
+const winston = require("winston");
+const Progress = require("progress");
+const axios = require("axios");
+
+const logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(
+    winston.format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss",
+    }),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({
+      filename: "error.log",
+      level: "error",
+      flags: "w",
+    }),
+    new winston.transports.File({ filename: "combined.log", flags: "w" }),
+  ],
+});
+
+class transferCommissionBot {
+  constructor() {
+    this.db = new DB();
+    this.cmBot = new cmBot();
+    this.pages = [];
+    this.pages_idle = [];
+  }
+
+  async init(page_length) {
+    for (let i = 0; i < page_length; i++) {
+      const page = await this.cmBot.createNewPage();
+      this.pages.push(page);
+      this.pages_idle.push(true); // true is mean idle
+    }
+  }
+
+  async getCommissionCredit(page) {
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        await this.cmBot.loadUserProfilePage(page);
+        await page.waitForSelector("tr", { visible: true, timeout: 5000 });
+        const trs = await page.$$("tr");
+        for (const tr of trs) {
+          const tds = await tr.$$("td");
+          if (
+            tds[0] &&
+            (await tds[0].evaluate((el) => el.textContent)) === "Credit Available"
+          ) {
+            const text = await tds[2].evaluate((el) => el.textContent);
+            const match = text.match(/\d+(\.\d+)?/);
+            return match ? match[0] : null;
+          }
+        }
+        throw new Error(`Failed to get commission credit after ${attempt} attempt(s)`);
+      } catch (error) {
+        if (attempt < 3) {
+          logger.warn(`Failed to get commission credit after ${attempt} attempt(s)`);
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+
+  async transferCredit(page, acc) {
+    try {
+      await this.cmBot.login(page, acc.f_username, acc.f_password);
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      logger.info(`User: ${acc.f_username}, logged in successfully`);
+      const commission = parseFloat(await this.getCommissionCredit(page));
+      logger.info(`User: ${acc.f_username}, commission: ${commission}`);
+      if (commission <= 0.01) {
+        logger.warn(
+          `Skipping transfer for ${acc.f_username} due to insufficient commission`
+        );
+      } else {
+        await this.cmBot.fillTransferForm(
+          page,
+          acc.t_username,
+          acc.t_password,
+          (commission - 0.01).toString()
+        );
+        logger.info(
+          `Successfully transferred ${commission} credit from ${acc.f_username} to ${acc.t_username}`
+        );
+      }
+    } catch (error) {
+      logger.error(
+        `Error transferring credit from ${acc.f_username}: ${error.message}`
+      );
+      if (error.message.includes("unable to login")) {
+        logger.warn(`Skipping transfer for ${acc.f_username} due to login failure`);
+      } else if (error.message.includes("wrong sec pin")) {
+        logger.warn(`Skipping transfer for ${acc.f_username} due to wrong sec pin`);
+      }
+    }
+  }
+
+  async getPagesIdleIndex() {
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        const index = this.pages_idle.findIndex((page) => page === true);
+        if (index !== -1) {
+          clearInterval(interval);
+          resolve(index);
+        }
+      }, 1000);
+    });
+  }
+
+  async transferCommission() {
+    console.log("Transfer commission is running");
+
+    const response = await axios.get('https://api2.luckytown888.net/user');
+    const accs = response.data;
+
+    const progressBar = new Progress(
+      ":bar [:current/:total] [:percent] [:elapsed]",
+      {
+        complete: "=",
+        incomplete: " ",
+        width: 20,
+        total: accs.length,
+      }
+    );
+
+    await Promise.all(
+      accs.map(async (acc) => {
+        if (
+          acc.f_password &&
+          acc.f_password !== "" &&
+          acc.f_password !== "na" &&
+          acc.t_password !== ""
+        ) {
+          const page_index = await this.getPagesIdleIndex();
+          this.pages_idle[page_index] = false;
+          await this.transferCredit(this.pages[page_index], acc);
+          this.pages_idle[page_index] = true;
+        }
+        progressBar.tick();
+      })
+    );
+  }
+
+  async closeAllPages() {
+    for (const page of this.pages) {
+      this.cmBot.close(page);
+    }
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    const [numPages] = process.argv.slice(2);
+    const bot = new transferCommissionBot();
+    await bot.init(numPages ? Number(numPages) : 1);
+    await bot.transferCommission();
+    await bot.closeAllPages();
+  })();
+}
+
+module.exports = transferCommissionBot;

src/visualWebApi.cjs

@@ -0,0 +1,77 @@
+const express = require("express");
+const cors = require("cors");
+const app = express();
+const DB = require("./db");
+const port = 3000;
+
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.post("/update-acc-data", async (req, res) => {
+  const { username, password, status, link } = req.body;
+  const db = new DB();
+  try {
+    await db.query(
+      "UPDATE acc SET password = ?, status = ? , link = ? WHERE username = ?",
+      [password, status, link, username]
+    );
+    res.send("Data updated successfully");
+  } catch (error) {
+    console.error(error);
+    res.status(500).send("Error updating data");
+  }
+});
+
+app.post("/update-user-data", async (req, res) => {
+    const { f_username, f_password, t_username, t_password } = req.body;
+    const db = new DB();
+    try {
+      await db.query(
+        "UPDATE user SET f_password = ?, t_password = ?, t_username = ? WHERE f_username = ?",
+        [f_password, t_password, t_username, f_username]
+      );
+      res.send("Data updated successfully");
+    } catch (error) {
+      console.error(error);
+      res.status(500).send("Error updating data");
+    }
+  });
+
+app.get("/acc/:username?", async (req, res) => {
+  const db = new DB();
+  const { username } = req.params;
+  try {
+    const query = username
+      ? "SELECT username, password, status, link FROM acc WHERE username = ?"
+      : "SELECT username, password, status, link FROM acc";
+    const queryParams = username ? [username] : [];
+    const results = await db.query(query, queryParams);
+    res.json(results);
+  } catch (error) {
+    console.error(error);
+    res.status(404).send("Not Found");
+  }
+});
+
+app.get("/user/:f_username?", async (req, res) => {
+    const db = new DB();
+    const { f_username } = req.params;
+    try {
+      const query = f_username
+        ? "SELECT f_username, f_password, t_username, t_password FROM user WHERE f_username = ?"
+        : "SELECT f_username, f_password, t_username, t_password FROM user";
+      const queryParams = f_username ? [f_username] : [];
+      const results = await db.query(query, queryParams);
+      res.json(results);
+    } catch (error) {
+      console.error(error);
+      res.status(404).send("Not Found");
+    }
+  });
+
+
+app.listen(port, () => {
+  console.log(`Visual Web App Listening at Port : ${port}`);
+});
+