"""
PyQt5 自定义控件
- FileBrowser: 远程文件浏览 + 上传/下载/删除
- MonitorPanel: CPU/内存/磁盘/网络实时监控面板
- AIChatPanel: AI Agent 对话面板
"""
import os
import time
from pathlib import Path
from datetime import datetime
from typing import Optional, List, Dict
from PyQt5.QtCore import Qt, pyqtSignal, QSize, QTimer
from PyQt5.QtGui import QFont, QColor, QIcon, QPixmap, QPainter, QBrush, QKeySequence
from PyQt5.QtWidgets import (
QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QLineEdit,
QTableWidget, QTableWidgetItem, QHeaderView, QAbstractItemView,
QFileDialog, QMessageBox, QProgressBar, QTreeWidget, QTreeWidgetItem,
QTextEdit, QSplitter, QFrame, QSizePolicy, QGroupBox, QFormLayout,
QComboBox, QToolButton, QStyle, QApplication, QInputDialog,
QListWidget, QListWidgetItem, QTabWidget, QMenu, QShortcut,
)
from core.ssh_client import SSHConnection
from core.monitor import SystemMonitor
from core.manager import ConnectionManager
from .workers import (
ListDirWorker, UploadWorker, DownloadWorker, MonitorWorker, AIWorker,
)
# ============================================================
# 文件浏览面板
# ============================================================
class FileBrowser(QWidget):
"""远程 SFTP 文件浏览：路径栏 + 工具栏 + 表格 + 状态栏"""
def __init__(self, manager: ConnectionManager, parent=None):
super().__init__(parent)
self.manager = manager
self.current_host_id: Optional[str] = None
self.current_path: str = "/"
self.cwd_history: List[str] = [] # 简单的前进/后退栈
self.list_worker: Optional[ListDirWorker] = None
self._build_ui()
def _build_ui(self):
layout = QVBoxLayout(self)
layout.setContentsMargins(8, 8, 8, 8)
layout.setSpacing(6)
# 路径栏
nav = QHBoxLayout()
self.btn_back = QPushButton("◀")
self.btn_back.setFixedWidth(32)
self.btn_back.clicked.connect(self._go_back)
self.btn_up = QPushButton("▲")
self.btn_up.setFixedWidth(32)
self.btn_up.clicked.connect(self._go_up)
self.path_edit = QLineEdit("/")
self.path_edit.returnPressed.connect(self._go_to_path)
self.btn_refresh = QPushButton("刷新")
self.btn_refresh.clicked.connect(lambda: self._refresh())
nav.addWidget(self.btn_back)
nav.addWidget(self.btn_up)
nav.addWidget(self.path_edit, 1)
nav.addWidget(self.btn_refresh)
layout.addLayout(nav)
# 工具栏
toolbar = QHBoxLayout()
self.btn_upload = QPushButton("⬆ 上传")
self.btn_upload.clicked.connect(self._upload)
self.btn_download = QPushButton("⬇ 下载")
self.btn_download.clicked.connect(self._download)
self.btn_mkdir = QPushButton("新建目录")
self.btn_mkdir.clicked.connect(self._mkdir)
self.btn_delete = QPushButton("删除")
self.btn_delete.clicked.connect(self._delete)
self.btn_rename = QPushButton("重命名")
self.btn_rename.clicked.connect(self._rename)
for w in (self.btn_upload, self.btn_download, self.btn_mkdir,
self.btn_delete, self.btn_rename):
toolbar.addWidget(w)
toolbar.addStretch(1)
self.progress = QProgressBar()
self.progress.setFixedWidth(180)
self.progress.setVisible(False)
toolbar.addWidget(self.progress)
layout.addLayout(toolbar)
# 文件表格
self.table = QTableWidget(0, 4)
self.table.setHorizontalHeaderLabels(["名称", "大小", "修改时间", "类型"])
self.table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeToContents)
self.table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeToContents)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setAlternatingRowColors(True)
self.table.doubleClicked.connect(self._on_double_clicked)
layout.addWidget(self.table, 1)
# 状态栏
self.status_label = QLabel("未连接")
self.status_label.setStyleSheet("color: #888;")
layout.addWidget(self.status_label)
# ------- 连接管理 -------
def set_host(self, host_id: str):
self.current_host_id = host_id
self.current_path = "/"
self.path_edit.setText("/")
self.cwd_history.clear()
conn = self.manager.get_connection(host_id)
if conn and conn.connected:
self.status_label.setText(f"已连接: {conn.username}@{conn.host}")
self._refresh()
else:
self.status_label.setText("主机未连接，无法浏览")
self.table.setRowCount(0)
def refresh(self):
self._refresh()
# ------- 内部操作 -------
def _conn(self) -> Optional[SSHConnection]:
if not self.current_host_id:
return None
c = self.manager.get_connection(self.current_host_id)
if not c or not c.connected:
QMessageBox.warning(self, "未连接", "请先在「主机」面板连接当前主机")
return None
return c
def _go_back(self):
if len(self.cwd_history) > 1:
self.cwd_history.pop()
self.current_path = self.cwd_history[-1]
self.path_edit.setText(self.current_path)
self._refresh()
def _go_up(self):
p = self.current_path.rstrip("/")
if not p:
return
parent = os.path.dirname(p) or "/"
self.current_path = parent
self.path_edit.setText(parent)
self._refresh()
def _go_to_path(self):
path = self.path_edit.text().strip() or "/"
self.current_path = path
self._refresh()
def _refresh(self):
conn = self._conn()
if not conn:
return
if self.list_worker and self.list_worker.isRunning():
return
self.status_label.setText(f"加载中: {self.current_path}")
self.list_worker = ListDirWorker(conn, self.current_path)
self.list_worker.finished_with.connect(self._on_list_done)
self.list_worker.start()
def _on_list_done(self, path: str, entries: list):
if path != self.current_path:
return # 用户已跳转
self.table.setRowCount(0)
# 当前目录放第一行
cur = QTableWidgetItem(f"📁 .")
self.table.insertRow(0)
self.table.setItem(0, 0, cur)
self.table.setItem(0, 1, QTableWidgetItem("-"))
self.table.setItem(0, 2, QTableWidgetItem("-"))
self.table.setItem(0, 3, QTableWidgetItem("dir"))
for e in entries:
row = self.table.rowCount()
self.table.insertRow(row)
icon = "📁" if e["is_dir"] else "📄"
self.table.setItem(row, 0, QTableWidgetItem(f"{icon} {e['name']}"))
self.table.setItem(row, 1, QTableWidgetItem(
"-" if e["is_dir"] else SystemMonitor.format_bytes(e["size"])
))
try:
ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(e["mtime"]))
except Exception:
ts = "-"
self.table.setItem(row, 2, QTableWidgetItem(ts))
self.table.setItem(row, 3, QTableWidgetItem("dir" if e["is_dir"] else "file"))
if self.current_path not in self.cwd_history or self.cwd_history[-1] != self.current_path:
self.cwd_history.append(self.current_path)
self.status_label.setText(f"路径: {self.current_path} · 共 {len(entries)} 项")
def _on_double_clicked(self, idx):
row = idx.row()
if row == 0:
self._go_up()
return
name_item = self.table.item(row, 0)
if not name_item:
return
# 去掉 emoji 前缀
name = name_item.text().lstrip("📁📄 ").strip()
type_item = self.table.item(row, 3)
is_dir = type_item and type_item.text() == "dir"
if is_dir:
new_path = self.current_path.rstrip("/") + "/" + name
if not new_path.startswith("/"):
new_path = "/" + new_path
self.current_path = new_path
self.path_edit.setText(new_path)
self._refresh()
else:
self._download_for_item(name)
def _selected_remote_path(self) -> Optional[str]:
rows = self.table.selectionModel().selectedRows()
if not rows:
QMessageBox.information(self, "提示", "请先选中一个文件或目录")
return None
row = rows[0].row()
if row == 0:
return None
name_item = self.table.item(row, 0)
name = name_item.text().lstrip("📁📄 ").strip()
return self.current_path.rstrip("/") + "/" + name
def _upload(self):
conn = self._conn()
if not conn:
return
files, _ = QFileDialog.getOpenFileNames(self, "选择要上传的文件")
if not files:
return
for local in files:
base = os.path.basename(local)
remote = self.current_path.rstrip("/") + "/" + base
self._start_upload(conn, local, remote)
def _start_upload(self, conn, local, remote):
self.progress.setVisible(True)
self.progress.setValue(0)
worker = UploadWorker(conn, local, remote)
worker.progress.connect(lambda d, t: self.progress.setValue(
int(d / t * 100) if t else 0))
worker.finished_with.connect(
lambda ok, msg, w=worker: self._on_upload_done(ok, msg, w))
worker.start()
self._active_workers = getattr(self, "_active_workers", [])
self._active_workers.append(worker)
def _on_upload_done(self, ok, msg, worker):
self.progress.setVisible(False)
if ok:
self.status_label.setText(msg)
self._refresh()
else:
QMessageBox.critical(self, "上传失败", msg)
if worker in getattr(self, "_active_workers", []):
self._active_workers.remove(worker)
def _download(self):
rp = self._selected_remote_path()
if rp:
self._download_for_path(rp)
def _download_for_item(self, name: str):
rp = self.current_path.rstrip("/") + "/" + name
self._download_for_path(rp)
def _download_for_path(self, remote: str):
conn = self._conn()
if not conn:
return
default_name = os.path.basename(remote) or "download"
local, _ = QFileDialog.getSaveFileName(self, "保存到", default_name)
if not local:
return
self.progress.setVisible(True)
self.progress.setValue(0)
worker = DownloadWorker(conn, remote, local)
worker.progress.connect(lambda d, t: self.progress.setValue(
int(d / t * 100) if t else 0))
worker.finished_with.connect(
lambda ok, msg, w=worker: self._on_download_done(ok, msg, w))
worker.start()
self._active_workers = getattr(self, "_active_workers", [])
self._active_workers.append(worker)
def _on_download_done(self, ok, msg, worker):
self.progress.setVisible(False)
if ok:
self.status_label.setText(msg)
else:
QMessageBox.critical(self, "下载失败", msg)
if worker in getattr(self, "_active_workers", []):
self._active_workers.remove(worker)
def _mkdir(self):
conn = self._conn()
if not conn:
return
name, ok = QInputDialog.getText(self, "新建目录", "目录名:")
if not ok or not name.strip():
return
remote = self.current_path.rstrip("/") + "/" + name.strip()
ok2, msg = conn.mkdir(remote)
if ok2:
self._refresh()
else:
QMessageBox.critical(self, "创建失败", msg)
def _delete(self):
conn = self._conn()
if not conn:
return
rp = self._selected_remote_path()
if not rp:
return
if QMessageBox.question(
self, "确认删除",
f"确定要删除 {rp} 吗？\n目录将递归删除需用命令执行。",
QMessageBox.Yes | QMessageBox.No
) != QMessageBox.Yes:
return
ok, msg = conn.remove(rp)
if ok:
self._refresh()
else:
QMessageBox.critical(self, "删除失败", msg)
def _rename(self):
conn = self._conn()
if not conn:
return
rp = self._selected_remote_path()
if not rp:
return
new_name, ok = QInputDialog.getText(
self, "重命名", "新名称:", text=os.path.basename(rp))
if not ok or not new_name.strip():
return
new_path = self.current_path.rstrip("/") + "/" + new_name.strip()
ok2, msg = conn.rename(rp, new_path)
if ok2:
self._refresh()
else:
QMessageBox.critical(self, "重命名失败", msg)
# ============================================================
# 监控面板
# ============================================================
class MonitorPanel(QWidget):
"""实时监控：CPU、内存、磁盘、网络"""
def __init__(self, manager: ConnectionManager, parent=None):
super().__init__(parent)
self.manager = manager
self.current_host_id: Optional[str] = None
self.worker: Optional[MonitorWorker] = None
self._last_net: Dict[str, tuple] = {} # iface -> (rx, ts)
self._build_ui()
def _build_ui(self):
layout = QVBoxLayout(self)
layout.setContentsMargins(10, 10, 10, 10)
layout.setSpacing(10)
# 顶部：主机信息 + 控制
head = QHBoxLayout()
self.host_label = QLabel("未连接")
self.host_label.setStyleSheet("font-size: 14pt; font-weight: bold;")
head.addWidget(self.host_label)
head.addStretch(1)
self.interval_combo = QComboBox()
self.interval_combo.addItems(["1 秒", "2 秒", "3 秒", "5 秒", "10 秒"])
self.interval_combo.setCurrentIndex(2)
head.addWidget(QLabel("刷新:"))
head.addWidget(self.interval_combo)
self.btn_toggle = QPushButton("开始监控")
self.btn_toggle.setCheckable(True)
self.btn_toggle.toggled.connect(self._on_toggle)
head.addWidget(self.btn_toggle)
layout.addLayout(head)
# 主机信息
self.info_label = QLabel("-")
self.info_label.setStyleSheet("color: #666;")
layout.addWidget(self.info_label)
# 用 Splitter 把 4 行指标卡 + 磁盘网络 放上半，进程表放下半
splitter = QSplitter(Qt.Vertical)
layout.addWidget(splitter, 1)
# ---- 上半：指标卡 + 磁盘 + 网络 ----
upper = QWidget()
uv = QVBoxLayout(upper)
uv.setContentsMargins(0, 0, 0, 0)
uv.setSpacing(10)
# CPU + 内存行
grid = QHBoxLayout()
grid.addWidget(self._build_card("CPU 使用率", "cpu_card"))
grid.addWidget(self._build_card("内存", "mem_card"))
uv.addLayout(grid)
# 负载 + 启动时间
grid2 = QHBoxLayout()
grid2.addWidget(self._build_card("系统负载", "load_card"))
grid2.addWidget(self._build_card("启动时间", "uptime_card"))
uv.addLayout(grid2)
# 进程统计 + 磁盘
grid_proc_disk = QHBoxLayout()
grid_proc_disk.addWidget(self._build_proc_summary())
self.disk_group = self._build_table_card("磁盘", ["挂载点", "已用/总大小", "使用率", "进度"])
grid_proc_disk.addWidget(self.disk_group, 2)
uv.addLayout(grid_proc_disk)
# 网络
self.net_group = self._build_table_card("网络", ["网卡", "↓ 接收", "↑ 发送", "速率"])
uv.addWidget(self.net_group)
splitter.addWidget(upper)
# ---- 下半：进程表 ----
self.proc_group = self._build_proc_table()
splitter.addWidget(self.proc_group)
splitter.setSizes([400, 350])
def _build_card(self, title: str, name: str) -> QGroupBox:
box = QGroupBox(title)
v = QVBoxLayout(box)
big = QLabel("0%")
big.setObjectName(f"{name}_value")
big.setStyleSheet("font-size: 28pt; font-weight: bold;")
big.setAlignment(Qt.AlignCenter)
v.addWidget(big)
sub = QLabel("-")
sub.setObjectName(f"{name}_sub")
sub.setAlignment(Qt.AlignCenter)
sub.setStyleSheet("color: #888;")
v.addWidget(sub)
return box
def _build_table_card(self, title: str, headers: list) -> QGroupBox:
box = QGroupBox(title)
v = QVBoxLayout(box)
table = QTableWidget(0, len(headers))
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
table.verticalHeader().setVisible(False)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
v.addWidget(table)
return box
def _build_proc_summary(self) -> QGroupBox:
"""进程总数 / 运行中 / 睡眠 / 僵尸 概览卡"""
box = QGroupBox("进程概览")
v = QVBoxLayout(box)
# 4 个数字一行
row1 = QHBoxLayout()
self.proc_total_value = QLabel("0")
self.proc_total_value.setStyleSheet("font-size: 18pt; font-weight: bold; color: #42a5f5;")
self.proc_total_value.setAlignment(Qt.AlignCenter)
row1.addWidget(self._wrap_with_caption(self.proc_total_value, "总数"))
self.proc_running_value = QLabel("0")
self.proc_running_value.setStyleSheet("font-size: 18pt; font-weight: bold; color: #66bb6a;")
self.proc_running_value.setAlignment(Qt.AlignCenter)
row1.addWidget(self._wrap_with_caption(self.proc_running_value, "运行"))
self.proc_sleep_value = QLabel("0")
self.proc_sleep_value.setStyleSheet("font-size: 18pt; font-weight: bold; color: #b0bec5;")
self.proc_sleep_value.setAlignment(Qt.AlignCenter)
row1.addWidget(self._wrap_with_caption(self.proc_sleep_value, "睡眠"))
self.proc_zombie_value = QLabel("0")
self.proc_zombie_value.setStyleSheet("font-size: 18pt; font-weight: bold; color: #ef5350;")
self.proc_zombie_value.setAlignment(Qt.AlignCenter)
row1.addWidget(self._wrap_with_caption(self.proc_zombie_value, "僵尸"))
v.addLayout(row1)
box.setMaximumWidth(380)
return box
def _wrap_with_caption(self, value_label: QLabel, caption: str) -> QWidget:
w = QWidget()
v = QVBoxLayout(w)
v.setContentsMargins(0, 0, 0, 0)
v.setSpacing(2)
v.addWidget(value_label)
cap = QLabel(caption)
cap.setAlignment(Qt.AlignCenter)
cap.setStyleSheet("color: #888; font-size: 9pt;")
v.addWidget(cap)
return w
def _build_proc_table(self) -> QGroupBox:
"""进程列表（搜索 + 排序 + 右键杀进程）"""
box = QGroupBox("进程列表（前 200，按 CPU 降序，双击/右键杀进程）")
v = QVBoxLayout(box)
# 工具栏
toolbar = QHBoxLayout()
self.proc_search = QLineEdit()
self.proc_search.setPlaceholderText("🔍 过滤（PID/用户/命令行，含空格时拆分多关键字）...")
self.proc_search.textChanged.connect(self._apply_proc_filter)
toolbar.addWidget(self.proc_search, 1)
self.proc_sort_combo = QComboBox()
self.proc_sort_combo.addItems([
"按 CPU 降序", "按内存降序", "按 PID 升序", "按启动时间降序", "按用户",
])
self.proc_sort_combo.currentIndexChanged.connect(self._apply_proc_filter)
toolbar.addWidget(QLabel("排序:"))
toolbar.addWidget(self.proc_sort_combo)
v.addLayout(toolbar)
# 表格
headers = ["PID", "用户", "CPU%", "MEM%", "RSS", "STAT", "启动", "CPU时间", "命令"]
self.proc_table = QTableWidget(0, len(headers))
self.proc_table.setHorizontalHeaderLabels(headers)
self.proc_table.verticalHeader().setVisible(False)
self.proc_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.proc_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.proc_table.setAlternatingRowColors(True)
# 列宽策略
h = self.proc_table.horizontalHeader()
h.setSectionResizeMode(0, QHeaderView.ResizeToContents) # PID
h.setSectionResizeMode(1, QHeaderView.ResizeToContents) # USER
h.setSectionResizeMode(2, QHeaderView.ResizeToContents) # CPU%
h.setSectionResizeMode(3, QHeaderView.ResizeToContents) # MEM%
h.setSectionResizeMode(4, QHeaderView.ResizeToContents) # RSS
h.setSectionResizeMode(5, QHeaderView.ResizeToContents) # STAT
h.setSectionResizeMode(6, QHeaderView.ResizeToContents) # ETIME
h.setSectionResizeMode(7, QHeaderView.ResizeToContents) # TIME
h.setSectionResizeMode(8, QHeaderView.Stretch) # COMMAND
# 右键菜单
self.proc_table.setContextMenuPolicy(Qt.CustomContextMenu)
self.proc_table.customContextMenuRequested.connect(self._proc_context_menu)
# 双击行 -> 杀进程
self.proc_table.doubleClicked.connect(self._proc_kill_selected)
v.addWidget(self.proc_table, 1)
# 提示
hint = QLabel("提示: 右键/双击进程可执行 kill / kill -9。危险操作，请确认 PID。")
hint.setStyleSheet("color: #888; font-size: 9pt;")
v.addWidget(hint)
# 当前缓存的进程数据（worker 回调里更新）
self._proc_data: List[dict] = []
return box
def _value_label(self, name: str) -> QLabel:
return self.findChild(QLabel, f"{name}_value")
def _sub_label(self, name: str) -> QLabel:
return self.findChild(QLabel, f"{name}_sub")
def set_host(self, host_id: str):
"""切换主机时停止旧监控并刷新 UI"""
self._stop_worker()
self.current_host_id = host_id
if not host_id:
self.host_label.setText("未连接")
return
h = self.manager.get_host(host_id)
if h:
self.host_label.setText(f"{h.get('name', h.get('host'))} ({h.get('host')})")
if self.btn_toggle.isChecked():
self._start_worker()
def _on_toggle(self, checked: bool):
if checked:
self.btn_toggle.setText("停止监控")
self._start_worker()
else:
self.btn_toggle.setText("开始监控")
self._stop_worker()
def _start_worker(self):
if not self.current_host_id:
return
conn = self.manager.get_connection(self.current_host_id)
if not conn or not conn.connected:
self.info_label.setText("⚠ 当前主机未连接")
return
idx = self.interval_combo.currentIndex()
interval = [1, 2, 3, 5, 10][idx]
self._stop_worker()
self.worker = MonitorWorker(conn, interval=interval)
self.worker.sample_ready.connect(self._on_sample)
self.worker.error.connect(lambda m: self.info_label.setText(f"⚠ {m}"))
self.worker.start()
self.info_label.setText(f"已启动监控，每 {interval} 秒刷新")
def _stop_worker(self):
if self.worker:
self.worker.stop()
self.worker.wait(2000)
self.worker = None
self._last_net.clear()
def _on_sample(self, m: dict):
if m.get("error"):
self.info_label.setText(f"⚠ {m['error']}")
return
# 主机
os_info = m.get("os", "")
krn = m.get("kernel", "")
host = m.get("hostname", "")
self.info_label.setText(f"主机: {host} · 系统: {os_info} · 内核: {krn}")
# CPU
cpu = m.get("cpu", 0)
self._value_label("cpu_card").setText(f"{cpu:.1f}%")
cores = m.get("cores", 1)
self._sub_label("cpu_card").setText(f"{cores} 核 CPU")
# 内存
mp = m.get("mem_percent", 0)
mu = SystemMonitor.format_bytes(m.get("mem_used", 0))
mt = SystemMonitor.format_bytes(m.get("mem_total", 0))
self._value_label("mem_card").setText(f"{mp:.1f}%")
self._sub_label("mem_card").setText(f"{mu} / {mt}")
# 负载
l1, l5, l15 = m.get("load1", 0), m.get("load5", 0), m.get("load15", 0)
self._value_label("load_card").setText(f"{l1:.2f}")
self._sub_label("load_card").setText(
f"5分钟: {l5:.2f} · 15分钟: {l15:.2f} (核心数={cores})"
)
# 启动时间
ut = SystemMonitor.format_uptime(m.get("uptime", 0))
self._value_label("uptime_card").setText(ut)
boot_ts = time.time() - m.get("uptime", 0)
self._sub_label("uptime_card").setText(
f"启动于: {time.strftime('%Y-%m-%d %H:%M', time.localtime(boot_ts))}"
)
# 进程概览
self.proc_total_value.setText(str(m.get("proc_total", 0)))
self.proc_running_value.setText(str(m.get("proc_running", 0)))
self.proc_sleep_value.setText(str(m.get("proc_sleep", 0)))
self.proc_zombie_value.setText(str(m.get("proc_zombie", 0)))
# 进程列表
self._proc_data = m.get("processes", [])
self._apply_proc_filter()
# 磁盘表
disks = m.get("disks", [])
disk_table: QTableWidget = self.disk_group.findChild(QTableWidget)
disk_table.setRowCount(len(disks))
for i, d in enumerate(disks):
disk_table.setItem(i, 0, QTableWidgetItem(d["mount"]))
used_s = SystemMonitor.format_bytes(d["used"])
total_s = SystemMonitor.format_bytes(d["total"])
disk_table.setItem(i, 1, QTableWidgetItem(f"{used_s} / {total_s}"))
pct = d["percent"]
disk_table.setItem(i, 2, QTableWidgetItem(f"{pct}%"))
bar = QProgressBar()
bar.setValue(min(pct, 100))
bar.setFormat(f"{pct}%")
disk_table.setCellWidget(i, 3, bar)
# 网络表（计算每秒速率）
nets = m.get("net", [])
net_table: QTableWidget = self.net_group.findChild(QTableWidget)
net_table.setRowCount(len(nets))
now = time.time()
for i, n in enumerate(nets):
rx, tx, iface = n["rx"], n["tx"], n["iface"]
rx_s, tx_s = "-", "-"
if iface in self._last_net:
last_rx, last_tx, last_ts = self._last_net[iface]
dt = max(now - last_ts, 0.001)
rx_speed = (rx - last_rx) / dt
tx_speed = (tx - last_tx) / dt
rx_s = f"{SystemMonitor.format_bytes(rx)} ({SystemMonitor.format_bytes(int(rx_speed))}/s)"
tx_s = f"{SystemMonitor.format_bytes(tx)} ({SystemMonitor.format_bytes(int(tx_speed))}/s)"
else:
rx_s = f"{SystemMonitor.format_bytes(rx)}"
tx_s = f"{SystemMonitor.format_bytes(tx)}"
self._last_net[iface] = (rx, tx, now)
net_table.setItem(i, 0, QTableWidgetItem(iface))
net_table.setItem(i, 1, QTableWidgetItem(rx_s))
net_table.setItem(i, 2, QTableWidgetItem(tx_s))
if iface in self._last_net and len(self._last_net[iface]) == 3:
last_rx, last_tx, last_ts = self._last_net[iface]
dt = max(now - last_ts, 0.001)
rx_speed = (rx - last_rx) / dt
tx_speed = (tx - last_tx) / dt
net_table.setItem(i, 3, QTableWidgetItem(
f"↓{SystemMonitor.format_bytes(int(rx_speed))}/s ↑{SystemMonitor.format_bytes(int(tx_speed))}/s"))
else:
net_table.setItem(i, 3, QTableWidgetItem("采样中..."))
# ============================================================
# 进程表：过滤 / 排序 / 杀进程
# ============================================================
def _apply_proc_filter(self):
"""根据搜索框 + 排序下拉，过滤并刷新进程表"""
if not hasattr(self, "proc_table"):
return
query = self.proc_search.text().strip().lower() if hasattr(self, "proc_search") else ""
terms = [t for t in query.split() if t]
sort_idx = self.proc_sort_combo.currentIndex() if hasattr(self, "proc_sort_combo") else 0
data = list(self._proc_data)
# 过滤
if terms:
def match(p):
hay = f"{p.get('pid','')} {p.get('user','')} {p.get('stat','')} {p.get('comm','')}".lower()
return all(t in hay for t in terms)
data = [p for p in data if match(p)]
# 排序
if sort_idx == 0: # CPU 降序
data.sort(key=lambda p: p.get("pcpu", 0), reverse=True)
elif sort_idx == 1: # MEM 降序
data.sort(key=lambda p: p.get("pmem", 0), reverse=True)
elif sort_idx == 2: # PID 升序
data.sort(key=lambda p: p.get("pid", 0))
elif sort_idx == 3: # 启动时间降序（etime 大 = 新）
data.sort(key=lambda p: p.get("etime", 0), reverse=True)
elif sort_idx == 4: # 按用户，再 CPU
data.sort(key=lambda p: (p.get("user", ""), -p.get("pcpu", 0)))
self.proc_table.setRowCount(len(data))
for row, p in enumerate(data):
pid = p.get("pid", 0)
user = p.get("user", "")
pcpu = p.get("pcpu", 0.0)
pmem = p.get("pmem", 0.0)
rss = p.get("rss", 0)
stat = p.get("stat", "")
etime = p.get("etime", 0)
ptime = p.get("time", 0)
comm = p.get("comm", "")
# PID 列把 pid 存到 UserRole，方便右键菜单拿到
pid_item = QTableWidgetItem(str(pid))
pid_item.setData(Qt.UserRole, pid)
pid_item.setData(Qt.UserRole + 1, comm)
pid_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.proc_table.setItem(row, 0, pid_item)
self.proc_table.setItem(row, 1, QTableWidgetItem(user))
cpu_item = QTableWidgetItem(f"{pcpu:.1f}")
cpu_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
# 高的 CPU/MEM 标色
if pcpu >= 50:
cpu_item.setForeground(QColor("#ef5350"))
elif pcpu >= 20:
cpu_item.setForeground(QColor("#ffa726"))
self.proc_table.setItem(row, 2, cpu_item)
mem_item = QTableWidgetItem(f"{pmem:.1f}")
mem_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
if pmem >= 10:
mem_item.setForeground(QColor("#ef5350"))
elif pmem >= 5:
mem_item.setForeground(QColor("#ffa726"))
self.proc_table.setItem(row, 3, mem_item)
rss_item = QTableWidgetItem(SystemMonitor.format_bytes(rss * 1024))
rss_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.proc_table.setItem(row, 4, rss_item)
# STAT 含 Z 用红色
stat_item = QTableWidgetItem(stat)
if stat.startswith("Z"):
stat_item.setForeground(QColor("#ef5350"))
self.proc_table.setItem(row, 5, stat_item)
self.proc_table.setItem(row, 6, QTableWidgetItem(self._fmt_duration(etime)))
self.proc_table.setItem(row, 7, QTableWidgetItem(self._fmt_duration(ptime)))
comm_item = QTableWidgetItem(comm)
comm_item.setToolTip(comm)
self.proc_table.setItem(row, 8, comm_item)
# 更新标题栏显示当前过滤后条数
total = len(self._proc_data)
shown = len(data)
title = "进程列表"
if terms or sort_idx != 0:
title += f" (显示 {shown}/{total})"
else:
title += f" (前 {total})"
self.proc_group.setTitle(title)
@staticmethod
def _fmt_duration(seconds: int) -> str:
"""把秒数格式化成 5d3h / 2h15m / 45s"""
s = int(seconds)
if s < 0:
s = 0
days, rem = divmod(s, 86400)
hours, rem = divmod(rem, 3600)
mins, secs = divmod(rem, 60)
if days:
return f"{days}d{hours}h"
if hours:
return f"{hours}h{mins}m"
if mins:
return f"{mins}m{secs}s"
return f"{secs}s"
def _proc_context_menu(self, pos):
idx = self.proc_table.indexAt(pos)
if not idx.isValid():
return
row = idx.row()
pid_item = self.proc_table.item(row, 0)
if not pid_item:
return
pid = pid_item.data(Qt.UserRole)
comm = pid_item.data(Qt.UserRole + 1) or ""
menu = QMenu(self.proc_table)
a_soft = menu.addAction(f"🔪 kill {pid} (SIGTERM)")
a_hard = menu.addAction(f"☠ kill -9 {pid} (SIGKILL)")
menu.addSeparator()
a_copy = menu.addAction("复制 PID")
a_copy_comm = menu.addAction("复制命令行")
a_filter = menu.addAction("按此命令过滤")
chosen = menu.exec_(self.proc_table.viewport().mapToGlobal(pos))
if chosen == a_soft:
self._proc_kill(pid, comm, force=False)
elif chosen == a_hard:
self._proc_kill(pid, comm, force=True)
elif chosen == a_copy:
QApplication.clipboard().setText(str(pid))
elif chosen == a_copy_comm:
QApplication.clipboard().setText(comm)
elif chosen == a_filter:
# 取 comm 的第一段（命令名）
base = comm.split()[0] if comm else ""
if base:
self.proc_search.setText(base)
def _proc_kill_selected(self):
"""双击行：杀进程（弹确认）"""
rows = self.proc_table.selectionModel().selectedRows()
if not rows:
return
row = rows[0].row()
pid_item = self.proc_table.item(row, 0)
if not pid_item:
return
pid = pid_item.data(Qt.UserRole)
comm = pid_item.data(Qt.UserRole + 1) or ""
self._proc_kill(pid, comm, force=False)
def _proc_kill(self, pid: int, comm: str, force: bool = False):
"""在远程主机上执行 kill [pid]"""
if not self.current_host_id:
return
conn = self.manager.get_connection(self.current_host_id)
if not conn or not conn.connected:
QMessageBox.warning(self, "未连接", "主机未连接")
return
sig = "SIGKILL" if force else "SIGTERM"
flag = "-9" if force else ""
short_comm = (comm[:60] + "…") if len(comm) > 60 else comm
reply = QMessageBox.question(
self, f"杀进程 {pid}",
f"确定要 {sig} 进程 {pid} 吗？\n\n"
f"命令: {short_comm}\n\n"
f"建议: 先 SIGTERM 让进程清理；不响应再 SIGKILL。",
QMessageBox.Yes | QMessageBox.No,
)
if reply != QMessageBox.Yes:
return
code, out, err = conn.exec_command(f"kill {flag} {pid} 2>&1; echo \"exit=$?\"", timeout=10)
if code == 0:
QMessageBox.information(self, "完成",
f"已对 PID {pid} 发送 {sig}\n远程返回:\n{out.strip()}")
else:
QMessageBox.critical(self, "失败",
f"kill {pid} 失败\n退出码: {code}\nstderr: {err.strip()}\nstdout: {out.strip()}")
# ============================================================
# AI Agent 对话面板
# ============================================================
class AIChatPanel(QWidget):
"""AI Agent 对话面板"""
def __init__(self, manager: ConnectionManager, agent, parent=None):
super().__init__(parent)
self.manager = manager
self.agent = agent
self.worker: Optional[AIWorker] = None
self.current_host_id: Optional[str] = None
self._build_ui()
def _build_ui(self):
layout = QVBoxLayout(self)
layout.setContentsMargins(8, 8, 8, 8)
# 顶部状态
head = QHBoxLayout()
self.status_label = QLabel("AI Agent: 未配置")
self.status_label.setStyleSheet("color: #888;")
head.addWidget(self.status_label)
head.addStretch(1)
self.btn_config = QPushButton("⚙ AI 设置")
self.btn_config.clicked.connect(self._show_config)
head.addWidget(self.btn_config)
self.btn_clear = QPushButton("清空对话")
self.btn_clear.clicked.connect(self._clear)
head.addWidget(self.btn_clear)
layout.addLayout(head)
# 快捷指令
quick = QHBoxLayout()
quick.addWidget(QLabel("快捷:"))
for label, prompt in [
("检查状态", "帮我检查当前主机的运行状态，包括 CPU/内存/磁盘/网络"),
("查日志", "查看最近 100 行系统日志，重点关注 error 和 warning"),
("找大文件", "列出 /var/log 目录下最大的 10 个文件"),
("查端口", "查看当前监听的端口以及对应进程"),
]:
b = QPushButton(label)
b.clicked.connect(lambda _, p=prompt: self.input_edit.setText(p))
quick.addWidget(b)
quick.addStretch(1)
layout.addLayout(quick)
# 对话显示
self.chat_view = QTextEdit()
self.chat_view.setReadOnly(True)
self.chat_view.setStyleSheet("""
QTextEdit {
background: #1e1e1e;
color: #e0e0e0;
font-family: Consolas, 'Courier New', monospace;
font-size: 10pt;
}
""")
layout.addWidget(self.chat_view, 1)
# 输入区
input_layout = QHBoxLayout()
self.input_edit = QLineEdit()
self.input_edit.setPlaceholderText("输入问题，回车发送（Shift+回车换行）...")
self.input_edit.returnPressed.connect(self._send)
self.btn_send = QPushButton("发送")
self.btn_send.clicked.connect(self._send)
input_layout.addWidget(self.input_edit, 1)
input_layout.addWidget(self.btn_send)
layout.addLayout(input_layout)
self._append("系统", "AI Agent 已就绪。请先点击「⚙ AI 设置」配置 API Key。")
def set_host(self, host_id: str):
self.current_host_id = host_id
if host_id:
h = self.manager.get_host(host_id)
if h:
self._append("系统", f"已切换到主机: {h.get('name', h.get('host'))}")
def _append(self, role: str, content: str, color: str = ""):
ts = datetime.now().strftime("%H:%M:%S")
color_map = {
"user": "#4fc3f7", "assistant": "#aed581", "assistant_thinking": "#ffb74d",
"tool_call": "#ba68c8", "tool_result": "#90a4ae", "error": "#ef5350",
"system": "#888",
}
c = color or color_map.get(role, "#e0e0e0")
safe = (content or "").replace("&", "&").replace("<", "<").replace(">", ">")
safe = safe.replace("\n", "
")
role_label_map = {
"user": "我", "assistant": "AI", "assistant_thinking": "AI 思考",
"tool_call": "调用", "tool_result": "结果", "error": "错误", "system": "系统",
}
rl = role_label_map.get(role, role)
self.chat_view.append(
f'[{ts}] '
f'{rl}: '
f'{safe}'
)
# 滚动到底
sb = self.chat_view.verticalScrollBar()
sb.setValue(sb.maximum())
def _send(self):
if self.worker and self.worker.isRunning():
return
text = self.input_edit.text().strip()
if not text:
return
if not self.agent.api_key:
QMessageBox.warning(self, "未配置", "请先在「⚙ AI 设置」中配置 API Key")
return
self._append("user", text)
self.input_edit.clear()
self.btn_send.setEnabled(False)
self.btn_send.setText("思考中...")
conn = self.manager.get_connection(self.current_host_id) if self.current_host_id else None
self.worker = AIWorker(self.agent, text, conn)
self.worker.step.connect(self._append)
self.worker.finished_with.connect(self._on_done)
self.worker.error.connect(self._on_error)
self.worker.start()
def _on_done(self, final: str):
self._append("assistant", final)
self.btn_send.setEnabled(True)
self.btn_send.setText("发送")
def _on_error(self, msg: str):
self._append("error", msg)
self.btn_send.setEnabled(True)
self.btn_send.setText("发送")
def _clear(self):
self.agent.clear_history()
self.chat_view.clear()
self._append("系统", "对话历史已清空")
def _show_config(self):
from .config_dialog import AIConfigDialog
dlg = AIConfigDialog(self.agent, self)
if dlg.exec_():
self.status_label.setText(
f"AI Agent: {self.agent.model} @ {self.agent.base_url}")
self._append("系统", "AI 配置已更新")