goat
command
Unknown
No description
0
views
0
likes
0
installs
raw source
const fs = require('fs');
const path = require('path');
const os = require('os');
const crypto = require('crypto');
const { GIFEncoder } = require('gif-encoder-2');
const { createCanvas, loadImage } = require('canvas');
// ---------------------------------------------------------------------------
// SAFE FILESYSTEM / PATH HELPERS
// These wrappers make sure we never hand fs/path a non-string value, which
// was the root cause of:
// TypeError [ERR_INVALID_ARG_TYPE]: The "path" argument must be of type string
// ---------------------------------------------------------------------------
function toSafeString(value, fallback = '') {
if (typeof value === 'string') return value;
if (value === null || value === undefined) return fallback;
try {
return String(value);
} catch {
return fallback;
}
}
function safeJoin(...parts) {
const cleanParts = parts
.map(p => toSafeString(p, null))
.filter(p => p !== null && p !== '');
if (cleanParts.length === 0) return null;
try {
return path.join(...cleanParts);
} catch (err) {
console.error('[safeJoin] Failed to join path parts:', parts, err.message);
return null;
}
}
function safeExists(targetPath) {
if (typeof targetPath !== 'string' || targetPath.length === 0) return false;
try {
return fs.existsSync(targetPath);
} catch {
return false;
}
}
function safeStat(targetPath) {
if (!safeExists(targetPath)) return null;
try {
return fs.statSync(targetPath);
} catch (err) {
console.error(`[safeStat] Failed to stat ${targetPath}:`, err.message);
return null;
}
}
function safeReadDir(targetPath) {
if (!safeExists(targetPath)) return [];
try {
return fs.readdirSync(targetPath);
} catch (err) {
console.error(`[safeReadDir] Failed to read dir ${targetPath}:`, err.message);
return [];
}
}
function safeReadFile(targetPath, encoding = 'utf8') {
if (!safeExists(targetPath)) return null;
try {
return fs.readFileSync(targetPath, encoding);
} catch (err) {
console.error(`[safeReadFile] Failed to read file ${targetPath}:`, err.message);
return null;
}
}
function safeUnlink(targetPath) {
if (!safeExists(targetPath)) return false;
try {
fs.unlinkSync(targetPath);
return true;
} catch (err) {
console.error(`[safeUnlink] Failed to delete file ${targetPath}:`, err.message);
return false;
}
}
function safeRequireJson(targetPath, fallback = {}) {
if (!safeExists(targetPath)) return fallback;
try {
delete require.cache[require.resolve(targetPath)];
return require(targetPath);
} catch (err) {
console.error(`[safeRequireJson] Failed to require ${targetPath}:`, err.message);
return fallback;
}
}
module.exports = {
name: 'cpannel',
aliases: ['qm', 'dash', 'qmonitor', 'nexus'],
description: 'Ultra premium quantum holographic live monitor with AI analytics',
usage: '!quantummonitor [mode] [theme] [interval]',
category: 'Quantum Systems',
cooldown: 60,
premium: true,
adminOnly: true,
role: '2',
version: '5.1.0',
author: 'Badhon-00',
config: {
modes: ['quantum', 'hologram', 'neural', 'matrix', 'cyber', 'infinity'],
themes: ['dark', 'neon', 'cosmic', 'midnight', 'aurora', 'plasma'],
intervals: [1, 2, 5, 10, 30, 60],
maxHistoryPoints: 100,
aiPredictionEnabled: true,
holographicMode: true,
onStart: true
},
async onStart(client) {
try {
const botInfo = await this.getAdvancedBotInfo(client);
console.log(`[QUANTUM MONITOR] System initialized for ${botInfo.name} v${botInfo.version}`);
console.log(`[QUANTUM MONITOR] FCA Type: ${botInfo.fca.type}`);
console.log(`[QUANTUM MONITOR] Commands: ${botInfo.commands} | Events: ${botInfo.events}`);
console.log(`[QUANTUM MONITOR] Author: ${botInfo.author}`);
if (!client.quantumSystems) {
client.quantumSystems = new Map();
}
return true;
} catch (error) {
console.error('[QUANTUM MONITOR] Failed to initialize:', error);
return false;
}
},
async execute(client, message, args) {
try {
const safeArgs = Array.isArray(args) ? args.map(a => toSafeString(a, '')) : [];
const mode = safeArgs[0] ? safeArgs[0].toLowerCase() : 'quantum';
const theme = safeArgs[1] ? safeArgs[1].toLowerCase() : 'cosmic';
const parsedInterval = parseInt(safeArgs[2], 10);
const interval = Math.min(Number.isNaN(parsedInterval) ? 5 : parsedInterval, 60);
if (!this.config.modes.includes(mode)) {
return message.reply(`❌ Invalid mode! Available: ${this.config.modes.join(', ')}`);
}
if (!this.config.themes.includes(theme)) {
return message.reply(`❌ Invalid theme! Available: ${this.config.themes.join(', ')}`);
}
const quantumSignature = this.generateQuantumSignature();
await this.playLoadingSequence(message);
const channelName = `🌌-quantum-nexus-${quantumSignature.slice(0, 8)}`;
let monitorChannel = await this.setupMonitorChannel(message, channelName);
await this.initializeQuantumSystem(client, monitorChannel, mode, theme, interval, quantumSignature);
await this.sendActivationMessage(message, quantumSignature, mode, theme, interval);
} catch (error) {
console.error('Quantum Monitor Error:', error);
await this.sendErrorEmbed(message, error);
}
},
generateQuantumSignature() {
const timestamp = Date.now().toString(36);
const entropy = crypto.randomBytes(16).toString('hex');
const quantumHash = crypto.createHash('sha256')
.update(timestamp + entropy + os.hostname())
.digest('hex')
.toUpperCase();
return `QN-${quantumHash.slice(0, 16)}-${timestamp}`;
},
async playLoadingSequence(message) {
const loadingStages = [
'🔮 Initializing Quantum Core...',
'🌌 Calibrating Holographic Display...',
'⚡ Activating Neural Networks...',
'🧬 Analyzing Bot DNA...',
'🔬 Scanning File Structure...',
'💾 Loading System Metrics...',
'🎯 Synchronizing Quantum Entanglement...',
'✨ Activating Premium Features...'
];
const loadingMsg = await message.reply('🚀 Starting Quantum Monitor...');
try {
for (let i = 0; i < loadingStages.length; i++) {
const progress = Math.round(((i + 1) / loadingStages.length) * 100);
const progressBar = '█'.repeat(Math.floor(progress / 10)) + '░'.repeat(10 - Math.floor(progress / 10));
await loadingMsg.edit({
embeds: [{
color: 0x00ffff,
title: '🌌 QUANTUM SYSTEM INITIALIZATION',
description: `\`\`\`\n${loadingStages[i]}\n\`\`\`\n**Progress:** ${progress}%\n${progressBar}\n\n**Quantum Signature:** \`Generating...\``,
footer: { text: 'Quantum Holographic Monitor System v5.1' }
}]
});
await new Promise(resolve => setTimeout(resolve, 500));
}
} catch (err) {
console.error('[playLoadingSequence] Failed to update loading message:', err.message);
} finally {
await loadingMsg.delete().catch(() => {});
}
},
async setupMonitorChannel(message, channelName) {
let monitorChannel = message.guild.channels.cache.find(ch => ch.name === channelName);
if (!monitorChannel) {
monitorChannel = await message.guild.channels.create(channelName, {
type: 'GUILD_TEXT',
topic: '🌌 Quantum Holographic Monitor - Premium System',
permissionOverwrites: [
{
id: message.guild.id,
deny: ['SEND_MESSAGES', 'ADD_REACTIONS'],
allow: ['VIEW_CHANNEL', 'READ_MESSAGE_HISTORY']
},
{
id: message.author.id,
allow: ['SEND_MESSAGES', 'MANAGE_MESSAGES', 'ADD_REACTIONS']
}
]
});
}
return monitorChannel;
},
async initializeQuantumSystem(client, channel, mode, theme, interval, signature) {
try {
const messages = await channel.messages.fetch({ limit: 100 });
await channel.bulkDelete(messages).catch(() => {});
} catch (err) {
console.error('[initializeQuantumSystem] Failed to clear channel:', err.message);
}
if (!client.quantumSystems) {
client.quantumSystems = new Map();
}
// If a monitor already exists for this channel, clear its old interval first
const existing = client.quantumSystems.get(channel.id);
if (existing && existing.intervalId) {
clearInterval(existing.intervalId);
}
const quantumState = {
mode,
theme,
interval,
signature,
startTime: Date.now(),
history: [],
predictions: [],
anomalies: [],
performanceMetrics: []
};
client.quantumSystems.set(channel.id, quantumState);
this.startQuantumLoop(client, channel, quantumState);
},
async startQuantumLoop(client, channel, quantumState) {
const intervalId = setInterval(async () => {
try {
await this.updateQuantumDisplay(client, channel, quantumState);
} catch (error) {
console.error('Quantum Loop Error:', error);
}
}, quantumState.interval * 1000);
quantumState.intervalId = intervalId;
await this.updateQuantumDisplay(client, channel, quantumState);
},
async updateQuantumDisplay(client, channel, quantumState) {
let canvasBuffer = null;
try {
const botData = await this.collectQuantumData(client);
const embed = await this.generateQuantumEmbed(botData, quantumState);
const prediction = this.generateAIPredictions(botData, quantumState);
try {
canvasBuffer = await this.generateQuantumCanvas(botData, quantumState);
} catch (canvasErr) {
console.error('[updateQuantumDisplay] Canvas generation failed:', canvasErr.message);
canvasBuffer = null;
}
quantumState.history.push(botData);
if (quantumState.history.length > this.config.maxHistoryPoints) {
quantumState.history.shift();
}
quantumState.predictions = prediction;
quantumState.anomalies = this.detectAnomalies(botData, quantumState.history);
try {
const messages = await channel.messages.fetch({ limit: 10 });
await channel.bulkDelete(messages).catch(() => {});
} catch (clearErr) {
console.error('[updateQuantumDisplay] Failed to clear old messages:', clearErr.message);
}
const payload = { embeds: [embed] };
if (canvasBuffer) {
payload.files = [{
attachment: canvasBuffer,
name: `quantum-${quantumState.mode}-${Date.now()}.png`
}];
}
await channel.send(payload);
if (quantumState.anomalies.length > 0) {
await this.sendAnomalyAlerts(channel, quantumState.anomalies);
}
} catch (error) {
console.error('[updateQuantumDisplay] Unexpected failure:', error);
} finally {
// Nothing persistent to clean up here since we generate PNG buffers
// in-memory rather than temp files, but this guarantees we never
// leak references if future code starts writing to disk.
canvasBuffer = null;
}
},
async collectQuantumData(client) {
const botInfo = await this.getAdvancedBotInfo(client);
const systemInfo = this.getAdvancedSystemInfo();
const fileInfo = this.getAdvancedFileInfo();
const networkInfo = await this.getAdvancedNetworkInfo(client);
const securityInfo = this.getSecurityInfo();
const analyticsInfo = this.getAnalyticsInfo(botInfo, systemInfo);
return {
timestamp: Date.now(),
bot: botInfo,
system: systemInfo,
files: fileInfo,
network: networkInfo,
security: securityInfo,
analytics: analyticsInfo,
quantum: {
entropy: crypto.randomBytes(4).readUInt32LE(0) / 0xFFFFFFFF,
coherence: Math.random() * 100,
entanglement: Math.random() * 100,
superposition: Math.random() * 100
}
};
},
async getAdvancedBotInfo(client) {
const packageJsonPath = safeJoin(process.cwd(), 'package.json');
const packageJson = safeRequireJson(packageJsonPath, {});
const botName = packageJson.name || 'GoatBot';
const version = packageJson.version || '5.1.0';
const author = packageJson.author || 'Badhon-00';
const fcaInfo = this.detectAdvancedFCA();
const uptime = process.uptime();
const startDate = new Date(Date.now() - uptime * 1000);
const botAge = this.calculateBotAge(packageJsonPath);
return {
name: botName,
version,
author,
fca: fcaInfo,
uptime: this.formatUptime(uptime),
startDate,
botAge,
guilds: client?.guilds?.cache?.size ?? 0,
users: client?.users?.cache?.size ?? 0,
channels: client?.channels?.cache?.size ?? 0,
commands: this.countAdvancedCommands(),
events: this.countAdvancedEvents(),
modules: this.countModules(),
features: this.detectFeatures(client)
};
},
detectAdvancedFCA() {
const fcaTypes = [
'fca-unofficial',
'fca-horizon',
'fca-remastered',
'fca-advanced',
'fca-premium',
'fca-ultimate',
'facebook-chat-api',
'fca-core'
];
for (const fca of fcaTypes) {
const fcaPath = safeJoin(process.cwd(), 'node_modules', fca);
if (fcaPath && safeExists(fcaPath)) {
const fcaPackagePath = safeJoin(fcaPath, 'package.json');
const fcaPackage = safeRequireJson(fcaPackagePath, {});
return {
type: fca,
version: fcaPackage.version || 'unknown',
author: fcaPackage.author || 'unknown',
location: 'node_modules'
};
}
}
const srcPath = safeJoin(process.cwd(), 'src');
if (srcPath && safeExists(srcPath)) {
const srcFiles = safeReadDir(srcPath);
for (const file of srcFiles) {
const safeFile = toSafeString(file, '');
if (safeFile.includes('fca') || safeFile.includes('facebook')) {
return {
type: `src/${safeFile}`,
version: 'custom',
author: 'custom',
location: 'src'
};
}
}
}
const packageJsonPath = safeJoin(process.cwd(), 'package.json');
const packageJson = safeRequireJson(packageJsonPath, {});
const deps = { ...(packageJson.dependencies || {}), ...(packageJson.devDependencies || {}) };
for (const dep of Object.keys(deps)) {
if (dep.includes('fca') || dep.includes('facebook')) {
return {
type: dep,
version: deps[dep],
author: 'npm',
location: 'package.json'
};
}
}
return {
type: 'unknown',
version: 'N/A',
author: 'N/A',
location: 'N/A'
};
},
calculateBotAge(packageJsonPath) {
const safePkgPath = packageJsonPath || safeJoin(process.cwd(), 'package.json');
const stats = safeStat(safePkgPath);
if (!stats) {
return { days: 0, months: 0, years: 0, created: new Date() };
}
const createdDate = stats.birthtime;
const ageDays = Math.floor((Date.now() - createdDate.getTime()) / 86400000);
return {
days: ageDays,
months: Math.floor(ageDays / 30),
years: Math.floor(ageDays / 365),
created: createdDate
};
},
formatUptime(uptime) {
const days = Math.floor(uptime / 86400);
const hours = Math.floor((uptime % 86400) / 3600);
const minutes = Math.floor((uptime % 3600) / 60);
const seconds = Math.floor(uptime % 60);
return { days, hours, minutes, seconds, total: uptime };
},
getAdvancedSystemInfo() {
const totalMem = os.totalmem();
const freeMem = os.freemem();
const usedMem = totalMem - freeMem;
const cpus = os.cpus() || [];
// ROM / disk usage (best-effort, cross-platform safe fallback).
// fs.statfsSync is only available on Node 18.15+/19.6+, so we guard it.
let disk = { total: 0, free: 0, used: 0, usagePercent: 0, available: false };
try {
if (typeof fs.statfsSync === 'function') {
const stat = fs.statfsSync(process.cwd());
const total = stat.blocks * stat.bsize;
const free = stat.bfree * stat.bsize;
disk = {
total,
free,
used: total - free,
usagePercent: total > 0 ? ((total - free) / total) * 100 : 0,
available: true
};
}
} catch (err) {
console.error('[getAdvancedSystemInfo] Disk stats unavailable:', err.message);
}
// GPU info: Node.js/os module has no native GPU API. We report
// "unavailable" rather than fabricating data, and note how to add
// real GPU stats (e.g. via the optional 'systeminformation' package)
// if the host environment supports it.
let gpu = { available: false, note: 'Install "systeminformation" package for real GPU stats' };
try {
// Optional dependency - only used if already installed, never required as a hard dependency.
const si = require('systeminformation');
gpu = { available: true, viaSystemInformation: true, module: si };
} catch {
// systeminformation not installed - keep the safe fallback above.
}
return {
platform: os.platform(),
arch: os.arch(),
cpu: cpus[0]?.model || 'Unknown CPU',
cores: cpus.length,
memory: {
total: totalMem,
free: freeMem,
used: usedMem,
usagePercent: totalMem > 0 ? (usedMem / totalMem) * 100 : 0
},
disk,
gpu,
node: process.version,
pid: process.pid,
uptime: os.uptime(),
load: os.loadavg(),
network: os.networkInterfaces()
};
},
getAdvancedFileInfo() {
const rootDir = toSafeString(process.cwd(), '.');
const allFiles = this.getAllFilesAdvanced(rootDir);
const fileInfo = {
total: allFiles.length,
size: 0,
types: {},
folders: {},
commands: [],
events: [],
configs: [],
modules: [],
recent: []
};
allFiles.forEach(file => {
const stats = safeStat(file);
if (!stats) return;
const ext = path.extname(file).toLowerCase();
const relative = path.relative(rootDir, file);
const folder = path.dirname(relative);
fileInfo.size += stats.size;
fileInfo.types[ext] = (fileInfo.types[ext] || 0) + 1;
fileInfo.folders[folder] = (fileInfo.folders[folder] || 0) + 1;
if (relative.includes('command')) fileInfo.commands.push(relative);
if (relative.includes('event')) fileInfo.events.push(relative);
if (relative.includes('config')) fileInfo.configs.push(relative);
if (relative.includes('module')) fileInfo.modules.push(relative);
if (Date.now() - stats.mtimeMs < 86400000) {
fileInfo.recent.push({
path: relative,
modified: stats.mtime,
size: stats.size
});
}
});
fileInfo.sizeMB = (fileInfo.size / 1024 / 1024).toFixed(2);
fileInfo.sizeKB = (fileInfo.size / 1024).toFixed(2);
return fileInfo;
},
getAllFilesAdvanced(dir, depth = 0, maxDepth = 10) {
const safeDir = toSafeString(dir, null);
if (!safeDir || depth > maxDepth || !safeExists(safeDir)) return [];
const files = [];
const skipDirs = ['node_modules', '.git', 'dist', 'build', 'coverage', '.cache'];
const items = safeReadDir(safeDir);
items.forEach(item => {
const safeItem = toSafeString(item, null);
if (!safeItem) return;
const fullPath = safeJoin(safeDir, safeItem);
if (!fullPath) return;
const stat = safeStat(fullPath);
if (!stat) return;
if (stat.isDirectory()) {
if (!skipDirs.includes(safeItem)) {
files.push(...this.getAllFilesAdvanced(fullPath, depth + 1, maxDepth));
}
} else {
if (!safeItem.startsWith('.')) {
files.push(fullPath);
}
}
});
return files;
},
async getAdvancedNetworkInfo(client) {
const guilds = client?.guilds?.cache;
if (!guilds) {
return {
totalGuilds: 0,
totalMembers: 0,
avgMembers: 0,
topGuilds: [],
ping: client?.ws?.ping ?? -1,
status: client?.ws?.status ?? 'unknown'
};
}
const totalMembers = guilds.reduce((acc, guild) => acc + (guild.memberCount || 0), 0);
const topGuilds = guilds
.sort((a, b) => (b.memberCount || 0) - (a.memberCount || 0))
.first(15)
.map((guild, index) => ({
rank: index + 1,
name: guild.name,
members: guild.memberCount,
channels: guild.channels?.cache?.size ?? 0,
roles: guild.roles?.cache?.size ?? 0,
boostLevel: guild.premiumTier,
boostCount: guild.premiumSubscriptionCount,
region: guild.preferredLocale,
created: guild.createdAt
}));
return {
totalGuilds: guilds.size,
totalMembers,
avgMembers: guilds.size > 0 ? totalMembers / guilds.size : 0,
topGuilds,
ping: client.ws?.ping ?? -1,
status: client.ws?.status ?? 'unknown'
};
},
getSecurityInfo() {
const envPath = safeJoin(process.cwd(), '.env');
const configPath = safeJoin(process.cwd(), 'config.json');
return {
tokenEncrypted: process.env.TOKEN ? '✅ Encrypted' : '❌ Not Encrypted',
envFile: safeExists(envPath) ? '✅ Present' : '❌ Missing',
configFile: safeExists(configPath) ? '✅ Present' : '❌ Missing',
permissions: this.checkPermissions(),
vulnerabilities: this.scanVulnerabilities()
};
},
checkPermissions() {
const perms = [];
const cwd = toSafeString(process.cwd(), '.');
try {
fs.accessSync(cwd, fs.constants.W_OK);
perms.push('✅ Write Access');
} catch {
perms.push('❌ No Write Access');
}
try {
fs.accessSync(cwd, fs.constants.R_OK);
perms.push('✅ Read Access');
} catch {
perms.push('❌ No Read Access');
}
return perms;
},
scanVulnerabilities() {
const vulnerabilities = [];
const files = this.getAllFilesAdvanced(process.cwd(), 0, 2);
files.forEach(file => {
const content = safeReadFile(file, 'utf8');
if (content === null) return;
if (content.includes('TOKEN') && !file.includes('.env')) {
vulnerabilities.push(`⚠️ Token exposed in ${path.basename(file)}`);
}
if (content.includes('PASSWORD') && !file.includes('.env')) {
vulnerabilities.push(`⚠️ Password exposed in ${path.basename(file)}`);
}
});
return vulnerabilities;
},
getAnalyticsInfo(botInfo, systemInfo) {
return {
efficiency: this.calculateEfficiency(botInfo),
stability: this.calculateStability(systemInfo),
growth: this.calculateGrowth(botInfo),
performance: this.calculatePerformance(botInfo, systemInfo),
score: this.calculateOverallScore(botInfo, systemInfo)
};
},
calculateEfficiency(botInfo) {
const commandEfficiency = Math.min((botInfo.commands / 100) * 100, 100);
const moduleEfficiency = Math.min((botInfo.modules / 50) * 100, 100);
return (commandEfficiency + moduleEfficiency) / 2;
},
calculateStability(systemInfo) {
const memoryStability = 100 - systemInfo.memory.usagePercent;
const loadStability = Math.max(0, 100 - (systemInfo.load[0] / 8) * 100);
return (memoryStability + loadStability) / 2;
},
calculateGrowth(botInfo) {
const ageInDays = botInfo.botAge.days || 1;
const guildGrowth = (botInfo.guilds / ageInDays) * 10;
const userGrowth = (botInfo.users / ageInDays) * 10;
return Math.min(guildGrowth + userGrowth, 100);
},
calculatePerformance(botInfo, systemInfo) {
const uptimeScore = Math.min((botInfo.uptime.total / 86400) * 100, 100);
const memoryScore = 100 - systemInfo.memory.usagePercent;
return (uptimeScore + memoryScore) / 2;
},
calculateOverallScore(botInfo, systemInfo) {
const efficiency = this.calculateEfficiency(botInfo);
const stability = this.calculateStability(systemInfo);
const growth = this.calculateGrowth(botInfo);
const performance = this.calculatePerformance(botInfo, systemInfo);
return (efficiency + stability + growth + performance) / 4;
},
generateAIPredictions(botData, quantumState) {
if (!this.config.aiPredictionEnabled || quantumState.history.length < 10) {
return [];
}
const predictions = [];
const history = quantumState.history;
const guildHistory = history.map(h => h.bot.guilds);
const guildTrend = this.calculateTrend(guildHistory);
predictions.push({
metric: 'Guild Growth',
current: botData.bot.guilds,
predicted: botData.bot.guilds + guildTrend * 10,
trend: guildTrend > 0 ? '📈 Increasing' : guildTrend < 0 ? '📉 Decreasing' : '➡️ Stable',
confidence: this.calculateConfidence(guildHistory)
});
const memHistory = history.map(h => h.system.memory.usagePercent);
const memTrend = this.calculateTrend(memHistory);
predictions.push({
metric: 'Memory Usage',
current: botData.system.memory.usagePercent,
predicted: botData.system.memory.usagePercent + memTrend * 10,
trend: memTrend > 0 ? '📈 Increasing' : memTrend < 0 ? '📉 Decreasing' : '➡️ Stable',
confidence: this.calculateConfidence(memHistory)
});
const cmdHistory = history.map(h => h.bot.commands);
const cmdTrend = this.calculateTrend(cmdHistory);
predictions.push({
metric: 'Commands',
current: botData.bot.commands,
predicted: botData.bot.commands + cmdTrend * 5,
trend: cmdTrend > 0 ? '📈 Growing' : cmdTrend < 0 ? '📉 Shrinking' : '➡️ Stable',
confidence: this.calculateConfidence(cmdHistory)
});
return predictions;
},
calculateTrend(history) {
if (history.length < 2) return 0;
const x = Array.from({ length: history.length }, (_, i) => i);
const y = history;
const n = x.length;
const sumX = x.reduce((a, b) => a + b, 0);
const sumY = y.reduce((a, b) => a + b, 0);
const sumXY = x.reduce((a, b, i) => a + b * y[i], 0);
const sumXX = x.reduce((a, b) => a + b * b, 0);
const denominator = (n * sumXX - sumX * sumX);
if (denominator === 0) return 0;
return (n * sumXY - sumX * sumY) / denominator;
},
calculateConfidence(history) {
if (history.length < 2) return 0;
const mean = history.reduce((a, b) => a + b, 0) / history.length;
if (mean === 0) return 0;
const variance = history.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / history.length;
const stdDev = Math.sqrt(variance);
return Math.max(0, Math.min(100, 100 - (stdDev / mean) * 100));
},
detectAnomalies(botData, history) {
const anomalies = [];
if (history.length < 5) return anomalies;
const prevData = history[history.length - 2];
if (!prevData) return anomalies;
const memChange = botData.system.memory.usagePercent - prevData.system.memory.usagePercent;
if (Math.abs(memChange) > 20) {
anomalies.push({
type: 'Memory',
severity: 'HIGH',
message: `Memory usage changed by ${memChange.toFixed(2)}% suddenly`,
timestamp: new Date()
});
}
const guildChange = botData.bot.guilds - prevData.bot.guilds;
if (Math.abs(guildChange) > 10) {
anomalies.push({
type: 'Network',
severity: 'MEDIUM',
message: `Guild count changed by ${guildChange} servers`,
timestamp: new Date()
});
}
if (botData.network.ping > 1000) {
anomalies.push({
type: 'Performance',
severity: 'HIGH',
message: `High ping detected: ${botData.network.ping}ms`,
timestamp: new Date()
});
}
return anomalies;
},
async sendAnomalyAlerts(channel, anomalies) {
const embed = {
color: 0xff0000,
title: '⚠️ QUANTUM ANOMALY DETECTED',
description: anomalies.map(a =>
`**${a.type}** (${a.severity})\n${a.message}\n*Detected: <t:${Math.floor(a.timestamp.getTime() / 1000)}:R>*`
).join('\n\n'),
footer: { text: 'Quantum Holographic Monitor System' },
timestamp: new Date()
};
await channel.send({ embeds: [embed] }).catch(err => {
console.error('[sendAnomalyAlerts] Failed to send alert:', err.message);
});
},
async generateQuantumCanvas(botData, quantumState) {
const width = 1600;
const height = 900;
let canvas = null;
try {
canvas = createCanvas(width, height);
const ctx = canvas.getContext('2d');
const theme = this.getThemeColors(quantumState.theme);
this.createHolographicBackground(ctx, width, height, theme, quantumState);
this.drawQuantumGrid(ctx, width, height, theme);
await this.drawQuantumDashboard(ctx, botData, quantumState, theme);
this.drawHolographicEffects(ctx, width, height, theme, quantumState);
this.drawQuantumParticles(ctx, width, height, theme, quantumState);
this.drawQuantumWatermark(ctx, quantumState, theme);
return canvas.toBuffer('image/png');
} catch (error) {
console.error('[generateQuantumCanvas] Rendering failed:', error.message);
throw error;
} finally {
// node-canvas buffers are garbage collected normally, but we
// drop our reference explicitly so a failed render doesn't
// keep a half-drawn canvas pinned in memory.
canvas = null;
}
},
getThemeColors(theme) {
const themes = {
dark: {
bg1: '#0a0a0a', bg2: '#1a1a1a',
primary: '#ffffff', secondary: '#888888',
accent: '#00ff00', glow: 'rgba(0, 255, 0, 0.5)',
grid: 'rgba(255, 255, 255, 0.1)'
},
neon: {
bg1: '#000033', bg2: '#330066',
primary: '#00ffff', secondary: '#ff00ff',
accent: '#ffff00', glow: 'rgba(0, 255, 255, 0.5)',
grid: 'rgba(0, 255, 255, 0.2)'
},
cosmic: {
bg1: '#0a0020', bg2: '#200040',
primary: '#8a2be2', secondary: '#9370db',
accent: '#da70d6', glow: 'rgba(138, 43, 226, 0.5)',
grid: 'rgba(138, 43, 226, 0.2)'
},
midnight: {
bg1: '#000010', bg2: '#001030',
primary: '#4169e1', secondary: '#6495ed',
accent: '#87ceeb', glow: 'rgba(65, 105, 225, 0.5)',
grid: 'rgba(65, 105, 225, 0.2)'
},
aurora: {
bg1: '#001010', bg2: '#003030',
primary: '#00ff7f', secondary: '#00ced1',
accent: '#7fffd4', glow: 'rgba(0, 255, 127, 0.5)',
grid: 'rgba(0, 255, 127, 0.2)'
},
plasma: {
bg1: '#100010', bg2: '#301030',
primary: '#ff00ff', secondary: '#ff1493',
accent: '#ff69b4', glow: 'rgba(255, 0, 255, 0.5)',
grid: 'rgba(255, 0, 255, 0.2)'
}
};
return themes[theme] || themes.cosmic;
},
createHolographicBackground(ctx, width, height, theme, quantumState) {
const gradient = ctx.createLinearGradient(0, 0, width, height);
gradient.addColorStop(0, theme.bg1);
gradient.addColorStop(1, theme.bg2);
ctx.fillStyle = gradient;
ctx.fillRect(0, 0, width, height);
const time = Date.now() / 1000;
for (let i = 0; i < 10; i++) {
const y = (height / 10) * i + Math.sin(time + i) * 50;
const alpha = 0.05 + (i / 10) * 0.1;
ctx.fillStyle = theme.glow.replace('0.5', alpha.toString());
ctx.beginPath();
ctx.moveTo(0, y);
for (let x = 0; x <= width; x += 50) {
const waveY = y + Math.sin(x * 0.01 + time * 2 + i) * 30;
ctx.lineTo(x, waveY);
}
ctx.lineTo(width, height);
ctx.lineTo(0, height);
ctx.closePath();
ctx.fill();
}
},
drawQuantumGrid(ctx, width, height, theme) {
ctx.strokeStyle = theme.grid;
ctx.lineWidth = 1;
for (let x = 0; x < width; x += 50) {
ctx.beginPath();
ctx.moveTo(x, 0);
ctx.lineTo(x, height);
ctx.stroke();
}
for (let y = 0; y < height; y += 50) {
ctx.beginPath();
ctx.moveTo(0, y);
ctx.lineTo(width, y);
ctx.stroke();
}
ctx.strokeStyle = theme.grid.replace('0.2', '0.05');
for (let i = -height; i < width; i += 100) {
ctx.beginPath();
ctx.moveTo(i, 0);
ctx.lineTo(i + height, height);
ctx.stroke();
}
},
async drawQuantumDashboard(ctx, botData, quantumState, theme) {
ctx.fillStyle = theme.primary;
ctx.font = 'bold 44px Arial';
ctx.textAlign = 'center';
ctx.shadowColor = theme.glow;
ctx.shadowBlur = 20;
ctx.fillText('🌌 QUANTUM HOLOGRAPHIC MONITOR', 800, 55);
ctx.shadowBlur = 0;
const gb = botData.system.gpu?.available ? 'Available' : 'N/A (needs systeminformation)';
const diskLine = botData.system.disk?.available
? `Disk: ${(botData.system.disk.used / 1024 / 1024 / 1024).toFixed(2)}/${(botData.system.disk.total / 1024 / 1024 / 1024).toFixed(2)} GB (${botData.system.disk.usagePercent.toFixed(1)}%)`
: 'Disk: N/A on this platform';
this.drawInfoPanel(ctx, 50, 90, 500, 310, 'BOT INFORMATION', [
`Name: ${botData.bot.name}`,
`Version: ${botData.bot.version}`,
`Author: ${botData.bot.author}`,
`FCA: ${botData.bot.fca.type}`,
`Uptime: ${botData.bot.uptime.days}d ${botData.bot.uptime.hours}h ${botData.bot.uptime.minutes}m`,
`Age: ${botData.bot.botAge.days} days`,
`Commands: ${botData.bot.commands}`,
`Events: ${botData.bot.events}`,
`Modules: ${botData.bot.modules}`
], theme);
this.drawInfoPanel(ctx, 550, 90, 500, 310, 'SYSTEM INFORMATION', [
`Platform: ${botData.system.platform} ${botData.system.arch}`,
`CPU: ${botData.system.cpu}`,
`Cores: ${botData.system.cores}`,
`RAM: ${(botData.system.memory.used / 1024 / 1024 / 1024).toFixed(2)}/${(botData.system.memory.total / 1024 / 1024 / 1024).toFixed(2)} GB`,
diskLine,
`GPU: ${gb}`,
`Node.js: ${botData.system.node}`,
`PID: ${botData.system.pid}`,
`Load: ${botData.system.load.map(l => l.toFixed(2)).join(', ')}`
], theme);
this.drawInfoPanel(ctx, 1050, 90, 500, 310, 'FILE STATISTICS', [
`Total Files: ${botData.files.total}`,
`Total Size: ${botData.files.sizeMB} MB`,
`Commands: ${botData.files.commands.length}`,
`Events: ${botData.files.events.length}`,
`Configs: ${botData.files.configs.length}`,
`Modules: ${botData.files.modules.length}`,
`Recent: ${botData.files.recent.length} files modified`
], theme);
this.drawInfoPanel(ctx, 50, 420, 500, 260, 'NETWORK STATISTICS', [
`Servers: ${botData.network.totalGuilds}`,
`Members: ${botData.network.totalMembers}`,
`Avg Members: ${botData.network.avgMembers.toFixed(0)}`,
`Ping: ${botData.network.ping}ms`,
`Status: ${botData.network.status}`
], theme);
this.drawInfoPanel(ctx, 550, 420, 500, 260, 'SECURITY STATUS', [
`Token: ${botData.security.tokenEncrypted}`,
`Env File: ${botData.security.envFile}`,
`Config: ${botData.security.configFile}`,
...botData.security.permissions
], theme);
this.drawInfoPanel(ctx, 1050, 420, 500, 260, 'AI ANALYTICS', [
`Efficiency: ${botData.analytics.efficiency.toFixed(2)}%`,
`Stability: ${botData.analytics.stability.toFixed(2)}%`,
`Growth: ${botData.analytics.growth.toFixed(2)}%`,
`Performance: ${botData.analytics.performance.toFixed(2)}%`,
`Overall Score: ${botData.analytics.score.toFixed(2)}%`
], theme);
},
drawInfoPanel(ctx, x, y, width, height, title, lines, theme) {
ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
ctx.fillRect(x, y, width, height);
ctx.strokeStyle = theme.glow;
ctx.lineWidth = 2;
ctx.strokeRect(x, y, width, height);
ctx.fillStyle = theme.accent;
ctx.font = 'bold 20px Arial';
ctx.textAlign = 'left';
ctx.fillText(title, x + 20, y + 35);
ctx.fillStyle = theme.primary;
ctx.font = '15px Arial';
lines.forEach((line, index) => {
ctx.fillText(line, x + 20, y + 62 + index * 24);
});
},
drawHolographicEffects(ctx, width, height, theme, quantumState) {
const time = Date.now() / 1000;
for (let i = 0; i < 20; i++) {
const x = (Math.sin(time + i) + 1) * width / 2;
const y = (Math.cos(time * 0.7 + i) + 1) * height / 2;
const radius = 2 + Math.sin(time + i) * 1.5;
const gradient = ctx.createRadialGradient(x, y, 0, x, y, radius * 3);
gradient.addColorStop(0, theme.glow);
gradient.addColorStop(1, 'rgba(0, 0, 0, 0)');
ctx.fillStyle = gradient;
ctx.beginPath();
ctx.arc(x, y, radius * 3, 0, Math.PI * 2);
ctx.fill();
}
},
drawQuantumParticles(ctx, width, height, theme, quantumState) {
const time = Date.now() / 1000;
for (let i = 0; i < 50; i++) {
const x = (Math.sin(time * 0.5 + i * 0.7) + 1) * width / 2;
const y = (Math.cos(time * 0.3 + i * 0.5) + 1) * height / 2;
ctx.fillStyle = theme.accent;
ctx.globalAlpha = 0.3 + Math.sin(time + i) * 0.2;
ctx.beginPath();
ctx.arc(x, y, 2, 0, Math.PI * 2);
ctx.fill();
}
ctx.globalAlpha = 1;
},
drawQuantumWatermark(ctx, quantumState, theme) {
ctx.fillStyle = theme.secondary;
ctx.font = '16px Arial';
ctx.textAlign = 'right';
ctx.fillText(`Signature: ${quantumState.signature}`, 1580, 860);
ctx.fillText('Created by Badhon-00', 1580, 880);
},
async generateQuantumEmbed(botData, quantumState) {
const embed = {
color: 0x8a2be2,
title: '🌌 QUANTUM MONITOR UPDATE',
description: `**Signature:** \`${quantumState.signature}\`\n**Mode:** ${quantumState.mode.toUpperCase()}\n**Theme:** ${quantumState.theme.toUpperCase()}`,
fields: [
{
name: '🤖 Bot Info',
value: `Name: ${botData.bot.name}\nVersion: ${botData.bot.version}\nAuthor: ${botData.bot.author}\nFCA: ${botData.bot.fca.type}`,
inline: true
},
{
name: '💻 System',
value: `Platform: ${botData.system.platform}\nCPU: ${botData.system.cpu}\nCores: ${botData.system.cores}\nNode: ${botData.system.node}`,
inline: true
},
{
name: '📊 Stats',
value: `Commands: ${botData.bot.commands}\nEvents: ${botData.bot.events}\nFiles: ${botData.files.total}\nPing: ${botData.network.ping}ms`,
inline: true
}
],
footer: { text: 'Quantum Monitor v5.1.0 | Author: Badhon-00' },
timestamp: new Date()
};
if (quantumState.predictions.length > 0) {
embed.fields.push({
name: '🔮 AI Predictions',
value: quantumState.predictions.map(p =>
`${p.metric}: ${p.trend} (${p.confidence.toFixed(1)}% confidence)`
).join('\n'),
inline: false
});
}
return embed;
},
async sendActivationMessage(message, signature, mode, theme, interval) {
const embed = {
color: 0x00ff00,
title: '✅ QUANTUM MONITOR ACTIVATED',
description: `**Signature:** \`${signature}\`\n**Mode:** ${mode.toUpperCase()}\n**Theme:** ${theme.toUpperCase()}\n**Update Interval:** ${interval} seconds`,
fields: [
{
name: '📊 Monitored Data',
value: '• Bot Information\n• System Metrics (CPU, RAM, Disk, GPU)\n• File Statistics\n• Network Status & Ping\n• Security Status\n• AI Analytics'
},
{
name: '⚡ Premium Features',
value: '• Real-time Updates\n• AI Predictions\n• Anomaly Detection\n• Quantum Visualization\n• Holographic Display'
}
],
footer: { text: 'Quantum Monitor v5.1.0 | Author: Badhon-00' },
timestamp: new Date()
};
await message.reply({ embeds: [embed] });
},
async sendErrorEmbed(message, error) {
const embed = {
color: 0xff0000,
title: '❌ QUANTUM SYSTEM FAILURE',
description: `An error occurred in the quantum monitoring system.\n\n**Error:** ${error?.message || 'Unknown error'}`,
footer: { text: 'Check system logs for details' },
timestamp: new Date()
};
await message.reply({ embeds: [embed] }).catch(() => {});
},
countAdvancedCommands() {
const dirs = ['commands', 'cmd', 'modules/commands', 'src/commands'];
for (const dir of dirs) {
const fullPath = safeJoin(process.cwd(), dir);
if (fullPath && safeExists(fullPath)) {
return this.countJSFiles(fullPath);
}
}
return 0;
},
countAdvancedEvents() {
const dirs = ['events', 'event', 'modules/events', 'src/events'];
for (const dir of dirs) {
const fullPath = safeJoin(process.cwd(), dir);
if (fullPath && safeExists(fullPath)) {
return this.countJSFiles(fullPath);
}
}
return 0;
},
countModules() {
const dirs = ['modules', 'src/modules', 'lib', 'utils'];
for (const dir of dirs) {
const fullPath = safeJoin(process.cwd(), dir);
if (fullPath && safeExists(fullPath)) {
return this.countJSFiles(fullPath);
}
}
return 0;
},
countJSFiles(dir) {
const safeDir = toSafeString(dir, null);
if (!safeDir || !safeExists(safeDir)) return 0;
let count = 0;
const items = safeReadDir(safeDir);
items.forEach(item => {
const safeItem = toSafeString(item, null);
if (!safeItem) return;
const fullPath = safeJoin(safeDir, safeItem);
if (!fullPath) return;
const stat = safeStat(fullPath);
if (!stat) return;
if (stat.isDirectory()) {
count += this.countJSFiles(fullPath);
} else if (safeItem.endsWith('.js')) {
count++;
}
});
return count;
},
detectFeatures(client) {
const features = [];
if (!client) return features;
if (client.commands) features.push('Command Handler');
if (client.events) features.push('Event Handler');
if (client.database) features.push('Database');
if (client.economy) features.push('Economy System');
if (client.leveling) features.push('Leveling System');
if (client.music) features.push('Music System');
if (client.moderation) features.push('Moderation');
if (client.automod) features.push('Auto Moderation');
if (client.welcome) features.push('Welcome System');
if (client.logging) features.push('Logging System');
if (client.customCommands) features.push('Custom Commands');
if (client.reactionRoles) features.push('Reaction Roles');
if (client.tickets) features.push('Ticket System');
if (client.giveaways) features.push('Giveaway System');
if (client.polls) features.push('Poll System');
return features;
}
};