MultiAccounts on Same Server LyFeLevanter Bot

YoBot.js

const fs = require('fs').promises;
const path = require('path');
const { bot, sleep } = require('../lib');
const { restartInstance } = require('../lib/pm2');


const T1 = "Converting, Restarting Bot, wait a moment...";
const T2 = "Session Manager";
const T3 = "Add new session:";
const T4 = "Delete session:";
const T5 = "Remember to READ the Tutorial:";
const T6 = "Get Session ID:";
const T7 = "Incorrect format";
const T8 = "Session added!";
const T9 = "Key:";
const T10 = "Session ID:";
const T11 = "THE BOT WILL RESTART NOW";
const T12 = "Session deleted";
const T13 = "not found";
const T14 = "Specify the session to delete. Example:";
const T15 = "Error:";

const defaultSessionConfig = {
    "PREFIX": "^[.,!/]",
    "SUDO": "0",
    "STICKER_PACKNAME": "💝ByLyfe",
    "ALWAYS_ONLINE": "false",
    "FORCE_LOGOUT": "false",
    "REJECT_CALL": "false",
    "AUTO_STATUS_VIEW": "false",
    "SEND_READ": "false",
    "AJOIN": "false",
    "PERSONAL_MESSAGE": "null",
    "DISABLE_START_MESSAGE": "false",
    "CMD_REACTION": "true"
};

class SessionManager {
  constructor() {
    this.configPath = path.join(process.cwd(), 'config.json');
    this.envPath = path.join(process.cwd(), 'config.env');
    this.dbPath = path.join(process.cwd(), 'database.db');
  }

  async checkAndDeleteDatabase() {
    try {
      await fs.access(this.configPath);
    } catch (configError) {
      if (configError.code === 'ENOENT') {
        try {
          await fs.access(this.dbPath);
          await fs.unlink(this.dbPath);
          console.log('Database.db eliminado');
        } catch (dbError) {
          if (dbError.code !== 'ENOENT') {
            console.error('yobot-PLUGIN Error eliminando database:', dbError);
          }
        }
      }
    }
  }

  async loadConfig() {
    try {
      const configData = await fs.readFile(this.configPath, 'utf8');
      return JSON.parse(configData);
    } catch (error) {
      if (error.code === 'ENOENT') {
        return null;
      }
      throw error;
    }
  }

  async saveConfig(config) {
    await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf8');
  }

  async loadEnvFile() {
    try {
      const envData = await fs.readFile(this.envPath, 'utf8');
      const envVars = {};
      
      const lines = envData.split('\n');
      for (const line of lines) {
        const trimmedLine = line.trim();
        
       
        if (!trimmedLine || trimmedLine.startsWith('#')) continue;
        
       
        const match = trimmedLine.match(/^([^=]+)=(.*)$/);
        if (match) {
          const key = match[1].trim();
          let value = match[2].trim();
          
          
          if ((value.startsWith('"') && value.endsWith('"')) || 
              (value.startsWith("'") && value.endsWith("'"))) {
            value = value.slice(1, -1);
          }
          
          envVars[key] = value;
        }
      }
      
      return envVars;
    } catch (error) {
      console.error('Error leyendo config.env:', error);
      return {};
    }
  }

  extractFirstSudo(sudoString) {
    if (!sudoString) return null;
    const firstNumber = sudoString.split(',')[0].trim();
    return firstNumber || null;
  }

  async getEnvVars(ctx) {
    
    const firstSudo = ctx.SUDO ? this.extractFirstSudo(ctx.SUDO) : null;
    const stickerPackname = ctx.STICKER_PACKNAME || null;
    
    return {
      SUDO: firstSudo,
      STICKER_PACKNAME: stickerPackname
    };
  }

  getNextSessionNumber(config) {
    const sessionKeys = Object.keys(config).filter(key => key.startsWith('session'));
    if (sessionKeys.length === 0) return 1;
    
    const sessionNumbers = sessionKeys.map(key => {
      const match = key.match(/session(\d+)/);
      return match ? parseInt(match[1], 10) : 0;
    });
    
    return Math.max(...sessionNumbers) + 1;
  }

  async convertEnvToJson() {
    try {
      const envVars = await this.loadEnvFile();
      
      if (Object.keys(envVars).length === 0) {
        return {
          success: false,
          error: 'config.env not found or empty'
        };
      }

      const config = {};
      const sessionKey = 'session1';
      
      
      config[sessionKey] = {};
      
      
      for (const [key, value] of Object.entries(envVars)) {
        config[sessionKey][key] = value;
      }
      
      
      for (const [key, defaultValue] of Object.entries(defaultSessionConfig)) {
        if (key !== 'SUDO' && key !== 'STICKER_PACKNAME' && !config[sessionKey][key]) {
          config[sessionKey][key] = defaultValue;
        }
      }
      
      await this.saveConfig(config);
      
      return {
        success: true,
        sessionKey,
        converted: true
      };
    } catch (error) {
      console.error('Error en conversión:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  async addSession(sessionId, ctx) {
    try {
      const config = await this.loadConfig();
      
      if (!sessionId.toLowerCase().includes('levanter')) {
        return {
          success: false,
          error: 'INVALID_SESSION_FORMAT'
        };
      }

      
      if (!config) {
        await this.checkAndDeleteDatabase();
      }

      const currentConfig = config || {};
      const nextSessionNumber = this.getNextSessionNumber(currentConfig);
      const sessionKey = `session${nextSessionNumber}`;
      
      
      const envVars = await this.getEnvVars(ctx);
      
      currentConfig[sessionKey] = {
        SESSION_ID: sessionId,
        ...defaultSessionConfig
      };
      
      
      if (envVars.SUDO) {
        currentConfig[sessionKey].SUDO = envVars.SUDO;
      }
      if (envVars.STICKER_PACKNAME) {
        currentConfig[sessionKey].STICKER_PACKNAME = envVars.STICKER_PACKNAME;
      }
      
      await this.saveConfig(currentConfig);
      
      return {
        success: true,
        sessionKey,
        sessionNumber: nextSessionNumber,
        needsRestart: true
      };
    } catch (error) {
      console.error(`yobot-PLUGIN Error adding session: ${error.message}`);
      return {
        success: false,
        error: error.message
      };
    }
  }

  async deleteSession(sessionIdentifier) {
    try {
      const config = await this.loadConfig();
      
      if (!config) {
        return {
          success: false,
          error: 'config.json not found'
        };
      }
      
      let sessionKey = sessionIdentifier;
      
      if (/^\d+$/.test(sessionIdentifier)) {
        sessionKey = `session${sessionIdentifier}`;
      }
      
      if (config[sessionKey]) {
        delete config[sessionKey];
        await this.saveConfig(config);
        return {
          success: true,
          sessionKey,
          needsRestart: true
        };
      } else {
        return {
          success: false,
          error: `${T13}: ${sessionKey}`
        };
      }
    } catch (error) {
      console.error(`yobot-PLUGIN Error deleting session: ${error.message}`);
      return {
        success: false,
        error: error.message
      };
    }
  }
}

const sessionManager = new SessionManager();

bot(
  {
    pattern: 'yobot ?(.*)',
    fromMe: true,
    desc: 'Session Manager',
    type: 'config',
  },
  async (message, match, ctx) => {
    const input = match.trim();
    
    // Comando sin nada
    if (!input) {
      const config = await sessionManager.loadConfig();
      
      // env conver 
      if (!config) {
        await message.send(
          `⚙️ ${T1}\n\n` +
          `> 🗝️ *${T2}*\n` +
          `${T3}\n\`yobot\` <sessionId>\n` +
          `${T4}\n\`yobot del\` <number/key>\n` +
          `⚠️ *${T5}*\n` +
          `${T6}\nlevanter-delta.vercel.app/`,
          { quoted: message.data }
        );
        
        const result = await sessionManager.convertEnvToJson();
        
        if (result.success) {
          await sleep(2000);
          restartInstance();
        } else {
          await message.send(`❌ ${T15} ${result.error}`);
        }
        return;
      }
      
      
      await message.send(
        `> 🗝️ *${T2}*\n` +
        `${T3}\n\`yobot\` <sessionId>\n` +
        `${T4}\n\`yobot del\` <number/key>\n` +
        `⚠️ *${T5}*\n` +
        `${T6}\nlevanter-delta.vercel.app/`,
        { quoted: message.data }
      );
      return;
    }

    // eliminar sess
    if (input.startsWith('del ')) {
      const sessionIdentifier = input.substring(4).trim();
      if (!sessionIdentifier) {
        await message.send(`${T14} \`.yobot del 3\``);
        return;
      }
      
      const result = await sessionManager.deleteSession(sessionIdentifier);
      if (result.success) {
        await message.send(`✅ ${T12}: *${result.sessionKey}*`);
        if (result.needsRestart) {
          await sleep(2000);
          restartInstance();
        }
      } else {
        await message.send(`❌ ${T15} ${result.error}`);
      }
      return;
    }

    // add sess
    const sessionId = input;
    if (!sessionId.toLowerCase().includes('levanter')) {
      await message.send(
        `🔒 ${T7}\n` +
        `⚠️ *${T5}*`,
        { quoted: message.data }
      );
      return;
    }

    try {
      const result = await sessionManager.addSession(sessionId, ctx);
      
      if (result.success) {
        await message.send(
          `✅ *${T8}*\n` +
          `📝 ${T9}\n> ${result.sessionKey}\n` +
          `🔑 ${T10}\n> ${sessionId}\n` +
          `⚠️ *${T5}*\n` +
          `‼️ *${T11}* ‼️`,
          { quoted: message.data }
        );
        
        if (result.needsRestart) {
          await sleep(2000);
          restartInstance();
        }
      } else {
        if (result.error === 'INVALID_SESSION_FORMAT') {
          await message.send(
            `🔒 ${T7}\n` +
            `⚠️ *${T5}*`,
            { quoted: message.data }
          );
        } else {
          await message.send(
            `❌ ${T15} ${result.error}`,
            { quoted: message.data }
          );
        }
      }
    } catch (error) {
      console.error(`yobot-PLUGIN Error: ${error.message}`);
      await message.send(
        `❌ ${T15} ${error.message}`,
        { quoted: message.data }
      );
    }
  }
);

module.exports = { sessionManager };