koishi-plugin-docker-control 0.0.4 → 0.0.6

package/lib/commands/compose.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Docker Compose 命令 - 展示和发送 docker compose 配置
+ */
+import { Context } from 'koishi';
+import type { DockerControlConfig } from '../types';
+type GetService = () => any;
+/**
+ * 注册 docker.compose 命令
+ */
+export declare function registerComposeCommand(ctx: Context, getService: GetService, config?: DockerControlConfig): void;
+export {};

package/lib/commands/compose.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerComposeCommand = registerComposeCommand;
+/**
+ * Docker Compose 命令 - 展示和发送 docker compose 配置
+ */
+const koishi_1 = require("koishi");
+const render_1 = require("../utils/render");
+const logger_1 = require("../utils/logger");
+/**
+ * 注册 docker.compose 命令
+ */
+function registerComposeCommand(ctx, getService, config) {
+    const useImageOutput = config?.imageOutput === true;
+    ctx
+        .command('docker.compose <node> <container>', '展示 Docker Compose 配置')
+        .alias('dockercompose', 'compose', 'docker-compose')
+        .option('download', '-d 直接发送 compose 文件(base64编码)')
+        .option('image', '-i 强制使用图片展示')
+        .option('text', '-t 强制使用文字展示')
+        .action(async ({ options, session }, nodeSelector, container) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        if (!nodeSelector || !container) {
+            return '请指定节点和容器: docker.compose <节点> <容器>';
+        }
+        // 获取节点
+        const nodes = service.getNodesBySelector(nodeSelector);
+        if (nodes.length === 0) {
+            return `未找到节点: ${nodeSelector}`;
+        }
+        const node = nodes[0];
+        if (node.status !== 'connected') {
+            return `节点 ${node.name} 未连接`;
+        }
+        // 查找容器
+        let containers;
+        try {
+            containers = await node.listContainers(true);
+        }
+        catch (e) {
+            return `获取容器列表失败: ${e.message}`;
+        }
+        // 支持容器名称或 ID 前缀匹配
+        const targetContainer = containers.find(c => c.Names[0]?.replace('/', '') === container ||
+            c.Id.startsWith(container));
+        if (!targetContainer) {
+            return `未找到容器: ${container}`;
+        }
+        try {
+            // 获取 compose 文件信息
+            const composeInfo = await node.getComposeFileInfo(targetContainer.Id);
+            if (!composeInfo) {
+                return `容器 ${container} 不是由 Docker Compose 启动，或无法找到 compose 文件`;
+            }
+            // 如果指定了 -d 参数，作为文件发送
+            if (options.download) {
+                try {
+                    const filename = `${composeInfo.projectName}-docker-compose.yaml`;
+                    const buffer = Buffer.from(composeInfo.content, 'utf-8');
+                    // 1. 构建 Data URI 字符串
+                    // 使用 application/octet-stream 以避免适配器自作聪明改文件名
+                    const dataUri = 'data:application/octet-stream;base64,' + buffer.toString('base64');
+                    // === 方案 A: 优先尝试使用 assets 服务上传 ===
+                    if (ctx.assets) {
+                        try {
+                            logger_1.connectorLogger.debug(`[compose] 正在通过 assets 上传文件: ${filename}`);
+                            // 传入 Data URI 字符串
+                            const url = await ctx.assets.upload(dataUri, filename);
+                            logger_1.connectorLogger.info(`[compose] Assets 上传成功: ${url}`);
+                            // 直接发送 URL，文件名由 assets 插件的 URL 决定
+                            return koishi_1.h.file(url);
+                        }
+                        catch (e) {
+                            logger_1.connectorLogger.warn(`[compose] Assets 上传失败，尝试降级: ${e.message}`);
+                        }
+                    }
+                    // === 方案 B: 降级方案 ===
+                    // 失败后直接发送 Data URI
+                    logger_1.connectorLogger.debug(`[compose] 发送 DataURI (降级): filename=${filename}`);
+                    return koishi_1.h.file(dataUri, {
+                        filename: filename,
+                        name: filename,
+                    });
+                }
+                catch (e) {
+                    logger_1.connectorLogger.error(`[compose] 生成文件失败: ${e.message}`);
+                    return `生成文件失败: ${e.message}`;
+                }
+            }
+            // 判断使用图片还是文字展示
+            // -i 强制图片，-t 强制文字，都没指定则根据配置
+            const forceImage = options.image;
+            const forceText = options.text;
+            const shouldUseImage = forceImage || (!forceText && useImageOutput && ctx.puppeteer);
+            if (shouldUseImage) {
+                try {
+                    const html = (0, render_1.generateComposeHtml)(node.name, container, composeInfo.projectName, composeInfo.originalPath, composeInfo.serviceCount, composeInfo.content);
+                    return await (0, render_1.renderToImage)(ctx, html);
+                }
+                catch (e) {
+                    // 如果图片渲染失败，回退到文字
+                    if (e.message?.includes('puppeteer')) {
+                        return [
+                            `=== Docker Compose: ${composeInfo.projectName} ===`,
+                            `节点: ${node.name}`,
+                            `容器: ${container}`,
+                            `文件路径: ${composeInfo.originalPath}`,
+                            `服务数量: ${composeInfo.serviceCount}`,
+                            '',
+                            '--- compose.yaml ---',
+                            '',
+                            composeInfo.content,
+                        ].join('\n');
+                    }
+                    throw e;
+                }
+            }
+            // 文字展示
+            return [
+                `=== Docker Compose: ${composeInfo.projectName} ===`,
+                `节点: ${node.name}`,
+                `容器: ${container}`,
+                `文件路径: ${composeInfo.originalPath}`,
+                `服务数量: ${composeInfo.serviceCount}`,
+                '',
+                '--- compose.yaml ---',
+                '',
+                composeInfo.content,
+            ].join('\n');
+        }
+        catch (e) {
+            return `获取 compose 配置失败: ${e.message}`;
+        }
+    });
+}

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/commands/index.js

@@ -4,6 +4,7 @@ exports.registerCommands = registerCommands;
 const list_1 = require("./list");
 const control_1 = require("./control");
 const logs_1 = require("./logs");
+const compose_1 = require("./compose");
 const render_1 = require("../utils/render");
 /**
  * 注册所有指令
@@ -13,6 +14,7 @@ function registerCommands(ctx, getService, config) {
     (0, list_1.registerListCommand)(ctx, getService, config);
     (0, control_1.registerControlCommands)(ctx, getService, config);
     (0, logs_1.registerLogsCommand)(ctx, getService, config);
+    (0, compose_1.registerComposeCommand)(ctx, getService, config);
     // 注册辅助指令
     registerHelperCommands(ctx, getService, config);
 }

package/lib/index.d.ts

@@ -23,6 +23,9 @@ declare module 'koishi' {
         puppeteer?: {
             render: (html: string, callback?: (page: any, next: (handle?: any) => Promise<string>) => Promise<string>) => Promise<string>;
         };
+        assets?: {
+            upload: (data: string | Buffer, filename: string) => Promise<string>;
+        };
     }
     interface Tables {
         'docker_control_subscriptions': DockerControlSubscription;

package/lib/index.js

@@ -13,7 +13,7 @@ const commands_1 = require("./commands");
 exports.name = 'docker-control';
 exports.inject = {
     required: ['database'],
-    optional: ['puppeteer'],
+    optional: ['puppeteer', 'assets'],
 };
 // 导出配置 Schema
 exports.Config = koishi_1.Schema.object({

package/lib/service/connector.d.ts

@@ -74,4 +74,23 @@ export declare class DockerConnector {
      * 获取凭证配置
      */
     private getCredential;
+    /**
+     * 读取文件内容 (支持 Windows 路径和 WSL 路径自动转换)
+     * @param filePath 文件路径 (可能是 Windows 路径如 C:\xxx 或 WSL 路径如 /mnt/c/xxx)
+     * @returns 文件内容
+     */
+    readFile(filePath: string): Promise<string>;
+    /**
+     * 内部文件读取方法
+     */
+    private readFileInternal;
+    /**
+     * 将 Windows 路径转换为 WSL 路径
+     * 例如: C:\Users\anyul\anyulapp\RSSHub\docker-compose.yml -> /mnt/c/Users/anyul/anyulapp/RSSHub/docker-compose.yml
+     */
+    convertWindowsToWslPath(windowsPath: string): string;
+    /**
+     * 检查文件是否存在
+     */
+    fileExists(filePath: string): Promise<boolean>;
 }

package/lib/service/connector.js

@@ -61,8 +61,10 @@ class DockerConnector {
                     catch (e) {
                         // 可能已经关闭，忽略错误
                     }
-                    if (stderr.includes('Error') || stderr.includes('error')) {
-                        reject(new Error(stderr.trim()));
+                    // 非零退出码或包含错误信息时抛出异常
+                    if (code !== 0 || stderr.includes('Error') || stderr.includes('error') || stderr.includes('No such file')) {
+                        const errorMsg = stderr.trim() || `命令执行失败，退出码: ${code}`;
+                        reject(new Error(errorMsg));
                     }
                     else {
                         resolve(stdout.trim());
@@ -300,5 +302,60 @@ class DockerConnector {
     getCredential() {
         return (0, config_1.getCredentialById)(this.fullConfig, this.config.credentialId);
     }
+    /**
+     * 读取文件内容 (支持 Windows 路径和 WSL 路径自动转换)
+     * @param filePath 文件路径 (可能是 Windows 路径如 C:\xxx 或 WSL 路径如 /mnt/c/xxx)
+     * @returns 文件内容
+     */
+    async readFile(filePath) {
+        // 检测是否是 Windows 路径 (包含盘符如 C:\)
+        const isWindowsPath = /^[A-Za-z]:/.test(filePath);
+        if (isWindowsPath) {
+            // 第一次尝试使用原始路径
+            try {
+                return await this.readFileInternal(filePath);
+            }
+            catch (originalError) {
+                // 如果失败，尝试转换为 WSL 路径
+                const wslPath = this.convertWindowsToWslPath(filePath);
+                logger_1.connectorLogger.debug(`[${this.config.name}] 原始路径失败 (${filePath})，尝试 WSL 路径: ${wslPath}`);
+                return await this.readFileInternal(wslPath);
+            }
+        }
+        // 非 Windows 路径直接读取
+        return await this.readFileInternal(filePath);
+    }
+    /**
+     * 内部文件读取方法
+     */
+    async readFileInternal(filePath) {
+        // 使用 cat 命令读取文件
+        // 对路径进行引号处理以支持包含空格的路径
+        const escapedPath = filePath.replace(/"/g, '\\"');
+        return this.exec(`cat "${escapedPath}"`);
+    }
+    /**
+     * 将 Windows 路径转换为 WSL 路径
+     * 例如: C:\Users\anyul\anyulapp\RSSHub\docker-compose.yml -> /mnt/c/Users/anyul/anyulapp/RSSHub/docker-compose.yml
+     */
+    convertWindowsToWslPath(windowsPath) {
+        // 匹配 Windows 盘符路径 (如 C:\xxx 或 C:/xxx)
+        const match = windowsPath.match(/^([A-Za-z]):[\\/](.*)$/);
+        if (!match) {
+            // 如果不是有效的 Windows 路径，返回原路径
+            return windowsPath;
+        }
+        const driveLetter = match[1].toLowerCase();
+        const restPath = match[2].replace(/\\/g, '/');
+        return `/mnt/${driveLetter}/${restPath}`;
+    }
+    /**
+     * 检查文件是否存在
+     */
+    async fileExists(filePath) {
+        const escapedPath = filePath.replace(/"/g, '\\"');
+        const result = await this.execWithExitCode(`test -f "${escapedPath}" && echo "exists" || echo "not exists"`);
+        return result.output.trim() === 'exists';
+    }
 }
 exports.DockerConnector = DockerConnector;

package/lib/service/node.d.ts

@@ -1,4 +1,4 @@
-import type { NodeConfig, ContainerInfo, DockerEvent, NodeStatusType, CredentialConfig } from '../types';
+import type { NodeConfig, ContainerInfo, DockerEvent, NodeStatusType, CredentialConfig, ComposeFileInfo, ContainerComposeInfo } from '../types';
 export declare class DockerNode {
     /** 节点配置 */
     readonly config: NodeConfig;
@@ -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>;
     /**
      * 执行容器内命令
      */
@@ -94,10 +78,76 @@ export declare class DockerNode {
      * 获取镜像数量
      */
     getImageCount(): Promise<number>;
+    /**
+     * 获取容器的 Docker Compose 信息
+     * 通过标签 com.docker.compose.project.config_files 获取 compose 文件路径
+     */
+    getContainerComposeInfo(containerId: string): Promise<ContainerComposeInfo | null>;
+    /**
+     * 获取容器的 Docker Compose 文件信息
+     * 读取并解析 compose 文件
+     */
+    getComposeFileInfo(containerId: string): Promise<ComposeFileInfo | null>;
+    /**
+     * 统计 compose 文件中的服务数量
+     */
+    private countServices;
     /**
      * 获取容器详细信息 (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);
-    }
     /**
      * 执行容器内命令
      */
@@ -185,9 +155,15 @@ class DockerNode {
         if (!this.connector)
             return null;
         try {
-            // 使用更可靠的格式
-            const output = await this.connector.exec('docker info --format "{{.NCPU}} {{.MemTotal}} {{.MemAvailable}}"');
-            const parts = output.trim().split(/\s+/);
+            // 使用 execWithExitCode 避免非零退出码抛出异常
+            const result = await this.connector.execWithExitCode('docker info --format "{{.NCPU}} {{.MemTotal}} {{.MemAvailable}}"');
+            logger_1.nodeLogger.debug(`[${this.name}] docker info 输出: "${result.output}", 退出码: ${result.exitCode}`);
+            // docker info 可能返回退出码 1 但仍有输出（权限问题），只要有输出就解析
+            if (!result.output.trim()) {
+                logger_1.nodeLogger.warn(`[${this.name}] docker info 输出为空`);
+                return null;
+            }
+            const parts = result.output.trim().split(/\s+/);
             if (parts.length >= 2) {
                 return {
                     NCPU: parseInt(parts[0]) || 0,
@@ -198,6 +174,7 @@ class DockerNode {
             return null;
         }
         catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 获取系统信息异常: ${e}`);
             return null;
         }
     }
@@ -233,6 +210,79 @@ class DockerNode {
             return 0;
         }
     }
+    /**
+     * 获取容器的 Docker Compose 信息
+     * 通过标签 com.docker.compose.project.config_files 获取 compose 文件路径
+     */
+    async getContainerComposeInfo(containerId) {
+        if (!this.connector)
+            throw new Error('未连接');
+        try {
+            // 使用 docker inspect 获取容器标签
+            const output = await this.connector.exec(`docker inspect ${containerId} --format "{{json .Config.Labels}}"`);
+            if (!output.trim()) {
+                return null;
+            }
+            const labels = JSON.parse(output);
+            // 获取 compose 项目名称和配置文件路径
+            const projectName = labels['com.docker.compose.project'] || '';
+            const configFiles = labels['com.docker.compose.project.config_files'] || '';
+            if (!projectName || !configFiles) {
+                return null;
+            }
+            return {
+                containerId,
+                containerName: labels['com.docker.compose.container-number'] || '',
+                projectName,
+                composeFilePath: configFiles,
+            };
+        }
+        catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 获取容器 ${containerId} 的 compose 信息失败: ${e}`);
+            return null;
+        }
+    }
+    /**
+     * 获取容器的 Docker Compose 文件信息
+     * 读取并解析 compose 文件
+     */
+    async getComposeFileInfo(containerId) {
+        if (!this.connector)
+            throw new Error('未连接');
+        try {
+            const composeInfo = await this.getContainerComposeInfo(containerId);
+            if (!composeInfo) {
+                return null;
+            }
+            const filePath = composeInfo.composeFilePath;
+            const originalPath = filePath;
+            // 尝试读取文件 (支持 Windows 路径自动转换)
+            const content = await this.connector.readFile(filePath);
+            // 统计服务数量 (简单的 yaml 解析)
+            const serviceCount = this.countServices(content);
+            return {
+                originalPath,
+                effectivePath: filePath,
+                usedWslPath: false, // 实际是否使用了 WSL 路径在内部处理
+                content,
+                projectName: composeInfo.projectName,
+                serviceCount,
+            };
+        }
+        catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 获取 compose 文件信息失败: ${e.message}`);
+            return null;
+        }
+    }
+    /**
+     * 统计 compose 文件中的服务数量
+     */
+    countServices(content) {
+        // 简单的正则匹配 services: 下面的服务名
+        const servicePattern = /^[a-zA-Z0-9_-]+:\s*$/gm;
+        const matches = content.match(servicePattern);
+        return matches ? matches.length : 0;
+    }
     /**
      * 获取容器详细信息 (docker inspect)
      */
@@ -243,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 输出
      */
@@ -593,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/types.d.ts

@@ -98,3 +98,27 @@ export interface SubscriptionConfig {
     /** 创建时间 */
     createdAt?: number;
 }
+export interface ComposeFileInfo {
+    /** 原始路径 (Windows 路径或 WSL 路径) */
+    originalPath: string;
+    /** 实际使用的路径 (尝试转换后的路径) */
+    effectivePath: string;
+    /** 是否使用了 WSL 路径转换 */
+    usedWslPath: boolean;
+    /** Compose 文件内容 */
+    content: string;
+    /** 所属项目名称 */
+    projectName: string;
+    /** 容器数量 */
+    serviceCount: number;
+}
+export interface ContainerComposeInfo {
+    /** 容器 ID */
+    containerId: string;
+    /** 容器名称 */
+    containerName: string;
+    /** 所属 Docker Compose 项目 */
+    projectName: string;
+    /** Compose 文件路径 */
+    composeFilePath: string;
+}

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
  */
@@ -45,4 +55,8 @@ export declare function generateLogsHtml(nodeName: string, containerName: string
  * 生成执行结果 HTML
  */
 export declare function generateExecHtml(nodeName: string, containerName: string, command: string, output: string, exitCode: number): string;
+/**
+ * 生成 Docker Compose 配置 HTML
+ */
+export declare function generateComposeHtml(nodeName: string, containerName: string, projectName: string, filePath: string, serviceCount: number, composeContent: string): string;
 export {};

package/lib/utils/render.js

@@ -8,6 +8,7 @@ exports.generateNodesHtml = generateNodesHtml;
 exports.generateNodeDetailHtml = generateNodeDetailHtml;
 exports.generateLogsHtml = generateLogsHtml;
 exports.generateExecHtml = generateExecHtml;
+exports.generateComposeHtml = generateComposeHtml;
 const koishi_1 = require("koishi");
 // 基础样式
 const STYLE = `
@@ -299,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;
@@ -334,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 },
@@ -343,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 },
@@ -353,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 = `
@@ -380,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
  */
@@ -680,3 +787,80 @@ function generateExecHtml(nodeName, containerName, command, output, exitCode) {
   `;
     return wrapHtml(header + body);
 }
+/**
+ * 生成 Docker Compose 配置 HTML
+ */
+function generateComposeHtml(nodeName, containerName, projectName, filePath, serviceCount, composeContent) {
+    // 对内容进行语法高亮
+    const highlightedContent = highlightYaml(composeContent);
+    const header = `
+    <div class="header">
+      <div class="header-title">Docker Compose</div>
+      <div class="header-badge">${nodeName}/${containerName}</div>
+    </div>
+  `;
+    const body = `
+    <div class="content">
+      <div class="detail-card" style="margin-bottom: 20px;">
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 16px;">
+          <div class="detail-item">
+            <div class="detail-label">项目名称</div>
+            <div class="detail-value highlight">${projectName}</div>
+          </div>
+          <div class="detail-item">
+            <div class="detail-label">服务数量</div>
+            <div class="detail-value">${serviceCount} 个</div>
+          </div>
+          <div class="detail-item" style="grid-column: 1 / -1;">
+            <div class="detail-label">文件路径</div>
+            <div class="detail-value" style="font-size: 13px;">${filePath}</div>
+          </div>
+        </div>
+      </div>
+
+      <div style="
+        background: rgba(0, 0, 0, 0.3);
+        border-radius: 8px;
+        padding: 16px;
+        font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+        font-size: 12px;
+        line-height: 1.6;
+        white-space: pre-wrap;
+        word-break: break-all;
+      ">${highlightedContent}</div>
+    </div>
+  `;
+    // 添加 YAML 高亮样式
+    const yamlStyle = `
+    .yaml-key { color: #60a5fa; }
+    .yaml-string { color: #a5f3fc; }
+    .yaml-number { color: #f472b6; }
+    .yaml-boolean { color: #fbbf24; }
+    .yaml-null { color: #94a3b8; }
+    .yaml-comment { color: #64748b; font-style: italic; }
+    .yaml-bracket { color: #f87171; }
+  `;
+    return wrapHtml(header + body, STYLE + yamlStyle);
+}
+/**
+ * 简单的 YAML 语法高亮
+ */
+function highlightYaml(content) {
+    // HTML 转义
+    let html = escapeHtml(content);
+    // 高亮键名 (冒号前的单词)
+    html = html.replace(/^([a-zA-Z0-9_-]+):(\s*)$/gm, '<span class="yaml-key">$1</span>:<br>');
+    // 高亮带引号的字符串
+    html = html.replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, '<span class="yaml-string">$1</span>');
+    // 高亮数字
+    html = html.replace(/\b(\d+\.?\d*)\b/g, '<span class="yaml-number">$1</span>');
+    // 高亮布尔值
+    html = html.replace(/\b(true|false|yes|no|on|off)\b/gi, '<span class="yaml-boolean">$1</span>');
+    // 高亮 null
+    html = html.replace(/\bnull\b/gi, '<span class="yaml-null">null</span>');
+    // 高亮注释
+    html = html.replace(/#.*$/gm, '<span class="yaml-comment">$&</span>');
+    // 高亮括号
+    html = html.replace(/([\[\]{}()])/g, '<span class="yaml-bracket">$1</span>');
+    return html;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-docker-control",
   "description": "Koishi 插件 - 通过 SSH 控制 Docker 容器",
-  "version": "0.0.4",
+  "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",