@vectorx/agent-simulator 0.1.0

package/README.md

@@ -0,0 +1,76 @@
+# VectorX Agent Simulator
+
+VectorX Agent模拟器是一个开发工具，用于帮助开发和调试AI代理应用。它提供了一个简单的界面和调试环境，允许开发者在本地模拟API请求和响应。
+
+## 特性
+
+- 提供Web界面用于实时查看模拟器状态
+- 使用标准 Fetch API 直接连接Agent服务
+- 支持流式响应和普通 JSON 响应
+- 提供命令行工具，便于快速启动和配置
+
+## 安装
+
+```bash
+# 在项目根目录安装依赖
+npm install
+
+# 构建模拟器
+cd packages/vectorx-agent-simulator
+npm run build
+```
+
+## 实现方式
+
+VectorX Agent Simulator 使用标准的 Fetch API 直接连接Agent服务。
+
+这种实现方式具有以下优势：
+- 使用标准 Web API，无需额外依赖
+- 直接与Agent服务通信，无需模拟层
+- 支持流式响应，实时更新内容
+- 便于理解和扩展
+
+## 使用方法
+
+### 命令行
+
+使用以下命令启动模拟器：
+
+```bash
+agent -p 3001 --agent-server-url http://localhost:3000/v1/aiagent/agents/123
+```
+
+#### 命令行参数
+
+- `-p, --port <port>`: 模拟器HTTP服务端口 (默认: 3001)
+- `--agent-server-url <agentServerUrl>`: **[必填]** Agent服务器完整URL地址，例如: http://localhost:3000/v1/aiagent/agents/123
+- `-o, --open`: 启动后自动打开浏览器 (默认: true)
+
+#### 示例
+
+```bash
+# 基本使用
+agent --agent-server-url http://localhost:3000/v1/aiagent/agents/my-agent
+
+# 指定端口
+agent -p 8080 --agent-server-url http://localhost:3000/v1/aiagent/agents/my-agent
+
+# 不自动打开浏览器
+agent --agent-server-url http://localhost:3000/v1/aiagent/agents/my-agent --no-open
+```
+
+## 开发
+
+要在开发模式下运行模拟器：
+
+```bash
+# 监视文件变化并重新构建
+npm run dev
+
+# 在另一个终端启动模拟器
+node bin/agent.js --agent-server-url http://localhost:3000/v1/aiagent/agents/demo-agent
+```
+
+## 许可证
+
+ISC 

package/bin/agent.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const { AgentSimulator } = require('../lib/simulator');
+const path = require('path');
+const fs = require('fs');
+const { Command } = require('commander');
+
+// 获取版本信息
+const packageJsonPath = path.resolve(__dirname, '../package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+// 创建命令行解析器
+const program = new Command();
+
+program
+  .name('agent')
+  .description('VectorX Agent模拟器 - 用于开发和调试AI代理应用')
+  .version(packageJson.version);
+
+program
+  .option('-p, --port <port>', '模拟器服务端口', '3001')
+  .requiredOption('--agent-server-url <agentServerUrl>', 'Agent服务器完整URL地址，例如: http://localhost:3000/v1/aiagent/agents/123')
+  .option('-o, --open', '启动后自动打开浏览器', true)
+  .action(async (options) => {
+    try {
+      // 参数处理
+      const simulatorOptions = {
+        port: parseInt(options.port, 10),
+        agentServerUrl: options.agentServerUrl,
+        open: options.open === true || options.open === 'true'
+      };
+      
+      // 创建并启动模拟器
+      const simulator = new AgentSimulator(simulatorOptions);
+      
+      console.log('\x1b[34m正在启动VectorX Agent模拟器...\x1b[0m');
+      
+      // 处理进程结束信号
+      process.on('SIGINT', async () => {
+        console.log('\n' + '\x1b[33m接收到终止信号，正在关闭模拟器...\x1b[0m');
+        await simulator.stop();
+        process.exit(0);
+      });
+      
+      // 启动模拟器
+      await simulator.start();
+      
+    } catch (error) {
+      console.error('\x1b[31m模拟器启动失败:\x1b[0m', error);
+      process.exit(1);
+    }
+  });
+
+// 启动CLI
+program.parse(process.argv); 

package/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentSimulator = void 0;
+const simulator_1 = require("./simulator");
+Object.defineProperty(exports, "AgentSimulator", { enumerable: true, get: function () { return simulator_1.AgentSimulator; } });

package/lib/simulator.js

@@ -0,0 +1,224 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentSimulator = void 0;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+function parseAgentServerUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        return {
+            protocol: urlObj.protocol,
+            hostname: urlObj.hostname,
+            port: urlObj.port || (urlObj.protocol === "https:" ? "443" : "80"),
+            pathname: urlObj.pathname,
+            baseUrl: `${urlObj.protocol}//${urlObj.hostname}${urlObj.port ? ":" + urlObj.port : ""}`,
+            fullUrl: url,
+        };
+    }
+    catch (error) {
+        throw new Error(`无效的 Agent Server URL: ${url}`);
+    }
+}
+class AgentSimulator {
+    constructor(options) {
+        this.server = null;
+        this.agentStatus = "normal";
+        this.options = Object.assign({ open: true }, options);
+        this.parsedServerUrl = parseAgentServerUrl(options.agentServerUrl);
+        this.app = (0, express_1.default)();
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.app.use((0, cors_1.default)());
+            this.app.use(express_1.default.json());
+            const publicPath = path_1.default.resolve(__dirname, "../public");
+            this.app.use(express_1.default.static(publicPath));
+            this.setupProxy();
+            this.setupRoutes();
+            return new Promise((resolve) => {
+                this.server = this.app.listen(this.options.port, () => {
+                    console.log(chalk_1.default.green(`
+┌────────────────────────────────────────────────────┐
+│                                                    │
+│  🚀 Agent模拟器已启动!                             │
+│                                                    │
+│  📡 模拟器地址: ${chalk_1.default.blue(`http://localhost:${this.options.port}`)}             │
+│  🔄 Agent服务: ${chalk_1.default.blue(this.options.agentServerUrl)}      │
+│                                                    │
+└────────────────────────────────────────────────────┘
+        `));
+                    if (this.options.open) {
+                        console.log(chalk_1.default.yellow(`请手动在浏览器中打开: ${chalk_1.default.blue(`http://localhost:${this.options.port}`)}`));
+                    }
+                    resolve();
+                });
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve, reject) => {
+            if (this.server) {
+                this.server.close((err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    console.log(chalk_1.default.yellow("模拟器已停止"));
+                    resolve();
+                });
+                this.server.closeAllConnections();
+                setTimeout(() => {
+                    resolve();
+                }, 2000);
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    setupProxy() {
+        const proxyOptions = {
+            target: this.parsedServerUrl.baseUrl,
+            changeOrigin: true,
+            pathRewrite: {
+                "^/api": "",
+            },
+            logLevel: "silent",
+        };
+        this.app.use("/api", (req, res, next) => {
+            if (req.path === "/sse" || req.path === "/chat" || req.path === "/control" || req.path === "/restart") {
+                return next();
+            }
+            return (0, http_proxy_middleware_1.createProxyMiddleware)(proxyOptions)(req, res, next);
+        });
+    }
+    setupRoutes() {
+        this.app.get("/agentInfo/get", (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const agentSimulatorInfo = yield this.getAgentSimulatorInfo();
+                res.json(agentSimulatorInfo);
+            }
+            catch (error) {
+                console.error("获取Agent信息失败:", error);
+                res.status(500).json({
+                    error: error instanceof Error ? error.message : "获取Agent信息失败",
+                });
+            }
+        }));
+        this.app.get("/agentInfo/status", (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const healthUrl = `${this.parsedServerUrl.fullUrl}/health`;
+                const response = yield (0, node_fetch_1.default)(healthUrl);
+                if (response.ok) {
+                    const healthData = yield response.json();
+                    this.agentStatus = "normal";
+                    res.json({
+                        status: "normal",
+                        health: healthData,
+                        timestamp: Date.now(),
+                        agentServerUrl: this.options.agentServerUrl,
+                        parsedUrl: {
+                            hostname: this.parsedServerUrl.hostname,
+                            port: this.parsedServerUrl.port,
+                            baseUrl: this.parsedServerUrl.baseUrl,
+                        },
+                    });
+                }
+                else {
+                    this.agentStatus = "error";
+                    res.json({
+                        status: "error",
+                        message: `后端服务响应异常: ${response.status}`,
+                        timestamp: Date.now(),
+                        agentServerUrl: this.options.agentServerUrl,
+                        parsedUrl: {
+                            hostname: this.parsedServerUrl.hostname,
+                            port: this.parsedServerUrl.port,
+                            baseUrl: this.parsedServerUrl.baseUrl,
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                this.agentStatus = "error";
+                res.json({
+                    status: "error",
+                    message: `无法连接到后端服务: ${error.message}`,
+                    timestamp: Date.now(),
+                    agentServerUrl: this.options.agentServerUrl,
+                    parsedUrl: {
+                        hostname: this.parsedServerUrl.hostname,
+                        port: this.parsedServerUrl.port,
+                        baseUrl: this.parsedServerUrl.baseUrl,
+                    },
+                });
+            }
+        }));
+        this.app.get("/simulator/status", (req, res) => {
+            res.json({
+                status: "running",
+                port: this.options.port,
+                agentServerUrl: this.options.agentServerUrl,
+                agentStatus: this.agentStatus,
+                parsedUrl: {
+                    hostname: this.parsedServerUrl.hostname,
+                    port: this.parsedServerUrl.port,
+                    baseUrl: this.parsedServerUrl.baseUrl,
+                },
+            });
+        });
+        this.app.get("*", (req, res, next) => {
+            if (req.path.startsWith("/api") || req.path.startsWith("/simulator")) {
+                return next();
+            }
+            res.sendFile(path_1.default.resolve(__dirname, "../public/index.html"));
+        });
+        this.app.use((req, res) => {
+            res.status(404).json({ error: "未找到请求路径" });
+        });
+    }
+    getAgentSimulatorInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const healthUrl = `${this.parsedServerUrl.fullUrl}/info`;
+            const response = yield (0, node_fetch_1.default)(healthUrl);
+            if (!response.ok) {
+                throw new Error(`无法连接到后端服务: ${response.status} ${response.statusText}`);
+            }
+            const resData = yield response.json();
+            if (resData.code !== 0) {
+                throw new Error(`后端服务返回错误: ${resData.message || "未知错误"}`);
+            }
+            const { agent_info } = resData.data;
+            if (!agent_info) {
+                throw new Error("后端服务返回的数据中缺少 agent_info 字段");
+            }
+            return this.transformToAgentSimulatorInfo(agent_info);
+        });
+    }
+    transformToAgentSimulatorInfo(agentInfo) {
+        return {
+            agentInfo: {
+                agent_icon: agentInfo.agent_icon,
+                agent_id: agentInfo.agent_id,
+                agent_name: agentInfo.agent_name,
+            },
+            agentServerUrl: this.options.agentServerUrl,
+        };
+    }
+}
+exports.AgentSimulator = AgentSimulator;

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateId = void 0;
+const generateId = () => {
+    return Date.now() + "-" + Math.random().toString(36).substr(2, 9);
+};
+exports.generateId = generateId;

package/lib/webview-ui/Agent.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSendMessageUri = getSendMessageUri;
+exports.getHealthUri = getHealthUri;
+function getSendMessageUri(agentSimulatorInfo) {
+    if (!agentSimulatorInfo) {
+        throw new Error("agentSimulatorInfo is not set");
+    }
+    return `${agentSimulatorInfo.agentServerUrl}/send-message`;
+}
+function getHealthUri(agentSimulatorInfo) {
+    if (!agentSimulatorInfo) {
+        throw new Error("agentSimulatorInfo is not set");
+    }
+    return `${agentSimulatorInfo.agentServerUrl}/health`;
+}