540 lines
17 KiB
JavaScript
540 lines
17 KiB
JavaScript
const SystemCommandBase = require('../../classes/SystemCommandBase');
|
|
const { SlashCommandBuilder } = require('discord.js');
|
|
|
|
class PM2Control extends SystemCommandBase {
|
|
constructor(client) {
|
|
super(client);
|
|
this.name = 'pm2';
|
|
this.description = 'Control PM2 processes';
|
|
}
|
|
|
|
addOptions(builder) {
|
|
return builder
|
|
.addSubcommand(subcommand =>
|
|
subcommand
|
|
.setName('list')
|
|
.setDescription('List all PM2 processes')
|
|
)
|
|
.addSubcommand(subcommand =>
|
|
subcommand
|
|
.setName('info')
|
|
.setDescription('Get detailed information about a PM2 process')
|
|
.addStringOption(option =>
|
|
option
|
|
.setName('process')
|
|
.setDescription('Process name or ID')
|
|
.setRequired(true)
|
|
.setAutocomplete(true)
|
|
)
|
|
)
|
|
.addSubcommand(subcommand =>
|
|
subcommand
|
|
.setName('start')
|
|
.setDescription('Start a PM2 process')
|
|
.addStringOption(option =>
|
|
option
|
|
.setName('process')
|
|
.setDescription('Process name or ID')
|
|
.setRequired(true)
|
|
.setAutocomplete(true)
|
|
)
|
|
)
|
|
.addSubcommand(subcommand =>
|
|
subcommand
|
|
.setName('stop')
|
|
.setDescription('Stop a PM2 process')
|
|
.addStringOption(option =>
|
|
option
|
|
.setName('process')
|
|
.setDescription('Process name or ID')
|
|
.setRequired(true)
|
|
.setAutocomplete(true)
|
|
)
|
|
)
|
|
.addSubcommand(subcommand =>
|
|
subcommand
|
|
.setName('restart')
|
|
.setDescription('Restart a PM2 process')
|
|
.addStringOption(option =>
|
|
option
|
|
.setName('process')
|
|
.setDescription('Process name or ID')
|
|
.setRequired(true)
|
|
.setAutocomplete(true)
|
|
)
|
|
)
|
|
.addSubcommand(subcommand =>
|
|
subcommand
|
|
.setName('logs')
|
|
.setDescription('Show recent logs for a PM2 process')
|
|
.addStringOption(option =>
|
|
option
|
|
.setName('process')
|
|
.setDescription('Process name or ID')
|
|
.setRequired(true)
|
|
.setAutocomplete(true)
|
|
)
|
|
.addIntegerOption(option =>
|
|
option
|
|
.setName('lines')
|
|
.setDescription('Number of log lines to show')
|
|
.setRequired(false)
|
|
)
|
|
);
|
|
}
|
|
|
|
async execute(interaction) {
|
|
await interaction.deferReply();
|
|
|
|
const subcommand = interaction.options.getSubcommand();
|
|
|
|
try {
|
|
switch (subcommand) {
|
|
case 'list':
|
|
await this.handleListCommand(interaction);
|
|
break;
|
|
|
|
case 'info':
|
|
await this.handleInfoCommand(interaction);
|
|
break;
|
|
|
|
case 'start':
|
|
await this.handleStartCommand(interaction);
|
|
break;
|
|
|
|
case 'stop':
|
|
await this.handleStopCommand(interaction);
|
|
break;
|
|
|
|
case 'restart':
|
|
await this.handleRestartCommand(interaction);
|
|
break;
|
|
|
|
case 'logs':
|
|
await this.handleLogsCommand(interaction);
|
|
break;
|
|
|
|
default:
|
|
await interaction.editReply(`Unknown subcommand: ${subcommand}`);
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error executing PM2 command:`, error);
|
|
await interaction.editReply({
|
|
content: `Error executing command: ${error.message}`
|
|
});
|
|
}
|
|
}
|
|
|
|
async handleListCommand(interaction) {
|
|
const { stdout } = await this.execCommand('pm2 jlist');
|
|
|
|
try {
|
|
const processes = JSON.parse(stdout);
|
|
|
|
if (processes.length === 0) {
|
|
await interaction.editReply('No PM2 processes found.');
|
|
return;
|
|
}
|
|
|
|
const embed = {
|
|
title: 'PM2 Process List',
|
|
color: 0x3498db,
|
|
fields: [],
|
|
timestamp: new Date(),
|
|
footer: { text: 'PM2 Process Manager' }
|
|
};
|
|
|
|
processes.forEach(proc => {
|
|
// Format memory to MB
|
|
const memory = Math.round(proc.monit.memory / (1024 * 1024) * 10) / 10;
|
|
|
|
// Get appropriate status emoji
|
|
let statusEmoji = '⚪';
|
|
switch (proc.pm2_env.status) {
|
|
case 'online': statusEmoji = '🟢'; break;
|
|
case 'stopping': statusEmoji = '🟠'; break;
|
|
case 'stopped': statusEmoji = '🔴'; break;
|
|
case 'errored': statusEmoji = '❌'; break;
|
|
case 'launching': statusEmoji = '🟡'; break;
|
|
}
|
|
|
|
// Calculate uptime
|
|
const uptime = proc.pm2_env.status === 'online' ?
|
|
this.formatUptime(Date.now() - proc.pm2_env.pm_uptime) :
|
|
'Not running';
|
|
|
|
embed.fields.push({
|
|
name: `${statusEmoji} ${proc.name} (ID: ${proc.pm_id})`,
|
|
value: [
|
|
`**Status:** ${proc.pm2_env.status}`,
|
|
`**CPU:** ${proc.monit.cpu}%`,
|
|
`**Memory:** ${memory} MB`,
|
|
`**Uptime:** ${uptime}`,
|
|
`**Restarts:** ${proc.pm2_env.restart_time}`
|
|
].join('\n'),
|
|
inline: true
|
|
});
|
|
});
|
|
|
|
await interaction.editReply({ embeds: [embed] });
|
|
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list:', error);
|
|
await interaction.editReply({
|
|
content: `Failed to parse PM2 process list: ${error.message}`,
|
|
files: stdout.length > 0 ? [{
|
|
attachment: Buffer.from(stdout),
|
|
name: 'pm2-list.json'
|
|
}] : []
|
|
});
|
|
}
|
|
}
|
|
|
|
async handleInfoCommand(interaction) {
|
|
const processName = interaction.options.getString('process');
|
|
|
|
// Get detailed info about the process
|
|
const { success, stdout, stderr } = await this.execCommand(`pm2 show ${processName} --format json`);
|
|
|
|
if (!success) {
|
|
await interaction.editReply(`Failed to get info for PM2 process "${processName}":\n\`\`\`${stderr}\`\`\``);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// Parse the JSON output
|
|
const procInfo = JSON.parse(stdout);
|
|
|
|
// Get status emoji
|
|
let statusEmoji = '⚪';
|
|
switch (procInfo.status) {
|
|
case 'online': statusEmoji = '🟢'; break;
|
|
case 'stopping': statusEmoji = '🟠'; break;
|
|
case 'stopped': statusEmoji = '🔴'; break;
|
|
case 'errored': statusEmoji = '❌'; break;
|
|
case 'launching': statusEmoji = '🟡'; break;
|
|
}
|
|
|
|
// Format memory
|
|
const memory = procInfo.memory ?
|
|
Math.round(procInfo.memory / (1024 * 1024) * 10) / 10 :
|
|
0;
|
|
|
|
// Create embed
|
|
const embed = {
|
|
title: `${statusEmoji} PM2 Process: ${procInfo.name}`,
|
|
color: procInfo.status === 'online' ? 0x00FF00 : 0xFF0000,
|
|
fields: [
|
|
{
|
|
name: 'General',
|
|
value: [
|
|
`**ID:** ${procInfo.pm_id}`,
|
|
`**Status:** ${procInfo.status}`,
|
|
`**Version:** ${procInfo.version || 'N/A'}`,
|
|
`**Instances:** ${procInfo.exec_instances || 1}`,
|
|
`**Exec Mode:** ${procInfo.exec_mode || 'N/A'}`
|
|
].join('\n'),
|
|
inline: true
|
|
},
|
|
{
|
|
name: 'Resources',
|
|
value: [
|
|
`**CPU:** ${procInfo.cpu || 0}%`,
|
|
`**Memory:** ${memory} MB`,
|
|
`**Uptime:** ${this.formatUptime(procInfo.pm_uptime) || 'Not running'}`,
|
|
`**Restarts:** ${procInfo.restart_time || 0}`,
|
|
`**Unstable Restarts:** ${procInfo.unstable_restarts || 0}`
|
|
].join('\n'),
|
|
inline: true
|
|
},
|
|
{
|
|
name: 'Paths',
|
|
value: [
|
|
`**Path:** ${procInfo.path || 'N/A'}`,
|
|
`**Current Path:** ${procInfo.cwd || 'N/A'}`,
|
|
`**Script:** ${procInfo.script || 'N/A'}`
|
|
].join('\n'),
|
|
inline: false
|
|
}
|
|
],
|
|
timestamp: new Date(),
|
|
footer: { text: 'PM2 Process Manager' }
|
|
};
|
|
|
|
// Add logs section if available
|
|
if (procInfo.out_log_path || procInfo.error_log_path) {
|
|
embed.fields.push({
|
|
name: 'Logs',
|
|
value: [
|
|
`**Output:** ${procInfo.out_log_path || 'N/A'}`,
|
|
`**Error:** ${procInfo.error_log_path || 'N/A'}`
|
|
].join('\n'),
|
|
inline: false
|
|
});
|
|
}
|
|
|
|
await interaction.editReply({ embeds: [embed] });
|
|
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process info:', error);
|
|
await interaction.editReply(`Failed to parse info for PM2 process "${processName}":\n\`\`\`${error.message}\`\`\``);
|
|
}
|
|
}
|
|
|
|
async handleStartCommand(interaction) {
|
|
const processName = interaction.options.getString('process');
|
|
|
|
// First get current status
|
|
const { success: infoSuccess, stdout: infoStdout } = await this.execCommand(`pm2 jlist`);
|
|
let beforeStatus = 'unknown';
|
|
|
|
if (infoSuccess) {
|
|
try {
|
|
const processes = JSON.parse(infoStdout);
|
|
const proc = processes.find(p => p.name === processName || p.pm_id.toString() === processName);
|
|
if (proc) {
|
|
beforeStatus = proc.pm2_env.status;
|
|
}
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list before start:', error);
|
|
}
|
|
}
|
|
|
|
// Start the process
|
|
await interaction.editReply(`Starting PM2 process \`${processName}\`...`);
|
|
const { success, stdout, stderr } = await this.execCommand(`pm2 start ${processName}`);
|
|
|
|
if (!success) {
|
|
await interaction.editReply(`Failed to start PM2 process "${processName}":\n\`\`\`${stderr}\`\`\``);
|
|
return;
|
|
}
|
|
|
|
// Get new status
|
|
const { success: newInfoSuccess, stdout: newInfoStdout } = await this.execCommand(`pm2 jlist`);
|
|
let afterStatus = 'unknown';
|
|
|
|
if (newInfoSuccess) {
|
|
try {
|
|
const processes = JSON.parse(newInfoStdout);
|
|
const proc = processes.find(p => p.name === processName || p.pm_id.toString() === processName);
|
|
if (proc) {
|
|
afterStatus = proc.pm2_env.status;
|
|
}
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list after start:', error);
|
|
}
|
|
}
|
|
|
|
// Create status emoji
|
|
let statusEmoji = '⚪';
|
|
switch (afterStatus) {
|
|
case 'online': statusEmoji = '🟢'; break;
|
|
case 'stopping': statusEmoji = '🟠'; break;
|
|
case 'stopped': statusEmoji = '🔴'; break;
|
|
case 'errored': statusEmoji = '❌'; break;
|
|
case 'launching': statusEmoji = '🟡'; break;
|
|
}
|
|
|
|
await interaction.editReply(`PM2 process \`${processName}\` started.\n\nStatus: ${statusEmoji} ${afterStatus}\nPrevious status: ${beforeStatus}`);
|
|
}
|
|
|
|
async handleStopCommand(interaction) {
|
|
const processName = interaction.options.getString('process');
|
|
|
|
// First get current status
|
|
const { success: infoSuccess, stdout: infoStdout } = await this.execCommand(`pm2 jlist`);
|
|
let beforeStatus = 'unknown';
|
|
|
|
if (infoSuccess) {
|
|
try {
|
|
const processes = JSON.parse(infoStdout);
|
|
const proc = processes.find(p => p.name === processName || p.pm_id.toString() === processName);
|
|
if (proc) {
|
|
beforeStatus = proc.pm2_env.status;
|
|
}
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list before stop:', error);
|
|
}
|
|
}
|
|
|
|
// Stop the process
|
|
await interaction.editReply(`Stopping PM2 process \`${processName}\`...`);
|
|
const { success, stdout, stderr } = await this.execCommand(`pm2 stop ${processName}`);
|
|
|
|
if (!success) {
|
|
await interaction.editReply(`Failed to stop PM2 process "${processName}":\n\`\`\`${stderr}\`\`\``);
|
|
return;
|
|
}
|
|
|
|
// Get new status
|
|
const { success: newInfoSuccess, stdout: newInfoStdout } = await this.execCommand(`pm2 jlist`);
|
|
let afterStatus = 'unknown';
|
|
|
|
if (newInfoSuccess) {
|
|
try {
|
|
const processes = JSON.parse(newInfoStdout);
|
|
const proc = processes.find(p => p.name === processName || p.pm_id.toString() === processName);
|
|
if (proc) {
|
|
afterStatus = proc.pm2_env.status;
|
|
}
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list after stop:', error);
|
|
}
|
|
}
|
|
|
|
// Create status emoji
|
|
let statusEmoji = '⚪';
|
|
switch (afterStatus) {
|
|
case 'online': statusEmoji = '🟢'; break;
|
|
case 'stopping': statusEmoji = '🟠'; break;
|
|
case 'stopped': statusEmoji = '🔴'; break;
|
|
case 'errored': statusEmoji = '❌'; break;
|
|
case 'launching': statusEmoji = '🟡'; break;
|
|
}
|
|
|
|
await interaction.editReply(`PM2 process \`${processName}\` stopped.\n\nStatus: ${statusEmoji} ${afterStatus}\nPrevious status: ${beforeStatus}`);
|
|
}
|
|
|
|
async handleRestartCommand(interaction) {
|
|
const processName = interaction.options.getString('process');
|
|
|
|
// First get current status
|
|
const { success: infoSuccess, stdout: infoStdout } = await this.execCommand(`pm2 jlist`);
|
|
let beforeStatus = 'unknown';
|
|
|
|
if (infoSuccess) {
|
|
try {
|
|
const processes = JSON.parse(infoStdout);
|
|
const proc = processes.find(p => p.name === processName || p.pm_id.toString() === processName);
|
|
if (proc) {
|
|
beforeStatus = proc.pm2_env.status;
|
|
}
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list before restart:', error);
|
|
}
|
|
}
|
|
|
|
// Restart the process
|
|
await interaction.editReply(`Restarting PM2 process \`${processName}\`...`);
|
|
const { success, stdout, stderr } = await this.execCommand(`pm2 restart ${processName}`);
|
|
|
|
if (!success) {
|
|
await interaction.editReply(`Failed to restart PM2 process "${processName}":\n\`\`\`${stderr}\`\`\``);
|
|
return;
|
|
}
|
|
|
|
// Get new status
|
|
const { success: newInfoSuccess, stdout: newInfoStdout } = await this.execCommand(`pm2 jlist`);
|
|
let afterStatus = 'unknown';
|
|
|
|
if (newInfoSuccess) {
|
|
try {
|
|
const processes = JSON.parse(newInfoStdout);
|
|
const proc = processes.find(p => p.name === processName || p.pm_id.toString() === processName);
|
|
if (proc) {
|
|
afterStatus = proc.pm2_env.status;
|
|
}
|
|
} catch (error) {
|
|
console.error('Error parsing PM2 process list after restart:', error);
|
|
}
|
|
}
|
|
|
|
// Create status emoji
|
|
let statusEmoji = '⚪';
|
|
switch (afterStatus) {
|
|
case 'online': statusEmoji = '🟢'; break;
|
|
case 'stopping': statusEmoji = '🟠'; break;
|
|
case 'stopped': statusEmoji = '🔴'; break;
|
|
case 'errored': statusEmoji = '❌'; break;
|
|
case 'launching': statusEmoji = '🟡'; break;
|
|
}
|
|
|
|
await interaction.editReply(`PM2 process \`${processName}\` restarted.\n\nStatus: ${statusEmoji} ${afterStatus}\nPrevious status: ${beforeStatus}`);
|
|
}
|
|
|
|
async handleLogsCommand(interaction) {
|
|
const processName = interaction.options.getString('process');
|
|
const lines = interaction.options.getInteger('lines') || 20;
|
|
|
|
// Get logs for the process
|
|
await interaction.editReply(`Fetching logs for PM2 process \`${processName}\`...`);
|
|
const { success, stdout, stderr } = await this.execCommand(`pm2 logs ${processName} --lines ${lines} --nostream --raw`);
|
|
|
|
if (!success) {
|
|
await interaction.editReply(`Failed to get logs for PM2 process "${processName}":\n\`\`\`${stderr}\`\`\``);
|
|
return;
|
|
}
|
|
|
|
// Format the logs
|
|
const logs = stdout.trim();
|
|
|
|
if (!logs) {
|
|
await interaction.editReply(`No logs found for PM2 process \`${processName}\`.`);
|
|
return;
|
|
}
|
|
|
|
// If logs are too long, split into files
|
|
if (logs.length > 1950) {
|
|
await interaction.editReply({
|
|
content: `Logs for PM2 process \`${processName}\` (last ${lines} lines):`,
|
|
files: [{
|
|
attachment: Buffer.from(logs),
|
|
name: `${processName}-logs.txt`
|
|
}]
|
|
});
|
|
} else {
|
|
await interaction.editReply(`Logs for PM2 process \`${processName}\` (last ${lines} lines):\n\`\`\`\n${logs}\n\`\`\``);
|
|
}
|
|
}
|
|
|
|
// Helper method to autocomplete process names
|
|
async handleAutocomplete(interaction) {
|
|
try {
|
|
const focusedValue = interaction.options.getFocused();
|
|
const { success, stdout } = await this.execCommand('pm2 jlist');
|
|
|
|
if (!success) {
|
|
return interaction.respond([]);
|
|
}
|
|
|
|
const processes = JSON.parse(stdout);
|
|
const choices = processes.map(proc => ({
|
|
name: `${proc.name} (${proc.pm2_env.status})`,
|
|
value: proc.name
|
|
}));
|
|
|
|
// Filter choices based on user input
|
|
const filtered = choices.filter(choice =>
|
|
choice.name.toLowerCase().includes(focusedValue.toLowerCase())
|
|
);
|
|
|
|
await interaction.respond(filtered.slice(0, 25));
|
|
} catch (error) {
|
|
console.error('Error in PM2 autocomplete:', error);
|
|
await interaction.respond([]);
|
|
}
|
|
}
|
|
|
|
// Helper to format uptime
|
|
formatUptime(ms) {
|
|
if (!ms || ms <= 0) return 'Not running';
|
|
|
|
const seconds = Math.floor(ms / 1000);
|
|
const minutes = Math.floor(seconds / 60);
|
|
const hours = Math.floor(minutes / 60);
|
|
const days = Math.floor(hours / 24);
|
|
|
|
if (days > 0) {
|
|
return `${days}d ${hours % 24}h ${minutes % 60}m`;
|
|
} else if (hours > 0) {
|
|
return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
|
|
} else if (minutes > 0) {
|
|
return `${minutes}m ${seconds % 60}s`;
|
|
} else {
|
|
return `${seconds}s`;
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = PM2Control;
|