koishi-plugin-docker-control 0.1.1 → 0.1.2

package/lib/commands/index.js

@@ -133,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/service/connector.d.ts

@@ -1,9 +1,18 @@
+/**
+ * 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>;
     /**
      * 验证并修正配置
      */

package/lib/service/connector.js

@@ -17,6 +17,13 @@ class DockerConnector {
         // 立即验证并修正配置
         this.validateConfig();
     }
+    /**
+     * 获取内部 SSH Client（用于连接复用）
+     * 如果尚未连接，会触发连接建立
+     */
+    async getSshClient() {
+        return await this.getConnection();
+    }
     /**
      * 验证并修正配置
      */
@@ -55,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; // 重试
                 }
@@ -67,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;
                 }
@@ -196,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 = () => {
@@ -211,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) => {
@@ -251,6 +260,7 @@ class DockerConnector {
      */
     dispose() {
         if (this.sshClient) {
+            logger_1.connectorLogger.info(`[${this.config.name}] 主动销毁 SSH 连接`);
             this.sshClient.end();
             this.sshClient = null;
         }
@@ -272,29 +282,32 @@ 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()}`);
             });
-            // 确保 port 是数字类型
-            const port = typeof this.config.port === 'string'
-                ? parseInt(this.config.port, 10)
-                : (this.config.port || 22);
             const connectConfig = {
                 host: this.config.host,
                 port: port,
@@ -302,6 +315,9 @@ class DockerConnector {
                 readyTimeout: constants_1.SSH_TIMEOUT,
                 timeout: constants_1.SSH_TIMEOUT,
                 tryKeyboard: true,
+                // === 保持连接活跃，防止被服务器踢掉 ===
+                keepaliveInterval: 15000, // 每15秒发送一次心跳
+                keepaliveCountMax: 3, // 失败3次认为断开
                 ...this.buildAuthOptions(credential),
             };
             conn.connect(connectConfig);

package/lib/service/node.d.ts

@@ -10,8 +10,10 @@ export declare class DockerNode {
     status: NodeStatusType;
     /** Koishi Context (用于数据库操作) */
     private readonly ctx;
-    /** SSH 连接器 */
+    /** SSH 连接器 (Fallback用) */
     private connector;
+    /** 持久化 SSH 客户端 (API用) */
+    private sshClient;
     /** Dockerode 实例 (用于 API 调用) */
     private dockerode;
     /** Docker API 是否可用 */
@@ -43,13 +45,17 @@ export declare class DockerNode {
     constructor(ctx: Context, config: NodeConfig, credential: CredentialConfig, debug?: boolean);
     /**
      * 连接到 Docker (带重试)
-     * 前 3 次失败后每 1 分钟重试一次，直到成功
+     * 优化：优先尝试 API 连接，成功则不再建立多余的 SSH 命令行连接
      */
     connect(): Promise<void>;
     /**
      * 验证和清理配置
      */
     private validateAndCleanConfig;
+    /**
+     * 销毁 SSH 客户端
+     */
+    private disposeSshClient;
     /**
      * 断开连接
      */
@@ -79,6 +85,7 @@ export declare class DockerNode {
     }>;
     /**
      * 获取系统信息 (CPU、内存)
+     * 优先使用 Docker API，失败时降级到 SSH 命令
      */
     getSystemInfo(): Promise<{
         NCPU: number;
@@ -264,7 +271,7 @@ export declare class DockerNode {
     }>>;
     /**
      * 初始化 Dockerode
-     * 根据配置决定连接本地 Socket 还是通过 SSH 连接远程
+     * 建立唯一的 SSH 连接，并通过 `docker system dial-stdio` 复用连接
      */
     private initDockerode;
     /**
@@ -329,6 +336,7 @@ export declare class DockerNode {
     private startMonitoring;
     /**
      * 启动 API 健康检查
+     * DPanel模式：信任底层 Keep-Alive，不主动 Ping，只在操作报错时重连
      */
     private startHealthCheck;
     /**
@@ -349,8 +357,13 @@ export declare class DockerNode {
     private pollContainerStates;
     /**
      * 启动 Docker 事件流监听
+     * 优先使用 Docker API (长连接且有心跳)，失败降级到 SSH 命令
      */
     private startEventStream;
+    /**
+     * 重启事件流
+     */
+    private restartEventStream;
     /**
      * 处理事件流中的一行数据
      */

package/lib/service/node.js

@@ -9,6 +9,8 @@ exports.DockerNode = void 0;
  */
 const koishi_1 = require("koishi");
 const dockerode_1 = __importDefault(require("dockerode"));
+const http_1 = __importDefault(require("http"));
+const ssh2_1 = require("ssh2");
 const constants_1 = require("../constants");
 const connector_1 = require("./connector");
 const logger_1 = require("../utils/logger");
@@ -18,8 +20,10 @@ class DockerNode {
     constructor(ctx, config, credential, debug = false) {
         /** 节点状态 */
         this.status = constants_1.NodeStatus.DISCONNECTED;
-        /** SSH 连接器 */
+        /** SSH 连接器 (Fallback用) */
         this.connector = null;
+        /** 持久化 SSH 客户端 (API用) */
+        this.sshClient = null;
         /** Dockerode 实例 (用于 API 调用) */
         this.dockerode = null;
         /** Docker API 是否可用 */
@@ -67,7 +71,7 @@ class DockerNode {
     }
     /**
      * 连接到 Docker (带重试)
-     * 前 3 次失败后每 1 分钟重试一次，直到成功
+     * 优化：优先尝试 API 连接，成功则不再建立多余的 SSH 命令行连接
      */
     async connect() {
         if (this.status === constants_1.NodeStatus.CONNECTING) {
@@ -91,21 +95,33 @@ class DockerNode {
                 logger_1.nodeLogger.info(`[${this.name}] 连接尝试 ${attempt} (每 ${LONG_RETRY_INTERVAL / 1000} 秒重试)...`);
             }
             try {
-                // 创建 connector（仅建立连接，不执行命令）
-                const connector = new connector_1.DockerConnector(this.config, { credentials: [this.credential], nodes: [this.config] });
-                this.connector = connector;
-                // 尝试初始化 Dockerode (优先使用 API)
+                // === 优化策略：完全依赖 Docker API，不预创建 connector ===
+                // 只有在 API 真正失败时，才创建 connector 并建立 SSH 连接
+                // 1. 先尝试初始化 Docker API（不创建 connector）
+                // 这可能会产生 1-2 个 SSH 连接（ping + getEvents）
                 await this.initDockerode();
-                // 如果 API 不可用，测试 SSH 连接和 docker 命令
+                // 2. 只有当 API 不可用时，才创建 connector 并降级到 SSH 命令
                 if (!this.dockerApiAvailable) {
-                    logger_1.nodeLogger.debug(`[${this.name}] Docker API 不可用，测试 SSH docker 命令`);
+                    logger_1.nodeLogger.warn(`[${this.name}] Docker API 不可用，创建 connector 并降级到 SSH 命令...`);
+                    const connector = new connector_1.DockerConnector(this.config, { credentials: [this.credential], nodes: [this.config] });
+                    this.connector = connector;
+                    // 测试 SSH 命令（这会建立第 1 个 SSH 连接）
                     await connector.exec('docker version --format "{{.Server.Version}}"');
+                    logger_1.nodeLogger.info(`[${this.name}] ⚠ 已启用 SSH 命令模式`);
+                }
+                else {
+                    // API 可用：创建一个懒加载的 connector（不立即连接）
+                    // 只有当真正需要执行 SSH 命令时才建立连接
+                    const connector = new connector_1.DockerConnector(this.config, { credentials: [this.credential], nodes: [this.config] });
+                    this.connector = connector;
+                    // 标记为 connected（但实际 SSH 连接尚未建立）
+                    connector.setConnected(true);
+                    logger_1.nodeLogger.info(`[${this.name}] ✅ Connector 已创建（懒加载模式，使用时才连接）`);
                 }
-                // 标记连接可用，允许事件流自动重连
-                connector.setConnected(true);
                 this.status = constants_1.NodeStatus.CONNECTED;
-                logger_1.nodeLogger.info(`[${this.name}] 连接成功 (SSH + ${this.dockerApiAvailable ? 'Docker API' : 'SSH 命令模式'})`);
-                // 启动监控
+                const mode = this.dockerApiAvailable ? 'Docker API (SSH隧道复用)' : 'SSH 命令模式';
+                logger_1.nodeLogger.info(`[${this.name}] 连接成功 [模式: ${mode}]`);
+                // 启动监控 (此时 API 已就绪，startEventStream 会复用 API 连接，不会产生新登录)
                 this.startMonitoring();
                 // 触发上线事件
                 this.emitEvent({
@@ -122,8 +138,10 @@ class DockerNode {
                 const lastError = error instanceof Error ? error : new Error(String(error));
                 logger_1.nodeLogger.warn(`[${this.name}] 连接失败: ${lastError.message}`);
                 // 清理连接
+                this.disposeSshClient();
                 this.connector?.dispose();
                 this.connector = null;
+                this.dockerode = null; // 确保清理
                 // 等待后重试
                 logger_1.nodeLogger.info(`[${this.name}] ${currentInterval / 1000} 秒后重试...`);
                 await new Promise(resolve => setTimeout(resolve, currentInterval));
@@ -165,12 +183,28 @@ class DockerNode {
             logger_1.nodeLogger.info(`[${this.name}] 配置已修正: host="${this.config.host}", port=${cleanedPort}`);
         }
     }
+    /**
+     * 销毁 SSH 客户端
+     */
+    disposeSshClient() {
+        if (this.sshClient) {
+            try {
+                logger_1.nodeLogger.debug(`[${this.name}] 销毁 SSH 主连接`);
+                this.sshClient.end();
+            }
+            catch (e) {
+                // 忽略销毁错误
+            }
+            this.sshClient = null;
+        }
+    }
     /**
      * 断开连接
      */
     async disconnect() {
         this.stopMonitoring();
         this.clearTimers();
+        this.disposeSshClient();
         this.connector?.dispose();
         this.connector = null;
         this.dockerode = null;
@@ -286,28 +320,58 @@ class DockerNode {
     }
     /**
      * 获取系统信息 (CPU、内存)
+     * 优先使用 Docker API，失败时降级到 SSH 命令
      */
     async getSystemInfo() {
-        if (!this.connector)
+        // 方式 1: 尝试使用 Docker API
+        logger_1.nodeLogger.debug(`[${this.name}] getSystemInfo 调用: dockerode=${!!this.dockerode}, apiAvailable=${this.dockerApiAvailable}`);
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                logger_1.nodeLogger.debug(`[${this.name}] 使用 Docker API 获取系统信息`);
+                const info = await this.dockerode.info();
+                logger_1.nodeLogger.debug(`[${this.name}] Docker API 返回: NCPU=${info.NCPU}, MemTotal=${info.MemTotal}, MemAvailable=${info.MemAvailable}`);
+                const result = {
+                    NCPU: info.NCPU || 0,
+                    MemTotal: info.MemTotal || 0,
+                    MemAvailable: info.MemAvailable, // 可能不存在
+                };
+                logger_1.nodeLogger.debug(`[${this.name}] 返回系统信息: NCPU=${result.NCPU}, MemTotal=${result.MemTotal}`);
+                return result;
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API getSystemInfo 失败，降级到 SSH: ${e.message}`);
+            }
+        }
+        // 方式 2: SSH 命令行回退
+        logger_1.nodeLogger.debug(`[${this.name}] 使用 SSH 命令获取系统信息`);
+        if (!this.connector) {
+            logger_1.nodeLogger.warn(`[${this.name}] connector 不存在，无法获取系统信息`);
             return null;
+        }
         try {
-            // 使用 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 但仍有输出（权限问题），只要有输出就解析
+            // 使用 JSON 格式获取完整信息，避免字段不存在导致的问题
+            const result = await this.connector.execWithExitCode('docker info --format "{{json .}}"');
+            logger_1.nodeLogger.debug(`[${this.name}] docker info 输出长度: ${result.output.length}, 退出码: ${result.exitCode}`);
             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,
-                    MemTotal: parseInt(parts[1]) || 0,
-                    MemAvailable: parts[2] ? parseInt(parts[2]) : undefined,
+            try {
+                const info = JSON.parse(result.output);
+                logger_1.nodeLogger.debug(`[${this.name}] SSH docker info 解析: NCPU=${info.NCPU}, MemTotal=${info.MemTotal}, MemAvailable=${info.MemAvailable}`);
+                const sshResult = {
+                    NCPU: info.NCPU || 0,
+                    MemTotal: info.MemTotal || 0,
+                    MemAvailable: info.MemAvailable, // 可能不存在
                 };
+                logger_1.nodeLogger.debug(`[${this.name}] SSH 返回系统信息: NCPU=${sshResult.NCPU}, MemTotal=${sshResult.MemTotal}`);
+                return sshResult;
+            }
+            catch (parseError) {
+                logger_1.nodeLogger.warn(`[${this.name}] 解析 docker info JSON 失败: ${parseError}`);
+                logger_1.nodeLogger.warn(`[${this.name}] 原始输出: ${result.output.substring(0, 200)}`);
+                return null;
             }
-            return null;
         }
         catch (e) {
             logger_1.nodeLogger.warn(`[${this.name}] 获取系统信息异常: ${e}`);
@@ -1178,76 +1242,123 @@ class DockerNode {
     }
     /**
      * 初始化 Dockerode
-     * 根据配置决定连接本地 Socket 还是通过 SSH 连接远程
+     * 建立唯一的 SSH 连接，并通过 `docker system dial-stdio` 复用连接
      */
-    async initDockerode() {
+    async initDockerode(connector) {
         try {
             let dockerOptions;
             // 判断是否是本地节点
             const isLocal = this.config.host === '127.0.0.1' || this.config.host === 'localhost';
             if (isLocal) {
-                // 本地连接
-                dockerOptions = {
-                    socketPath: '/var/run/docker.sock',
-                };
+                // 本地连接：直接使用 Unix Socket
+                this.dockerode = new dockerode_1.default({ socketPath: '/var/run/docker.sock' });
+                await this.dockerode.ping();
+                this.dockerApiAvailable = true;
+                logger_1.nodeLogger.info(`[${this.name}] ✅ Docker API 连接成功 (Local Socket)`);
+                return;
             }
-            else {
-                // === 远程 SSH 连接配置 ===
-                // 1. 确保端口是数字
-                let portNumber = 22;
-                if (typeof this.config.port === 'number') {
-                    portNumber = this.config.port;
+            // === 远程 SSH 连接配置 (单连接复用方案) ===
+            // 1. 关闭旧连接
+            this.disposeSshClient();
+            // 2. 准备 SSH 配置
+            let portNumber = 22;
+            if (typeof this.config.port === 'number') {
+                portNumber = this.config.port;
+            }
+            else if (typeof this.config.port === 'string') {
+                const parsed = parseInt(this.config.port, 10);
+                if (!isNaN(parsed) && parsed > 0) {
+                    portNumber = parsed;
+                }
+            }
+            const sshConfig = {
+                host: this.config.host,
+                port: portNumber,
+                username: this.credential.username,
+                readyTimeout: 20000,
+                keepaliveInterval: 10000, // 10秒心跳，防止被踢
+                keepaliveCountMax: 3,
+            };
+            // 注入认证信息
+            if (this.credential.authType === 'password' && this.credential.password) {
+                sshConfig.password = this.credential.password;
+            }
+            else if (this.credential.privateKey) {
+                sshConfig.privateKey = this.credential.privateKey.trim();
+                if (this.credential.passphrase) {
+                    sshConfig.passphrase = this.credential.passphrase;
                 }
-                else if (typeof this.config.port === 'string') {
-                    const parsed = parseInt(this.config.port, 10);
-                    if (!isNaN(parsed) && parsed > 0)
-                        portNumber = parsed;
+            }
+            logger_1.nodeLogger.info(`[${this.name}] 正在建立 SSH 主连接...`);
+            // 3. 建立 SSH 连接
+            this.sshClient = new ssh2_1.Client();
+            await new Promise((resolve, reject) => {
+                if (!this.sshClient) {
+                    return reject(new Error('SSH client initialization failed'));
                 }
-                // 2. 准备 SSH 认证选项
-                // 关键点：将 port 放在这里，而不是顶层
-                const sshOpts = {
-                    port: portNumber,
-                    readyTimeout: 20000,
+                const onReady = () => {
+                    this.sshClient?.removeListener('error', onError);
+                    resolve();
                 };
-                // 注入认证信息
-                if (this.credential.authType === 'password' && this.credential.password) {
-                    sshOpts.password = this.credential.password;
+                const onError = (err) => {
+                    this.sshClient?.removeListener('ready', onReady);
+                    reject(err);
+                };
+                this.sshClient.on('ready', onReady).on('error', onError).connect(sshConfig);
+            });
+            // 监听连接断开，触发重连逻辑
+            this.sshClient.on('close', () => {
+                if (this.status === constants_1.NodeStatus.CONNECTED) {
+                    logger_1.nodeLogger.warn(`[${this.name}] SSH 主连接已断开，触发重连`);
+                    // 不直接调用 disconnect()，避免状态混乱
+                    // 让上层监控逻辑处理重连
                 }
-                else if (this.credential.privateKey) {
-                    sshOpts.privateKey = this.credential.privateKey.trim();
-                    if (this.credential.passphrase) {
-                        sshOpts.passphrase = this.credential.passphrase;
-                    }
+            });
+            logger_1.nodeLogger.info(`[${this.name}] ✅ SSH 主连接建立成功 (单次登录，复用所有API请求)`);
+            // 4. 创建自定义 Agent，劫持 createConnection
+            // 这允许 dockerode 的所有请求都复用这一个 SSH 连接
+            const agent = new http_1.default.Agent();
+            agent.createConnection = (options, cb) => {
+                logger_1.nodeLogger.debug(`[${this.name}] 🔧 Agent.createConnection 被调用，复用 SSH 隧道`);
+                // 使用 docker system dial-stdio 建立到 Docker Socket 的流
+                // 这是官方 CLI 远程连接的标准方式，支持双向流
+                if (!this.sshClient) {
+                    cb(new Error('SSH client not connected'), null);
+                    return null;
                 }
-                // 3. 构建 Dockerode 配置
-                // 核心修复：
-                // - 保留 host: 让 dockerode 知道是远程连接（解决"只获取本地容器"问题）
-                // - 移除 port: 避免 docker-modem 拼接 URL 时出错（解决 "Invalid port" 问题）
-                // - sshOptions: 包含 port 和认证信息，供底层 ssh2 使用
-                dockerOptions = {
-                    protocol: 'ssh',
-                    host: this.config.host, // 必须保留
-                    username: this.credential.username, // 必须保留
-                    sshOptions: sshOpts, // 包含 port
-                };
-                logger_1.nodeLogger.info(`[${this.name}] 初始化 Docker API (SSH模式): host="${this.config.host}", port=${portNumber}`);
-            }
+                this.sshClient.exec('docker system dial-stdio', (err, stream) => {
+                    if (err) {
+                        logger_1.nodeLogger.warn(`[${this.name}] SSH dial-stdio 失败: ${err.message}`);
+                        return cb(err, null);
+                    }
+                    // stream 是双工流，可以直接作为 socket 使用
+                    logger_1.nodeLogger.debug(`[${this.name}] ✅ SSH 隧道已建立`);
+                    cb(null, stream);
+                });
+                return null;
+            };
+            // 5. 初始化 Dockerode
+            // 使用 'http' 协议欺骗 dockerode 使用我们的 agent
+            dockerOptions = {
+                protocol: 'http',
+                host: '127.0.0.1', // 这里的 host/port 会被 agent 忽略
+                port: 2375,
+                agent: agent,
+            };
+            logger_1.nodeLogger.info(`[${this.name}] 🔨 创建 Dockerode 实例 (使用自定义 Agent)`);
             this.dockerode = new dockerode_1.default(dockerOptions);
-            // 测试连接
-            try {
-                await this.dockerode.ping();
-                this.dockerApiAvailable = true;
-                logger_1.nodeLogger.info(`[${this.name}] Docker API 连接成功 (${isLocal ? 'Local' : 'SSH'})`);
-            }
-            catch (e) {
-                this.dockerApiAvailable = false;
-                logger_1.nodeLogger.warn(`[${this.name}] Docker API 连接失败: ${e.message} (将降级使用 SSH 命令)`);
-            }
+            // 测试 API
+            logger_1.nodeLogger.info(`[${this.name}] 🔍 测试 Docker API 连接...`);
+            await this.dockerode.ping();
+            this.dockerApiAvailable = true;
+            logger_1.nodeLogger.info(`[${this.name}] ✅ Docker API 隧道测试成功 (所有请求复用单条 SSH 连接)`);
         }
         catch (e) {
+            this.disposeSshClient();
             this.dockerode = null;
             this.dockerApiAvailable = false;
-            logger_1.nodeLogger.debug(`[${this.name}] Dockerode 初始化异常: ${e}`);
+            logger_1.nodeLogger.warn(`[${this.name}] Docker API 隧道建立失败: ${e.message}`);
+            throw e; // 抛出错误让 connect 方法处理降级
         }
     }
     /**
@@ -1638,15 +1749,21 @@ class DockerNode {
     }
     /**
      * 启动 API 健康检查
+     * DPanel模式：信任底层 Keep-Alive，不主动 Ping，只在操作报错时重连
      */
     startHealthCheck() {
-        // 立即检查一次
+        // 方案：移除定时器，改为惰性检查
+        // 底层 keepaliveInterval: 15s 的静默心跳已经足够防止断连
+        // 主动 Ping 是产生日志的元凶，必须移除
+        // 仅在启动时检查一次，确保 API 正常
         this.checkApiHealth();
-        // 定期检查API健康状态
+        // 不再设置定时器，完全信任底层 TCP Keep-Alive
+        /*
         this.healthCheckTimer = setInterval(async () => {
-            await this.checkApiHealth();
-        }, constants_1.API_HEALTH_CHECK_INTERVAL);
-        logger_1.nodeLogger.debug(`[${this.name}] API健康检查已启动 (间隔: ${constants_1.API_HEALTH_CHECK_INTERVAL / 1000}秒)`);
+          await this.checkApiHealth()
+        }, CHECK_INTERVAL)
+        */
+        logger_1.nodeLogger.debug(`[${this.name}] API健康检查策略: 仅启动时检查 (依赖底层 TCP Keep-Alive 保活，无定时Ping)`);
     }
     /**
      * 检查 Docker API 健康状态
@@ -1674,7 +1791,8 @@ class DockerNode {
                 // API健康，无需操作
             }
             catch (e) {
-                logger_1.nodeLogger.warn(`[${this.name}] Docker API 健康检查失败: ${e.message}，启动降级轮询`);
+                logger_1.nodeLogger.error(`[${this.name}] ❌ Docker API 健康检查失败: ${e.message}`);
+                logger_1.nodeLogger.warn(`[${this.name}] ⚠ API失败后将进入降级模式，每${constants_1.DEGRADED_POLL_INTERVAL / 1000}秒执行一次SSH命令`);
                 this.dockerApiAvailable = false;
                 this.startDegradedPolling();
             }
@@ -1700,7 +1818,8 @@ class DockerNode {
         this.degradedPollTimer = setInterval(async () => {
             await this.pollContainerStates();
         }, constants_1.DEGRADED_POLL_INTERVAL);
-        logger_1.nodeLogger.info(`[${this.name}] 降级轮询已启动 (间隔: ${constants_1.DEGRADED_POLL_INTERVAL / 1000}秒)`);
+        logger_1.nodeLogger.warn(`[${this.name}] ⚠ 进入降级模式: 每${constants_1.DEGRADED_POLL_INTERVAL / 1000}秒执行一次SSH命令查询容器状态`);
+        logger_1.nodeLogger.warn(`[${this.name}] ⚠ 这是产生频繁SSH登录记录的主要原因！建议修复Docker API连接以减少SSH使用`);
     }
     /**
      * 停止降级轮询
@@ -1714,7 +1833,7 @@ class DockerNode {
             clearInterval(this.degradedPollTimer);
             this.degradedPollTimer = null;
         }
-        logger_1.nodeLogger.info(`[${this.name}] 降级轮询已停止，恢复Docker API模式`);
+        logger_1.nodeLogger.info(`[${this.name}] ✅ Docker API已恢复，停止降级轮询 (不再频繁执行SSH命令)`);
     }
     /**
      * 轮询容器状态 (用于降级模式)
@@ -1723,9 +1842,10 @@ class DockerNode {
         if (this.status !== constants_1.NodeStatus.CONNECTED)
             return;
         try {
+            logger_1.nodeLogger.debug(`[${this.name}] 🔍 执行降级轮询: 使用SSH命令查询容器状态 (这会产生SSH登录记录)`);
             const containers = await this.listContainers(true);
             this.checkContainerStateChanges(containers);
-            logger_1.nodeLogger.debug(`[${this.name}] 降级轮询: 检查了 ${containers.length} 个容器`);
+            logger_1.nodeLogger.debug(`[${this.name}] 降级轮询完成: 检查了 ${containers.length} 个容器`);
         }
         catch (e) {
             logger_1.nodeLogger.warn(`[${this.name}] 降级轮询失败: ${e}`);
@@ -1733,42 +1853,127 @@ class DockerNode {
     }
     /**
      * 启动 Docker 事件流监听
+     * 优先使用 Docker API (长连接且有心跳)，失败降级到 SSH 命令
      */
-    startEventStream() {
-        if (!this.connector)
-            return;
-        // 防止并发启动：使用 _startingStream 标志
+    async startEventStream() {
+        // 防止并发启动
         if (this._startingStream) {
             logger_1.nodeLogger.debug(`[${this.name}] 事件流正在启动中，跳过`);
             return;
         }
         ;
         this._startingStream = true;
-        // 检查是否已有活跃的流
-        if (this._activeStreamCount > 0) {
-            logger_1.nodeLogger.debug(`[${this.name}] 已有 ${this._activeStreamCount} 个活跃事件流，跳过启动`);
+        // 清理旧的流
+        if (this._eventStreamStop) {
+            try {
+                this._eventStreamStop();
+                this._eventStreamStop = null;
+            }
+            catch (e) {
+                // 忽略清理错误
+            }
+        }
+        logger_1.nodeLogger.info(`[${this.name}] 🚀 启动事件流监听...`);
+        // === 方案 1: 优先使用 Docker API (dockerode) ===
+        // 优点: 复用已有的 Keep-Alive 连接，不会因为静默被防火墙切断
+        if (this.dockerode && this.dockerApiAvailable) {
+            try {
+                logger_1.nodeLogger.info(`[${this.name}] 尝试使用 Docker API 获取事件流 (推荐模式，有心跳保护)`);
+                logger_1.nodeLogger.info(`[${this.name}] 🔍 调用 dockerode.getEvents() (这可能会建立新的 SSH 连接)`);
+                const stream = await this.dockerode.getEvents({
+                    filters: { type: ['container'] }
+                });
+                logger_1.nodeLogger.info(`[${this.name}] ✅ getEvents() 成功返回流对象`);
+                // 处理数据流
+                stream.on('data', (chunk) => {
+                    try {
+                        const lines = chunk.toString().split('\n').filter(Boolean);
+                        for (const line of lines) {
+                            this.handleEventLine(line);
+                        }
+                    }
+                    catch (e) {
+                        logger_1.nodeLogger.debug(`[${this.name}] 处理事件数据失败: ${e}`);
+                    }
+                });
+                // 处理错误和断开
+                const onStreamError = (err) => {
+                    if (this._startingStream === false)
+                        return; // 已经手动停止
+                    logger_1.nodeLogger.warn(`[${this.name}] API 事件流异常: ${err.message || 'Stream ended'}`);
+                    this.restartEventStream();
+                };
+                stream.on('error', onStreamError);
+                stream.on('end', () => onStreamError(new Error('Stream ended')));
+                stream.on('close', () => onStreamError(new Error('Stream closed')));
+                this._eventStreamStop = () => {
+                    try {
+                        stream.destroy?.();
+                        stream.off('error', onStreamError);
+                        stream.off('end', onStreamError);
+                        stream.off('close', onStreamError);
+                        stream.off('data', () => { });
+                    }
+                    catch (e) {
+                        // 忽略清理错误
+                    }
+                };
+                this._startingStream = false;
+                logger_1.nodeLogger.info(`[${this.name}] ✅ API 事件流已连接 (享受心跳保护，不会超时)`);
+                return;
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] API 事件流启动失败: ${e.message}，降级到 SSH 命令`);
+            }
+        }
+        // === 方案 2: 降级使用 SSH 命令行 ===
+        // 只有 API 不可用时才走这里（可能因静默超时而频繁重连）
+        if (!this.connector) {
+            ;
             this._startingStream = false;
+            logger_1.nodeLogger.warn(`[${this.name}] 无可用连接器，跳过事件流监听`);
             return;
         }
-        ;
-        this._activeStreamCount = this._activeStreamCount || 0;
-        this._activeStreamCount++;
-        logger_1.nodeLogger.debug(`[${this.name}] 启动事件流 (活跃数: ${this._activeStreamCount})`);
+        logger_1.nodeLogger.warn(`[${this.name}] 使用 SSH 命令模式监听事件流 (注意: 可能因长时间静默被防火墙切断)`);
         this.connector.startEventStream((line) => {
             this.handleEventLine(line);
         }).then((stop) => {
             ;
             this._eventStreamStop = stop;
             this._startingStream = false;
-            logger_1.nodeLogger.debug(`[${this.name}] 事件流回调已注册`);
+            logger_1.nodeLogger.info(`[${this.name}] ✅ SSH 事件流已连接 (注意: SSH模式下可能因静默超时而频繁重连)`);
         }).catch((err) => {
             ;
-            this._activeStreamCount--;
             this._startingStream = false;
-            logger_1.nodeLogger.warn(`[${this.name}] 事件流启动失败: ${err.message}，5秒后重试`);
-            setTimeout(() => this.startEventStream(), 5000);
+            logger_1.nodeLogger.error(`[${this.name}] ❌ SSH 事件流启动失败: ${err.message}`);
+            this.restartEventStream();
         });
     }
+    /**
+     * 重启事件流
+     */
+    restartEventStream() {
+        // 清理旧的流
+        if (this._eventStreamStop) {
+            try {
+                this._eventStreamStop();
+                this._eventStreamStop = null;
+            }
+            catch (e) {
+                // 忽略清理错误
+            }
+        }
+        // 重置启动标志
+        ;
+        this._startingStream = false;
+        // 5秒后重试
+        setTimeout(() => {
+            if (this.status === constants_1.NodeStatus.CONNECTED) {
+                logger_1.nodeLogger.info(`[${this.name}] 重新启动事件流...`);
+                this.startEventStream();
+            }
+        }, 5000);
+    }
     /**
      * 处理事件流中的一行数据
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-docker-control",
   "description": "Koishi 插件 - 通过 SSH 控制 Docker 容器 (支持连接池、缓存、权限控制、审计日志)",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [