@ai-setting/roy-agent-cli 1.0.0

package/src/commands/eventsource/add.ts

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview EventSource Add Command
+ * 
+ * 添加新的事件源
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import { generateId } from "@ai-setting/roy-agent-core";
+import type { EventSourceType, EventSourceComponentInterface } from "@ai-setting/roy-agent-core";
+
+// 生成事件源 ID
+function uuid(): string {
+  return generateId();
+}
+
+export interface EventSourceAddOptions {
+  name: string;
+  type: EventSourceType;
+  eventTypes?: string;
+  command?: string;
+  url?: string;
+  interval?: number;
+  cron?: string;
+  config?: string;
+}
+
+export const EventSourceAddCommand: CommandModule<object, object> = {
+  command: "add <name> <type>",
+  describe: "添加新的事件源",
+
+  builder: (yargs) =>
+    yargs
+      .positional("name", {
+        describe: "事件源名称",
+        type: "string",
+        demandOption: true,
+      })
+      .positional("type", {
+        describe: "事件源类型",
+        type: "string",
+        demandOption: true,
+        choices: ["lark-cli", "websocket", "timer", "http-webhook", "file-watcher"],
+      })
+      .option("event-types", {
+        alias: "e",
+        describe: "事件类型过滤（逗号分隔，支持通配符如 im.message.*）",
+        type: "string",
+      })
+      .option("command", {
+        alias: "c",
+        describe: "执行的命令（lark-cli 类型）",
+        type: "string",
+      })
+      .option("url", {
+        alias: "u",
+        describe: "WebSocket URL",
+        type: "string",
+      })
+      .option("interval", {
+        alias: "i",
+        describe: "定时器间隔（毫秒）",
+        type: "number",
+      })
+      .option("cron", {
+        describe: "Cron 表达式",
+        type: "string",
+      }),
+
+  async handler(args) {
+    const a = args as any;
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: a.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const esComponent = env.getComponent("event-source") as unknown as EventSourceComponentInterface | undefined;
+
+      if (!esComponent) {
+        output.error("EventSourceComponent not available");
+        process.exit(1);
+      }
+
+      // 解析事件类型
+      const eventTypes = a.eventTypes?.split(",").map((s: string) => s.trim());
+
+      // 构建配置
+      const config = {
+        id: uuid(),
+        name: a.name,
+        type: a.type as EventSourceType,
+        enabled: true,
+        eventTypes,
+        command: a.command,
+        url: a.url,
+        interval: a.interval,
+        cron: a.cron,
+      };
+
+      // 注册
+      esComponent.register(config);
+
+      // 持久化（暂时禁用，等待实现持久化）
+      // await esComponent.saveConfig();
+
+      output.success(chalk.green(`事件源 '${a.name}' 添加成功！`));
+      output.log("");
+      output.log(`  ID: ${chalk.gray(config.id)}`);
+      output.log(`  Type: ${chalk.cyan(a.type)}`);
+      if (eventTypes?.length) {
+        output.log(`  Event Types: ${chalk.gray(eventTypes.join(", "))}`);
+      }
+      if (a.command) {
+        output.log(`  Command: ${chalk.gray(a.command)}`);
+      }
+      if (a.interval) {
+        output.log(`  Interval: ${chalk.gray(`${a.interval}ms`)}`);
+      }
+      output.log("");
+      output.log(chalk.gray(`使用 'roy eventsource start ${config.id.substring(0, 8)}' 启动它。`));
+
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/eventsource/index.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview EventSource Command
+ * 
+ * 事件源管理命令入口
+ */
+
+import { CommandModule } from "yargs";
+import { EventSourceListCommand } from "./list";
+import { EventSourceAddCommand } from "./add";
+import { EventSourceRemoveCommand } from "./remove";
+import { EventSourceStartCommand } from "./start";
+import { EventSourceStopCommand } from "./stop";
+import { EventSourceStatusCommand } from "./status";
+
+/**
+ * EventSource Command
+ * 
+ * 事件源管理命令
+ */
+export const EventSourceCommand: CommandModule = {
+  command: "eventsource",
+  aliases: ["es", "event-source"],
+  describe: "事件源管理 - 添加、启动、停止各种事件源（lark-cli、timer、websocket）",
+
+  builder: (yargs) =>
+    yargs
+      .command(EventSourceListCommand)
+      .command(EventSourceAddCommand)
+      .command(EventSourceRemoveCommand)
+      .command(EventSourceStartCommand)
+      .command(EventSourceStopCommand)
+      .command(EventSourceStatusCommand)
+      .demandCommand()
+      .help(),
+
+  handler: () => {
+    // 空实现，yargs 会显示帮助信息
+  },
+};
+
+export {
+  EventSourceListCommand,
+  EventSourceAddCommand,
+  EventSourceRemoveCommand,
+  EventSourceStartCommand,
+  EventSourceStopCommand,
+  EventSourceStatusCommand,
+};

package/src/commands/eventsource/list.ts

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview EventSource List Command
+ * 
+ * 列出所有已配置的事件源
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk, { ChalkInstance } from "chalk";
+import type { EventSourceComponentInterface, EventSourceConfig } from "@ai-setting/roy-agent-core";
+
+export interface EventSourceListOptions {
+  json?: boolean;
+  quiet?: boolean;
+  config?: string;
+}
+
+interface SourceRow {
+  id: string;
+  name: string;
+  type: string;
+  status: string;
+  enabled: string;
+}
+
+/**
+ * 计算字符串的视觉宽度（中文字符占2格）
+ */
+function visualWidth(str: string): number {
+  let width = 0;
+  for (const char of str) {
+    if (char.charCodeAt(0) > 255) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+
+/**
+ * 按视觉宽度截断字符串
+ */
+function truncateVisual(str: string, maxWidth: number): string {
+  let result = "";
+  let width = 0;
+  for (const char of str) {
+    const charWidth = char.charCodeAt(0) > 255 ? 2 : 1;
+    if (width + charWidth > maxWidth) break;
+    result += char;
+    width += charWidth;
+  }
+  return result;
+}
+
+/**
+ * 格式化事件源表格
+ */
+function formatSourcesTable(sources: SourceRow[]): string {
+  if (sources.length === 0) {
+    return chalk.yellow("没有配置的事件源，使用 'roy eventsource add' 添加");
+  }
+
+  const ID_WIDTH = 10;
+  const NAME_WIDTH = 20;
+  const TYPE_WIDTH = 12;
+  const STATUS_WIDTH = 10;
+  const ENABLED_WIDTH = 8;
+  const GAP = "  ";
+
+  const headerLine = [
+    chalk.bold("ID".padEnd(ID_WIDTH)),
+    chalk.bold("NAME".padEnd(NAME_WIDTH)),
+    chalk.bold("TYPE".padEnd(TYPE_WIDTH)),
+    chalk.bold("STATUS".padEnd(STATUS_WIDTH)),
+    chalk.bold("ENABLED".padEnd(ENABLED_WIDTH)),
+  ].join(GAP);
+
+  const sepLine = "─".repeat(ID_WIDTH + NAME_WIDTH + TYPE_WIDTH + STATUS_WIDTH + ENABLED_WIDTH + GAP.length * 4);
+
+  const formatRow = (src: SourceRow): string => {
+    const id = truncateVisual(src.id, ID_WIDTH).padEnd(ID_WIDTH);
+    const name = truncateVisual(src.name, NAME_WIDTH).padEnd(NAME_WIDTH);
+    const type = truncateVisual(src.type, TYPE_WIDTH).padEnd(TYPE_WIDTH);
+    const status = truncateVisual(src.status, STATUS_WIDTH).padEnd(STATUS_WIDTH);
+    const enabled = src.enabled.padEnd(ENABLED_WIDTH);
+    return `${id}${GAP}${name}${GAP}${type}${GAP}${status}${GAP}${enabled}`;
+  };
+
+  const rows = sources.map(formatRow);
+  return [headerLine, sepLine, ...rows].join("\n");
+}
+
+export const EventSourceListCommand: CommandModule<object, EventSourceListOptions> = {
+  command: "list",
+  aliases: ["ls"],
+  describe: "列出所有事件源",
+
+  builder: (yargs) =>
+    yargs
+      .option("json", {
+        alias: "j",
+        describe: "JSON 格式输出",
+        type: "boolean",
+        default: false,
+      })
+      .option("quiet", {
+        alias: "q",
+        describe: "静默模式",
+        type: "boolean",
+        default: false,
+      }),
+
+  async handler(args) {
+    const output = new OutputService();
+    output.configure({ quiet: args.quiet });
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      
+      // Debug: 列出所有组件
+      const components = env.listComponents().map(c => c.name);
+      output.log("Available components: " + components.join(", "));
+      
+      const esComponent = env.getComponent("event-source") as unknown as EventSourceComponentInterface | undefined;
+
+      if (!esComponent) {
+        output.error("EventSourceComponent not available");
+        process.exit(1);
+      }
+
+      const sources = esComponent.list();
+
+      if (!sources || sources.length === 0) {
+        if (args.json) {
+          output.json({ sources: [], count: 0 });
+        } else {
+          output.log(chalk.yellow("没有配置的事件源，使用 'roy eventsource add' 添加"));
+        }
+        return;
+      }
+
+      if (args.json) {
+        const sourcesWithStatus = sources.map((s) => ({
+          ...s,
+          status: esComponent.getStatus(s.id) || "unknown",
+        }));
+        output.json({ sources: sourcesWithStatus, count: sources.length });
+        return;
+      }
+
+      // 表格输出
+      const rows: SourceRow[] = sources.map((s) => {
+        const status = esComponent.getStatus(s.id) || "unknown";
+        const statusColorMap: Record<string, ChalkInstance> = {
+          running: chalk.green,
+          stopped: chalk.gray,
+          error: chalk.red,
+          starting: chalk.yellow,
+          created: chalk.gray,
+          stopping: chalk.yellow,
+          unknown: chalk.gray,
+        };
+        const statusColor = statusColorMap[status] || chalk.gray;
+
+        return {
+          id: s.id.substring(0, 8),
+          name: s.name,
+          type: s.type,
+          status: statusColor(status),
+          enabled: s.enabled ? chalk.green("✓") : chalk.gray("✗"),
+        };
+      });
+
+      output.log(formatSourcesTable(rows));
+      output.info("");
+      output.log(
+        chalk.green(`✅ 共 ${sources.length} 个事件源`)
+      );
+    } catch (error) {
+      output.error(`Failed to list event sources: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/eventsource/remove.ts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview EventSource Remove Command
+ * 
+ * 移除事件源
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { EventSourceComponentInterface } from "@ai-setting/roy-agent-core";
+
+export interface EventSourceRemoveOptions {
+  id: string;
+  config?: string;
+  force?: boolean;
+}
+
+export const EventSourceRemoveCommand: CommandModule<object, EventSourceRemoveOptions> = {
+  command: "remove <id>",
+  aliases: ["rm"],
+  describe: "移除指定的事件源",
+
+  builder: (yargs) =>
+    yargs
+      .positional("id", {
+        describe: "事件源 ID（支持前缀匹配）",
+        type: "string",
+        demandOption: true,
+      })
+      .option("force", {
+        alias: "f",
+        describe: "强制移除（即使正在运行）",
+        type: "boolean",
+        default: false,
+      }),
+
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const esComponent = env.getComponent("event-source") as unknown as EventSourceComponentInterface | undefined;
+
+      if (!esComponent) {
+        output.error("EventSourceComponent not available");
+        process.exit(1);
+      }
+
+      // 查找事件源（支持前缀匹配）
+      const sources = esComponent.list();
+      const matchedSource = sources.find(
+        (s) => s.id === args.id || s.id.startsWith(args.id)
+      );
+
+      if (!matchedSource) {
+        output.error(`事件源不存在: ${args.id}`);
+        process.exit(1);
+      }
+
+      // 检查是否正在运行
+      const status = esComponent.getStatus(matchedSource.id);
+      if (status === "running" && !args.force) {
+        output.error(`事件源正在运行中，请先停止: ${matchedSource.name} (${status})`);
+        output.log(chalk.gray(`使用 --force 强制移除或 'roy eventsource stop ${matchedSource.id.substring(0, 8)}' 先停止`));
+        process.exit(1);
+      }
+
+      // 如果正在运行，先停止
+      if (status === "running") {
+        await esComponent.stopSource(matchedSource.id);
+        output.info(`已停止事件源: ${matchedSource.name}`);
+      }
+
+      // 移除
+      const result = esComponent.unregister(matchedSource.id);
+
+      if (result) {
+        output.success(chalk.green(`事件源已移除: ${matchedSource.name}`));
+      } else {
+        output.error("移除失败");
+        process.exit(1);
+      }
+
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/eventsource/start.ts

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview EventSource Start Command
+ * 
+ * 启动事件源
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { EventSourceComponentInterface } from "@ai-setting/roy-agent-core";
+
+export interface EventSourceStartOptions {
+  id: string;
+  config?: string;
+  background?: boolean;
+}
+
+export const EventSourceStartCommand: CommandModule<object, EventSourceStartOptions> = {
+  command: "start <id>",
+  describe: "启动指定的事件源",
+
+  builder: (yargs) =>
+    yargs
+      .positional("id", {
+        describe: "事件源 ID（支持前缀匹配）",
+        type: "string",
+        demandOption: true,
+      })
+      .option("background", {
+        alias: "b",
+        describe: "后台运行",
+        type: "boolean",
+        default: false,
+      }),
+
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const esComponent = env.getComponent("event-source") as unknown as EventSourceComponentInterface | undefined;
+
+      if (!esComponent) {
+        output.error("EventSourceComponent not available");
+        process.exit(1);
+      }
+
+      // 查找事件源（支持前缀匹配）
+      const sources = esComponent.list();
+      const matchedSource = sources.find(
+        (s) => s.id === args.id || s.id.startsWith(args.id)
+      );
+
+      if (!matchedSource) {
+        output.error(`事件源不存在: ${args.id}`);
+        process.exit(1);
+      }
+
+      // 检查状态
+      const status = esComponent.getStatus(matchedSource.id);
+      if (status === "running") {
+        output.log(chalk.yellow(`事件源已在运行: ${matchedSource.name}`));
+        return;
+      }
+
+      // 启动
+      output.info(`正在启动事件源 '${matchedSource.name}'...`);
+
+      try {
+        await esComponent.startSource(matchedSource.id);
+        output.success(chalk.green(`事件源已启动: ${matchedSource.name}`));
+
+        if (!args.background) {
+          output.log(chalk.gray("按 Ctrl+C 停止..."));
+
+          // 等待信号
+          await new Promise<void>((resolve) => {
+            const cleanup = () => {
+              process.removeListener("SIGINT", cleanup);
+              process.removeListener("SIGTERM", cleanup);
+              resolve();
+            };
+            process.on("SIGINT", cleanup);
+            process.on("SIGTERM", cleanup);
+          });
+        }
+      } catch (error) {
+        output.error(`启动失败: ${error}`);
+        process.exit(1);
+      }
+
+    } finally {
+      await envService.dispose();
+    }
+  },
+};