@cloudbase/cli 2.10.0-beta.0 → 2.11.0-beta.0

package/lib/commands/ag/run.js

@@ -0,0 +1,644 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRunCommand = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+const open_1 = __importDefault(require("open"));
+const execa_1 = __importDefault(require("execa"));
+const dotenv = __importStar(require("dotenv"));
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const common_1 = require("../common");
+const decorators_1 = require("../../decorators");
+const base_1 = require("./base");
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const i18n_1 = require("../../i18n");
+let AgentRunCommand = class AgentRunCommand extends common_1.Command {
+    get options() {
+        return {
+            cmd: 'ag',
+            childCmd: 'run <agentName>',
+            allowUnknownOption: true,
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: (0, i18n_1.t)('环境 ID')
+                },
+                {
+                    flags: '--extendedContext <extendedContext>',
+                    desc: (0, i18n_1.t)('扩展上下文，示例：--extendedContext \'{"a":1,"b":2}\'')
+                },
+                {
+                    flags: '--port <port>',
+                    desc: (0, i18n_1.t)('监听的端口，默认为 3000'),
+                    defaultValue: 3000
+                },
+                {
+                    flags: '--dry-run',
+                    desc: (0, i18n_1.t)('是否不启动服务，只验证代码可以正常加载，默认为 false')
+                },
+                {
+                    flags: '--open-debug-panel',
+                    desc: (0, i18n_1.t)('是否打开调试面板，默认为 true'),
+                    defaultValue: 'false'
+                },
+                {
+                    flags: '--entryPath <entryPath>',
+                    desc: (0, i18n_1.t)('指定 Agent 服务启动的入口文件路径')
+                },
+                {
+                    flags: '--web',
+                    desc: (0, i18n_1.t)('同时启动前端项目（如果存在 client 目录）')
+                }
+            ],
+            requiredEnvId: false,
+            autoRunLogin: true,
+            desc: (0, i18n_1.t)('本地运行 Agent 进行调试')
+        };
+    }
+    async execute(ctx, envId, log, params, options) {
+        const agentName = params[0];
+        const { extendedContext, port = 9000, dryRun, openDebugPanel = 'false', entryPath, web: enableWeb = 'false' } = options;
+        const workDir = process.cwd();
+        const cloudbaseConfig = await (0, base_1.getCloudbaseConfig)(workDir);
+        if (!envId) {
+            if (cloudbaseConfig.envId) {
+                envId = cloudbaseConfig.envId;
+            }
+            else {
+                envId = await this.selectEnv();
+            }
+        }
+        log.info((0, i18n_1.t)(`当前环境：${envId}`));
+        let agentConfig;
+        try {
+            agentConfig = await (0, base_1.getAgentConfig)(agentName, workDir);
+        }
+        catch (error) {
+            throw new base_1.AgentError((0, i18n_1.t)(`未找到 Agent 配置，请先运行 tcb ag create ${agentName}`));
+        }
+        log.info((0, i18n_1.t)(`当前 Agent：${agentConfig.name}`));
+        const agentRoot = path_1.default.join(workDir, cloudbaseConfig.agentRoot);
+        const agentDir = path_1.default.join(agentRoot, agentName);
+        await this.setupEnvironment(envId, agentConfig, extendedContext, ctx, options);
+        console.log(chalk_1.default.green((0, i18n_1.t)('正在启动 Agent 本地调试服务...')));
+        await this.startNormal({
+            workDir: agentDir,
+            agentName,
+            port,
+            openDebugPanel: openDebugPanel !== 'false',
+            dryRun,
+            log,
+            entryPath,
+            enableWeb: enableWeb !== 'false'
+        });
+    }
+    async selectEnv() {
+        return (0, utils_1.selectEnv)({ source: [constants_1.EnvSource.MINIAPP, constants_1.EnvSource.QCLOUD] });
+    }
+    async setupEnvironment(envId, agentConfig, extendedContext, ctx, options) {
+        const credential = await (0, utils_1.getCredential)(ctx, options);
+        process.env.CLOUDBASE_ENV_ID = envId;
+        process.env.AGENT_NAME = agentConfig.name;
+        if (agentConfig.environment) {
+            Object.entries(agentConfig.environment).forEach(([key, value]) => {
+                process.env[key] = String(value);
+            });
+        }
+        const extendedContextObj = {
+            tmpSecret: {
+                secretId: credential.secretId,
+                secretKey: credential.secretKey,
+                token: credential.token
+            },
+            source: 'local_dev',
+            envId,
+            agentName: agentConfig.name,
+            accessToken: `Bearer ${await (0, utils_1.fetchAccessToken)({
+                envId,
+                secretId: credential.secretId,
+                secretKey: credential.secretKey,
+                token: credential.token
+            })}`
+        };
+        if (extendedContext) {
+            try {
+                const userContext = JSON.parse(extendedContext);
+                Object.assign(extendedContextObj, userContext);
+            }
+            catch (error) {
+                throw new base_1.AgentError((0, i18n_1.t)('扩展上下文格式错误，请提供有效的 JSON 字符串'));
+            }
+        }
+        process.env.EXTENDED_CONTEXT = JSON.stringify(extendedContextObj);
+        process.env.STATIC_SERVE_ROOT = __dirname;
+        process.env.ENABLE_CORS = 'true';
+        process.env.ALLOWED_ORIGINS = '*';
+        process.env.CLOUDBASE_RUNTIME = 'agent';
+    }
+    async startNormal(options) {
+        const { workDir, agentName, port, openDebugPanel, dryRun, log, entryPath, enableWeb } = options;
+        if (dryRun) {
+            log.info((0, i18n_1.t)('代码验证模式，不启动服务'));
+            return;
+        }
+        const agentServicePromise = this.startAgentService(workDir, agentName, port, log, entryPath);
+        if (openDebugPanel) {
+            this.startDebugPanelAfterAgentReady(agentName, port, log);
+        }
+        if (enableWeb) {
+            this.startWebProjectAfterAgentReady(workDir, port, log);
+        }
+        await agentServicePromise;
+    }
+    async startDebugPanelAfterAgentReady(agentName, agentPort, log) {
+        setTimeout(async () => {
+            try {
+                const agentUrl = `http://127.0.0.1:${agentPort}`;
+                await this.waitForService(agentUrl, 30000);
+                log.info((0, i18n_1.t)('Agent 服务已就绪，正在启动调试面板...'));
+                const debugPort = await this.startDebugPanelServer(agentName, agentPort, log);
+                await this.openDebugPanel(agentName, agentPort, debugPort, log);
+            }
+            catch (error) {
+                log.warn((0, i18n_1.t)('启动调试面板失败：{{error}}', { error: error.message }));
+                log.info((0, i18n_1.t)('Agent 服务仍在正常运行，可以手动访问：http://127.0.0.1:{{port}}', { port: agentPort }));
+            }
+        }, 1000);
+    }
+    async startWebProjectAfterAgentReady(workDir, agentPort, log) {
+        setTimeout(async () => {
+            try {
+                const clientDir = path_1.default.join(workDir, 'client');
+                if (!await fs_extra_1.default.pathExists(clientDir)) {
+                    log.warn((0, i18n_1.t)('未找到前端项目目录 (client)，跳过前端启动'));
+                    return;
+                }
+                const agentUrl = `http://127.0.0.1:${agentPort}`;
+                await this.waitForService(agentUrl, 30000);
+                log.info((0, i18n_1.t)('Agent 服务已就绪，正在启动前端项目...'));
+                await this.startWebProject(clientDir, agentPort, log);
+            }
+            catch (error) {
+                log.warn((0, i18n_1.t)(`启动前端项目失败：${error.message}`));
+                log.info((0, i18n_1.t)(`Agent 服务仍在正常运行，可以手动访问：http://127.0.0.1:${agentPort}`));
+            }
+        }, 1000);
+    }
+    async startWebProject(clientDir, agentPort, log) {
+        const packageJsonPath = path_1.default.join(clientDir, 'package.json');
+        if (!await fs_extra_1.default.pathExists(packageJsonPath)) {
+            throw new Error((0, i18n_1.t)('前端项目缺少 package.json 文件'));
+        }
+        let packageJson;
+        try {
+            packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+        }
+        catch (error) {
+            throw new Error((0, i18n_1.t)(`读取前端项目 package.json 失败：${error.message}`));
+        }
+        const scripts = packageJson.scripts || {};
+        let startScript = 'dev';
+        if (!scripts.dev && scripts.start) {
+            startScript = 'start';
+        }
+        else if (!scripts.dev && !scripts.start) {
+            throw new Error((0, i18n_1.t)('前端项目缺少 dev 或 start 脚本'));
+        }
+        log.info((0, i18n_1.t)('正在安装前端项目依赖...'));
+        const nodeModulesPath = path_1.default.join(clientDir, 'node_modules');
+        if (!await fs_extra_1.default.pathExists(nodeModulesPath)) {
+            try {
+                await (0, execa_1.default)('npm', ['install'], {
+                    cwd: clientDir,
+                    stdio: 'inherit'
+                });
+                log.info((0, i18n_1.t)('前端项目依赖安装完成'));
+            }
+            catch (error) {
+                throw new Error((0, i18n_1.t)(`安装前端项目依赖失败：${error.message}`));
+            }
+        }
+        log.info((0, i18n_1.t)('正在启动前端项目...'));
+        const env = {
+            ...process.env,
+            VITE_TS_AGENT_SERVER_URL: `http://127.0.0.1:${agentPort}`,
+            VITE_PYTHON_AGENT_SERVER_URL: `http://127.0.0.1:${agentPort}`,
+        };
+        const child = (0, execa_1.default)('npm', ['run', startScript], {
+            cwd: clientDir,
+            stdio: 'inherit',
+            env
+        });
+        child.on('exit', (code, signal) => {
+            if (code !== null) {
+                log.info((0, i18n_1.t)(`前端项目已退出，退出码：${code}`));
+            }
+            else if (signal) {
+                log.info((0, i18n_1.t)(`前端项目被信号终止：${signal}`));
+            }
+        });
+        child.on('error', (error) => {
+            log.error((0, i18n_1.t)(`前端项目启动失败：${error.message}`));
+        });
+        log.info((0, i18n_1.t)('前端项目已启动'));
+        log.info((0, i18n_1.t)('前端访问地址通常为：http://localhost:3000 或 http://localhost:5173'));
+        log.info((0, i18n_1.t)(`Agent API 地址：http://127.0.0.1:${agentPort}`));
+    }
+    async startDebugPanelServer(agentName, agentPort, log) {
+        const debugApp = (0, express_1.default)();
+        const debugPort = await this.findAvailablePort(agentPort + 1000);
+        debugApp.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(200);
+            }
+            else {
+                next();
+            }
+        });
+        const staticPath = path_1.default.join(__dirname, './debug');
+        debugApp.use(express_1.default.static(staticPath));
+        const server = (0, http_1.createServer)(debugApp);
+        return new Promise((resolve, reject) => {
+            server.listen(debugPort, '127.0.0.1', () => {
+                log.info((0, i18n_1.t)(`调试面板服务器已启动，端口：${debugPort}`));
+                resolve(debugPort);
+            });
+            server.on('error', (error) => {
+                reject(new base_1.AgentError((0, i18n_1.t)(`启动调试面板服务器失败：${error.message}`)));
+            });
+        });
+    }
+    async findAvailablePort(startPort) {
+        const net = await Promise.resolve().then(() => __importStar(require('net')));
+        return new Promise((resolve, reject) => {
+            const server = net.createServer();
+            server.listen(startPort, '127.0.0.1', () => {
+                var _a;
+                const port = (_a = server.address()) === null || _a === void 0 ? void 0 : _a.port;
+                server.close(() => resolve(port));
+            });
+            server.on('error', () => {
+                this.findAvailablePort(startPort + 1).then(resolve).catch(reject);
+            });
+        });
+    }
+    async openDebugPanel(agentName, agentPort, debugPort, log) {
+        const debugUrl = `http://127.0.0.1:${debugPort}/?agentName=${agentName}&agentPort=${agentPort}`;
+        log.info((0, i18n_1.t)(`调试面板地址：${debugUrl}`));
+        console.log(chalk_1.default.green((0, i18n_1.t)(`🚀 Agent 调试面板：${debugUrl}`)));
+        console.log(chalk_1.default.gray((0, i18n_1.t)(`Agent 服务地址：http://127.0.0.1:${agentPort}`)));
+        try {
+            await this.waitForService(debugUrl);
+            await (0, open_1.default)(debugUrl, { wait: false });
+            console.log(chalk_1.default.green((0, i18n_1.t)('已自动打开 Agent 调试面板')));
+        }
+        catch (error) {
+            log.warn((0, i18n_1.t)(`无法自动打开调试面板，请手动访问：${debugUrl}`));
+        }
+    }
+    async waitForService(url, timeout = 10000) {
+        const startTime = Date.now();
+        const { default: fetch } = await Promise.resolve().then(() => __importStar(require('node-fetch')));
+        while (Date.now() - startTime < timeout) {
+            try {
+                const response = await fetch(url, {
+                    timeout: 2000,
+                    method: 'GET'
+                });
+                if (response.status < 500) {
+                    return;
+                }
+            }
+            catch (error) {
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        throw new Error((0, i18n_1.t)('等待服务就绪超时'));
+    }
+    async startAgentService(workDir, agentName, port, log, customEntryPath) {
+        let entryPath;
+        if (customEntryPath) {
+            await this.validateCustomEntryPath(customEntryPath, workDir);
+            entryPath = customEntryPath;
+            log.info((0, i18n_1.t)(`使用自定义入口文件：${entryPath}`));
+        }
+        else {
+            entryPath = await this.getEntryPath(workDir);
+            log.info((0, i18n_1.t)(`使用默认入口文件：${entryPath}`));
+        }
+        process.env.PORT = String(port);
+        try {
+            const language = await this.detectLanguage(entryPath, workDir);
+            log.info((0, i18n_1.t)(`检测到项目语言：${language}`));
+            if (language === 'python') {
+                await this.startWithPython(entryPath, port, log, workDir);
+            }
+            else {
+                await this.startWithNode(entryPath, port, log, workDir);
+            }
+        }
+        catch (error) {
+            throw new base_1.AgentError((0, i18n_1.t)('启动 Agent 服务失败：{{error}}', { error: error.message }));
+        }
+    }
+    async detectLanguage(entryPath, workDir) {
+        const ext = path_1.default.extname(entryPath).toLowerCase();
+        if (['.py'].includes(ext)) {
+            return 'python';
+        }
+        if (['.js', '.ts', '.mjs', '.cjs'].includes(ext)) {
+            return 'node';
+        }
+        const packageJsonPath = path_1.default.join(workDir, 'package.json');
+        const requirementsPath = path_1.default.join(workDir, 'requirements.txt');
+        const setupPyPath = path_1.default.join(workDir, 'setup.py');
+        const pyprojectPath = path_1.default.join(workDir, 'pyproject.toml');
+        const hasPythonConfig = await Promise.all([
+            fs_extra_1.default.pathExists(requirementsPath),
+            fs_extra_1.default.pathExists(setupPyPath),
+            fs_extra_1.default.pathExists(pyprojectPath)
+        ]);
+        const hasNodeConfig = await fs_extra_1.default.pathExists(packageJsonPath);
+        if (hasPythonConfig.some(exists => exists)) {
+            return 'python';
+        }
+        if (hasNodeConfig) {
+            return 'node';
+        }
+        return 'node';
+    }
+    async validateCustomEntryPath(entryPath, workDir) {
+        try {
+            const fullPath = path_1.default.isAbsolute(entryPath) ? entryPath : path_1.default.resolve(workDir, entryPath);
+            if (!(await fs_extra_1.default.pathExists(fullPath))) {
+                throw new base_1.AgentError((0, i18n_1.t)(`指定的入口文件不存在：${entryPath}`));
+            }
+            const ext = path_1.default.extname(fullPath).toLowerCase();
+            if (!['.js', '.ts', '.mjs', '.cjs', '.py'].includes(ext)) {
+                throw new base_1.AgentError((0, i18n_1.t)(`入口文件必须是 JavaScript、TypeScript 或 Python 文件：${entryPath}`));
+            }
+        }
+        catch (error) {
+            if (error instanceof base_1.AgentError) {
+                throw error;
+            }
+            throw new base_1.AgentError((0, i18n_1.t)(`验证入口文件失败：${error.message}`));
+        }
+    }
+    async getPythonEntryPath(workDir) {
+        const commonEntryFiles = [
+            'main.py',
+            'app.py',
+            'server.py',
+            'run.py',
+            'index.py',
+            'src/main.py',
+            'src/app.py'
+        ];
+        for (const entryFile of commonEntryFiles) {
+            const fullPath = path_1.default.join(workDir, entryFile);
+            if (await fs_extra_1.default.pathExists(fullPath)) {
+                return entryFile;
+            }
+        }
+        throw new base_1.AgentError((0, i18n_1.t)(`未找到 Python 入口文件，请确保存在以下文件之一：${commonEntryFiles.join(', ')}`));
+    }
+    async getEntryPath(workDir) {
+        const language = await this.detectLanguage('', workDir);
+        if (language === 'python') {
+            return await this.getPythonEntryPath(workDir);
+        }
+        try {
+            const packageJsonPath = path_1.default.join(workDir, 'package.json');
+            if (!(await fs_extra_1.default.pathExists(packageJsonPath))) {
+                throw new base_1.AgentError((0, i18n_1.t)('未找到 package.json 文件'));
+            }
+            const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
+            if (!packageJson.main) {
+                throw new base_1.AgentError((0, i18n_1.t)('package.json 中未配置 main 字段'));
+            }
+            const mainFile = path_1.default.resolve(workDir, packageJson.main);
+            if (!(await fs_extra_1.default.pathExists(mainFile))) {
+                throw new base_1.AgentError((0, i18n_1.t)(`main 字段指向的文件不存在：${packageJson.main}`));
+            }
+            return packageJson.main;
+        }
+        catch (error) {
+            if (error instanceof base_1.AgentError) {
+                throw error;
+            }
+            throw new base_1.AgentError((0, i18n_1.t)(`读取 package.json 失败：${error.message}`));
+        }
+    }
+    async startWithPython(entryPath, port, log, agentDir) {
+        log.info((0, i18n_1.t)('使用 Python 启动服务...'));
+        console.log('entryPath', entryPath);
+        console.log('agentDir', agentDir);
+        await this.checkPythonAvailable();
+        const envVars = await this.loadEnvFile(agentDir, log);
+        console.log('process.env', envVars);
+        log.info((0, i18n_1.t)('Agent 服务启动中...'));
+        let pythonCommand = 'python3';
+        try {
+            await (0, execa_1.default)('which', ['python3'], { stdio: 'pipe' });
+        }
+        catch {
+            try {
+                await (0, execa_1.default)('which', ['python'], { stdio: 'pipe' });
+                pythonCommand = 'python';
+            }
+            catch {
+                throw new base_1.AgentError((0, i18n_1.t)('未找到 Python 解释器，请确保已安装 Python'));
+            }
+        }
+        const child = (0, execa_1.default)(pythonCommand, [entryPath], {
+            cwd: agentDir,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ...envVars,
+                PORT: String(port),
+                PYTHONPATH: agentDir,
+                PYTHONUNBUFFERED: '1'
+            }
+        });
+        let isExiting = false;
+        const handleExit = () => {
+            if (isExiting)
+                return;
+            isExiting = true;
+            log.info((0, i18n_1.t)('正在关闭 Agent 服务...'));
+            child.kill('SIGTERM');
+        };
+        process.on('SIGINT', handleExit);
+        process.on('SIGTERM', handleExit);
+        child.on('exit', (code, signal) => {
+            if (code !== null) {
+                log.info((0, i18n_1.t)(`Agent 服务已退出，退出码：${code}`));
+            }
+            else if (signal) {
+                log.info((0, i18n_1.t)(`Agent 服务被信号终止：${signal}`));
+            }
+            process.removeListener('SIGINT', handleExit);
+            process.removeListener('SIGTERM', handleExit);
+            if (isExiting) {
+                process.exit(0);
+            }
+        });
+        try {
+            await child;
+        }
+        catch (error) {
+            log.error((0, i18n_1.t)(`Agent 服务启动失败：${error.message}`));
+            process.exit(1);
+        }
+    }
+    async checkPythonAvailable() {
+        try {
+            const result = await (0, execa_1.default)('python3', ['--version'], { stdio: 'pipe' });
+            console.log(`Python version: ${result.stdout}`);
+            return;
+        }
+        catch {
+            try {
+                const result = await (0, execa_1.default)('python', ['--version'], { stdio: 'pipe' });
+                console.log(`Python version: ${result.stdout}`);
+                return;
+            }
+            catch {
+                throw new base_1.AgentError((0, i18n_1.t)('未找到 Python 解释器，请确保已安装 Python 3.7+'));
+            }
+        }
+    }
+    async startWithNode(entryPath, port, log, agentDir) {
+        log.info((0, i18n_1.t)('使用 Node.js 启动服务...'));
+        console.log('entryPath', entryPath);
+        console.log('agentDir', agentDir);
+        const envVars = await this.loadEnvFile(agentDir, log);
+        console.log('process.env', envVars);
+        log.info((0, i18n_1.t)('Agent 服务启动中...'));
+        const child = (0, execa_1.default)('node', [entryPath], {
+            cwd: agentDir,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ...envVars,
+                PORT: String(port)
+            }
+        });
+        let isExiting = false;
+        const handleExit = () => {
+            if (isExiting)
+                return;
+            isExiting = true;
+            log.info((0, i18n_1.t)('正在关闭 Agent 服务...'));
+            child.kill('SIGTERM');
+        };
+        process.on('SIGINT', handleExit);
+        process.on('SIGTERM', handleExit);
+        child.on('exit', (code, signal) => {
+            if (code !== null) {
+                log.info((0, i18n_1.t)(`Agent 服务已退出，退出码：${code}`));
+            }
+            else if (signal) {
+                log.info((0, i18n_1.t)(`Agent 服务被信号终止：${signal}`));
+            }
+            process.removeListener('SIGINT', handleExit);
+            process.removeListener('SIGTERM', handleExit);
+            if (isExiting) {
+                process.exit(0);
+            }
+        });
+        try {
+            await child;
+        }
+        catch (error) {
+            log.error((0, i18n_1.t)(`Agent 服务启动失败：${error.message}`));
+            process.exit(1);
+        }
+    }
+    async loadEnvFile(agentDir, log) {
+        const envFiles = ['.env', '.env.local', '.env.development'];
+        const envVars = {};
+        for (const envFileName of envFiles) {
+            const envFilePath = path_1.default.join(agentDir, envFileName);
+            if (await fs_extra_1.default.pathExists(envFilePath)) {
+                try {
+                    const result = dotenv.config({ path: envFilePath });
+                    if (result.error) {
+                        log.warn((0, i18n_1.t)(`解析环境变量文件失败：${envFileName} - ${result.error.message}`));
+                        continue;
+                    }
+                    if (result.parsed) {
+                        Object.assign(envVars, result.parsed);
+                        log.info((0, i18n_1.t)(`加载环境变量文件：${envFileName}`));
+                        console.log((0, i18n_1.t)(`加载了 ${Object.keys(result.parsed).length} 个环境变量从 ${envFileName}`));
+                    }
+                }
+                catch (error) {
+                    log.warn((0, i18n_1.t)(`读取环境变量文件失败：${envFileName} - ${error.message}`));
+                }
+            }
+        }
+        return envVars;
+    }
+};
+__decorate([
+    (0, decorators_1.InjectParams)(),
+    __param(0, (0, decorators_1.CmdContext)()),
+    __param(1, (0, decorators_1.EnvId)()),
+    __param(2, (0, decorators_1.Log)()),
+    __param(3, (0, decorators_1.ArgsParams)()),
+    __param(4, (0, decorators_1.ArgsOptions)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, decorators_1.Logger, Array, Object]),
+    __metadata("design:returntype", Promise)
+], AgentRunCommand.prototype, "execute", null);
+AgentRunCommand = __decorate([
+    (0, common_1.ICommand)()
+], AgentRunCommand);
+exports.AgentRunCommand = AgentRunCommand;