@roidev/kachina-md 1.0.0

package/lib/client/Client.js

@@ -0,0 +1,257 @@
+import makeWASocket, {
+    DisconnectReason,
+    useMultiFileAuthState,
+    makeInMemoryStore,
+    makeCacheableSignalKeyStore,
+    fetchLatestBaileysVersion
+} from 'baileys';
+import { Boom } from '@hapi/boom';
+import pino from 'pino';
+import qrcode from 'qrcode-terminal';
+import EventEmitter from 'events';
+import { serialize } from '../helpers/serialize.js';
+import { PluginHandler } from '../handlers/PluginHandler.js';
+
+export class Client extends EventEmitter {
+    constructor(options = {}) {
+        super();
+
+        this.config = {
+            sessionId: options.sessionId || 'kachina-session',
+            phoneNumber: options.phoneNumber || '',
+            printQRInTerminal: options.printQRInTerminal !== false,
+            loginMethod: options.loginMethod || 'qr', // 'qr' or 'pairing'
+            browser: options.browser || ['Kachina-MD', 'Chrome', '1.0.0'],
+            logger: options.logger || pino({ level: 'silent' }),
+            ...options
+        };
+
+        this.sock = null;
+        this.store = null;
+        this.isReady = false;
+        this.pluginHandler = new PluginHandler(this);
+    }
+
+    async start() {
+        const { state, saveCreds } = await useMultiFileAuthState(this.config.sessionId);
+        const { version } = await fetchLatestBaileysVersion();
+
+        if (this.config.useStore) {
+            this.store = makeInMemoryStore({
+                logger: pino().child({ level: 'silent', stream: 'store' })
+            });
+        }
+
+        this.sock = makeWASocket({
+            version,
+            auth: {
+                creds: state.creds,
+                keys: makeCacheableSignalKeyStore(state.keys, this.config.logger)
+            },
+            logger: this.config.logger,
+            printQRInTerminal: this.config.printQRInTerminal && this.config.loginMethod === 'qr',
+            browser: this.config.browser,
+            getMessage: async (key) => {
+                if (this.store) {
+                    const msg = await this.store.loadMessage(key.remoteJid, key.id);
+                    return msg?.message || undefined;
+                }
+                return { conversation: '' };
+            }
+        });
+
+        if (this.store) {
+            this.store.bind(this.sock.ev);
+        }
+
+        this.sock.ev.on('creds.update', saveCreds);
+
+        this.sock.ev.on('connection.update', async (update) => {
+            await this.handleConnectionUpdate(update);
+        });
+
+        this.sock.ev.on('messages.upsert', async ({ messages, type }) => {
+            if (type !== 'notify') return;
+
+            for (const message of messages) {
+                const m = await serialize(message, this.sock);
+                this.emit('message', m);
+
+                // Auto plugin handler
+                if (this.pluginHandler.isLoaded && m.body?.startsWith(this.config.prefix || '!')) {
+                    await this.pluginHandler.execute(m);
+                }
+            }
+        });
+
+        this.sock.ev.on('group-participants.update', (update) => {
+            this.emit('group.update', update);
+        });
+
+        this.sock.ev.on('groups.update', (updates) => {
+            this.emit('groups.update', updates);
+        });
+
+        this.sock.ev.on('call', (calls) => {
+            this.emit('call', calls);
+        });
+
+        return this.sock;
+    }
+
+    async handleConnectionUpdate(update) {
+        const { connection, lastDisconnect, qr } = update;
+
+        if (qr && this.config.loginMethod === 'qr') {
+            qrcode.generate(qr, { small: true });
+        }
+
+        if (connection === 'close') {
+            const shouldReconnect = (lastDisconnect?.error instanceof Boom)
+                ? lastDisconnect.error.output.statusCode !== DisconnectReason.loggedOut
+                : true;
+
+            if (shouldReconnect) {
+                this.emit('reconnecting');
+                await this.start();
+            } else {
+                this.emit('logout');
+            }
+        } else if (connection === 'open') {
+            this.isReady = true;
+            this.user = this.sock.user;
+            this.emit('ready', this.user);
+
+            // Request pairing code if needed
+            if (!this.sock.authState.creds.registered && this.config.loginMethod === 'pairing') {
+                if (this.config.phoneNumber) {
+                    setTimeout(async () => {
+                        const code = await this.sock.requestPairingCode(this.config.phoneNumber);
+                        this.emit('pairing.code', code);
+                    }, 3000);
+                }
+            }
+        } else if (connection === 'connecting') {
+            this.emit('connecting');
+        }
+    }
+
+    // Helper methods
+    async sendMessage(jid, content, options = {}) {
+        return await this.sock.sendMessage(jid, content, options);
+    }
+
+    async sendText(jid, text, options = {}) {
+        return await this.sendMessage(jid, { text }, options);
+    }
+
+    async sendImage(jid, buffer, caption = '', options = {}) {
+        const content = {
+            image: buffer,
+            ...options
+        };
+        if (caption) content.caption = caption;
+        return await this.sendMessage(jid, content, options);
+    }
+
+    async sendVideo(jid, buffer, caption = '', options = {}) {
+        const content = {
+            video: buffer,
+            ...options
+        };
+        if (caption) content.caption = caption;
+        return await this.sendMessage(jid, content, options);
+    }
+
+    async sendAudio(jid, buffer, options = {}) {
+        const content = {
+            audio: buffer,
+            mimetype: options.mimetype || 'audio/mp4',
+            ptt: options.ptt || false, // Push to talk (voice note)
+            ...options
+        };
+        return await this.sendMessage(jid, content, options);
+    }
+
+    async sendDocument(jid, buffer, filename, mimetype, options = {}) {
+        return await this.sendMessage(jid, {
+            document: buffer,
+            fileName: filename,
+            mimetype,
+            ...options
+        });
+    }
+
+    async sendSticker(jid, buffer, options = {}) {
+        return await this.sendMessage(jid, {
+            sticker: buffer,
+            ...options
+        });
+    }
+
+    async sendContact(jid, contacts, options = {}) {
+        // contacts = [{ displayName, vcard }]
+        return await this.sendMessage(jid, {
+            contacts: { contacts },
+            ...options
+        });
+    }
+
+    async sendLocation(jid, latitude, longitude, options = {}) {
+        return await this.sendMessage(jid, {
+            location: { degreesLatitude: latitude, degreesLongitude: longitude },
+            ...options
+        });
+    }
+
+    async sendPoll(jid, name, values, options = {}) {
+        return await this.sendMessage(jid, {
+            poll: {
+                name,
+                values,
+                selectableCount: options.selectableCount || 1
+            },
+            ...options
+        });
+    }
+
+    async sendReact(jid, messageKey, emoji) {
+        return await this.sendMessage(jid, {
+            react: { text: emoji, key: messageKey }
+        });
+    }
+
+    async groupMetadata(jid) {
+        return await this.sock.groupMetadata(jid);
+    }
+
+    async groupParticipantsUpdate(jid, participants, action) {
+        return await this.sock.groupParticipantsUpdate(jid, participants, action);
+    }
+
+    async groupUpdateSubject(jid, subject) {
+        return await this.sock.groupUpdateSubject(jid, subject);
+    }
+
+    async groupUpdateDescription(jid, description) {
+        return await this.sock.groupUpdateDescription(jid, description);
+    }
+
+    async loadPlugin(path) {
+        await this.pluginHandler.load(path);
+    }
+
+    async loadPlugins(directory) {
+        await this.pluginHandler.loadAll(directory);
+    }
+
+    get prefix() {
+        return this.config.prefix || '!';
+    }
+
+    set prefix(prefix) {
+        this.config.prefix = prefix;
+    }
+}
+
+export default Client;

package/lib/handlers/PluginHandler.js

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export class PluginHandler {
+    constructor(client) {
+        this.client = client;
+        this.plugins = new Map();
+        this.commands = new Map();
+        this.isLoaded = false;
+    }
+
+    async load(pluginPath) {
+        try {
+            const module = await import(`file://${pluginPath}?update=${Date.now()}`);
+
+            if (!module.default && !module.handler) {
+                throw new Error('Plugin must export default or handler');
+            }
+
+            const plugin = module.default || module.handler;
+
+            // Validate plugin
+            if (!plugin.name) {
+                plugin.name = path.basename(pluginPath, '.js');
+            }
+
+            if (!plugin.exec && !plugin.execute) {
+                throw new Error('Plugin must have exec or execute function');
+            }
+
+            // Normalize commands
+            const commands = Array.isArray(plugin.command)
+                ? plugin.command
+                : plugin.commands
+                    ? Array.isArray(plugin.commands)
+                        ? plugin.commands
+                        : [plugin.commands]
+                    : [plugin.name];
+
+            plugin.commands = commands.map(cmd => cmd.toLowerCase());
+
+            // Store plugin
+            this.plugins.set(plugin.name, plugin);
+
+            // Map commands to plugin
+            for (const cmd of plugin.commands) {
+                this.commands.set(cmd, plugin);
+            }
+
+            return plugin;
+        } catch (error) {
+            console.error(`Failed to load plugin ${pluginPath}:`, error.message);
+            return null;
+        }
+    }
+
+    async loadAll(directory) {
+        if (!fs.existsSync(directory)) {
+            console.warn(`Plugin directory not found: ${directory}`);
+            return;
+        }
+
+        const files = this.findFiles(directory, '.js');
+
+        let loaded = 0;
+        for (const file of files) {
+            const plugin = await this.load(file);
+            if (plugin) loaded++;
+        }
+
+        this.isLoaded = true;
+        console.log(`Loaded ${loaded}/${files.length} plugins`);
+
+        return loaded;
+    }
+
+    findFiles(dir, ext) {
+        let results = [];
+        const list = fs.readdirSync(dir);
+
+        for (const file of list) {
+            const filePath = path.join(dir, file);
+            const stat = fs.statSync(filePath);
+
+            if (stat && stat.isDirectory()) {
+                results = results.concat(this.findFiles(filePath, ext));
+            } else if (file.endsWith(ext)) {
+                results.push(filePath);
+            }
+        }
+
+        return results;
+    }
+
+    async execute(m) {
+        if (!m.body) return;
+
+        // Parse command
+        const prefix = this.client.config.prefix || '!';
+        if (!m.body.startsWith(prefix)) return;
+
+        const [cmdName, ...args] = m.body.slice(prefix.length).trim().split(/\s+/);
+        const command = cmdName.toLowerCase();
+
+        // Find plugin
+        const plugin = this.commands.get(command);
+        if (!plugin) return;
+
+        // Check conditions
+        if (plugin.owner && !this.isOwner(m.sender)) {
+            return await m.reply('⚠️ This command is for owner only!');
+        }
+
+        if (plugin.group && !m.isGroup) {
+            return await m.reply('⚠️ This command can only be used in groups!');
+        }
+
+        if (plugin.private && m.isGroup) {
+            return await m.reply('⚠️ This command can only be used in private chat!');
+        }
+
+        if (plugin.admin && m.isGroup) {
+            const groupMetadata = await this.client.groupMetadata(m.chat);
+            const participants = groupMetadata.participants;
+            const admins = participants.filter(p => p.admin).map(p => p.id);
+
+            if (!admins.includes(m.sender)) {
+                return await m.reply('⚠️ This command is for group admins only!');
+            }
+        }
+
+        if (plugin.botAdmin && m.isGroup) {
+            const groupMetadata = await this.client.groupMetadata(m.chat);
+            const participants = groupMetadata.participants;
+            const admins = participants.filter(p => p.admin).map(p => p.id);
+            const botNumber = this.client.user.id.split(':')[0] + '@s.whatsapp.net';
+
+            if (!admins.includes(botNumber)) {
+                return await m.reply('⚠️ Bot must be admin to use this command!');
+            }
+        }
+
+        // Execute plugin
+        try {
+            const exec = plugin.exec || plugin.execute;
+            await exec({
+                client: this.client,
+                m,
+                args,
+                command,
+                prefix,
+                sock: this.client.sock
+            });
+        } catch (error) {
+            console.error(`Error executing ${command}:`, error);
+            await m.reply(`❌ Error: ${error.message}`);
+        }
+    }
+
+    isOwner(jid) {
+        const owners = this.client.config.owners || this.client.config.owner || [];
+        const ownerList = Array.isArray(owners) ? owners : [owners];
+        const number = jid.split('@')[0];
+        return ownerList.includes(number) || ownerList.includes(jid);
+    }
+
+    reload(pluginName) {
+        const plugin = this.plugins.get(pluginName);
+        if (!plugin) return false;
+
+        // Remove from maps
+        for (const cmd of plugin.commands) {
+            this.commands.delete(cmd);
+        }
+        this.plugins.delete(pluginName);
+
+        return true;
+    }
+
+    list() {
+        return Array.from(this.plugins.values());
+    }
+
+    get(name) {
+        return this.plugins.get(name);
+    }
+}
+
+export default PluginHandler;

package/lib/helpers/database.js

@@ -0,0 +1,117 @@
+import { Low } from 'lowdb';
+import { JSONFile } from 'lowdb/node';
+import fs from 'fs';
+import path from 'path';
+
+export class Database {
+    constructor(options = {}) {
+        this.path = options.path || './database';
+        this.collections = new Map();
+
+        // Ensure database directory exists
+        if (!fs.existsSync(this.path)) {
+            fs.mkdirSync(this.path, { recursive: true });
+        }
+    }
+
+    async collection(name, defaultData = {}) {
+        if (this.collections.has(name)) {
+            return this.collections.get(name);
+        }
+
+        const filePath = path.join(this.path, `${name}.json`);
+        const adapter = new JSONFile(filePath);
+        const db = new Low(adapter, defaultData);
+
+        await db.read();
+        db.data ||= defaultData;
+        await db.write();
+
+        this.collections.set(name, db);
+        return db;
+    }
+
+    async get(collection, key, defaultValue = null) {
+        const db = await this.collection(collection, {});
+        await db.read();
+        return db.data[key] ?? defaultValue;
+    }
+
+    async set(collection, key, value) {
+        const db = await this.collection(collection, {});
+        await db.read();
+        db.data[key] = value;
+        await db.write();
+        return value;
+    }
+
+    async has(collection, key) {
+        const db = await this.collection(collection, {});
+        await db.read();
+        return key in db.data;
+    }
+
+    async delete(collection, key) {
+        const db = await this.collection(collection, {});
+        await db.read();
+        delete db.data[key];
+        await db.write();
+        return true;
+    }
+
+    async all(collection) {
+        const db = await this.collection(collection, {});
+        await db.read();
+        return db.data;
+    }
+
+    async clear(collection) {
+        const db = await this.collection(collection, {});
+        db.data = {};
+        await db.write();
+        return true;
+    }
+
+    async update(collection, key, updater) {
+        const db = await this.collection(collection, {});
+        await db.read();
+
+        if (typeof updater === 'function') {
+            db.data[key] = updater(db.data[key]);
+        } else {
+            db.data[key] = { ...db.data[key], ...updater };
+        }
+
+        await db.write();
+        return db.data[key];
+    }
+
+    async increment(collection, key, field, amount = 1) {
+        return await this.update(collection, key, (data) => {
+            data = data || {};
+            data[field] = (data[field] || 0) + amount;
+            return data;
+        });
+    }
+
+    async push(collection, key, value) {
+        return await this.update(collection, key, (data) => {
+            data = data || [];
+            if (Array.isArray(data)) {
+                data.push(value);
+            }
+            return data;
+        });
+    }
+
+    async pull(collection, key, value) {
+        return await this.update(collection, key, (data) => {
+            if (Array.isArray(data)) {
+                return data.filter(item => item !== value);
+            }
+            return data;
+        });
+    }
+}
+
+export default Database;

package/lib/helpers/index.js

@@ -0,0 +1,74 @@
+export { serialize } from './serialize.js';
+export { Database } from './database.js';
+export { Logger } from './logger.js';
+export * from './sticker.js';
+
+// Utility functions
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export function formatTime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+
+    if (days > 0) return `${days}d ${hours}h ${minutes}m`;
+    if (hours > 0) return `${hours}h ${minutes}m ${secs}s`;
+    if (minutes > 0) return `${minutes}m ${secs}s`;
+    return `${secs}s`;
+}
+
+export function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+export function parseCommand(text, prefix = '!') {
+    if (!text.startsWith(prefix)) return null;
+
+    const [command, ...args] = text.slice(prefix.length).trim().split(/\s+/);
+    return {
+        command: command.toLowerCase(),
+        args,
+        text: args.join(' ')
+    };
+}
+
+export function isUrl(text) {
+    return /^https?:\/\//i.test(text);
+}
+
+export function extractUrls(text) {
+    const urlRegex = /https?:\/\/[^\s]+/gi;
+    return text.match(urlRegex) || [];
+}
+
+export function randomString(length = 10) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+
+export function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export function pickRandom(array) {
+    return array[Math.floor(Math.random() * array.length)];
+}
+
+export function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}

package/lib/helpers/logger.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+
+export class Logger {
+    constructor(options = {}) {
+        this.level = options.level || 'info';
+        this.prefix = options.prefix || '';
+        this.levels = {
+            debug: 0,
+            info: 1,
+            success: 1,
+            warn: 2,
+            error: 3
+        };
+    }
+
+    shouldLog(level) {
+        return this.levels[level] >= this.levels[this.level];
+    }
+
+    format(level, ...args) {
+        const timestamp = new Date().toLocaleTimeString();
+        const prefix = this.prefix ? `[${this.prefix}] ` : '';
+        return `${chalk.gray(timestamp)} ${prefix}${args.join(' ')}`;
+    }
+
+    debug(...args) {
+        if (this.shouldLog('debug')) {
+            console.log(chalk.gray('[DEBUG]'), this.format('debug', ...args));
+        }
+    }
+
+    info(...args) {
+        if (this.shouldLog('info')) {
+            console.log(chalk.blue('[INFO]'), this.format('info', ...args));
+        }
+    }
+
+    success(...args) {
+        if (this.shouldLog('success')) {
+            console.log(chalk.green('[SUCCESS]'), this.format('success', ...args));
+        }
+    }
+
+    warn(...args) {
+        if (this.shouldLog('warn')) {
+            console.log(chalk.yellow('[WARN]'), this.format('warn', ...args));
+        }
+    }
+
+    error(...args) {
+        if (this.shouldLog('error')) {
+            console.error(chalk.red('[ERROR]'), this.format('error', ...args));
+        }
+    }
+
+    command(command, from) {
+        console.log(
+            chalk.cyan('[CMD]'),
+            chalk.yellow(command),
+            chalk.gray('from'),
+            chalk.green(from)
+        );
+    }
+}
+
+export default Logger;