koishi-plugin-docker-control 0.1.0 → 0.1.2

package/lib/commands/compose.js

@@ -135,4 +135,97 @@ function registerComposeCommand(ctx, getService, config) {
             return `获取 compose 配置失败: ${e.message}`;
         }
     });
+    /**
+     * 更新 compose 缓存命令
+     */
+    ctx
+        .command('docker.compose.update <node> <container>', '手动更新 compose 文件缓存')
+        .alias('compose.update')
+        .action(async (_, nodeSelector, container) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        if (!nodeSelector || !container) {
+            return '请指定节点和容器: docker.compose.update <节点> <容器>';
+        }
+        // 获取节点
+        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}`;
+        }
+        // 更新缓存
+        const result = await node.updateComposeCache(targetContainer.Id);
+        return result.message;
+    });
+    /**
+     * 清除 compose 缓存命令
+     */
+    ctx
+        .command('docker.compose.clear [node] [container]', '清除 compose 文件缓存')
+        .alias('compose.clear')
+        .action(async (_, nodeSelector, container) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        if (!nodeSelector) {
+            // 清除所有缓存
+            let totalCleared = 0;
+            const nodes = service.getAllNodes();
+            for (const node of nodes) {
+                const result = await node.clearComposeCache();
+                totalCleared += result.cleared;
+            }
+            return totalCleared > 0
+                ? `已清除所有节点的 compose 缓存 (共 ${totalCleared} 条)`
+                : '没有需要清除的缓存';
+        }
+        // 获取节点
+        const nodes = service.getNodesBySelector(nodeSelector);
+        if (nodes.length === 0) {
+            return `未找到节点: ${nodeSelector}`;
+        }
+        const node = nodes[0];
+        if (!container) {
+            // 清除指定节点的所有缓存
+            const result = await node.clearComposeCache();
+            return result.message;
+        }
+        // 查找容器
+        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}`;
+        }
+        // 清除指定容器的缓存
+        const result = await node.clearComposeCache(targetContainer.Id);
+        return result.message;
+    });
 }

package/lib/commands/index.js

@@ -34,6 +34,42 @@ function registerCommands(ctx, getService, config) {
  */
 function registerHelperCommands(ctx, getService, config) {
     const useImageOutput = config?.imageOutput === true;
+    /**
+     * 诊断：查看节点原始配置
+     */
+    ctx.command('docker.debug.config', '查看节点原始配置（诊断用）')
+        .action(async () => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        const nodes = service.getAllNodes();
+        if (nodes.length === 0) {
+            return '未配置任何节点';
+        }
+        const lines = [];
+        lines.push('=== 节点原始配置诊断 ===\n');
+        for (const node of nodes) {
+            const config = node.config;
+            lines.push(`【${config.name}】`);
+            lines.push(`  ID: ${config.id}`);
+            lines.push(`  Host: ${config.host}`);
+            lines.push(`  Port: ${config.port} (类型: ${typeof config.port})`);
+            lines.push(`  Credential: ${config.credentialId}`);
+            lines.push(`  Tags: ${config.tags.join(', ') || '(无)'}`);
+            // 检测异常
+            if (typeof config.port === 'string') {
+                if (config.port.includes('.') || config.port.includes(':')) {
+                    lines.push(`  ⚠️  检测到异常端口配置: 包含IP地址或特殊字符`);
+                }
+            }
+            else if (typeof config.port !== 'number') {
+                lines.push(`  ⚠️  检测到异常端口类型: ${typeof config.port}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    });
     /**
      * 查看节点列表
      */
@@ -97,18 +133,21 @@ function registerHelperCommands(ctx, getService, config) {
                 const html = (0, render_1.generateNodeDetailHtml)(nodeData, version, systemInfo);
                 return await (0, render_1.renderToImage)(ctx, html);
             }
-            const memoryUsed = systemInfo?.MemTotal && systemInfo?.MemAvailable !== undefined
-                ? `${Math.round((1 - systemInfo.MemAvailable / systemInfo.MemTotal) * 100)}%`
-                : '-';
             const nodeName = node.config?.name || node.name || node.Name || 'Unknown';
             const nodeId = node.id || node.ID || node.Id || node.config?.id || '-';
+            // 格式化内存显示：总内存量
+            let memoryDisplay = '-';
+            if (systemInfo?.MemTotal) {
+                const memGB = (systemInfo.MemTotal / 1024 / 1024 / 1024).toFixed(2);
+                memoryDisplay = `${memGB} GB`;
+            }
             const lines = [
                 `=== ${nodeName} ===`,
                 `ID: ${nodeId}`,
                 `状态: ${node.status || node.Status || 'unknown'}`,
                 `标签: ${node.tags?.join(', ') || node.config?.tags?.join(', ') || '无'}`,
                 `CPU: ${systemInfo?.NCPU || '-'} 核心`,
-                `内存: ${memoryUsed} (可用: ${systemInfo?.MemAvailable ? Math.round(systemInfo.MemAvailable / 1024 / 1024) + ' MB' : '-'})`,
+                `内存: ${memoryDisplay}`,
                 `容器: ${containerCount.running}/${containerCount.total} 运行中`,
                 `镜像: ${imageCount} 个`,
                 `Docker 版本: ${version.Version}`,

package/lib/constants.d.ts

@@ -8,6 +8,8 @@ export declare const MAX_RETRY_COUNT = 3;
 export declare const MONITOR_RETRY_INTERVAL = 30000;
 export declare const EVENTS_POLL_INTERVAL = 60000;
 export declare const CONTAINER_POLL_INTERVAL: number;
+export declare const API_HEALTH_CHECK_INTERVAL: number;
+export declare const DEGRADED_POLL_INTERVAL: number;
 export declare const DEFAULT_LOG_LINES = 100;
 export declare const NodeStatus: {
     readonly DISCONNECTED: "disconnected";

package/lib/constants.js

@@ -3,7 +3,7 @@
  * 常量定义
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerAction = exports.NodeStatus = exports.DEFAULT_LOG_LINES = exports.CONTAINER_POLL_INTERVAL = exports.EVENTS_POLL_INTERVAL = exports.MONITOR_RETRY_INTERVAL = exports.MAX_RETRY_COUNT = exports.SSH_TIMEOUT = exports.RETRY_INTERVAL = exports.DEFAULT_TIMEOUT = void 0;
+exports.ContainerAction = exports.NodeStatus = exports.DEFAULT_LOG_LINES = exports.DEGRADED_POLL_INTERVAL = exports.API_HEALTH_CHECK_INTERVAL = exports.CONTAINER_POLL_INTERVAL = exports.EVENTS_POLL_INTERVAL = exports.MONITOR_RETRY_INTERVAL = exports.MAX_RETRY_COUNT = exports.SSH_TIMEOUT = exports.RETRY_INTERVAL = exports.DEFAULT_TIMEOUT = void 0;
 // 默认请求超时时间 (毫秒)
 exports.DEFAULT_TIMEOUT = 5000;
 // 默认重试间隔 (毫秒)
@@ -16,8 +16,12 @@ exports.MAX_RETRY_COUNT = 3;
 exports.MONITOR_RETRY_INTERVAL = 30000;
 // Docker Events 监听间隔 (毫秒) - 已改为流式监听，此常量仅作备用
 exports.EVENTS_POLL_INTERVAL = 60000;
-// 容器状态轮询间隔 (毫秒) - 改为5分钟仅作兜底同步
+// 容器状态轮询间隔 (毫秒) - 仅在API降级时使用
 exports.CONTAINER_POLL_INTERVAL = 5 * 60 * 1000;
+// Docker API 健康检查间隔 (毫秒) - 定期检测API是否恢复
+exports.API_HEALTH_CHECK_INTERVAL = 60 * 1000;
+// 降级轮询间隔 (毫秒) - API不可用时的轮询频率
+exports.DEGRADED_POLL_INTERVAL = 30 * 1000;
 // 日志行数默认
 exports.DEFAULT_LOG_LINES = 100;
 // 节点状态枚举

package/lib/index.d.ts

@@ -43,6 +43,16 @@ interface AuditLogRecord {
     containerId: string;
     metadata: Record<string, any>;
 }
+interface ComposeFileCache {
+    id: string;
+    containerId: string;
+    filePath: string;
+    content: string;
+    projectName: string;
+    serviceCount: number;
+    mtime: number;
+    updatedAt: number;
+}
 declare module 'koishi' {
     interface Context {
         puppeteer?: {
@@ -56,6 +66,7 @@ declare module 'koishi' {
         'docker_control_subscriptions': DockerControlSubscription;
         'docker_user_permissions': UserPermissionRecord;
         'docker_audit_logs': AuditLogRecord;
+        'docker_compose_cache': ComposeFileCache;
     }
 }
 export declare const Config: Schema<Schemastery.ObjectS<{

package/lib/index.js

@@ -86,6 +86,46 @@ function apply(ctx, config) {
         logger_1.logger.info('Docker Control 配置未定义，跳过加载');
         return;
     }
+    // 🔍 诊断：打印原始配置信息
+    logger_1.logger.info('=== 配置诊断 ===');
+    logger_1.logger.info(`配置中的节点数量: ${config.nodes?.length || 0}`);
+    if (config.nodes && config.nodes.length > 0) {
+        for (const node of config.nodes) {
+            logger_1.logger.info(`节点 [${node.name}]:`);
+            logger_1.logger.info(`  ID: ${node.id}`);
+            logger_1.logger.info(`  Host: ${node.host}`);
+            logger_1.logger.info(`  Port: ${node.port} (类型: ${typeof node.port})`);
+            logger_1.logger.info(`  Credential: ${node.credentialId}`);
+        }
+    }
+    logger_1.logger.info('================');
+    // 🔧 第一道防线：在插件入口处清理配置
+    if (config.nodes) {
+        for (const node of config.nodes) {
+            if (typeof node.port === 'string') {
+                const portStr = node.port;
+                if (portStr.includes('.') || portStr.includes(':')) {
+                    logger_1.logger.warn(`[配置清理] 节点 ${node.name} 检测到异常端口: "${portStr}"，已修正为 22`);
+                    node.port = 22;
+                }
+                else {
+                    const parsed = parseInt(portStr, 10);
+                    if (!isNaN(parsed) && parsed >= 1 && parsed <= 65535) {
+                        ;
+                        node.port = parsed;
+                    }
+                    else {
+                        logger_1.logger.error(`[配置清理] 节点 ${node.name} 端口值无效: "${portStr}"，已修正为 22`);
+                        node.port = 22;
+                    }
+                }
+            }
+            else if (typeof node.port !== 'number' || node.port < 1 || node.port > 65535) {
+                logger_1.logger.error(`[配置清理] 节点 ${node.name} 端口异常: ${node.port} (${typeof node.port})，已修正为 22`);
+                node.port = 22;
+            }
+        }
+    }
     // 验证配置
     const errors = [];
     const credentialIds = new Set(config.credentials?.map(c => c.id) || []);

package/lib/service/connector.d.ts

@@ -1,9 +1,22 @@
+/**
+ * SSH 连接器 - 通过 SSH 执行 docker 命令
+ */
+import { Client } from 'ssh2';
 import type { NodeConfig, DockerControlConfig } from '../types';
 export declare class DockerConnector {
     private config;
     private fullConfig;
     private sshClient;
     constructor(config: NodeConfig, fullConfig: DockerControlConfig);
+    /**
+     * 获取内部 SSH Client（用于连接复用）
+     * 如果尚未连接，会触发连接建立
+     */
+    getSshClient(): Promise<Client>;
+    /**
+     * 验证并修正配置
+     */
+    private validateConfig;
     /**
      * 执行 SSH 命令
      */
@@ -93,4 +106,8 @@ export declare class DockerConnector {
      * 检查文件是否存在
      */
     fileExists(filePath: string): Promise<boolean>;
+    /**
+     * 获取文件修改时间 (Unix 时间戳，秒)
+     */
+    getFileModTime(filePath: string): Promise<number>;
 }

package/lib/service/connector.js

@@ -14,6 +14,38 @@ class DockerConnector {
         this.fullConfig = fullConfig;
         this.sshClient = null;
         this.connected = true;
+        // 立即验证并修正配置
+        this.validateConfig();
+    }
+    /**
+     * 获取内部 SSH Client（用于连接复用）
+     * 如果尚未连接，会触发连接建立
+     */
+    async getSshClient() {
+        return await this.getConnection();
+    }
+    /**
+     * 验证并修正配置
+     */
+    validateConfig() {
+        if (typeof this.config.port === 'string') {
+            const portStr = this.config.port;
+            if (portStr.includes('.') || portStr.includes(':')) {
+                logger_1.connectorLogger.warn(`[${this.config.name}] 检测到异常端口配置: "${portStr}"，已自动修正为 22`);
+                this.config.port = 22;
+            }
+            else {
+                const parsed = parseInt(portStr, 10);
+                if (!isNaN(parsed) && parsed >= 1 && parsed <= 65535) {
+                    ;
+                    this.config.port = parsed;
+                }
+                else {
+                    logger_1.connectorLogger.error(`[${this.config.name}] 端口值无效: "${portStr}"，已自动修正为 22`);
+                    this.config.port = 22;
+                }
+            }
+        }
     }
     /**
      * 执行 SSH 命令
@@ -30,7 +62,8 @@ class DockerConnector {
                 const msg = err.message || '';
                 // 如果是 SSH 通道打开失败，或者是连接已结束，则强制重连
                 if (msg.includes('Channel open failure') || msg.includes('Client ended') || msg.includes('Socket ended')) {
-                    logger_1.connectorLogger.warn(`[${this.config.name}] SSH 连接异常 (${msg})，尝试重连...`);
+                    logger_1.connectorLogger.warn(`[${this.config.name}] ⚠ SSH连接异常: ${msg}，尝试重连...`);
+                    logger_1.connectorLogger.debug(`[${this.config.name}] 重连将产生新的SSH登录记录`);
                     this.dispose(); // 强制销毁当前连接
                     continue; // 重试
                 }
@@ -42,11 +75,11 @@ class DockerConnector {
     }
     async execInternal(command) {
         const client = await this.getConnection();
-        logger_1.connectorLogger.debug(`[${this.config.name}] 执行命令: ${command}`);
+        logger_1.connectorLogger.debug(`[${this.config.name}] 🔧 执行SSH命令: ${command}`);
         return new Promise((resolve, reject) => {
             client.exec(command, (err, stream) => {
                 if (err) {
-                    logger_1.connectorLogger.debug(`[${this.config.name}] 命令执行错误: ${err.message}`);
+                    logger_1.connectorLogger.warn(`[${this.config.name}] SSH命令执行失败: ${err.message}`);
                     reject(err);
                     return;
                 }
@@ -171,7 +204,7 @@ class DockerConnector {
                     reject(err);
                     return;
                 }
-                logger_1.connectorLogger.info(`[${this.config.name}] Docker 事件流已连接`);
+                logger_1.connectorLogger.info(`[${this.config.name}] ✅ Docker 事件流已建立长连接 (docker events --format json --filter type=container)`);
                 let buffer = '';
                 let closed = false;
                 const stop = () => {
@@ -186,13 +219,14 @@ class DockerConnector {
                         catch (e) {
                             // 可能已经关闭，忽略错误
                         }
-                        logger_1.connectorLogger.debug(`[${this.config.name}] 主动停止事件流`);
+                        logger_1.connectorLogger.info(`[${this.config.name}] 🔒 主动停止事件流`);
                     }
                 };
                 stream.on('close', (code, signal) => {
                     if (!closed) {
                         closed = true;
-                        logger_1.connectorLogger.warn(`[${this.config.name}] 事件流意外断开 (Code: ${code}, Signal: ${signal})`);
+                        logger_1.connectorLogger.error(`[${this.config.name}] ❌ 事件流意外断开！Code: ${code}, Signal: ${signal}`);
+                        logger_1.connectorLogger.error(`[${this.config.name}] ⚠ 事件流断开后，node.ts 会自动重连 (将产生新的SSH登录记录)`);
                     }
                 });
                 stream.on('data', (data) => {
@@ -226,6 +260,7 @@ class DockerConnector {
      */
     dispose() {
         if (this.sshClient) {
+            logger_1.connectorLogger.info(`[${this.config.name}] 主动销毁 SSH 连接`);
             this.sshClient.end();
             this.sshClient = null;
         }
@@ -247,32 +282,42 @@ class DockerConnector {
         if (!credential) {
             throw new Error(`凭证不存在: ${this.config.credentialId}`);
         }
-        logger_1.connectorLogger.info(`[${this.config.name}] 正在连接到 ${this.config.host}:${this.config.port}`);
-        logger_1.connectorLogger.debug(`[${this.config.name}] 用户名: ${credential.username}, 认证方式: ${credential.authType}`);
+        const port = typeof this.config.port === 'string'
+            ? parseInt(this.config.port, 10)
+            : (this.config.port || 22);
+        logger_1.connectorLogger.info(`[${this.config.name}] 🔗 建立新的SSH连接...`);
+        logger_1.connectorLogger.info(`[${this.config.name}] 目标: ${credential.username}@${this.config.host}:${port}`);
+        logger_1.connectorLogger.info(`[${this.config.name}] 认证方式: ${credential.authType}`);
         return new Promise((resolve, reject) => {
             const conn = new ssh2_1.Client();
             conn.on('ready', () => {
-                logger_1.connectorLogger.info(`[${this.config.name}] SSH 连接成功`);
+                logger_1.connectorLogger.info(`[${this.config.name}] ✅ SSH连接成功 (user=${credential.username}, host=${this.config.host}, port=${port})`);
                 resolve(conn);
             });
             conn.on('error', (err) => {
-                logger_1.connectorLogger.error(`[${this.config.name}] SSH 连接失败: ${err.message}`);
+                logger_1.connectorLogger.error(`[${this.config.name}] ❌ SSH连接失败: ${err.message} (host=${this.config.host}, port=${port})`);
+                logger_1.connectorLogger.error(`[${this.config.name}] ⚠ 连接失败后将在片刻重试 (重试会产生新的SSH登录记录)`);
                 conn.end();
                 reject(err);
             });
             conn.on('close', () => {
-                logger_1.connectorLogger.debug(`[${this.config.name}] SSH 连接关闭`);
+                const reason = this.connected ? 'SSH连接意外断开' : 'SSH连接已关闭';
+                logger_1.connectorLogger.warn(`[${this.config.name}] ${reason} (host=${this.config.host}, port=${this.config.port})`);
+                this.connected = false;
             });
             conn.on('banner', (msg) => {
                 logger_1.connectorLogger.debug(`[${this.config.name}] SSH Banner: ${msg.trim()}`);
             });
             const connectConfig = {
                 host: this.config.host,
-                port: this.config.port,
+                port: port,
                 username: credential.username,
                 readyTimeout: constants_1.SSH_TIMEOUT,
                 timeout: constants_1.SSH_TIMEOUT,
                 tryKeyboard: true,
+                // === 保持连接活跃，防止被服务器踢掉 ===
+                keepaliveInterval: 15000, // 每15秒发送一次心跳
+                keepaliveCountMax: 3, // 失败3次认为断开
                 ...this.buildAuthOptions(credential),
             };
             conn.connect(connectConfig);
@@ -357,5 +402,13 @@ class DockerConnector {
         const result = await this.execWithExitCode(`test -f "${escapedPath}" && echo "exists" || echo "not exists"`);
         return result.output.trim() === 'exists';
     }
+    /**
+     * 获取文件修改时间 (Unix 时间戳，秒)
+     */
+    async getFileModTime(filePath) {
+        const escapedPath = filePath.replace(/"/g, '\\"');
+        const output = await this.exec(`stat -c %Y "${escapedPath}" 2>/dev/null || echo "0"`);
+        return parseInt(output.trim(), 10);
+    }
 }
 exports.DockerConnector = DockerConnector;

package/lib/service/index.d.ts

@@ -21,6 +21,10 @@ export declare class DockerService {
     auditLogger?: AuditLogger;
     reconnectManager?: ReconnectManager;
     constructor(ctx: Context, config: DockerControlConfig);
+    /**
+     * 清理节点配置
+     */
+    private cleanNodeConfig;
     /**
      * 初始化所有节点
      */

package/lib/service/index.js

@@ -12,6 +12,37 @@ class DockerService {
         this.ctx = ctx;
         this.config = config;
     }
+    /**
+     * 清理节点配置
+     */
+    cleanNodeConfig(nodeConfig) {
+        // 创建配置副本以避免修改原始配置
+        const cleaned = { ...nodeConfig };
+        // 验证并清理端口
+        if (typeof cleaned.port === 'string') {
+            const portStr = cleaned.port;
+            if (portStr.includes('.') || portStr.includes(':')) {
+                logger_1.logger.warn(`节点 ${cleaned.name} 检测到异常端口配置: "${portStr}"，已自动修正为 22`);
+                cleaned.port = 22;
+            }
+            else {
+                const parsed = parseInt(portStr, 10);
+                if (!isNaN(parsed) && parsed >= 1 && parsed <= 65535) {
+                    ;
+                    cleaned.port = parsed;
+                }
+                else {
+                    logger_1.logger.error(`节点 ${cleaned.name} 端口值无效: "${portStr}"，已自动修正为 22`);
+                    cleaned.port = 22;
+                }
+            }
+        }
+        else if (typeof cleaned.port !== 'number' || cleaned.port < 1 || cleaned.port > 65535) {
+            logger_1.logger.error(`节点 ${cleaned.name} 端口类型或值异常: ${cleaned.port}，已自动修正为 22`);
+            cleaned.port = 22;
+        }
+        return cleaned;
+    }
     /**
      * 初始化所有节点
      */
@@ -26,7 +57,9 @@ class DockerService {
                 logger_1.logger.warn(`节点 ${nodeConfig.name} 找不到凭证 ${nodeConfig.credentialId}，跳过`);
                 continue;
             }
-            const node = new node_1.DockerNode(nodeConfig, credential, this.config.debug);
+            // 清理和验证端口配置
+            const cleanedNodeConfig = this.cleanNodeConfig(nodeConfig);
+            const node = new node_1.DockerNode(this.ctx, cleanedNodeConfig, credential, this.config.debug);
             // 【关键修复】创建节点时，立即绑定事件转发
             // 无论 index.ts 何时调用 onNodeEvent，这里都会把事件转发给 eventCallbacks
             node.onEvent((event) => {