koishi-plugin-docker-control 0.0.5 → 0.0.6

package/lib/commands/control.js

@@ -3,6 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerControlCommands = registerControlCommands;
 const logger_1 = require("../utils/logger");
 const render_1 = require("../utils/render");
+/**
+ * 格式化网络流量显示
+ */
+function formatNet(bytes) {
+    const num = parseFloat(bytes);
+    if (isNaN(num))
+        return '-';
+    if (num < 1024)
+        return bytes + 'B';
+    if (num < 1024 * 1024)
+        return (num / 1024).toFixed(1) + 'KB';
+    return (num / 1024 / 1024).toFixed(2) + 'MB';
+}
 /**
  * 格式化容器搜索结果
  */
@@ -179,8 +192,13 @@ function registerControlCommands(ctx, getService, config) {
         try {
             const { node, container: found } = await service.findContainer(selector, container);
             const info = await node.getContainer(found.Id);
+            // 获取性能数据和端口映射
+            const [stats, ports] = await Promise.all([
+                node.getContainerStats(found.Id),
+                node.getContainerPorts(found.Id),
+            ]);
             if (useImageOutput && ctx.puppeteer) {
-                const html = (0, render_1.generateInspectHtml)(node.name, info);
+                const html = (0, render_1.generateInspectHtml)(node.name, info, stats, ports);
                 return await (0, render_1.renderToImage)(ctx, html);
             }
             const lines = [
@@ -192,6 +210,23 @@ function registerControlCommands(ctx, getService, config) {
                 `启动时间: ${info.State.StartedAt}`,
                 `重启次数: ${info.RestartCount || 0}`,
             ];
+            // 添加性能数据
+            if (stats) {
+                lines.push('');
+                lines.push('性能监控:');
+                lines.push(`  CPU: ${stats.cpuPercent}`);
+                lines.push(`  内存: ${stats.memoryPercent} (${stats.memoryUsage} / ${stats.memoryLimit})`);
+                lines.push(`  网络: ${formatNet(stats.networkIn)} / ${formatNet(stats.networkOut)}`);
+                lines.push(`  进程: ${stats.pids}`);
+            }
+            // 添加端口映射
+            if (ports && ports.length > 0) {
+                lines.push('');
+                lines.push('端口映射:');
+                for (const port of ports) {
+                    lines.push(`  ${port}`);
+                }
+            }
             if (info.State.Health) {
                 lines.push(`健康状态: ${info.State.Health.Status}`);
             }

package/lib/service/node.d.ts

@@ -6,6 +6,10 @@ export declare class DockerNode {
     status: NodeStatusType;
     /** SSH 连接器 */
     private connector;
+    /** Dockerode 实例 (用于 API 调用) */
+    private dockerode;
+    /** Docker API 是否可用 */
+    private dockerApiAvailable;
     /** 监控定时器 (容器状态轮询) */
     private monitorTimer;
     /** 事件监控定时器 (docker events) */
@@ -38,26 +42,6 @@ export declare class DockerNode {
      * 重新连接
      */
     reconnect(): Promise<void>;
-    /**
-     * 列出容器
-     */
-    listContainers(all?: boolean): Promise<ContainerInfo[]>;
-    /**
-     * 启动容器
-     */
-    startContainer(containerId: string): Promise<void>;
-    /**
-     * 停止容器
-     */
-    stopContainer(containerId: string, timeout?: number): Promise<void>;
-    /**
-     * 重启容器
-     */
-    restartContainer(containerId: string, timeout?: number): Promise<void>;
-    /**
-     * 获取容器日志
-     */
-    getContainerLogs(containerId: string, tail?: number): Promise<string>;
     /**
      * 执行容器内命令
      */
@@ -112,6 +96,58 @@ export declare class DockerNode {
      * 获取容器详细信息 (docker inspect)
      */
     getContainer(containerId: string): Promise<any>;
+    /**
+     * 初始化 Dockerode
+     * 根据配置决定连接本地 Socket 还是通过 SSH 连接远程
+     */
+    private initDockerode;
+    /**
+     * 列出容器 (优先使用 API)
+     */
+    listContainers(all?: boolean): Promise<ContainerInfo[]>;
+    /**
+     * 启动容器
+     */
+    startContainer(containerId: string): Promise<void>;
+    /**
+     * 停止容器
+     */
+    stopContainer(containerId: string, timeout?: number): Promise<void>;
+    /**
+     * 重启容器
+     */
+    restartContainer(containerId: string, timeout?: number): Promise<void>;
+    /**
+     * 获取容器日志 (优先使用 API)
+     */
+    getContainerLogs(containerId: string, tail?: number): Promise<string>;
+    /**
+     * 清洗 Docker 日志流 (去除 8 字节头部)
+     */
+    private cleanDockerLogStream;
+    /**
+     * 使用 Docker API 获取容器性能数据
+     */
+    private getContainerStatsByApi;
+    /**
+     * 获取容器性能数据 (CPU、内存使用率)
+     * 优先使用 Docker API，失败则降级到 SSH 命令
+     */
+    getContainerStats(containerId: string): Promise<{
+        cpuPercent: string;
+        memoryUsage: string;
+        memoryLimit: string;
+        memoryPercent: string;
+        networkIn: string;
+        networkOut: string;
+        blockIn: string;
+        blockOut: string;
+        pids: string;
+    } | null>;
+    /**
+     * 获取容器端口映射
+     */
+    getContainerPorts(containerId: string): Promise<string[]>;
     /**
      * 解析 docker ps 输出
      */

package/lib/service/node.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerNode = void 0;
 /**
  * Docker 节点类 - 通过 SSH 执行 docker 命令
  */
 const koishi_1 = require("koishi");
+const dockerode_1 = __importDefault(require("dockerode"));
 const constants_1 = require("../constants");
 const connector_1 = require("./connector");
 const logger_1 = require("../utils/logger");
@@ -16,6 +20,10 @@ class DockerNode {
         this.status = constants_1.NodeStatus.DISCONNECTED;
         /** SSH 连接器 */
         this.connector = null;
+        /** Dockerode 实例 (用于 API 调用) */
+        this.dockerode = null;
+        /** Docker API 是否可用 */
+        this.dockerApiAvailable = false;
         /** 监控定时器 (容器状态轮询) */
         this.monitorTimer = null;
         /** 事件监控定时器 (docker events) */
@@ -67,8 +75,10 @@ class DockerNode {
                 await connector.exec('docker version --format "{{.Server.Version}}"');
                 // 标记连接可用，允许事件流自动重连
                 connector.setConnected(true);
+                // 初始化 Dockerode (用于 API 调用)
+                this.initDockerode();
                 this.status = constants_1.NodeStatus.CONNECTED;
-                logger_1.nodeLogger.info(`[${this.name}] 连接成功`);
+                logger_1.nodeLogger.info(`[${this.name}] 连接成功 (SSH + ${this.dockerApiAvailable ? 'Docker API' : 'SSH 命令模式'})`);
                 // 启动监控
                 this.startMonitoring();
                 // 触发上线事件
@@ -102,6 +112,8 @@ class DockerNode {
         this.clearTimers();
         this.connector?.dispose();
         this.connector = null;
+        this.dockerode = null;
+        this.dockerApiAvailable = false;
         this.status = constants_1.NodeStatus.DISCONNECTED;
         logger_1.nodeLogger.info(`[${this.name}] 已断开连接`);
     }
@@ -112,48 +124,6 @@ class DockerNode {
         await this.disconnect();
         await this.connect();
     }
-    /**
-     * 列出容器
-     */
-    async listContainers(all = true) {
-        if (!this.connector || this.status !== constants_1.NodeStatus.CONNECTED) {
-            throw new Error(`节点 ${this.name} 未连接`);
-        }
-        const output = await this.connector.listContainers(all);
-        return this.parseContainerList(output);
-    }
-    /**
-     * 启动容器
-     */
-    async startContainer(containerId) {
-        if (!this.connector)
-            throw new Error('未连接');
-        await this.connector.startContainer(containerId);
-    }
-    /**
-     * 停止容器
-     */
-    async stopContainer(containerId, timeout = 10) {
-        if (!this.connector)
-            throw new Error('未连接');
-        await this.connector.stopContainer(containerId, timeout);
-    }
-    /**
-     * 重启容器
-     */
-    async restartContainer(containerId, timeout = 10) {
-        if (!this.connector)
-            throw new Error('未连接');
-        await this.connector.restartContainer(containerId, timeout);
-    }
-    /**
-     * 获取容器日志
-     */
-    async getContainerLogs(containerId, tail = 100) {
-        if (!this.connector)
-            throw new Error('未连接');
-        return this.connector.getLogs(containerId, tail);
-    }
     /**
      * 执行容器内命令
      */
@@ -323,6 +293,362 @@ class DockerNode {
         const info = JSON.parse(output);
         return Array.isArray(info) ? info[0] : info;
     }
+    /**
+     * 初始化 Dockerode
+     * 根据配置决定连接本地 Socket 还是通过 SSH 连接远程
+     */
+    initDockerode() {
+        try {
+            let dockerOptions;
+            // 判断是否是本地节点
+            const isLocal = this.config.host === '127.0.0.1' || this.config.host === 'localhost';
+            if (isLocal) {
+                // 本地连接
+                dockerOptions = {
+                    socketPath: '/var/run/docker.sock',
+                };
+            }
+            else {
+                // === 远程 SSH 连接配置 ===
+                // 1. 构建 ssh2 的连接参数
+                const sshOpts = {
+                    host: this.config.host,
+                    port: this.config.port || 22,
+                    username: this.credential.username,
+                    readyTimeout: 20000, // 连接超时
+                };
+                // 2. 根据认证类型注入凭证
+                if (this.credential.authType === 'password' && this.credential.password) {
+                    sshOpts.password = this.credential.password;
+                }
+                else if (this.credential.privateKey) {
+                    // 关键：私钥通常需要去掉首尾多余空白，否则 ssh2 解析会失败
+                    sshOpts.privateKey = this.credential.privateKey.trim();
+                    if (this.credential.passphrase) {
+                        sshOpts.passphrase = this.credential.passphrase;
+                    }
+                }
+                // 3. 构建 Dockerode 配置
+                // 重点：必须使用 sshOptions 属性包裹 ssh 配置，否则 dockerode 可能无法正确透传凭证
+                dockerOptions = {
+                    protocol: 'ssh',
+                    host: this.config.host,
+                    port: this.config.port || 22,
+                    username: this.credential.username,
+                    sshOptions: sshOpts, // <--- 这里是修复的关键
+                };
+            }
+            this.dockerode = new dockerode_1.default(dockerOptions);
+            // 测试连接是否真正可用
+            this.dockerode.ping().then(() => {
+                this.dockerApiAvailable = true;
+                logger_1.nodeLogger.debug(`[${this.name}] Docker API 连接成功 (${isLocal ? 'Local' : 'SSH'})`);
+            }).catch((e) => {
+                this.dockerApiAvailable = false;
+                // 详细记录错误原因，方便排查
+                logger_1.nodeLogger.warn(`[${this.name}] Docker API 连接失败: ${e.message} (将降级使用 SSH 命令)`);
+            });
+        }
+        catch (e) {
+            this.dockerode = null;
+            this.dockerApiAvailable = false;
+            logger_1.nodeLogger.debug(`[${this.name}] Dockerode 初始化异常: ${e}`);
+        }
+    }
+    /**
+     * 列出容器 (优先使用 API)
+     */
+    async listContainers(all = true) {
+        // 方式 1: 尝试使用 Docker API
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                const containers = await this.dockerode.listContainers({ all });
+                // 转换 Dockerode 的返回格式
+                return containers.map(c => ({
+                    Id: c.Id,
+                    Names: c.Names,
+                    Image: c.Image,
+                    ImageID: c.ImageID,
+                    Command: c.Command,
+                    Created: c.Created,
+                    Ports: c.Ports,
+                    Labels: c.Labels,
+                    State: c.State,
+                    Status: c.Status,
+                    HostConfig: { NetworkMode: c.HostConfig?.NetworkMode || '' },
+                    NetworkSettings: { Networks: c.NetworkSettings?.Networks || {} },
+                }));
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API listContainers 失败，降级到 SSH: ${e.message}`);
+            }
+        }
+        // 方式 2: SSH 命令行回退
+        if (!this.connector || this.status !== constants_1.NodeStatus.CONNECTED) {
+            throw new Error(`节点 ${this.name} 未连接`);
+        }
+        const output = await this.connector.listContainers(all);
+        return this.parseContainerList(output);
+    }
+    /**
+     * 启动容器
+     */
+    async startContainer(containerId) {
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                const container = this.dockerode.getContainer(containerId);
+                await container.start();
+                return;
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API startContainer 失败: ${e.message}`);
+            }
+        }
+        // Fallback
+        if (!this.connector)
+            throw new Error('未连接');
+        await this.connector.startContainer(containerId);
+    }
+    /**
+     * 停止容器
+     */
+    async stopContainer(containerId, timeout = 10) {
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                const container = this.dockerode.getContainer(containerId);
+                await container.stop({ t: timeout });
+                return;
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API stopContainer 失败: ${e.message}`);
+            }
+        }
+        // Fallback
+        if (!this.connector)
+            throw new Error('未连接');
+        await this.connector.stopContainer(containerId, timeout);
+    }
+    /**
+     * 重启容器
+     */
+    async restartContainer(containerId, timeout = 10) {
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                const container = this.dockerode.getContainer(containerId);
+                await container.restart({ t: timeout });
+                return;
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API restartContainer 失败: ${e.message}`);
+            }
+        }
+        // Fallback
+        if (!this.connector)
+            throw new Error('未连接');
+        await this.connector.restartContainer(containerId, timeout);
+    }
+    /**
+     * 获取容器日志 (优先使用 API)
+     */
+    async getContainerLogs(containerId, tail = 100) {
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                const container = this.dockerode.getContainer(containerId);
+                const buffer = await container.logs({
+                    follow: false,
+                    stdout: true,
+                    stderr: true,
+                    tail: tail,
+                    timestamps: false,
+                });
+                return this.cleanDockerLogStream(buffer);
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API getLogs 失败: ${e.message}`);
+            }
+        }
+        // Fallback
+        if (!this.connector)
+            throw new Error('未连接');
+        return this.connector.getLogs(containerId, tail);
+    }
+    /**
+     * 清洗 Docker 日志流 (去除 8 字节头部)
+     */
+    cleanDockerLogStream(buffer) {
+        let offset = 0;
+        let output = '';
+        while (offset < buffer.length) {
+            // 头部结构: [STREAM_TYPE, 0, 0, 0, SIZE1, SIZE2, SIZE3, SIZE4]
+            if (offset + 8 > buffer.length)
+                break;
+            // 读取 payload 大小 (大端序)
+            const size = buffer.readUInt32BE(offset + 4);
+            // 移动到 payload 开始
+            offset += 8;
+            if (offset + size > buffer.length)
+                break;
+            // 读取实际内容
+            output += buffer.subarray(offset, offset + size).toString('utf-8');
+            offset += size;
+        }
+        // 如果解析失败，直接转 string
+        if (!output && buffer.length > 0)
+            return buffer.toString('utf-8');
+        return output;
+    }
+    /**
+     * 使用 Docker API 获取容器性能数据
+     */
+    async getContainerStatsByApi(containerId) {
+        if (!this.dockerode || !this.dockerApiAvailable) {
+            return null;
+        }
+        try {
+            const container = this.dockerode.getContainer(containerId);
+            // stream: false 时，dockerode 直接返回解析好的 Object，而不是 Buffer 或 Stream
+            const data = await container.stats({ stream: false });
+            // 内存使用量 (bytes)
+            const memoryUsage = data.memory_stats?.usage || 0;
+            const memoryLimit = data.memory_stats?.limit || 0;
+            const memoryPercent = memoryLimit > 0 ? ((memoryUsage / memoryLimit) * 100).toFixed(2) + '%' : '0%';
+            // CPU 使用率计算 (基于 cpu_delta / system_cpu_delta)
+            const cpuUsage = data.cpu_stats?.cpu_usage?.total_usage || 0;
+            const systemUsage = data.cpu_stats?.system_cpu_usage || 0;
+            // 有些环境 online_cpus 不存在，回退到 percpu_usage 的长度
+            const cpuCount = data.cpu_stats?.online_cpus || data.cpu_stats?.cpu_usage?.percpu_usage?.length || 1;
+            let cpuPercent = '0.00%';
+            // 需要前一次的数据 (precpu_stats) 来计算差值
+            if (data.precpu_stats?.cpu_usage?.total_usage !== undefined && data.precpu_stats?.system_cpu_usage !== undefined) {
+                const cpuDelta = cpuUsage - data.precpu_stats.cpu_usage.total_usage;
+                const systemDelta = systemUsage - data.precpu_stats.system_cpu_usage;
+                if (systemDelta > 0 && cpuDelta > 0) {
+                    // 公式: (cpuDelta / systemDelta) * cpuCount * 100
+                    cpuPercent = ((cpuDelta / systemDelta) * cpuCount * 100).toFixed(2) + '%';
+                }
+            }
+            // 网络流量 (bytes)
+            const networks = data.networks || {};
+            let networkIn = 0;
+            let networkOut = 0;
+            // 累加所有网卡的流量
+            for (const net of Object.values(networks)) {
+                networkIn += net.rx_bytes || 0;
+                networkOut += net.tx_bytes || 0;
+            }
+            // Block IO (bytes)
+            const blkioStats = data.blkio_stats || {};
+            const ioServiceBytes = blkioStats.io_service_bytes_recursive || [];
+            let blockIn = 0;
+            let blockOut = 0;
+            for (const io of ioServiceBytes) {
+                if (io.op === 'Read')
+                    blockIn += io.value || 0;
+                if (io.op === 'Write')
+                    blockOut += io.value || 0;
+            }
+            // 进程数
+            const pids = data.pids_stats?.current || '-';
+            return {
+                cpuPercent,
+                memoryUsage: formatBytes(memoryUsage),
+                memoryLimit: formatBytes(memoryLimit),
+                memoryPercent,
+                networkIn: formatBytes(networkIn),
+                networkOut: formatBytes(networkOut),
+                blockIn: formatBytes(blockIn),
+                blockOut: formatBytes(blockOut),
+                pids: String(pids),
+            };
+        }
+        catch (e) {
+            // 只有在调试模式下打印详细错误，防止刷屏
+            if (this.debug) {
+                logger_1.nodeLogger.warn(`[${this.name}] Docker API 获取性能数据失败: ${e}`);
+            }
+            return null;
+        }
+    }
+    /**
+     * 获取容器性能数据 (CPU、内存使用率)
+     * 优先使用 Docker API，失败则降级到 SSH 命令
+     */
+    async getContainerStats(containerId) {
+        if (!this.connector)
+            return null;
+        // 优先尝试 Docker API
+        if (this.dockerApiAvailable) {
+            const apiResult = await this.getContainerStatsByApi(containerId);
+            if (apiResult) {
+                logger_1.nodeLogger.debug(`[${this.name}] Docker API 获取容器 ${containerId} 性能数据成功`);
+                return apiResult;
+            }
+            logger_1.nodeLogger.debug(`[${this.name}] Docker API 获取容器 ${containerId} 性能数据失败，降级到 SSH`);
+        }
+        // 降级到 SSH 命令
+        try {
+            // 使用 execWithExitCode，因为停止的容器返回退出码 1
+            const result = await this.connector.execWithExitCode(`docker stats --no-stream --no-trunc ${containerId} --format "{{.CPUPerc}}|{{.MemPerc}}|{{.MemUsage}}|{{.NetIn}}|{{.NetOut}}|{{.BlockIn}}|{{.BlockOut}}|{{.PIDs}}"`);
+            logger_1.nodeLogger.debug(`[${this.name}] SSH docker stats 输出: "${result.output}", 退出码: ${result.exitCode}`);
+            // 如果没有输出（容器可能不存在或已停止），返回 null
+            if (!result.output.trim()) {
+                logger_1.nodeLogger.debug(`[${this.name}] 容器 ${containerId} 性能数据为空，可能已停止`);
+                return null;
+            }
+            const parts = result.output.split('|');
+            if (parts.length < 8) {
+                logger_1.nodeLogger.warn(`[${this.name}] 容器 ${containerId} 性能数据格式异常: "${result.output}"`);
+                return null;
+            }
+            // MemUsage 格式: "123.4MiB / 2GiB"，解析内存使用量和限制
+            const memUsageParts = parts[2]?.split(' / ') || ['-', '-'];
+            return {
+                cpuPercent: parts[0]?.trim() || '-',
+                memoryPercent: parts[1]?.trim() || '-',
+                memoryUsage: memUsageParts[0]?.trim() || '-',
+                memoryLimit: memUsageParts[1]?.trim() || '-',
+                networkIn: parts[3]?.trim() || '-',
+                networkOut: parts[4]?.trim() || '-',
+                blockIn: parts[5]?.trim() || '-',
+                blockOut: parts[6]?.trim() || '-',
+                pids: parts[7]?.trim() || '-',
+            };
+        }
+        catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 获取容器 ${containerId} 性能数据失败: ${e}`);
+            return null;
+        }
+    }
+    /**
+     * 获取容器端口映射
+     */
+    async getContainerPorts(containerId) {
+        if (!this.connector)
+            return [];
+        try {
+            const output = await this.connector.exec(`docker inspect ${containerId} --format "{{json .HostConfig.PortBindings}}"`);
+            if (!output.trim() || output === 'null') {
+                return [];
+            }
+            const portBindings = JSON.parse(output);
+            const portStrings = [];
+            for (const [containerPort, bindings] of Object.entries(portBindings)) {
+                for (const binding of bindings) {
+                    if (binding.HostIp === '0.0.0.0' || binding.HostIp === '::') {
+                        portStrings.push(`${binding.HostPort}->${containerPort}`);
+                    }
+                    else {
+                        portStrings.push(`${binding.HostIp}:${binding.HostPort}->${containerPort}`);
+                    }
+                }
+            }
+            return portStrings.sort();
+        }
+        catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 获取容器 ${containerId} 端口映射失败: ${e}`);
+            return [];
+        }
+    }
     /**
      * 解析 docker ps 输出
      */
@@ -673,3 +999,14 @@ class DockerNode {
     get tags() { return this.config.tags; }
 }
 exports.DockerNode = DockerNode;
+/**
+ * 格式化字节为可读格式
+ */
+function formatBytes(bytes) {
+    if (!bytes || bytes < 0)
+        return '-';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}

package/lib/utils/render.d.ts

@@ -28,7 +28,17 @@ export declare function generateResultHtml(results: Array<{
 /**
  * 生成详情 HTML
  */
-export declare function generateInspectHtml(nodeName: string, info: any): string;
+export declare function generateInspectHtml(nodeName: string, info: any, stats?: {
+    cpuPercent: string;
+    memoryUsage: string;
+    memoryLimit: string;
+    memoryPercent: string;
+    networkIn: string;
+    networkOut: string;
+    blockIn: string;
+    blockOut: string;
+    pids: string;
+} | null, ports?: string[]): string;
 /**
  * 生成节点列表 HTML
  */

package/lib/utils/render.js

@@ -300,7 +300,7 @@ function generateResultHtml(results, title) {
 /**
  * 生成详情 HTML
  */
-function generateInspectHtml(nodeName, info) {
+function generateInspectHtml(nodeName, info, stats, ports) {
     const name = info.Name.replace('/', '');
     const shortId = info.Id.slice(0, 12);
     const isRunning = info.State.Running;
@@ -335,6 +335,67 @@ function generateInspectHtml(nodeName, info) {
             return `  ${mount.Source} → ${mount.Destination} (${mount.Type})`;
         }).join('\n')
         : '-';
+    // 端口映射
+    const portsDisplay = ports && ports.length > 0
+        ? ports.join('\n')
+        : '-';
+    // 判断容器是否运行
+    const containerRunning = info.State.Running;
+    // 性能数据
+    const statsDisplay = stats
+        ? containerRunning
+            ? `
+        <div style="display: grid; grid-template-columns: repeat(5, 1fr); gap: 6px; margin-top: 8px;">
+          <div style="background: rgba(0,0,0,0.15); padding: 6px 4px; border-radius: 6px; text-align: center;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">CPU</div>
+            <div style="font-size: 13px; font-weight: 600; color: ${parseCpuColor(stats.cpuPercent)}">${stats.cpuPercent}</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.15); padding: 6px 4px; border-radius: 6px; text-align: center;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">内存</div>
+            <div style="font-size: 13px; font-weight: 600; color: #60a5fa">${stats.memoryUsage}</div>
+            <div style="font-size: 9px; color: #cbd5e1;">/ ${stats.memoryLimit}</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.15); padding: 6px 4px; border-radius: 6px; text-align: center;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">网络</div>
+            <div style="font-size: 13px; font-weight: 600; color: #60a5fa">${stats.networkIn ? formatNetwork(stats.networkIn) : '-'}</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.15); padding: 6px 4px; border-radius: 6px; text-align: center;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">IO</div>
+            <div style="font-size: 13px; font-weight: 600; color: #f472b6">${stats.blockIn}</div>
+            <div style="font-size: 9px; color: #cbd5e1;">↓ ${stats.blockOut}↑</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.15); padding: 6px 4px; border-radius: 6px; text-align: center;">
+            <div style="font-size: 9px; color: #94a3b8; margin-bottom: 2px;">进程</div>
+            <div style="font-size: 13px; font-weight: 600; color: #a78bfa">${stats.pids}</div>
+          </div>
+        </div>
+      `
+            : `
+        <div style="display: grid; grid-template-columns: repeat(5, 1fr); gap: 6px; margin-top: 8px;">
+          <div style="background: rgba(0,0,0,0.1); padding: 6px 4px; border-radius: 6px; text-align: center; opacity: 0.6;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">CPU</div>
+            <div style="font-size: 13px; font-weight: 600; color: #94a3b8;">-</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.1); padding: 6px 4px; border-radius: 6px; text-align: center; opacity: 0.6;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">内存</div>
+            <div style="font-size: 13px; font-weight: 600; color: #94a3b8;">-</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.1); padding: 6px 4px; border-radius: 6px; text-align: center; opacity: 0.6;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">网络</div>
+            <div style="font-size: 13px; font-weight: 600; color: #94a3b8;">-</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.1); padding: 6px 4px; border-radius: 6px; text-align: center; opacity: 0.6;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">IO</div>
+            <div style="font-size: 13px; font-weight: 600; color: #94a3b8;">-</div>
+          </div>
+          <div style="background: rgba(0,0,0,0.1); padding: 6px 4px; border-radius: 6px; text-align: center; opacity: 0.6;">
+            <div style="font-size: 9px; color: #cbd5e1; margin-bottom: 2px;">进程</div>
+            <div style="font-size: 13px; font-weight: 600; color: #a78bfa">${stats.pids}</div>
+          </div>
+        </div>
+        <div style="font-size: 9px; color: #f59e0b; margin-top: 6px;">⚠ 容器已停止，无法获取实时监控数据</div>
+      `
+        : '<span style="color: #64748b; font-size: 11px;">(获取失败)</span>';
     const items = [
         { label: '容器名称', value: name, span: false },
         { label: '容器 ID', value: info.Id, span: false },
@@ -344,6 +405,8 @@ function generateInspectHtml(nodeName, info) {
         { label: '启动时间', value: new Date(info.State.StartedAt).toLocaleString(), span: false },
         { label: '重启策略', value: restartDisplay, span: false },
         { label: '重启次数', value: String(info.RestartCount), span: false },
+        { label: '性能监控', value: statsDisplay, span: true, isHtml: true },
+        { label: '端口映射', value: portsDisplay, span: true },
         { label: '网络', value: networkInfo, span: true },
         { label: '环境变量', value: envDisplay, span: true },
         { label: '挂载目录', value: mountsDisplay, span: true },
@@ -354,7 +417,7 @@ function generateInspectHtml(nodeName, info) {
     const gridItems = items.map(item => `
     <div class="detail-item ${item.span ? 'detail-span' : ''}">
       <div class="detail-label">${item.label}</div>
-      <div class="detail-value ${item.highlight ? 'highlight' : ''}">${item.value.replace(/\n/g, '<br>')}</div>
+      <div class="detail-value ${item.highlight ? 'highlight' : ''}">${item.isHtml ? item.value : item.value.replace(/\n/g, '<br>')}</div>
     </div>
   `).join('');
     const header = `
@@ -381,6 +444,49 @@ function generateInspectHtml(nodeName, info) {
   `;
     return wrapHtml(header + body);
 }
+/**
+ * 根据 CPU 使用率返回颜色
+ */
+function parseCpuColor(cpuPercent) {
+    const value = parseFloat(cpuPercent.replace('%', ''));
+    if (isNaN(value))
+        return '#94a3b8';
+    if (value < 30)
+        return '#4ade80';
+    if (value < 60)
+        return '#facc15';
+    if (value < 80)
+        return '#fb923c';
+    return '#f87171';
+}
+/**
+ * 根据内存使用率返回颜色
+ */
+function parseMemColor(memPercent) {
+    const value = parseFloat(memPercent.replace('%', ''));
+    if (isNaN(value))
+        return '#94a3b8';
+    if (value < 50)
+        return '#60a5fa';
+    if (value < 70)
+        return '#facc15';
+    if (value < 85)
+        return '#fb923c';
+    return '#f87171';
+}
+/**
+ * 格式化网络流量显示
+ */
+function formatNetwork(bytes) {
+    const num = parseFloat(bytes);
+    if (isNaN(num))
+        return '-';
+    if (num < 1024)
+        return bytes + 'B/s';
+    if (num < 1024 * 1024)
+        return (num / 1024).toFixed(1) + 'KB/s';
+    return (num / 1024 / 1024).toFixed(2) + 'MB/s';
+}
 /**
  * 生成节点列表 HTML
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-docker-control",
   "description": "Koishi 插件 - 通过 SSH 控制 Docker 容器",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -26,7 +26,8 @@
   },
   "dependencies": {
     "ssh2": "^1.17.0",
-    "puppeteer": "^21.0.0"
+    "puppeteer": "^21.0.0",
+    "dockerode": "^4.0.2"
   },
   "devDependencies": {
     "@types/node": "^20.19.27",