koishi-plugin-docker-control 0.0.1

package/lib/service/connector.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerConnector = void 0;
+/**
+ * SSH 连接器 - 通过 SSH 执行 docker 命令
+ */
+const ssh2_1 = require("ssh2");
+const constants_1 = require("../constants");
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+class DockerConnector {
+    constructor(config, fullConfig) {
+        this.config = config;
+        this.fullConfig = fullConfig;
+        this.sshClient = null;
+        this.connected = true;
+    }
+    /**
+     * 执行 SSH 命令
+     */
+    async exec(command) {
+        let lastError;
+        // 自动重试一次
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                return await this.execInternal(command);
+            }
+            catch (err) {
+                lastError = err;
+                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})，尝试重连...`);
+                    this.dispose(); // 强制销毁当前连接
+                    continue; // 重试
+                }
+                // 其他错误直接抛出
+                throw err;
+            }
+        }
+        throw lastError;
+    }
+    async execInternal(command) {
+        const client = await this.getConnection();
+        logger_1.connectorLogger.debug(`[${this.config.name}] 执行命令: ${command}`);
+        return new Promise((resolve, reject) => {
+            client.exec(command, (err, stream) => {
+                if (err) {
+                    logger_1.connectorLogger.debug(`[${this.config.name}] 命令执行错误: ${err.message}`);
+                    reject(err);
+                    return;
+                }
+                let stdout = '';
+                let stderr = '';
+                stream.on('close', (code, signal) => {
+                    logger_1.connectorLogger.debug(`[${this.config.name}] 命令完成: code=${code}, signal=${signal}`);
+                    // 显式结束 stream 防止 channel 泄露
+                    try {
+                        stream.end();
+                    }
+                    catch (e) {
+                        // 可能已经关闭，忽略错误
+                    }
+                    if (stderr.includes('Error') || stderr.includes('error')) {
+                        reject(new Error(stderr.trim()));
+                    }
+                    else {
+                        resolve(stdout.trim());
+                    }
+                });
+                stream.on('data', (data) => {
+                    stdout += data.toString();
+                });
+                stream.on('err', (data) => {
+                    stderr += data.toString();
+                });
+            });
+        });
+    }
+    /**
+     * 执行 docker ps 获取容器列表
+     */
+    async listContainers(all = true) {
+        const flag = all ? '-a' : '';
+        // 使用双引号包裹 format，以兼容 Windows CMD
+        return this.exec(`docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.State}}|{{.Status}}" ${flag}`);
+    }
+    /**
+     * 执行 docker start
+     */
+    async startContainer(containerId) {
+        await this.exec(`docker start ${containerId}`);
+    }
+    /**
+     * 执行 docker stop
+     */
+    async stopContainer(containerId, timeout = 10) {
+        await this.exec(`docker stop -t ${timeout} ${containerId}`);
+    }
+    /**
+     * 执行 docker restart
+     */
+    async restartContainer(containerId, timeout = 10) {
+        await this.exec(`docker restart -t ${timeout} ${containerId}`);
+    }
+    /**
+     * 获取容器日志
+     */
+    async getLogs(containerId, tail = 100) {
+        return this.exec(`docker logs --tail ${tail} ${containerId} 2>&1`);
+    }
+    /**
+     * 执行容器内命令
+     */
+    async execContainer(containerId, cmd) {
+        // 使用 docker exec 需要处理引号
+        const escapedCmd = cmd.replace(/'/g, "'\\''");
+        return this.exec(`docker exec ${containerId} sh -c '${escapedCmd}'`);
+    }
+    /**
+     * 监听 Docker 事件流
+     * @param callback 每行事件数据的回调
+     * @returns 停止监听的方法
+     */
+    async startEventStream(callback) {
+        const client = await this.getConnection();
+        logger_1.connectorLogger.debug(`[${this.config.name}] 正在启动事件流监听...`);
+        return new Promise((resolve, reject) => {
+            client.exec(`docker events --format "{{json .}}" --filter "type=container"`, (err, stream) => {
+                if (err) {
+                    logger_1.connectorLogger.error(`[${this.config.name}] 启动事件流失败: ${err.message}`);
+                    reject(err);
+                    return;
+                }
+                logger_1.connectorLogger.info(`[${this.config.name}] Docker 事件流已连接`);
+                let buffer = '';
+                let closed = false;
+                const stop = () => {
+                    if (!closed) {
+                        closed = true;
+                        // [新增] 强制销毁流，防止僵尸连接
+                        try {
+                            stream.unpipe();
+                            stream.destroy();
+                            this._eventStream = null;
+                        }
+                        catch (e) {
+                            // 可能已经关闭，忽略错误
+                        }
+                        logger_1.connectorLogger.debug(`[${this.config.name}] 主动停止事件流`);
+                    }
+                };
+                stream.on('close', (code, signal) => {
+                    if (!closed) {
+                        closed = true;
+                        logger_1.connectorLogger.warn(`[${this.config.name}] 事件流意外断开 (Code: ${code}, Signal: ${signal})`);
+                    }
+                });
+                stream.on('data', (data) => {
+                    buffer += data.toString();
+                    // 按行处理，解决 TCP 粘包问题
+                    let newlineIndex;
+                    while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                        const line = buffer.slice(0, newlineIndex).trim();
+                        buffer = buffer.slice(newlineIndex + 1);
+                        if (line) {
+                            callback(line);
+                        }
+                    }
+                });
+                stream.stderr.on('data', (data) => {
+                    logger_1.connectorLogger.debug(`[${this.config.name}] 事件流 stderr: ${data.toString().trim()}`);
+                });
+                this._eventStream = stream;
+                resolve(stop);
+            });
+        });
+    }
+    /**
+     * 标记连接状态
+     */
+    setConnected(status) {
+        this.connected = status;
+    }
+    /**
+     * 销毁连接
+     */
+    dispose() {
+        if (this.sshClient) {
+            this.sshClient.end();
+            this.sshClient = null;
+        }
+    }
+    /**
+     * 获取 SSH 连接
+     */
+    async getConnection() {
+        if (!this.sshClient) {
+            this.sshClient = await this.createConnection();
+        }
+        return this.sshClient;
+    }
+    /**
+     * 创建 SSH 连接
+     */
+    async createConnection() {
+        const credential = this.getCredential();
+        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}`);
+        return new Promise((resolve, reject) => {
+            const conn = new ssh2_1.Client();
+            conn.on('ready', () => {
+                logger_1.connectorLogger.info(`[${this.config.name}] SSH 连接成功`);
+                resolve(conn);
+            });
+            conn.on('error', (err) => {
+                logger_1.connectorLogger.error(`[${this.config.name}] SSH 连接失败: ${err.message}`);
+                conn.end();
+                reject(err);
+            });
+            conn.on('close', () => {
+                logger_1.connectorLogger.debug(`[${this.config.name}] SSH 连接关闭`);
+            });
+            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,
+                username: credential.username,
+                readyTimeout: constants_1.SSH_TIMEOUT,
+                timeout: constants_1.SSH_TIMEOUT,
+                tryKeyboard: true,
+                ...this.buildAuthOptions(credential),
+            };
+            conn.connect(connectConfig);
+        });
+    }
+    /**
+     * 构建认证选项
+     */
+    buildAuthOptions(credential) {
+        const options = {};
+        if (credential.authType === 'password') {
+            options.password = credential.password;
+        }
+        else {
+            if (credential.privateKey) {
+                options.privateKey = Buffer.from(credential.privateKey, 'utf8');
+            }
+            if (credential.passphrase) {
+                options.passphrase = credential.passphrase;
+            }
+        }
+        return options;
+    }
+    /**
+     * 获取凭证配置
+     */
+    getCredential() {
+        return (0, config_1.getCredentialById)(this.fullConfig, this.config.credentialId);
+    }
+}
+exports.DockerConnector = DockerConnector;

package/lib/service/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Docker 服务主类
+ * 管理所有 Docker 节点
+ */
+import { Context } from 'koishi';
+import type { DockerEvent, DockerControlConfig, ContainerInfo } from '../types';
+import { DockerNode } from './node';
+export declare class DockerService {
+    /** Koishi Context */
+    private readonly ctx;
+    /** 节点映射 */
+    private nodes;
+    /** 配置 */
+    private readonly config;
+    /** 全局事件回调集合 - 事件中转站 */
+    private eventCallbacks;
+    constructor(ctx: Context, config: DockerControlConfig);
+    /**
+     * 初始化所有节点
+     */
+    initialize(): Promise<void>;
+    /**
+     * 【新增】内部方法：分发全局事件
+     * 将节点事件转发给所有注册的全局回调
+     */
+    private dispatchGlobalEvent;
+    getNode(id: string): DockerNode | undefined;
+    getNodeByName(name: string): DockerNode | undefined;
+    getNodesByTag(tag: string): DockerNode[];
+    getNodesBySelector(selector: string): DockerNode[];
+    getAllNodes(): DockerNode[];
+    getOnlineNodes(): DockerNode[];
+    getOfflineNodes(): DockerNode[];
+    /**
+     * 搜索容器
+     */
+    findContainer(nodeId: string, containerIdOrName: string): Promise<{
+        node: DockerNode;
+        container: ContainerInfo;
+    }>;
+    /**
+     * 在所有节点上搜索容器
+     */
+    findContainerGlobal(containerIdOrName: string): Promise<Array<{
+        node: DockerNode;
+        container: ContainerInfo;
+    }>>;
+    /**
+     * 批量操作容器
+     */
+    operateContainers(nodeSelector: string, containerSelector: string, operation: 'start' | 'stop' | 'restart'): Promise<Array<{
+        node: DockerNode;
+        container: ContainerInfo;
+        success: boolean;
+        error?: string;
+    }>>;
+    private logNodeList;
+    /**
+     * 【关键修复】注册全局事件监听
+     * 不再遍历节点，而是添加到全局回调列表
+     * 无论节点何时创建，事件都能通过 dispatchGlobalEvent 转发
+     */
+    onNodeEvent(callback: (event: DockerEvent, nodeId: string) => void): () => void;
+    stopAll(): Promise<void>;
+}

package/lib/service/index.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerService = void 0;
+const node_1 = require("./node");
+const logger_1 = require("../utils/logger");
+class DockerService {
+    constructor(ctx, config) {
+        /** 节点映射 */
+        this.nodes = new Map();
+        /** 全局事件回调集合 - 事件中转站 */
+        this.eventCallbacks = new Set();
+        this.ctx = ctx;
+        this.config = config;
+    }
+    /**
+     * 初始化所有节点
+     */
+    async initialize() {
+        logger_1.logger.info('初始化 Docker 服务...');
+        const nodeConfigs = this.config.nodes || [];
+        const credentials = this.config.credentials || [];
+        for (const nodeConfig of nodeConfigs) {
+            // 查找对应的凭证
+            const credential = credentials.find(c => c.id === nodeConfig.credentialId);
+            if (!credential) {
+                logger_1.logger.warn(`节点 ${nodeConfig.name} 找不到凭证 ${nodeConfig.credentialId}，跳过`);
+                continue;
+            }
+            const node = new node_1.DockerNode(nodeConfig, credential, this.config.debug);
+            // 【关键修复】创建节点时，立即绑定事件转发
+            // 无论 index.ts 何时调用 onNodeEvent，这里都会把事件转发给 eventCallbacks
+            node.onEvent((event) => {
+                this.dispatchGlobalEvent(event, node.id);
+            });
+            this.nodes.set(nodeConfig.id, node);
+            logger_1.logger.info(`节点已创建: ${nodeConfig.name} (${nodeConfig.id})`);
+        }
+        this.logNodeList();
+        // 连接所有节点
+        const promises = [];
+        for (const node of this.nodes.values()) {
+            promises.push(node.connect().catch((e) => {
+                logger_1.logger.warn(`节点 ${node.name} 连接失败: ${e}`);
+            }));
+        }
+        await Promise.allSettled(promises);
+        const online = [...this.nodes.values()].filter((n) => n.status === 'connected').length;
+        const offline = [...this.nodes.values()].filter((n) => n.status === 'error' || n.status === 'disconnected').length;
+        logger_1.logger.info(`连接完成: ${online} 在线, ${offline} 离线`);
+    }
+    /**
+     * 【新增】内部方法：分发全局事件
+     * 将节点事件转发给所有注册的全局回调
+     */
+    dispatchGlobalEvent(event, nodeId) {
+        for (const callback of this.eventCallbacks) {
+            try {
+                callback(event, nodeId);
+            }
+            catch (e) {
+                logger_1.logger.error(`事件回调执行错误: ${e}`);
+            }
+        }
+    }
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    getNodeByName(name) {
+        return [...this.nodes.values()].find((n) => n.name === name);
+    }
+    getNodesByTag(tag) {
+        return [...this.nodes.values()].filter((n) => n.tags.includes(tag));
+    }
+    getNodesBySelector(selector) {
+        if (selector === 'all' || !selector) {
+            return [...this.nodes.values()];
+        }
+        if (selector.startsWith('@')) {
+            const tag = selector.slice(1);
+            return this.getNodesByTag(tag);
+        }
+        const node = this.getNode(selector) || this.getNodeByName(selector);
+        return node ? [node] : [];
+    }
+    getAllNodes() {
+        return [...this.nodes.values()];
+    }
+    getOnlineNodes() {
+        return [...this.nodes.values()].filter((n) => n.status === 'connected');
+    }
+    getOfflineNodes() {
+        return [...this.nodes.values()].filter((n) => n.status === 'error' || n.status === 'disconnected');
+    }
+    /**
+     * 搜索容器
+     */
+    async findContainer(nodeId, containerIdOrName) {
+        const node = this.getNode(nodeId);
+        if (!node) {
+            throw new Error(`节点不存在: ${nodeId}`);
+        }
+        const containers = await node.listContainers(true);
+        let container = containers.find((c) => c.Id.startsWith(containerIdOrName));
+        if (!container) {
+            container = containers.find((c) => c.Names.some((n) => n.replace('/', '') === containerIdOrName));
+        }
+        if (!container) {
+            container = containers.find((c) => c.Names.some((n) => n.includes(containerIdOrName)));
+        }
+        if (!container) {
+            throw new Error(`找不到容器: ${containerIdOrName}`);
+        }
+        return { node, container };
+    }
+    /**
+     * 在所有节点上搜索容器
+     */
+    async findContainerGlobal(containerIdOrName) {
+        const results = [];
+        for (const node of this.getOnlineNodes()) {
+            try {
+                const containers = await node.listContainers(true);
+                let container = containers.find((c) => c.Id.startsWith(containerIdOrName));
+                if (!container) {
+                    container = containers.find((c) => c.Names.some((n) => n.replace('/', '') === containerIdOrName));
+                }
+                if (container) {
+                    results.push({ node, container });
+                }
+            }
+            catch (e) {
+                logger_1.logger.warn(`[${node.name}] 搜索容器失败: ${e}`);
+            }
+        }
+        return results;
+    }
+    /**
+     * 批量操作容器
+     */
+    async operateContainers(nodeSelector, containerSelector, operation) {
+        const nodes = this.getNodesBySelector(nodeSelector);
+        const results = [];
+        for (const node of nodes) {
+            if (node.status !== 'connected') {
+                continue;
+            }
+            try {
+                const { container } = await this.findContainer(node.id, containerSelector);
+                switch (operation) {
+                    case 'start':
+                        await node.startContainer(container.Id);
+                        break;
+                    case 'stop':
+                        await node.stopContainer(container.Id);
+                        break;
+                    case 'restart':
+                        await node.restartContainer(container.Id);
+                        break;
+                }
+                results.push({ node, container, success: true });
+            }
+            catch (e) {
+                results.push({
+                    node,
+                    container: { Id: '', Names: [], State: 'stopped' },
+                    success: false,
+                    error: e.message,
+                });
+            }
+        }
+        return results;
+    }
+    logNodeList() {
+        logger_1.logger.info('=== Docker 节点列表 ===');
+        for (const node of this.nodes.values()) {
+            const tags = node.tags.length > 0 ? ` [@${node.tags.join(' @')}]` : '';
+            logger_1.logger.info(`  - ${node.name} (${node.id})${tags}`);
+        }
+        logger_1.logger.info('======================');
+    }
+    /**
+     * 【关键修复】注册全局事件监听
+     * 不再遍历节点，而是添加到全局回调列表
+     * 无论节点何时创建，事件都能通过 dispatchGlobalEvent 转发
+     */
+    onNodeEvent(callback) {
+        this.eventCallbacks.add(callback);
+        // 返回取消订阅函数
+        return () => {
+            this.eventCallbacks.delete(callback);
+        };
+    }
+    async stopAll() {
+        for (const node of this.nodes.values()) {
+            await node.dispose();
+        }
+        this.nodes.clear();
+        this.eventCallbacks.clear();
+        logger_1.logger.info('Docker 服务已停止');
+    }
+}
+exports.DockerService = DockerService;

package/lib/service/monitor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 监控器 - 智能事件处理
+ * 实现防抖、抖动检测
+ */
+import type { DockerEvent } from '../types';
+import { DockerNode } from './node';
+export interface ProcessedEvent {
+    eventType: string;
+    action: string;
+    nodeId: string;
+    nodeName: string;
+    containerId: string;
+    containerName: string;
+    timestamp: number;
+}
+export declare class MonitorManager {
+    private config;
+    /** 容器状态映射: nodeId -> containerId -> State */
+    private states;
+    /** 全局回调 */
+    private callback?;
+    constructor(config?: {
+        debounceWait?: number;
+        flappingWindow?: number;
+        flappingThreshold?: number;
+    });
+    /**
+     * 处理原始 Docker 事件
+     */
+    processEvent(node: DockerNode, event: DockerEvent): void;
+    /**
+     * 注册处理后事件的回调
+     */
+    onProcessedEvent(callback: (event: ProcessedEvent) => void): () => void;
+    private emit;
+    private getContainerState;
+    private cleanHistory;
+}