koishi-plugin-docker-control 0.0.1

package/lib/commands/control.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 容器控制指令
+ * docker.start / stop / restart / exec
+ */
+import { Context } from 'koishi';
+/**
+ * 注册控制指令
+ */
+export declare function registerControlCommands(ctx: Context, getService: () => any): void;

package/lib/commands/control.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerControlCommands = registerControlCommands;
+const logger_1 = require("../utils/logger");
+/**
+ * 格式化容器搜索结果
+ */
+function formatSearchResults(results, operation) {
+    const lines = [];
+    let successCount = 0;
+    let failCount = 0;
+    for (const r of results) {
+        const status = r.success ? '✅' : '❌';
+        const name = r.container.Names?.[0]?.replace('/', '') || r.container.Id?.slice(0, 8) || '?';
+        if (r.success) {
+            successCount++;
+            lines.push(`${status} ${r.node.name}: ${name}`);
+        }
+        else {
+            failCount++;
+            lines.push(`${status} ${r.node.name}: ${name} - ${r.error}`);
+        }
+    }
+    const summary = `共 ${results.length} 个，成功 ${successCount}，失败 ${failCount}`;
+    return [summary, ...lines].join('\n');
+}
+/**
+ * 注册控制指令
+ */
+function registerControlCommands(ctx, getService) {
+    /**
+     * 启动容器
+     */
+    ctx
+        .command('docker.start <selector> <container>', '启动容器')
+        .alias('docker启动', '容器启动', 'docker开启', '容器开启')
+        .option('async', '-a 异步执行，不等待结果', { fallback: false })
+        .action(async ({ options }, selector, container) => {
+        logger_1.commandLogger.debug(`docker.start 被调用: selector=${selector}, container=${container}`);
+        const service = getService();
+        if (!service) {
+            logger_1.commandLogger.debug('服务未初始化');
+            return 'Docker 服务未初始化';
+        }
+        try {
+            if (container === '*') {
+                logger_1.commandLogger.debug('批量启动容器');
+                // 批量操作
+                const results = await service.operateContainers(selector, container, 'start');
+                return formatSearchResults(results, '启动');
+            }
+            // 单个容器
+            logger_1.commandLogger.debug(`查找容器: ${container} 在 ${selector}`);
+            const { node, container: found } = await service.findContainer(selector, container);
+            logger_1.commandLogger.debug(`找到容器: ${found.Names[0]} 在节点 ${node.name}`);
+            await node.startContainer(found.Id);
+            logger_1.commandLogger.debug(`容器已启动: ${found.Id}`);
+            const name = found.Names[0]?.replace('/', '') || found.Id.slice(0, 8);
+            return `✅ ${node.name}: ${name} 已启动`;
+        }
+        catch (e) {
+            logger_1.commandLogger.error(`启动容器失败: ${e.message}`);
+            return `❌ 启动失败: ${e.message}`;
+        }
+    });
+    /**
+     * 停止容器
+     */
+    ctx
+        .command('docker.stop <selector> <container>', '停止容器')
+        .alias('docker停止', '容器停止', 'docker关闭', '容器关闭')
+        .option('async', '-a 异步执行，不等待结果', { fallback: false })
+        .action(async ({ options }, selector, container) => {
+        logger_1.commandLogger.debug(`docker.stop 被调用: selector=${selector}, container=${container}`);
+        const service = getService();
+        if (!service) {
+            logger_1.commandLogger.debug('服务未初始化');
+            return 'Docker 服务未初始化';
+        }
+        try {
+            if (container === '*') {
+                logger_1.commandLogger.debug('批量停止容器');
+                // 批量操作
+                const results = await service.operateContainers(selector, container, 'stop');
+                return formatSearchResults(results, '停止');
+            }
+            logger_1.commandLogger.debug(`查找容器: ${container} 在 ${selector}`);
+            const { node, container: found } = await service.findContainer(selector, container);
+            logger_1.commandLogger.debug(`找到容器: ${found.Names[0]} 在节点 ${node.name}`);
+            await node.stopContainer(found.Id);
+            logger_1.commandLogger.debug(`容器已停止: ${found.Id}`);
+            const name = found.Names[0]?.replace('/', '') || found.Id.slice(0, 8);
+            return `✅ ${node.name}: ${name} 已停止`;
+        }
+        catch (e) {
+            logger_1.commandLogger.error(`停止容器失败: ${e.message}`);
+            return `❌ 停止失败: ${e.message}`;
+        }
+    });
+    /**
+     * 重启容器
+     */
+    ctx
+        .command('docker.restart <selector> <container>', '重启容器')
+        .alias('docker重启', '容器重启')
+        .option('async', '-a 异步执行，不等待结果', { fallback: false })
+        .action(async ({ options }, selector, container) => {
+        logger_1.commandLogger.debug(`docker.restart 被调用: selector=${selector}, container=${container}`);
+        const service = getService();
+        if (!service) {
+            logger_1.commandLogger.debug('服务未初始化');
+            return 'Docker 服务未初始化';
+        }
+        try {
+            if (container === '*') {
+                logger_1.commandLogger.debug('批量重启容器');
+                // 批量操作
+                const results = await service.operateContainers(selector, container, 'restart');
+                return formatSearchResults(results, '重启');
+            }
+            logger_1.commandLogger.debug(`查找容器: ${container} 在 ${selector}`);
+            const { node, container: found } = await service.findContainer(selector, container);
+            logger_1.commandLogger.debug(`找到容器: ${found.Names[0]} 在节点 ${node.name}`);
+            await node.restartContainer(found.Id);
+            logger_1.commandLogger.debug(`容器已重启: ${found.Id}`);
+            const name = found.Names[0]?.replace('/', '') || found.Id.slice(0, 8);
+            return `✅ ${node.name}: ${name} 已重启`;
+        }
+        catch (e) {
+            logger_1.commandLogger.error(`重启容器失败: ${e.message}`);
+            return `❌ 重启失败: ${e.message}`;
+        }
+    });
+    /**
+     * 查看容器详情
+     */
+    ctx
+        .command('docker.inspect <selector> <container>', '查看容器详情')
+        .alias('docker详情', '容器详情', 'docker检查', '容器检查')
+        .action(async (_, selector, container) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        try {
+            const { node, container: found } = await service.findContainer(selector, container);
+            const info = await node.getContainer(found.Id);
+            const lines = [
+                `名称: ${info.Name.replace('/', '')}`,
+                `ID: ${info.Id.slice(0, 12)}`,
+                `镜像: ${info.Config.Image}`,
+                `状态: ${info.State.Status} (运行中: ${info.State.Running})`,
+                `创建时间: ${new Date(info.Created).toLocaleString()}`,
+                `启动时间: ${info.State.StartedAt}`,
+                `重启次数: ${info.RestartCount || 0}`,
+            ];
+            if (info.State.Health) {
+                lines.push(`健康状态: ${info.State.Health.Status}`);
+            }
+            return lines.join('\n');
+        }
+        catch (e) {
+            logger_1.commandLogger.error(`查看详情失败: ${e.message}`);
+            return `❌ 查看失败: ${e.message}`;
+        }
+    });
+    /**
+     * 执行命令
+     */
+    ctx
+        .command('docker.exec <selector> <container> <cmd>', '在容器内执行命令')
+        .option('timeout', '-t <seconds> 超时时间(秒)', { fallback: 30 })
+        .action(async ({ options }, selector, container, cmd) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        if (!cmd) {
+            return '请输入要执行的命令';
+        }
+        logger_1.commandLogger.info(`[${selector}] 执行命令: "${cmd}"`);
+        try {
+            const { node, container: found } = await service.findContainer(selector, container);
+            const result = await node.execContainer(found.Id, [
+                '/bin/sh',
+                '-c',
+                cmd,
+            ]);
+            const name = found.Names[0]?.replace('/', '') || found.Id.slice(0, 8);
+            if (result.output.trim()) {
+                return `=== ${node.name}: ${name} ===\n${result.output}`;
+            }
+            else {
+                return `✅ ${node.name}: ${name} - 命令执行完成（无输出）`;
+            }
+        }
+        catch (e) {
+            logger_1.commandLogger.error(`执行命令失败: ${e.message}`);
+            return `❌ 执行失败: ${e.message}`;
+        }
+    });
+}

package/lib/commands/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 指令注册入口
+ */
+import { Context } from 'koishi';
+import type { DockerControlConfig } from '../types';
+/**
+ * 获取服务的回调类型
+ */
+type GetService = () => any;
+/**
+ * 注册所有指令
+ */
+export declare function registerCommands(ctx: Context, getService: GetService, config?: DockerControlConfig): void;
+export {};

package/lib/commands/index.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = registerCommands;
+const list_1 = require("./list");
+const control_1 = require("./control");
+const logs_1 = require("./logs");
+/**
+ * 注册所有指令
+ */
+function registerCommands(ctx, getService, config) {
+    // 注册各模块指令
+    (0, list_1.registerListCommand)(ctx, getService, config);
+    (0, control_1.registerControlCommands)(ctx, getService);
+    (0, logs_1.registerLogsCommand)(ctx, getService, config);
+    // 注册辅助指令
+    registerHelperCommands(ctx, getService);
+}
+/**
+ * 注册辅助指令
+ */
+function registerHelperCommands(ctx, getService) {
+    /**
+     * 查看节点列表
+     */
+    ctx.command('docker.nodes', '查看节点').alias('docker节点', '容器节点').action(async () => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        const nodes = service.getAllNodes();
+        if (nodes.length === 0) {
+            return '未配置任何节点';
+        }
+        const lines = ['=== Docker 节点 ==='];
+        for (const node of nodes) {
+            const statusIcon = node.status === 'connected'
+                ? '🟢'
+                : node.status === 'connecting'
+                    ? '🟡'
+                    : '🔴';
+            const tags = node.tags.length > 0 ? ` [@${node.tags.join(' @')}]` : '';
+            lines.push(`${statusIcon} ${node.name} (${node.id})${tags} - ${node.status}`);
+        }
+        const online = nodes.filter((n) => n.status === 'connected').length;
+        lines.push(`\n总计: ${nodes.length} 个节点，${online} 个在线`);
+        return lines.join('\n');
+    });
+    /**
+     * 查看节点详情
+     */
+    ctx
+        .command('docker.node <selector>', '查看节点详情')
+        .alias('docker节点详情', '容器节点详情')
+        .action(async (_, selector) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        const nodes = service.getNodesBySelector(selector);
+        if (nodes.length === 0) {
+            return `未找到节点: ${selector}`;
+        }
+        const node = nodes[0];
+        try {
+            const version = await node.getVersion();
+            const lines = [
+                `=== ${node.name} ===`,
+                `ID: ${node.id}`,
+                `状态: ${node.status}`,
+                `标签: ${node.tags.join(', ') || '无'}`,
+                `Docker 版本: ${version.Version}`,
+                `API 版本: ${version.ApiVersion}`,
+                `操作系统: ${version.Os} (${version.Arch})`,
+                `内核: ${version.KernelVersion}`,
+            ];
+            return lines.join('\n');
+        }
+        catch (e) {
+            return `获取节点信息失败: ${e.message}`;
+        }
+    });
+    /**
+     * 搜索容器
+     */
+    ctx
+        .command('docker.find <container>', '搜索容器')
+        .alias('docker查找', '容器查找', 'docker搜索', '容器搜索')
+        .option('all', '-a 包含已停止的容器', { fallback: false })
+        .action(async ({ options }, container) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        try {
+            const results = await service.findContainerGlobal(container);
+            if (results.length === 0) {
+                return `未在任何节点找到容器: ${container}`;
+            }
+            const lines = [`找到 ${results.length} 个匹配:`];
+            for (const { node, container: c } of results) {
+                const status = c.State === 'running' ? '🟢' : '🔴';
+                const name = c.Names[0]?.replace('/', '') || c.Id.slice(0, 8);
+                lines.push(`${status} ${node.name}: ${name} (${c.Id.slice(0, 12)})`);
+            }
+            return lines.join('\n');
+        }
+        catch (e) {
+            return `搜索失败: ${e.message}`;
+        }
+    });
+    /**
+     * 执行命令 (一次性)
+     */
+    ctx
+        .command('docker.exec <container> <cmd>', '在容器中执行命令')
+        .alias('docker执行', '容器执行', 'dockerexec', 'dockercmd', 'docker命令', '容器命令')
+        .option('node', '-n <node> 指定节点', { fallback: '' })
+        .action(async ({ options }, container, cmd) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        const nodeSelector = options.node || 'all';
+        try {
+            const nodes = service.getNodesBySelector(nodeSelector);
+            if (nodes.length === 0) {
+                return `未找到节点: ${nodeSelector}`;
+            }
+            // 在匹配的节点上搜索容器
+            const results = await service.findContainerGlobal(container);
+            if (results.length === 0) {
+                return `未找到容器: ${container}`;
+            }
+            // 在第一个匹配的节点和容器上执行
+            const { node, container: c } = results[0];
+            if (c.State !== 'running') {
+                return `容器 ${container} 未运行`;
+            }
+            const result = await node.execContainer(c.Id, cmd.split(' '));
+            return [
+                `=== 执行结果 ===`,
+                `退出码: ${result.exitCode}`,
+                '',
+                result.output || '(无输出)',
+            ].join('\n');
+        }
+        catch (e) {
+            return `执行失败: ${e.message}`;
+        }
+    });
+    /**
+     * 交互式执行 (返回结果，不支持实时交互)
+     */
+    ctx
+        .command('docker.shell <container> <cmd>', '在容器中执行命令(交互式)')
+        .alias('dockershell', '容器shell')
+        .option('node', '-n <node> 指定节点', { fallback: '' })
+        .option('timeout', '-t <seconds> 超时时间', { fallback: 30 })
+        .action(async ({ options }, container, cmd) => {
+        const service = getService();
+        if (!service) {
+            return 'Docker 服务未初始化';
+        }
+        const nodeSelector = options.node || 'all';
+        try {
+            const nodes = service.getNodesBySelector(nodeSelector);
+            if (nodes.length === 0) {
+                return `未找到节点: ${nodeSelector}`;
+            }
+            const results = await service.findContainerGlobal(container);
+            if (results.length === 0) {
+                return `未找到容器: ${container}`;
+            }
+            const { node, container: c } = results[0];
+            if (c.State !== 'running') {
+                return `容器 ${container} 未运行`;
+            }
+            const result = await node.execContainer(c.Id, cmd.split(' '));
+            return [
+                `=== ${node.name}/${c.Names[0]?.replace('/', '') || c.Id.slice(0, 8)} ===`,
+                `> ${cmd}`,
+                ``,
+                result.output || '(无输出)',
+                ``,
+                `[退出码: ${result.exitCode}]`,
+            ].join('\n');
+        }
+        catch (e) {
+            return `执行失败: ${e.message}`;
+        }
+    });
+    /**
+     * 查看帮助
+     */
+    ctx.command('docker.help', '查看帮助').alias('docker帮助', 'docker帮助', '容器帮助').action(async () => {
+        return [
+            '=== Docker Control 帮助 ===',
+            '',
+            '【节点操作】',
+            '  docker.nodes               - 查看节点列表',
+            '  docker.node <节点>         - 查看节点详情',
+            '',
+            '【容器操作】',
+            '  docker.ls [节点]           - 列出容器',
+            '  docker.start <容器>        - 启动容器',
+            '  docker.stop <容器>         - 停止容器',
+            '  docker.restart <容器>      - 重启容器',
+            '  docker.logs <容器> [-t 行数] - 查看日志',
+            '  docker.find <容器>         - 搜索容器',
+            '  docker.exec <容器> <命令>  - 执行命令',
+            '  docker.shell <容器> <命令> - 交互式执行',
+            '',
+            '【节点选择器】',
+            '  all        - 所有节点',
+            '  @标签      - 指定标签的节点',
+            '  节点ID/名称 - 指定单个节点',
+            '',
+            '【通知事件类型】',
+            '  container.start/stop/restart/die',
+            '  container.health_status',
+            '  node.online/offline/error',
+        ].join('\n');
+    });
+}

package/lib/commands/list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 列出容器指令
+ * docker.ls - 支持集群视图和图片渲染
+ */
+import { Context } from 'koishi';
+export declare function registerListCommand(ctx: Context, getService: () => any, config?: any): void;