@sstar/embedlink_agent 0.1.0

package/dist/firmware/prepare_images.js

@@ -0,0 +1,184 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { encode } from '@toon-format/toon';
+// 返回类型已简化为纯字符串格式（TOON 格式分区信息）
+// 从 partition_toon.js 移植的解析函数
+async function parsePartitionLayout(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const lines = content.split('\n').map(line => line.trim()).filter(line => line);
+    const result = {
+        logicalGroups: [],
+        partitions: [],
+        metadata: {
+            flashUsed: null,
+            checksum: null,
+            magic: null,
+            checksumOk: false
+        }
+    };
+    // 解析逻辑分组信息
+    lines.forEach((line, index) => {
+        if (index >= 8)
+            return; // 跳过分区表部分
+        const logicalGroupMatch = line.match(/^(\w+(?:\s+\w+)*?):\s*(.+)$/);
+        if (logicalGroupMatch) {
+            const groupName = logicalGroupMatch[1];
+            const partitionSpecs = logicalGroupMatch[2];
+            const partitions = partitionSpecs.split(',').map(spec => {
+                const match = spec.trim().match(/^(0x[0-9a-fA-F]+|-)\(([^)]+)\)$/);
+                if (match) {
+                    return {
+                        address: match[1],
+                        name: match[2]
+                    };
+                }
+                return null;
+            }).filter(p => p !== null);
+            result.logicalGroups.push({
+                name: groupName,
+                partitions: partitions
+            });
+        }
+        // 解析 FLASH 使用量
+        const flashUsedMatch = line.match(/^FLASH\s+HAS\s+USED\s+(0x[0-9a-fA-F]+)KB$/);
+        if (flashUsedMatch) {
+            result.metadata.flashUsed = flashUsedMatch[1];
+        }
+        // 解析 Checksum
+        const checksumMatch = line.match(/^ChkSum\s*:\s*(\d+)$/);
+        if (checksumMatch) {
+            result.metadata.checksum = checksumMatch[1];
+        }
+        // 解析 Magic
+        const magicMatch = line.match(/^Magic\s*:\s*(.+)$/);
+        if (magicMatch) {
+            result.metadata.magic = magicMatch[1];
+        }
+        // 检查 Checksum 状态
+        if (line.includes('Checksum ok!!')) {
+            result.metadata.checksumOk = true;
+        }
+    });
+    // 解析详细分区表
+    let headerFound = false;
+    lines.forEach(line => {
+        // 查找分区表头部
+        if (line.includes('IDX:') && line.includes('StartBlk:') && line.includes('Name:')) {
+            headerFound = true;
+            return;
+        }
+        // 解析分区条目
+        if (headerFound && line.match(/^\s*\d+:/)) {
+            const parts = line.trim().split(/\s+/);
+            if (parts.length >= 8) {
+                const indexPart = parts[0].match(/^(\d+):$/);
+                const startBlockPart = parts[1].match(/^(\d+),\((0?X?[0-9a-fA-F]+)\)$/);
+                const blockCountPart = parts[2].match(/^(\d+),\((0?X?[0-9a-fA-F]+)\)$/);
+                const trunkBackupPart = parts[3].match(/^(\d+)\/(\d+)$/);
+                if (indexPart && startBlockPart && blockCountPart && trunkBackupPart) {
+                    const normalizeAddress = (addr) => {
+                        if (addr.startsWith('0x'))
+                            return '0x' + addr.substring(2).toLowerCase();
+                        if (addr.startsWith('0X'))
+                            return '0x' + addr.substring(2).toLowerCase();
+                        return '0x' + addr.toLowerCase();
+                    };
+                    const startAddress = normalizeAddress(startBlockPart[2]);
+                    const blockSize = normalizeAddress(blockCountPart[2]);
+                    result.partitions.push({
+                        index: parseInt(indexPart[1]),
+                        startBlock: {
+                            number: parseInt(startBlockPart[1]),
+                            address: startAddress
+                        },
+                        blockCount: {
+                            count: parseInt(blockCountPart[1]),
+                            size: blockSize
+                        },
+                        trunkBackup: `${trunkBackupPart[1]}/${trunkBackupPart[2]}`,
+                        group: parseInt(parts[4]),
+                        active: parseInt(parts[5]),
+                        name: parts[6],
+                        busCs: parts[7]
+                    });
+                }
+            }
+        }
+    });
+    return result;
+}
+// 转换分区数据为 TOON 格式
+function convertToToon(partitionData) {
+    const physicalPartitions = partitionData.partitions || [];
+    const logicalGroups = partitionData.logicalGroups || [];
+    // 构建简洁的数据结构
+    const toonData = {
+        partition_map: physicalPartitions.map((p) => ({
+            idx: p.index,
+            name: p.name,
+            addr: p.startBlock?.address,
+            size: p.blockCount?.size,
+            active: p.active === 1,
+            group: p.group
+        })),
+        group_mapping: logicalGroups.reduce((acc, group) => {
+            const partitions = group.partitions
+                .map((lp) => lp.name)
+                .filter((name) => name);
+            if (partitions.length > 0) {
+                acc[group.name] = partitions;
+            }
+            return acc;
+        }, {}),
+        summary: {
+            flash_used: partitionData.metadata?.flashUsed || null,
+            checksum: partitionData.metadata?.checksum || null,
+            magic: partitionData.metadata?.magic || null,
+            checksum_ok: partitionData.metadata?.checksumOk || false
+        }
+    };
+    // 使用官方 encode 函数转换为 TOON 格式
+    return encode(toonData, {
+        replacer: (key, value) => {
+            // 确保十六进制地址格式统一
+            if ((key === 'addr' || key === 'size') &&
+                typeof value === 'string' &&
+                value.startsWith('0x')) {
+                return value.toLowerCase();
+            }
+            return value;
+        },
+        indent: 0 // 紧凑格式，适合 AI 处理
+    });
+}
+export async function firmwarePrepareImages(params) {
+    const { cfg } = params;
+    const imagesRoot = params.imagesRoot && params.imagesRoot.length > 0 ? params.imagesRoot : 'images_agent';
+    const rootAbs = path.join(cfg.tftp.dir, imagesRoot);
+    let st;
+    try {
+        st = await fs.stat(rootAbs);
+    }
+    catch (e) {
+        throw new Error(`firmware.prepare_images: imagesRoot directory not found: ${rootAbs} (${e?.message || String(e)})`);
+    }
+    if (!st.isDirectory()) {
+        throw new Error(`firmware.prepare_images: imagesRoot must be a directory, got ${rootAbs}`);
+    }
+    // 尝试解析 partition_layout.txt 文件并转换为 TOON 格式
+    const partitionLayoutFile = path.join(rootAbs, 'partition_layout.txt');
+    try {
+        const partitionData = await parsePartitionLayout(partitionLayoutFile);
+        return convertToToon(partitionData); // 只返回 TOON 格式的分区信息
+    }
+    catch (e) {
+        // 如果解析失败，创建一个基本的 TOON 格式输出
+        return `partition_map[0]{idx,name,addr,size,active,group}:
+group_mapping:
+summary:
+flash_used: null
+checksum: null
+magic: null
+checksum_ok: false`;
+    }
+}

package/dist/firmware/user_guide.js

@@ -0,0 +1,43 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { getDefaultDocsDir, getDocsDir } from '../board/docs.js';
+function resolveFirmwareGuidePath() {
+    const docsDir = getDocsDir() || path.join(os.homedir(), '.config', 'embed_link');
+    const userPath = path.join(docsDir, 'firmware-upgrade.md');
+    const bundledPath = path.join(getDefaultDocsDir(), 'firmware-upgrade.md');
+    return { userPath, bundledPath };
+}
+export async function getFirmwareUserGuideMarkdown() {
+    const { userPath, bundledPath } = resolveFirmwareGuidePath();
+    try {
+        const buf = await fs.readFile(userPath, 'utf8');
+        if (!buf || !buf.trim().length) {
+            throw new Error('empty firmware_user_guide.md');
+        }
+        return buf;
+    }
+    catch {
+        try {
+            const bundled = await fs.readFile(bundledPath, 'utf8');
+            if (!bundled || !bundled.trim().length) {
+                throw new Error('empty bundled firmware_user_guide.md');
+            }
+            await fs.mkdir(path.dirname(userPath), { recursive: true });
+            await fs.writeFile(userPath, bundled, 'utf8');
+            return bundled;
+        }
+        catch {
+            // 最后兜底：返回一个简短的 Markdown 提示，避免抛出异常阻塞调用
+            const text = [
+                '# Firmware Burn User Guide',
+                '',
+                'firmware-upgrade.md is missing; please create it under docs directory or resources/docs.',
+                '',
+            ].join('\n');
+            await fs.mkdir(path.dirname(userPath), { recursive: true });
+            await fs.writeFile(userPath, text, 'utf8');
+            return text;
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { loadConfig } from './config/index.js';
+import { startGrpcServer } from './server/grpc.js';
+import { startWebServer } from './server/web.js';
+import { loadPlugins } from './plugins/loader.js';
+import { cleanupTftpDir, startTftpServer, stopTftpServer } from './tftp/index.js';
+import { createAgentPairingClient } from './ssh/paircheck.js';
+function getLocalUserName() {
+    const envUser = process.env.USER || process.env.LOGNAME || process.env.USERNAME;
+    if (envUser && envUser.trim())
+        return envUser.replace(/[\\/]/g, '_');
+    try {
+        const info = os.userInfo();
+        if (info.username)
+            return info.username.replace(/[\\/]/g, '_');
+    }
+    catch { }
+    return 'unknown';
+}
+function getLocalAgentConfigPath() {
+    const home = os.homedir();
+    return path.join(home, '.config', 'embed_link', 'agent.json');
+}
+async function readExistingAgentJson() {
+    const p = getLocalAgentConfigPath();
+    try {
+        const buf = await fs.readFile(p, 'utf8');
+        return JSON.parse(buf);
+    }
+    catch {
+        return null;
+    }
+}
+async function tryPairCheckExistingAgent(j) {
+    const host = j.endpoint?.grpc?.host || '127.0.0.1';
+    const port = j.endpoint?.grpc?.port;
+    const pairCode = j.agent?.pairCode;
+    if (!port || !pairCode)
+        return 'stale';
+    const addr = `${host}:${port}`;
+    try {
+        const client = createAgentPairingClient(addr);
+        const res = await client.pairCheck({ pairCode, clientId: 'embedlink-agent-bootstrap' });
+        if (res.accepted)
+            return 'accepted';
+        // pair-code mismatch 视为旧配置，可覆盖
+        return 'stale';
+    }
+    catch {
+        return 'stale';
+    }
+}
+async function writeLocalAgentConfig(cfg, identity) {
+    try {
+        const p = getLocalAgentConfigPath();
+        const dir = path.dirname(p);
+        await fs.mkdir(dir, { recursive: true });
+        const json = {
+            agent: {
+                id: identity.id,
+                version: identity.version,
+                pairCode: identity.pairCode,
+                startupTime: identity.startupTime,
+                originHost: identity.originHost,
+                originUser: identity.originUser,
+                description: cfg.agent?.description || '',
+                hostGrpcPort: cfg.grpc?.port,
+            },
+            endpoint: {
+                grpc: {
+                    host: '127.0.0.1',
+                    port: cfg.grpc?.port,
+                    scheme: 'grpc',
+                },
+            },
+            transport: {
+                mode: 'local',
+                local: {
+                    listenHost: cfg.grpc?.host || '0.0.0.0',
+                    listenPort: cfg.grpc?.port,
+                },
+            },
+        };
+        if (cfg.web?.port) {
+            json.endpoint = json.endpoint || {};
+            json.endpoint.web = {
+                host: cfg.web?.host || '127.0.0.1',
+                port: cfg.web?.port,
+            };
+        }
+        if (cfg.tftp && cfg.tftp.server) {
+            const mode = cfg.tftp.server.mode || (cfg.tftp.server.enabled === false ? 'disabled' : 'builtin');
+            const enabled = cfg.tftp.server.enabled !== false && mode !== 'disabled';
+            json.services = {
+                ...json.services,
+                tftp: {
+                    enabled,
+                    mode,
+                },
+            };
+        }
+        await fs.writeFile(p, JSON.stringify(json, null, 2), 'utf8');
+    }
+    catch {
+        // 发现信息写入失败不影响 Agent 主流程
+    }
+}
+// 打印所有环境变量及其功能说明
+function printEnvironmentVariables() {
+    console.log('\n=== EmbedLink Agent 环境变量配置 ===');
+    // 定义环境变量及其功能说明
+    const envVars = [
+        {
+            name: 'EMBEDLINK_GRPC_PORT',
+            current: process.env.EMBEDLINK_GRPC_PORT,
+            description: 'gRPC服务器端口',
+            default: '10000',
+        },
+        {
+            name: 'EMBEDLINK_WEB_HOST',
+            current: process.env.EMBEDLINK_WEB_HOST,
+            description: 'Web服务器主机地址',
+            default: '0.0.0.0',
+        },
+        {
+            name: 'EMBEDLINK_WEB_PORT',
+            current: process.env.EMBEDLINK_WEB_PORT,
+            description: 'Web服务器端口',
+            default: '8080',
+        },
+        {
+            name: 'EMBEDLINK_TFTP_DIR',
+            current: process.env.EMBEDLINK_TFTP_DIR,
+            description: 'TFTP文件服务目录',
+            default: '~/.local/embed_link/agent_files',
+        },
+        {
+            name: 'EMBEDLINK_TFTP_TTL_HOURS',
+            current: process.env.EMBEDLINK_TFTP_TTL_HOURS,
+            description: 'TFTP文件保存时间（小时）',
+            default: '24',
+        },
+        {
+            name: 'EMBEDLINK_TFTP_CLEANUP_INTERVAL_MIN',
+            current: process.env.EMBEDLINK_TFTP_CLEANUP_INTERVAL_MIN,
+            description: 'TFTP清理间隔（分钟）',
+            default: '60',
+        },
+        {
+            name: 'EMBEDLINK_BOARD_UART_PORT',
+            current: process.env.EMBEDLINK_BOARD_UART_PORT,
+            description: '板卡串口设备路径',
+            default: '自动检测',
+        },
+        {
+            name: 'EMBEDLINK_BOARD_UART_BAUD',
+            current: process.env.EMBEDLINK_BOARD_UART_BAUD,
+            description: '板卡串口波特率',
+            default: '115200',
+        },
+        {
+            name: 'EMBEDLINK_SSH_DEFAULT_KEY',
+            current: process.env.EMBEDLINK_SSH_DEFAULT_KEY,
+            description: 'SSH默认私钥路径',
+            default: '~/.ssh/id_rsa',
+        },
+        {
+            name: 'EMBEDLINK_AGENT_ID',
+            current: process.env.EMBEDLINK_AGENT_ID,
+            description: 'Agent实例ID',
+            default: '自动生成',
+        },
+        {
+            name: 'EMBEDLINK_AGENT_DISABLE_GATEKEEPER',
+            current: process.env.EMBEDLINK_AGENT_DISABLE_GATEKEEPER,
+            description: '禁用Agent互斥检查（测试用）',
+            default: 'false',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_ENABLED',
+            current: process.env.EMBEDLINK_FILES_LOG_ENABLED,
+            description: '启用文件操作日志',
+            default: 'true',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_LEVEL',
+            current: process.env.EMBEDLINK_FILES_LOG_LEVEL,
+            description: '文件操作日志级别',
+            default: 'DEBUG',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_INCLUDE_METADATA',
+            current: process.env.EMBEDLINK_FILES_LOG_INCLUDE_METADATA,
+            description: '文件日志包含元数据',
+            default: 'true',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_MAX_SIZE',
+            current: process.env.EMBEDLINK_FILES_LOG_MAX_SIZE,
+            description: '文件日志最大大小',
+            default: '50MB',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_DETAILED_DEBUG',
+            current: process.env.EMBEDLINK_FILES_LOG_DETAILED_DEBUG,
+            description: '启用详细调试日志',
+            default: 'true',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_PATH_RESOLUTION',
+            current: process.env.EMBEDLINK_FILES_LOG_PATH_RESOLUTION,
+            description: '记录路径解析过程',
+            default: 'true',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_SECURITY_CHECKS',
+            current: process.env.EMBEDLINK_FILES_LOG_SECURITY_CHECKS,
+            description: '记录安全检查过程',
+            default: 'true',
+        },
+        {
+            name: 'EMBEDLINK_FILES_LOG_PERFORMANCE_METRICS',
+            current: process.env.EMBEDLINK_FILES_LOG_PERFORMANCE_METRICS,
+            description: '记录性能指标',
+            default: 'true',
+        },
+        // Host端环境变量（用于调试）
+        {
+            name: 'EMBEDLINK_HOST_DEBUG',
+            current: process.env.EMBEDLINK_HOST_DEBUG,
+            description: 'Host端调试模式',
+            default: 'false',
+        },
+        {
+            name: 'EMBEDLINK_DEBUG',
+            current: process.env.EMBEDLINK_DEBUG,
+            description: '全局调试模式',
+            default: 'false',
+        },
+        {
+            name: 'EMBEDLINK_AGENT_ADDR',
+            current: process.env.EMBEDLINK_AGENT_ADDR,
+            description: 'Agent连接地址（Host端使用）',
+            default: '127.0.0.1:10000',
+        },
+        {
+            name: 'EMBEDLINK_LOG_LEVEL',
+            current: process.env.EMBEDLINK_LOG_LEVEL,
+            description: '日志级别',
+            default: 'DEBUG',
+        },
+        {
+            name: 'EMBEDLINK_LOG_DIR',
+            current: process.env.EMBEDLINK_LOG_DIR,
+            description: '日志目录',
+            default: '系统默认',
+        },
+    ];
+    // 找到最长的变量名长度，用于对齐
+    const maxNameLength = Math.max(...envVars.map((v) => v.name.length));
+    console.log(`变量名${' '.repeat(maxNameLength - 4)}  当前值${' '.repeat(15)}  默认值    功能描述`);
+    console.log('─'.repeat(maxNameLength + 50));
+    envVars.forEach((envVar) => {
+        const namePad = envVar.name.padEnd(maxNameLength);
+        const current = envVar.current || '(未设置)';
+        const currentPad = current.padEnd(15);
+        const defaultPad = envVar.default.padEnd(10);
+        console.log(`${namePad}  ${currentPad}  ${defaultPad}  ${envVar.description}`);
+    });
+    console.log('='.repeat(maxNameLength + 50));
+    console.log('');
+}
+function parseCliArgs(argv) {
+    const args = argv.slice(2);
+    let debug = false;
+    let noOpen = false;
+    for (const a of args) {
+        if (a === '-d')
+            debug = true;
+        else if (a === '--no-open')
+            noOpen = true;
+    }
+    return { debug, noOpen };
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    let cmd;
+    let cmdArgs;
+    if (platform === 'win32') {
+        cmd = 'cmd';
+        cmdArgs = ['/c', 'start', '', url];
+    }
+    else if (platform === 'darwin') {
+        cmd = 'open';
+        cmdArgs = [url];
+    }
+    else {
+        cmd = 'xdg-open';
+        cmdArgs = [url];
+    }
+    try {
+        const child = spawn(cmd, cmdArgs, { detached: true, stdio: 'ignore' });
+        child.unref();
+    }
+    catch {
+        // ignore
+    }
+}
+function getDefaultWebUiStaticDir() {
+    // dist/index.js lives in dist/, we bundle UI at dist/ui
+    const self = fileURLToPath(import.meta.url);
+    const distDir = path.dirname(self);
+    return path.join(distDir, 'ui');
+}
+async function main() {
+    const cli = parseCliArgs(process.argv);
+    // 默认少日志；-d 才输出详细信息
+    if (cli.debug) {
+        printEnvironmentVariables();
+    }
+    const cfg = await loadConfig();
+    const agentId = (cfg.agent && cfg.agent.id) || 'agent';
+    const originHost = os.hostname();
+    const originUser = getLocalUserName();
+    // Gatekeeper: reuse or validate existing agent.json（可通过环境变量禁用，仅用于测试/特殊场景）
+    const skipGatekeeper = process.env.EMBEDLINK_AGENT_DISABLE_GATEKEEPER === '1' ||
+        process.env.EMBEDLINK_AGENT_DISABLE_GATEKEEPER === 'true';
+    let reusePairCode;
+    if (!skipGatekeeper) {
+        const existing = await readExistingAgentJson();
+        if (existing && existing.agent?.pairCode && existing.endpoint?.grpc?.port) {
+            const state = await tryPairCheckExistingAgent(existing);
+            if (state === 'accepted') {
+                // 已有活跃 Agent 实例在使用该配置，拒绝启动新的实例
+                console.error(`embedlink-agent: detected existing active Agent (id=${existing.agent?.id || agentId}), aborting startup.`);
+                process.exit(1);
+            }
+            else {
+                reusePairCode = existing.agent.pairCode;
+            }
+        }
+    }
+    const pairCode = reusePairCode || randomUUID();
+    const startupTime = new Date().toISOString();
+    const identity = {
+        id: agentId,
+        version: '0.1.0',
+        pairCode,
+        startupTime,
+        originHost,
+        originUser,
+    };
+    // 根据配置启动 TFTP 服务器（builtin / external / disabled）
+    await startTftpServer(cfg);
+    const staticDir = cfg.web.staticDir || getDefaultWebUiStaticDir();
+    if (!fsSync.existsSync(staticDir)) {
+        console.error(`embedlink-agent: web UI assets not found at: ${staticDir}`);
+        console.error(`Hint: if you're developing from source, set web.staticDir explicitly.`);
+        process.exit(1);
+    }
+    const web = await startWebServer({
+        host: cfg.web.host,
+        port: cfg.web.port,
+        staticDir,
+        grpcPort: cfg.grpc.port,
+        agentId,
+        pairCode,
+        originHost,
+        originUser,
+        version: identity.version,
+        startupTime,
+        agentConfig: cfg,
+    });
+    const grpc = await startGrpcServer(cfg, identity);
+    await writeLocalAgentConfig(cfg, identity);
+    const open = !cli.noOpen;
+    if (open && cfg.web?.port) {
+        const port = cfg.web.port;
+        const hostForBrowser = '127.0.0.1';
+        const url = `http://${hostForBrowser}:${port}/`;
+        if (cli.debug) {
+            console.log(`Web UI: ${url}`);
+            console.log(`Hint: use --no-open to disable auto-open.`);
+        }
+        else {
+            console.log(`Web UI: ${url} (use --no-open to disable auto-open)`);
+        }
+        openBrowser(url);
+    }
+    else if (cli.debug) {
+        console.log('Web UI auto-open disabled.');
+    }
+    // 周期性清理 TFTP 目录中过期镜像文件
+    const ttlHours = cfg.tftp.ttlHours ?? 24;
+    const intervalMinutes = cfg.tftp.cleanupIntervalMinutes ?? 60;
+    if (ttlHours > 0 && intervalMinutes > 0) {
+        const ttlMs = ttlHours * 60 * 60 * 1000;
+        const intervalMs = intervalMinutes * 60 * 1000;
+        setInterval(() => {
+            cleanupTftpDir(cfg.tftp.dir, ttlMs).catch(() => { });
+        }, intervalMs).unref?.();
+    }
+    await loadPlugins('plugins');
+    // 优雅关闭处理函数
+    async function gracefulShutdown() {
+        try {
+            // 先关闭gRPC服务器，停止接受新请求
+            await new Promise((resolve) => {
+                grpc.tryShutdown(() => resolve());
+            });
+            // 关闭Web服务器
+            await new Promise((resolve) => {
+                web.server.close(() => resolve());
+            });
+            // 停止TFTP服务器
+            await stopTftpServer().catch(() => { });
+            process.exit(0);
+        }
+        catch (err) {
+            console.error('Error during shutdown:', err);
+            process.exit(1);
+        }
+    }
+    // 强制退出超时保护
+    let shutdownTimeout;
+    function scheduleForceExit() {
+        shutdownTimeout = setTimeout(() => process.exit(1), 5000);
+    }
+    // 信号处理器
+    function handleShutdown(signal) {
+        if (shutdownTimeout)
+            clearTimeout(shutdownTimeout);
+        scheduleForceExit();
+        gracefulShutdown();
+    }
+    process.on('SIGINT', () => handleShutdown('SIGINT'));
+    process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+}
+main().catch((e) => {
+    console.error('Agent failed:', e);
+    process.exit(1);
+});