koishi-plugin-docker-control 0.0.4 → 0.0.5

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/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;
@@ -94,6 +94,20 @@ 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)
      */

package/lib/service/node.js

@@ -185,9 +185,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 +204,7 @@ class DockerNode {
             return null;
         }
         catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 获取系统信息异常: ${e}`);
             return null;
         }
     }
@@ -233,6 +240,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)
      */

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

@@ -45,4 +45,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 = `
@@ -680,3 +681,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.5",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [