Your Name
591 lines
16 KiB
JavaScript
591 lines
16 KiB
JavaScript
const { app, BrowserWindow, ipcMain, Menu } = require('electron');
|
|
const path = require('path');
|
|
const { Client } = require('ssh2');
|
|
const Store = require('electron-store');
|
|
|
|
const store = new Store();
|
|
let mainWindow;
|
|
let sshConnections = {};
|
|
let sftpConnections = {};
|
|
let shellStreams = {};
|
|
|
|
function createWindow() {
|
|
mainWindow = new BrowserWindow({
|
|
width: 1400,
|
|
height: 900,
|
|
minWidth: 1200,
|
|
minHeight: 700,
|
|
webPreferences: {
|
|
nodeIntegration: true,
|
|
contextIsolation: false,
|
|
enableRemoteModule: true
|
|
},
|
|
title: 'SSH Client Pro'
|
|
});
|
|
|
|
// 加载页面
|
|
if (process.env.NODE_ENV === 'development') {
|
|
mainWindow.loadURL('http://localhost:5173');
|
|
mainWindow.webContents.openDevTools();
|
|
} else {
|
|
mainWindow.loadFile(path.join(__dirname, '../dist/index.html'));
|
|
}
|
|
|
|
mainWindow.on('closed', () => {
|
|
Object.values(sshConnections).forEach(conn => {
|
|
try { conn.end(); } catch (e) {}
|
|
});
|
|
mainWindow = null;
|
|
});
|
|
}
|
|
|
|
app.whenReady().then(() => {
|
|
Menu.setApplicationMenu(null);
|
|
createWindow();
|
|
});
|
|
|
|
app.on('window-all-closed', () => {
|
|
if (process.platform !== 'darwin') {
|
|
app.quit();
|
|
}
|
|
});
|
|
|
|
app.on('activate', () => {
|
|
if (BrowserWindow.getAllWindows().length === 0) {
|
|
createWindow();
|
|
}
|
|
});
|
|
|
|
// ========== 连接配置持久化 ==========
|
|
|
|
ipcMain.handle('get-connections', () => {
|
|
return store.get('connections', []);
|
|
});
|
|
|
|
ipcMain.handle('save-connection', (event, config) => {
|
|
const connections = store.get('connections', []);
|
|
const idx = connections.findIndex(c => c.id === config.id);
|
|
if (idx >= 0) {
|
|
connections[idx] = config;
|
|
} else {
|
|
connections.push(config);
|
|
}
|
|
store.set('connections', connections);
|
|
return { success: true };
|
|
});
|
|
|
|
ipcMain.handle('delete-connection', (event, id) => {
|
|
let connections = store.get('connections', []);
|
|
connections = connections.filter(c => c.id !== id);
|
|
store.set('connections', connections);
|
|
return { success: true };
|
|
});
|
|
|
|
// ========== SSH 连接管理 ==========
|
|
|
|
ipcMain.handle('ssh-connect', (event, { id, host, port, username, password, privateKey }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const conn = new Client();
|
|
let settled = false;
|
|
|
|
const timeout = setTimeout(() => {
|
|
if (!settled) {
|
|
settled = true;
|
|
try { conn.end(); } catch (e) {}
|
|
reject(new Error('连接超时'));
|
|
}
|
|
}, 15000);
|
|
|
|
conn.on('ready', () => {
|
|
if (settled) return;
|
|
settled = true;
|
|
clearTimeout(timeout);
|
|
sshConnections[id] = conn;
|
|
resolve({ success: true });
|
|
});
|
|
|
|
conn.on('error', (err) => {
|
|
if (!settled) {
|
|
settled = true;
|
|
clearTimeout(timeout);
|
|
reject(new Error(err.message));
|
|
} else {
|
|
if (mainWindow) {
|
|
mainWindow.webContents.send('ssh-error', { id, error: err.message });
|
|
}
|
|
}
|
|
});
|
|
|
|
conn.on('close', () => {
|
|
delete sshConnections[id];
|
|
delete sftpConnections[id];
|
|
delete shellStreams[id];
|
|
if (mainWindow) {
|
|
mainWindow.webContents.send('ssh-closed', { id });
|
|
}
|
|
});
|
|
|
|
const connectConfig = {
|
|
host,
|
|
port: port || 22,
|
|
username,
|
|
readyTimeout: 15000
|
|
};
|
|
|
|
if (privateKey && privateKey.trim()) {
|
|
connectConfig.privateKey = privateKey;
|
|
} else {
|
|
connectConfig.password = password;
|
|
}
|
|
|
|
conn.connect(connectConfig);
|
|
});
|
|
});
|
|
|
|
ipcMain.handle('ssh-disconnect', (event, { id }) => {
|
|
if (sshConnections[id]) {
|
|
try { sshConnections[id].end(); } catch (e) {}
|
|
delete sshConnections[id];
|
|
delete sftpConnections[id];
|
|
delete shellStreams[id];
|
|
}
|
|
return { success: true };
|
|
});
|
|
|
|
// ========== Shell 会话 ==========
|
|
|
|
ipcMain.handle('ssh-shell', (event, { id }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const conn = sshConnections[id];
|
|
if (!conn) {
|
|
reject(new Error('SSH连接不存在'));
|
|
return;
|
|
}
|
|
|
|
conn.shell({
|
|
term: 'xterm-256color',
|
|
cols: 120,
|
|
rows: 30
|
|
}, (err, stream) => {
|
|
if (err) {
|
|
reject(new Error(err.message));
|
|
return;
|
|
}
|
|
|
|
shellStreams[id] = stream;
|
|
|
|
stream.on('data', (data) => {
|
|
if (mainWindow) {
|
|
mainWindow.webContents.send('ssh-data', { id, data: data.toString('utf-8') });
|
|
}
|
|
});
|
|
|
|
stream.stderr.on('data', (data) => {
|
|
if (mainWindow) {
|
|
mainWindow.webContents.send('ssh-data', { id, data: data.toString('utf-8') });
|
|
}
|
|
});
|
|
|
|
stream.on('close', () => {
|
|
if (mainWindow) {
|
|
mainWindow.webContents.send('ssh-closed', { id });
|
|
}
|
|
});
|
|
|
|
resolve({ success: true });
|
|
});
|
|
});
|
|
});
|
|
|
|
// 终端输入
|
|
ipcMain.on('ssh-input', (event, { id, data }) => {
|
|
const stream = shellStreams[id];
|
|
if (stream) {
|
|
stream.write(data);
|
|
}
|
|
});
|
|
|
|
// 调整终端大小
|
|
ipcMain.on('ssh-resize', (event, { id, cols, rows }) => {
|
|
const stream = shellStreams[id];
|
|
if (stream) {
|
|
stream.setWindow(rows, cols, 0, 0);
|
|
}
|
|
});
|
|
|
|
// ========== SFTP 文件管理 ==========
|
|
|
|
ipcMain.handle('sftp-init', (event, { id }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const conn = sshConnections[id];
|
|
if (!conn) {
|
|
reject(new Error('SSH连接不存在'));
|
|
return;
|
|
}
|
|
conn.sftp((err, sftp) => {
|
|
if (err) {
|
|
reject(new Error(err.message));
|
|
return;
|
|
}
|
|
sftpConnections[id] = sftp;
|
|
resolve({ success: true });
|
|
});
|
|
});
|
|
});
|
|
|
|
ipcMain.handle('sftp-readdir', (event, { id, path }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const sftp = sftpConnections[id];
|
|
if (!sftp) {
|
|
reject(new Error('SFTP连接不存在'));
|
|
return;
|
|
}
|
|
|
|
sftp.readdir(path || '/', (err, list) => {
|
|
if (err) {
|
|
reject(new Error(err.message));
|
|
return;
|
|
}
|
|
|
|
const files = list.map(item => ({
|
|
filename: item.filename,
|
|
longname: item.longname,
|
|
attrs: {
|
|
size: item.attrs.size,
|
|
mtime: item.attrs.mtime,
|
|
atime: item.attrs.atime,
|
|
permissions: item.attrs.mode,
|
|
isDirectory: (item.attrs.mode & 0o40000) === 0o40000
|
|
}
|
|
}));
|
|
|
|
resolve({ success: true, files });
|
|
});
|
|
});
|
|
});
|
|
|
|
ipcMain.handle('sftp-readfile', (event, { id, path }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const sftp = sftpConnections[id];
|
|
if (!sftp) {
|
|
reject(new Error('SFTP连接不存在'));
|
|
return;
|
|
}
|
|
|
|
let content = '';
|
|
const stream = sftp.createReadStream(path, { encoding: 'utf-8' });
|
|
|
|
stream.on('data', (chunk) => {
|
|
content += chunk;
|
|
});
|
|
|
|
stream.on('end', () => {
|
|
resolve({ success: true, content });
|
|
});
|
|
|
|
stream.on('error', (err) => {
|
|
reject(new Error(err.message));
|
|
});
|
|
});
|
|
});
|
|
|
|
ipcMain.handle('sftp-writefile', (event, { id, path, content }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const sftp = sftpConnections[id];
|
|
if (!sftp) {
|
|
reject(new Error('SFTP连接不存在'));
|
|
return;
|
|
}
|
|
|
|
const stream = sftp.createWriteStream(path);
|
|
|
|
stream.on('close', () => {
|
|
resolve({ success: true });
|
|
});
|
|
|
|
stream.on('error', (err) => {
|
|
reject(new Error(err.message));
|
|
});
|
|
|
|
stream.end(content);
|
|
});
|
|
});
|
|
|
|
ipcMain.handle('sftp-mkdir', (event, { id, path }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const sftp = sftpConnections[id];
|
|
if (!sftp) {
|
|
reject(new Error('SFTP连接不存在'));
|
|
return;
|
|
}
|
|
|
|
sftp.mkdir(path, (err) => {
|
|
if (err) {
|
|
reject(new Error(err.message));
|
|
} else {
|
|
resolve({ success: true });
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
ipcMain.handle('sftp-rm', (event, { id, path, isDirectory }) => {
|
|
return new Promise((resolve, reject) => {
|
|
const sftp = sftpConnections[id];
|
|
if (!sftp) {
|
|
reject(new Error('SFTP连接不存在'));
|
|
return;
|
|
}
|
|
|
|
const callback = (err) => {
|
|
if (err) {
|
|
reject(new Error(err.message));
|
|
} else {
|
|
resolve({ success: true });
|
|
}
|
|
};
|
|
|
|
if (isDirectory) {
|
|
sftp.rmdir(path, callback);
|
|
} else {
|
|
sftp.unlink(path, callback);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ========== 系统监控 ==========
|
|
|
|
function execRemoteCommand(conn, cmd) {
|
|
return new Promise((resolve) => {
|
|
conn.exec(cmd, (err, stream) => {
|
|
if (err) { resolve(''); return; }
|
|
let output = '';
|
|
stream.on('data', (data) => { output += data.toString(); });
|
|
stream.stderr.on('data', (data) => { output += data.toString(); });
|
|
stream.on('close', () => { resolve(output); });
|
|
});
|
|
});
|
|
}
|
|
|
|
ipcMain.handle('system-monitor', async (event, { id }) => {
|
|
const conn = sshConnections[id];
|
|
if (!conn) {
|
|
return { success: false, error: 'SSH连接不存在' };
|
|
}
|
|
|
|
try {
|
|
// 并行执行所有命令
|
|
const [cpuOutput, memOutput, diskOutput, sysOutput, processOutput, uptimeOutput] = await Promise.all([
|
|
execRemoteCommand(conn, "top -bn1 | grep 'Cpu(s)' | head -1"),
|
|
execRemoteCommand(conn, "free -m | grep Mem"),
|
|
execRemoteCommand(conn, "df -h | grep -E '^/dev/'"),
|
|
execRemoteCommand(conn, "cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d'\"' -f2; echo '---'; uname -r; echo '---'; hostname"),
|
|
execRemoteCommand(conn, "ps aux | wc -l"),
|
|
execRemoteCommand(conn, "cat /proc/loadavg; echo '---'; uptime -p 2>/dev/null || uptime")
|
|
]);
|
|
|
|
// 解析CPU使用率
|
|
let cpuUsage = 0;
|
|
const cpuMatch = cpuOutput.match(/([\d.]+)\s*id/);
|
|
if (cpuMatch) {
|
|
cpuUsage = 100 - parseFloat(cpuMatch[1]);
|
|
}
|
|
|
|
// 解析内存 (单位MB)
|
|
let memoryStr = '0,0,0,0';
|
|
const memParts = memOutput.trim().split(/\s+/);
|
|
if (memParts.length >= 7) {
|
|
const total = parseInt(memParts[1]) || 0;
|
|
const used = parseInt(memParts[2]) || 0;
|
|
const free = parseInt(memParts[3]) || 0;
|
|
const available = parseInt(memParts[6]) || 0;
|
|
memoryStr = `${total},${used},${free},${available}`;
|
|
}
|
|
|
|
// 解析磁盘
|
|
const diskLines = diskOutput.trim().split('\n').filter(Boolean).map(line => {
|
|
const parts = line.split(/\s+/);
|
|
return `${parts[0]},${parts[1]},${parts[2]},${parts[3]},${parseInt(parts[4]) || 0},${parts[5]}`;
|
|
}).join('\n');
|
|
|
|
// 解析系统信息
|
|
const sysParts = sysOutput.split('---');
|
|
const systemInfo = [
|
|
sysParts[0]?.trim(),
|
|
sysParts[1]?.trim() ? `内核: ${sysParts[1].trim()}` : '',
|
|
sysParts[2]?.trim() ? `主机: ${sysParts[2].trim()}` : ''
|
|
].filter(Boolean).join('\n');
|
|
|
|
// 解析负载
|
|
const loadParts = uptimeOutput.split('---');
|
|
let loadStr = '0,0,0';
|
|
let uptimeStr = '-';
|
|
if (loadParts[0]) {
|
|
const loads = loadParts[0].trim().split(/\s+/);
|
|
loadStr = loads.slice(0, 3).join(',');
|
|
}
|
|
if (loadParts[1]) {
|
|
uptimeStr = loadParts[1].trim().replace('up ', '');
|
|
}
|
|
|
|
// 进程数
|
|
const processCount = parseInt(processOutput.trim()) || 0;
|
|
|
|
return {
|
|
success: true,
|
|
data: {
|
|
cpu: cpuUsage.toFixed(1),
|
|
memory: memoryStr,
|
|
disk: diskLines,
|
|
load: loadStr,
|
|
processes: processCount,
|
|
uptime: uptimeStr,
|
|
system: systemInfo
|
|
}
|
|
};
|
|
} catch (error) {
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
|
|
// ========== AI Agent 命令执行 ==========
|
|
|
|
const TASK_COMMANDS = {
|
|
system_info: "cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d'\"' -f2; uname -a",
|
|
cpu_info: "lscpu 2>/dev/null | head -20 || cat /proc/cpuinfo | head -30",
|
|
memory_usage: "free -h",
|
|
disk_usage: "df -h",
|
|
top_processes: "ps aux --sort=-%mem | head -16",
|
|
uptime_check: "uptime",
|
|
network_info: "ip addr 2>/dev/null || ifconfig",
|
|
port_listen: "ss -tulnp 2>/dev/null || netstat -tulnp",
|
|
nginx_status: "systemctl status nginx 2>/dev/null || service nginx status 2>/dev/null || echo 'Nginx未安装'",
|
|
mysql_status: "systemctl status mysql 2>/dev/null || systemctl status mysqld 2>/dev/null || echo 'MySQL未安装'",
|
|
docker: "docker ps 2>/dev/null || echo 'Docker未安装或未运行'",
|
|
logged_users: "who",
|
|
last_logins: "last -10 2>/dev/null || echo '无法获取登录记录'",
|
|
firewall: "iptables -L -n 2>/dev/null || echo '需要root权限'",
|
|
ssh_config: "cat /etc/ssh/sshd_config | grep -v '^#' | grep -v '^$'",
|
|
sudo_users: "cat /etc/sudoers 2>/dev/null | grep -v '^#' | grep -v '^$' || echo '需要root权限'",
|
|
services: "systemctl list-units --type=service --state=running 2>/dev/null | head -20 || service --status-all 2>/dev/null",
|
|
cron_jobs: "crontab -l 2>/dev/null || echo '无定时任务'; ls /etc/cron.d/ 2>/dev/null",
|
|
env_vars: "env | sort | head -30",
|
|
package_update: "apt list --upgradable 2>/dev/null || yum check-update 2>/dev/null || echo '无法检查更新'",
|
|
disk_io: "iostat -x 1 1 2>/dev/null || echo '需要安装sysstat'"
|
|
};
|
|
|
|
ipcMain.handle('ai-execute', (event, { id, task }) => {
|
|
return new Promise((resolve) => {
|
|
const conn = sshConnections[id];
|
|
if (!conn) {
|
|
resolve({ success: false, output: '错误: SSH连接不存在' });
|
|
return;
|
|
}
|
|
|
|
// 如果是预定义任务，使用对应命令；否则直接作为命令执行
|
|
const cmd = TASK_COMMANDS[task] || task;
|
|
|
|
conn.exec(cmd, (err, stream) => {
|
|
if (err) {
|
|
resolve({ success: false, output: '执行错误: ' + err.message });
|
|
return;
|
|
}
|
|
|
|
let output = '';
|
|
stream.on('data', (data) => { output += data.toString(); });
|
|
stream.stderr.on('data', (data) => { output += data.toString(); });
|
|
stream.on('close', (code) => {
|
|
resolve({ success: code === 0, output: output || '(无输出)' });
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
// ==================== 进程监控 ====================
|
|
ipcMain.handle('get-processes', async (event, { id, sortBy = 'cpu', limit = 20 }) => {
|
|
const conn = sshConnections[id];
|
|
if (!conn) {
|
|
return { success: false, error: 'SSH连接不存在' };
|
|
}
|
|
|
|
try {
|
|
const sortFlag = sortBy === 'memory' ? '--sort=-%mem' : '--sort=-%cpu';
|
|
const cmd = `ps aux ${sortFlag} | head -${limit + 1}`;
|
|
const output = await execRemoteCommand(conn, cmd);
|
|
|
|
const lines = output.trim().split('\n');
|
|
// 跳过表头
|
|
const processes = lines.slice(1).filter(Boolean).map(line => {
|
|
const parts = line.split(/\s+/);
|
|
return {
|
|
user: parts[0],
|
|
pid: parts[1],
|
|
cpu: parts[2],
|
|
mem: parts[3],
|
|
vsz: parts[4],
|
|
rss: parts[5],
|
|
stat: parts[7],
|
|
start: parts[8],
|
|
time: parts[9],
|
|
command: parts.slice(10).join(' ')
|
|
};
|
|
});
|
|
|
|
return { success: true, data: processes };
|
|
} catch (error) {
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
|
|
// ==================== AI 设置 ====================
|
|
ipcMain.handle('get-ai-settings', () => {
|
|
return store.get('aiSettings', { apiKey: '', baseUrl: 'https://api.openai.com/v1', model: 'gpt-3.5-turbo' });
|
|
});
|
|
|
|
ipcMain.handle('save-ai-settings', (event, settings) => {
|
|
store.set('aiSettings', settings);
|
|
return { success: true };
|
|
});
|
|
|
|
// AI 智能命令解析
|
|
ipcMain.handle('ai-parse-command', async (event, { input, apiKey, baseUrl, model }) => {
|
|
try {
|
|
const url = `${baseUrl.replace(/\/$/, '')}/chat/completions`;
|
|
const response = await fetch(url, {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': `Bearer ${apiKey}`
|
|
},
|
|
body: JSON.stringify({
|
|
model: model || 'gpt-3.5-turbo',
|
|
messages: [
|
|
{
|
|
role: 'system',
|
|
content: '你是一个Linux服务器管理专家。用户会用自然语言描述他们想要执行的服务器操作。你需要返回对应的Linux命令。只返回命令本身，不要任何解释、不要markdown格式、不要代码块标记。如果用户的请求不安全或无法理解，返回 #ERROR: 加上原因。'
|
|
},
|
|
{ role: 'user', content: input }
|
|
],
|
|
temperature: 0.1,
|
|
max_tokens: 200
|
|
})
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errText = await response.text();
|
|
return { success: false, error: `API请求失败 (${response.status}): ${errText}` };
|
|
}
|
|
|
|
const data = await response.json();
|
|
const command = data.choices[0].message.content.trim();
|
|
|
|
if (command.startsWith('#ERROR:')) {
|
|
return { success: false, error: command.replace('#ERROR:', '').trim() };
|
|
}
|
|
|
|
return { success: true, command };
|
|
} catch (error) {
|
|
return { success: false, error: `AI请求失败: ${error.message}` };
|
|
}
|
|
});
|