@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/cli/src/commands/debug/span.js

@@ -0,0 +1,187 @@
+/**
+ * @fileoverview Debug Span Command
+ *
+ * Command: roy debug span <spanId>
+ *
+ * 通过 spanId 从 SQLite 中查询详细的 span 信息
+ */
+import * as path from "path";
+import * as os from "os";
+import { SQLiteSpanStorage } from "@ai-setting/roy-agent-core";
+export const SpanCommand = {
+    command: "span",
+    describe: "通过 spanId 查询详细的 span 信息",
+    builder: (yargs) => yargs
+        .positional("spanId", {
+        type: "string",
+        describe: "Span ID",
+        demandOption: true,
+    })
+        .option("db", {
+        type: "string",
+        describe: "SQLite 数据库路径（可选，默认使用配置路径）",
+    }),
+    async handler(args) {
+        const spanId = args._[2] || args.spanId;
+        if (!spanId) {
+            console.error("Error: spanId is required");
+            console.error("Usage: roy debug span <spanId>");
+            process.exit(1);
+        }
+        // 获取数据库路径
+        const dbPath = args.db || getDefaultSpanDbPath();
+        // 创建存储实例并读取数据
+        const storage = new SQLiteSpanStorage(dbPath);
+        await storage.initialize();
+        try {
+            // 查询 span
+            const span = storage.findBySpanId(spanId);
+            if (!span) {
+                console.log(`Span ${spanId} not found.`);
+                return;
+            }
+            // 格式化输出详细信息
+            const output = formatSpanDetail(span);
+            console.log(output);
+        }
+        finally {
+            storage.close();
+        }
+    },
+};
+/**
+ * 获取默认的 span 数据库路径
+ */
+export function getDefaultSpanDbPath() {
+    // 支持环境变量覆盖
+    if (process.env.LOG_TRACE_TRACING_DB_PATH) {
+        return process.env.LOG_TRACE_TRACING_DB_PATH;
+    }
+    // 使用 XDG 标准路径
+    const home = os.homedir();
+    const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+    return path.join(dataHome, "roy-agent", "traces.db");
+}
+/**
+ * 安全序列化对象，处理循环引用和其他异常
+ */
+function safeStringify(obj, indent = 2) {
+    // 处理非对象类型
+    if (obj === null)
+        return "null";
+    if (obj === undefined)
+        return "undefined";
+    if (typeof obj !== "object")
+        return String(obj);
+    // 如果已经是字符串，可能是已经 stringify 过的
+    if (typeof obj === "string") {
+        // 尝试检测是否是 JSON 字符串
+        try {
+            const parsed = JSON.parse(obj);
+            return safeStringify(parsed, indent);
+        }
+        catch {
+            return obj;
+        }
+    }
+    // 处理数组
+    if (Array.isArray(obj)) {
+        try {
+            const items = obj.map(item => safeStringify(item, 0));
+            return `[${items.join(", ")}]`;
+        }
+        catch {
+            return "[Array - cannot stringify]";
+        }
+    }
+    // 使用 WeakSet 检测循环引用
+    const seen = new WeakSet();
+    const stringify = (value, depth) => {
+        if (value === null)
+            return "null";
+        if (value === undefined)
+            return "undefined";
+        if (typeof value !== "object")
+            return JSON.stringify(value);
+        if (typeof value === "string") {
+            // 可能是已经 stringify 过的 JSON 字符串
+            try {
+                const parsed = JSON.parse(value);
+                return JSON.stringify(parsed);
+            }
+            catch {
+                return JSON.stringify(value);
+            }
+        }
+        if (Array.isArray(value)) {
+            if (seen.has(value))
+                return '"[Circular]"';
+            seen.add(value);
+            const items = value.map(item => stringify(item, depth + 1));
+            return `[${items.join(", ")}]`;
+        }
+        if (seen.has(value))
+            return '"[Circular]"';
+        seen.add(value);
+        const entries = Object.entries(value);
+        const props = entries.map(([k, v]) => `"${k}": ${stringify(v, depth + 1)}`);
+        return `{${props.join(", ")}}`;
+    };
+    try {
+        return stringify(obj, 0);
+    }
+    catch (e) {
+        return `[Object - cannot stringify: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+}
+/**
+ * 格式化 span 为详细输出
+ */
+export function formatSpanDetail(span) {
+    const lines = [];
+    // 基本信息
+    lines.push(`Span ID:    ${span.spanId}`);
+    lines.push(`Trace ID:   ${span.traceId}`);
+    lines.push(`Name:       ${span.name}`);
+    lines.push(`Kind:       ${span.kind}`);
+    lines.push(`Status:     ${span.status}`);
+    // 时间信息
+    const duration = span.endTime
+        ? `${span.endTime - span.startTime}ms`
+        : "(running)";
+    lines.push(`Duration:   ${duration}`);
+    lines.push(`Start:      ${span.startTime} (${new Date(span.startTime).toISOString()})`);
+    if (span.endTime) {
+        lines.push(`End:        ${span.endTime} (${new Date(span.endTime).toISOString()})`);
+    }
+    // 父子关系
+    if (span.parentSpanId) {
+        lines.push(`Parent:     ${span.parentSpanId}`);
+    }
+    // 错误信息
+    if (span.error) {
+        lines.push(`Error:      ${span.error}`);
+    }
+    // 属性
+    if (span.attributes && Object.keys(span.attributes).length > 0) {
+        lines.push("");
+        lines.push("Attributes:");
+        for (const [key, value] of Object.entries(span.attributes)) {
+            lines.push(`  ${key}: ${safeStringify(value, 0)}`);
+        }
+    }
+    // 结果
+    if (span.result !== undefined) {
+        lines.push("");
+        lines.push("Result:");
+        // 如果是字符串，尝试解析为 JSON 显示；如果是已损坏的数据，显示提示
+        const resultStr = typeof span.result === "string"
+            ? (span.result.includes("[Object with circular reference")
+                ? "[Circular reference - original data contained circular structures]"
+                : span.result)
+            : safeStringify(span.result);
+        lines.push(`  ${resultStr}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=span.js.map

package/dist/cli/src/commands/debug/trace.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Debug Trace Command
+ *
+ * Command: roy debug trace <traceId>
+ *
+ * 以 tree 方式展示 traceId 的 spans
+ */
+import type { CommandModule } from "yargs";
+import type { Span } from "@ai-setting/roy-agent-core";
+interface TraceOptions {
+    traceId?: string;
+    db?: string;
+}
+export declare const TraceCommand: CommandModule<object, TraceOptions>;
+/**
+ * 获取默认的 span 数据库路径
+ */
+export declare function getDefaultSpanDbPath(): string;
+/**
+ * 格式化 spans 为 tree 视图
+ *
+ * spans 是已经构建好的树结构（根节点数组，每个节点有 children）
+ * 直接遍历输出即可
+ */
+export declare function formatSpanTree(spans: Span[]): string;
+export {};
+//# sourceMappingURL=trace.d.ts.map

package/dist/cli/src/commands/debug/trace.js

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Debug Trace Command
+ *
+ * Command: roy debug trace <traceId>
+ *
+ * 以 tree 方式展示 traceId 的 spans
+ */
+import * as path from "path";
+import * as os from "os";
+import { SQLiteSpanStorage } from "@ai-setting/roy-agent-core";
+export const TraceCommand = {
+    command: "trace",
+    describe: "以 tree 方式查看 trace 的 spans",
+    builder: (yargs) => yargs
+        .positional("traceId", {
+        type: "string",
+        describe: "Trace ID",
+        demandOption: true,
+    })
+        .option("db", {
+        type: "string",
+        describe: "SQLite 数据库路径（可选，默认使用配置路径）",
+    }),
+    async handler(args) {
+        const traceId = args._[2] || args.traceId;
+        if (!traceId) {
+            console.error("Error: traceId is required");
+            console.error("Usage: roy debug trace <traceId>");
+            process.exit(1);
+        }
+        // 获取数据库路径
+        const dbPath = args.db || getDefaultSpanDbPath();
+        // 创建存储实例并读取数据
+        const storage = new SQLiteSpanStorage(dbPath);
+        await storage.initialize();
+        try {
+            // 查询 spans
+            const spans = storage.findByTraceId(traceId);
+            if (spans.length === 0) {
+                console.log(`Trace ${traceId} not found.`);
+                return;
+            }
+            // 格式化输出为 tree
+            // 注意：spans 已经是 buildTree() 返回的根节点数组，每个节点有 children
+            const treeOutput = formatSpanTree(spans);
+            // 分段输出到 stderr，避免被 log-trace 的 maxOutput 截断
+            const chunkSize = 4000;
+            for (let i = 0; i < treeOutput.length; i += chunkSize) {
+                console.error(treeOutput.substring(i, i + chunkSize));
+            }
+        }
+        finally {
+            storage.close();
+        }
+    },
+};
+/**
+ * 获取默认的 span 数据库路径
+ */
+export function getDefaultSpanDbPath() {
+    // 支持环境变量覆盖
+    if (process.env.LOG_TRACE_TRACING_DB_PATH) {
+        return process.env.LOG_TRACE_TRACING_DB_PATH;
+    }
+    // 使用 XDG 标准路径
+    const home = os.homedir();
+    const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+    return path.join(dataHome, "roy-agent", "traces.db");
+}
+/**
+ * 格式化 spans 为 tree 视图
+ *
+ * spans 是已经构建好的树结构（根节点数组，每个节点有 children）
+ * 直接遍历输出即可
+ */
+export function formatSpanTree(spans) {
+    if (spans.length === 0) {
+        return "(empty)";
+    }
+    // spans 已经是根节点数组，直接格式化
+    const lines = [];
+    for (const root of spans) {
+        formatSpanNode(root, 0, lines);
+    }
+    return lines.join("\n");
+}
+/**
+ * 递归格式化单个 span
+ *
+ * 简化输出：只显示 name、duration、error、spanId
+ */
+function formatSpanNode(span, depth, lines) {
+    const indent = "  ".repeat(depth);
+    const connector = depth === 0 ? "" : "└── ";
+    // 计算耗时
+    const duration = span.endTime
+        ? `${span.endTime - span.startTime}ms`
+        : "(running)";
+    // 构建错误信息
+    const errorInfo = span.error
+        ? ` ⚠ ${span.error}`
+        : "";
+    // 添加 spanId 显示
+    const spanIdInfo = `[spanId:${span.spanId}]`;
+    lines.push(`${indent}${connector}${span.name} (${duration})${errorInfo} ${spanIdInfo}`);
+    // 递归处理子 span
+    for (const child of span.children || []) {
+        formatSpanNode(child, depth + 1, lines);
+    }
+}
+//# sourceMappingURL=trace.js.map

package/dist/cli/src/commands/eventsource/add.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview EventSource Add Command
+ *
+ * 添加新的事件源
+ */
+import { CommandModule } from "yargs";
+import type { EventSourceType } from "@ai-setting/roy-agent-core";
+export interface EventSourceAddOptions {
+    name: string;
+    type: EventSourceType;
+    eventTypes?: string;
+    command?: string;
+    url?: string;
+    interval?: number;
+    cron?: string;
+    config?: string;
+}
+export declare const EventSourceAddCommand: CommandModule<object, object>;
+//# sourceMappingURL=add.d.ts.map

package/dist/cli/src/commands/eventsource/add.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview EventSource Add Command
+ *
+ * 添加新的事件源
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+import { generateId } from "@ai-setting/roy-agent-core";
+// 生成事件源 ID
+function uuid() {
+    return generateId();
+}
+export const EventSourceAddCommand = {
+    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;
+        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");
+            if (!esComponent) {
+                output.error("EventSourceComponent not available");
+                process.exit(1);
+            }
+            // 解析事件类型
+            const eventTypes = a.eventTypes?.split(",").map((s) => s.trim());
+            // 构建配置
+            const config = {
+                id: uuid(),
+                name: a.name,
+                type: a.type,
+                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();
+        }
+    },
+};
+//# sourceMappingURL=add.js.map

package/dist/cli/src/commands/eventsource/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 declare const EventSourceCommand: CommandModule;
+export { EventSourceListCommand, EventSourceAddCommand, EventSourceRemoveCommand, EventSourceStartCommand, EventSourceStopCommand, EventSourceStatusCommand, };
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/eventsource/index.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview EventSource Command
+ *
+ * 事件源管理命令入口
+ */
+import { EventSourceListCommand } from "./list.js";
+import { EventSourceAddCommand } from "./add.js";
+import { EventSourceRemoveCommand } from "./remove.js";
+import { EventSourceStartCommand } from "./start.js";
+import { EventSourceStopCommand } from "./stop.js";
+import { EventSourceStatusCommand } from "./status.js";
+/**
+ * EventSource Command
+ *
+ * 事件源管理命令
+ */
+export const EventSourceCommand = {
+    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, };
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/eventsource/list.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview EventSource List Command
+ *
+ * 列出所有已配置的事件源
+ */
+import { CommandModule } from "yargs";
+export interface EventSourceListOptions {
+    json?: boolean;
+    quiet?: boolean;
+    config?: string;
+}
+export declare const EventSourceListCommand: CommandModule<object, EventSourceListOptions>;
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/src/commands/eventsource/list.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview EventSource List Command
+ *
+ * 列出所有已配置的事件源
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+/**
+ * 计算字符串的视觉宽度（中文字符占2格）
+ */
+function visualWidth(str) {
+    let width = 0;
+    for (const char of str) {
+        if (char.charCodeAt(0) > 255) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}
+/**
+ * 按视觉宽度截断字符串
+ */
+function truncateVisual(str, maxWidth) {
+    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) {
+    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) => {
+        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 = {
+    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");
+            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 = sources.map((s) => {
+                const status = esComponent.getStatus(s.id) || "unknown";
+                const statusColorMap = {
+                    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();
+        }
+    },
+};
+//# sourceMappingURL=list.js.map