@sstar/embedlink_agent 0.1.0

package/dist/config/index.js

@@ -0,0 +1,341 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import YAML from 'yaml';
+import { DefaultTimeouts } from '../core/errors.js';
+import { LogLevel } from '../logger.js';
+const HOME_CONFIG_PATH = path.join(os.homedir(), '.config', 'embed_link', 'config.json');
+function defaultTftpDir() {
+    return getDefaultAgentFilesDir();
+}
+function defaultShareUsername() {
+    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 && info.username.trim())
+            return info.username.replace(/[\\/]/g, '_');
+    }
+    catch { }
+    return 'user';
+}
+function getDefaultAgentFilesDir() {
+    return path.join(os.homedir(), '.local', 'embed_link', 'agent_files');
+}
+export const DEFAULT_CONFIG = {
+    grpc: { host: '0.0.0.0', port: 10000 },
+    web: { host: '0.0.0.0', port: 8080 },
+    boardUart: {
+        mock: false,
+        port: '',
+        baud: 115200,
+    },
+    network: {},
+    tftp: {
+        dir: getDefaultAgentFilesDir(),
+        server: {
+            enabled: true,
+            mode: 'builtin',
+            host: '0.0.0.0',
+            port: 69,
+        },
+    },
+    nfs: {
+        enabled: true,
+        localPath: getDefaultAgentFilesDir(),
+        exportName: '/shared',
+        description: 'Default NFS export',
+        username: defaultShareUsername(),
+        password: '',
+    },
+    flash: {},
+    ssh: {
+        enablePasswordFallback: true,
+        defaultKeyPath: '',
+    },
+    timeouts: DefaultTimeouts,
+    files: {
+        rootDir: getDefaultAgentFilesDir(),
+        maxFileSize: 100 * 1024 * 1024, // 100MB
+        allowedPaths: [getDefaultAgentFilesDir()],
+        maxTotalBytes: 5 * 1024 * 1024 * 1024, // 5GB
+        maxTotalFiles: 50000,
+        skipHiddenByDefault: false,
+    },
+    logging: {
+        files: {
+            enabled: true,
+            level: LogLevel.DEBUG,
+            includeMetadata: true,
+            maxLogSize: 50 * 1024 * 1024, // 50MB
+            detailedDebug: true,
+            pathResolution: true,
+            securityChecks: true,
+            performanceMetrics: true,
+        },
+    },
+};
+let lastConfigPath = null;
+function defaultKey() {
+    const home = os.homedir();
+    return path.join(home, '.ssh', 'id_rsa');
+}
+function normalize(p) {
+    return path.normalize(p);
+}
+function ensureTftpServerConfig(cfg) {
+    if (!cfg.tftp) {
+        cfg.tftp = {
+            dir: defaultTftpDir(),
+            ttlHours: 24,
+            cleanupIntervalMinutes: 60,
+            server: {
+                enabled: true,
+                mode: 'builtin',
+                host: '0.0.0.0',
+                port: 69,
+                blockSize: 1024, // 1KB块大小（原512字节）
+                timeout: 15000, // 15秒超时（原5000ms）
+                retryCount: 8, // 8次重试（原3次）
+            },
+        };
+        return;
+    }
+    if (!cfg.tftp.server) {
+        cfg.tftp.server = {
+            enabled: true,
+            mode: 'builtin',
+            host: '0.0.0.0',
+            port: 69,
+            blockSize: 512, // 默认 512 字节
+            timeout: 5000, // 默认 5 秒超时
+            retryCount: 3, // 默认 3 次重试
+        };
+    }
+    else {
+        if (typeof cfg.tftp.server.enabled !== 'boolean')
+            cfg.tftp.server.enabled = true;
+        if (!cfg.tftp.server.mode) {
+            cfg.tftp.server.mode = cfg.tftp.server.enabled === false ? 'disabled' : 'builtin';
+        }
+        if (cfg.tftp.server.mode === 'builtin') {
+            if (!cfg.tftp.server.host)
+                cfg.tftp.server.host = '0.0.0.0';
+            if (!cfg.tftp.server.port)
+                cfg.tftp.server.port = 69;
+            if (!cfg.tftp.server.blockSize)
+                cfg.tftp.server.blockSize = 512; // 默认 512 字节
+            if (!cfg.tftp.server.timeout)
+                cfg.tftp.server.timeout = 5000; // 默认 5 秒超时
+            if (!cfg.tftp.server.retryCount)
+                cfg.tftp.server.retryCount = 3; // 默认 3 次重试
+        }
+        if (cfg.tftp.server.mode === 'external') {
+            if (!cfg.tftp.server.externalPort)
+                cfg.tftp.server.externalPort = 69;
+        }
+        if (cfg.tftp.server.mode === 'disabled') {
+            cfg.tftp.server.enabled = false;
+        }
+    }
+}
+function ensureNfsConfig(cfg) {
+    if (!cfg.nfs) {
+        cfg.nfs = {
+            enabled: true,
+            localPath: cfg.tftp?.dir || getDefaultAgentFilesDir(),
+            exportName: '/shared',
+            description: 'Default NFS export',
+            username: defaultShareUsername(),
+            password: '',
+        };
+        return;
+    }
+    if (typeof cfg.nfs.enabled !== 'boolean')
+        cfg.nfs.enabled = true;
+    if (!cfg.nfs.localPath)
+        cfg.nfs.localPath = cfg.tftp?.dir || getDefaultAgentFilesDir();
+    if (!cfg.nfs.exportName)
+        cfg.nfs.exportName = '/shared';
+    if (!cfg.nfs.description)
+        cfg.nfs.description = 'Default NFS export';
+    if (!cfg.nfs.username || !cfg.nfs.username.trim())
+        cfg.nfs.username = defaultShareUsername();
+    if (typeof cfg.nfs.password !== 'string')
+        cfg.nfs.password = '';
+}
+function ensureNetworkConfig(cfg) {
+    if (!cfg.network) {
+        cfg.network = {};
+        return;
+    }
+    if (typeof cfg.network.preferredInterface !== 'string')
+        cfg.network.preferredInterface = '';
+    if (typeof cfg.network.preferredIp !== 'string')
+        cfg.network.preferredIp = '';
+}
+export async function loadConfig() {
+    const cwd = process.cwd();
+    const candidates = [
+        HOME_CONFIG_PATH,
+        path.join(cwd, 'agent.config.yaml'),
+        path.join(cwd, 'agent.config.yml'),
+        path.join(cwd, 'agent.config.json'),
+    ];
+    let cfg = DEFAULT_CONFIG;
+    for (const p of candidates) {
+        try {
+            const raw = await fs.readFile(p, 'utf8');
+            const y = p.endsWith('.json') ? JSON.parse(raw) : YAML.parse(raw);
+            cfg = { ...cfg, ...y };
+            lastConfigPath = p;
+            break;
+        }
+        catch { }
+    }
+    // ENV overrides
+    if (process.env.EMBEDLINK_GRPC_PORT)
+        cfg.grpc.port = Number(process.env.EMBEDLINK_GRPC_PORT);
+    if (process.env.EMBEDLINK_WEB_HOST)
+        cfg.web.host = process.env.EMBEDLINK_WEB_HOST;
+    if (process.env.EMBEDLINK_WEB_PORT)
+        cfg.web.port = Number(process.env.EMBEDLINK_WEB_PORT);
+    if (process.env.EMBEDLINK_TFTP_DIR)
+        cfg.tftp.dir = process.env.EMBEDLINK_TFTP_DIR;
+    if (process.env.EMBEDLINK_TFTP_TTL_HOURS)
+        cfg.tftp.ttlHours = Number(process.env.EMBEDLINK_TFTP_TTL_HOURS);
+    if (process.env.EMBEDLINK_TFTP_CLEANUP_INTERVAL_MIN)
+        cfg.tftp.cleanupIntervalMinutes = Number(process.env.EMBEDLINK_TFTP_CLEANUP_INTERVAL_MIN);
+    ensureTftpServerConfig(cfg);
+    // Board UART defaults / overrides
+    if (process.env.EMBEDLINK_BOARD_UART_PORT)
+        cfg.boardUart.port = process.env.EMBEDLINK_BOARD_UART_PORT;
+    if (process.env.EMBEDLINK_BOARD_UART_BAUD)
+        cfg.boardUart.baud = Number(process.env.EMBEDLINK_BOARD_UART_BAUD);
+    cfg.tftp.dir = normalize(cfg.tftp.dir);
+    ensureNfsConfig(cfg);
+    cfg.nfs.localPath = normalize(cfg.nfs.localPath);
+    // SSH 默认密钥路径：始终基于当前用户主目录计算，可通过环境变量覆盖
+    const envDefaultKey = (process.env.EMBEDLINK_SSH_DEFAULT_KEY || '').trim();
+    if (!cfg.ssh) {
+        cfg.ssh = {
+            enablePasswordFallback: true,
+            defaultKeyPath: envDefaultKey || defaultKey(),
+        };
+    }
+    else {
+        cfg.ssh.enablePasswordFallback =
+            typeof cfg.ssh.enablePasswordFallback === 'boolean' ? cfg.ssh.enablePasswordFallback : true;
+        cfg.ssh.defaultKeyPath = envDefaultKey || defaultKey();
+    }
+    if (!cfg.agent)
+        cfg.agent = { id: defaultAgentId() };
+    if (!cfg.agent.id)
+        cfg.agent.id = makeDefaultAgentId(os.hostname?.() || 'host', cfg.grpc.port);
+    if (process.env.EMBEDLINK_AGENT_ID)
+        cfg.agent.id = process.env.EMBEDLINK_AGENT_ID;
+    ensureNetworkConfig(cfg);
+    // 文件操作日志配置的环境变量支持
+    if (!cfg.logging)
+        cfg.logging = {};
+    if (!cfg.logging.files)
+        cfg.logging.files = DEFAULT_CONFIG.logging.files;
+    // 环境变量覆盖文件操作日志配置
+    if (process.env.EMBEDLINK_FILES_LOG_ENABLED !== undefined && cfg.logging.files) {
+        cfg.logging.files.enabled =
+            process.env.EMBEDLINK_FILES_LOG_ENABLED === '1' ||
+                process.env.EMBEDLINK_FILES_LOG_ENABLED === 'true';
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_LEVEL && cfg.logging.files) {
+        cfg.logging.files.level = process.env.EMBEDLINK_FILES_LOG_LEVEL;
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_INCLUDE_METADATA !== undefined && cfg.logging.files) {
+        cfg.logging.files.includeMetadata =
+            process.env.EMBEDLINK_FILES_LOG_INCLUDE_METADATA === '1' ||
+                process.env.EMBEDLINK_FILES_LOG_INCLUDE_METADATA === 'true';
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_MAX_SIZE && cfg.logging.files) {
+        const sizeStr = process.env.EMBEDLINK_FILES_LOG_MAX_SIZE;
+        const units = {
+            B: 1,
+            KB: 1024,
+            MB: 1024 * 1024,
+            GB: 1024 * 1024 * 1024,
+        };
+        const match = sizeStr.match(/^(\d+)(B|KB|MB|GB)?$/i);
+        if (match) {
+            const value = parseInt(match[1]);
+            const unit = match[2]?.toUpperCase() || 'B';
+            cfg.logging.files.maxLogSize = value * (units[unit] || 1);
+        }
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_DETAILED_DEBUG !== undefined && cfg.logging.files) {
+        cfg.logging.files.detailedDebug =
+            process.env.EMBEDLINK_FILES_LOG_DETAILED_DEBUG === '1' ||
+                process.env.EMBEDLINK_FILES_LOG_DETAILED_DEBUG === 'true';
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_PATH_RESOLUTION !== undefined && cfg.logging.files) {
+        cfg.logging.files.pathResolution =
+            process.env.EMBEDLINK_FILES_LOG_PATH_RESOLUTION === '1' ||
+                process.env.EMBEDLINK_FILES_LOG_PATH_RESOLUTION === 'true';
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_SECURITY_CHECKS !== undefined && cfg.logging.files) {
+        cfg.logging.files.securityChecks =
+            process.env.EMBEDLINK_FILES_LOG_SECURITY_CHECKS === '1' ||
+                process.env.EMBEDLINK_FILES_LOG_SECURITY_CHECKS === 'true';
+    }
+    if (process.env.EMBEDLINK_FILES_LOG_PERFORMANCE_METRICS !== undefined && cfg.logging.files) {
+        cfg.logging.files.performanceMetrics =
+            process.env.EMBEDLINK_FILES_LOG_PERFORMANCE_METRICS === '1' ||
+                process.env.EMBEDLINK_FILES_LOG_PERFORMANCE_METRICS === 'true';
+    }
+    // 统一文件存储路径：确保 Files 系统使用与 TFTP/NFS 相同的配置路径
+    // 这符合 Settings 页面"Local Artifacts Path"的设计意图
+    if (!cfg.files) {
+        cfg.files = DEFAULT_CONFIG.files;
+    }
+    // 如果用户在 Settings 页面配置了统一的 artifacts 路径（通过 tftp.dir），
+    // 则 Files 系统也使用相同路径，实现统一的文件存储管理
+    if (cfg.tftp && cfg.tftp.dir) {
+        cfg.files.rootDir = cfg.tftp.dir;
+        // 同时更新 allowedPaths，确保 Files 系统可以访问该路径
+        if (!cfg.files.allowedPaths || cfg.files.allowedPaths.length === 0) {
+            cfg.files.allowedPaths = [cfg.tftp.dir];
+        }
+        else if (!cfg.files.allowedPaths.includes(cfg.tftp.dir)) {
+            // 将统一路径添加到 allowedPaths 的开头，优先使用
+            cfg.files.allowedPaths = [
+                cfg.tftp.dir,
+                ...cfg.files.allowedPaths.filter((p) => p !== cfg.tftp.dir),
+            ];
+        }
+    }
+    if (!lastConfigPath)
+        lastConfigPath = HOME_CONFIG_PATH;
+    return cfg;
+}
+export function getConfigPath() {
+    return lastConfigPath || HOME_CONFIG_PATH;
+}
+export async function saveConfig(cfg, targetPath) {
+    const outPath = targetPath || getConfigPath();
+    const content = outPath.endsWith('.json') || outPath.endsWith('.json5')
+        ? JSON.stringify(cfg, null, 2)
+        : YAML.stringify(cfg);
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, content, 'utf8');
+    lastConfigPath = outPath;
+    return outPath;
+}
+function defaultAgentId() {
+    const seed = `${process.cwd()}|${process.pid}|${Date.now()}`;
+    let h = 5381;
+    for (let i = 0; i < seed.length; i++)
+        h = (h << 5) + h + seed.charCodeAt(i);
+    return `agent-${(h >>> 0).toString(16)}`;
+}
+function makeDefaultAgentId(hostname, port) {
+    const raw = `agent-${hostname}-${port}`;
+    return raw.replace(/[^A-Za-z0-9._-]/g, '-');
+}

package/dist/core/activity.js

@@ -0,0 +1,7 @@
+export let lastGrpcActivity = 0;
+export function markGrpcActivity() {
+    lastGrpcActivity = Date.now();
+}
+export function getGrpcLastActivity() {
+    return lastGrpcActivity;
+}

package/dist/core/errors.js

@@ -0,0 +1,45 @@
+export const ErrorCodes = {
+    EL_AGENT_UNAVAILABLE: 'EL_AGENT_UNAVAILABLE',
+    EL_PROCEDURE_TIMEOUT: 'EL_PROCEDURE_TIMEOUT',
+    EL_INVALID_PARAMS: 'EL_INVALID_PARAMS',
+    EL_BOARD_UART_OPEN_FAILED: 'EL_BOARD_UART_OPEN_FAILED',
+    EL_BOARD_UART_WRITE_FAILED: 'EL_BOARD_UART_WRITE_FAILED',
+    EL_BOARD_UART_READ_IN_PROGRESS: 'EL_BOARD_UART_READ_IN_PROGRESS',
+    EL_BOARD_UART_READ_TIMEOUT: 'EL_BOARD_UART_READ_TIMEOUT',
+    EL_BOARD_UART_MODULE_MISSING: 'EL_BOARD_UART_MODULE_MISSING',
+    EL_BOARD_UART_NO_DEVICE: 'EL_BOARD_UART_NO_DEVICE',
+    EL_BOARD_UART_DISABLED: 'EL_BOARD_UART_DISABLED',
+    EL_BOARD_UART_SESSION_NOT_FOUND: 'EL_BOARD_UART_SESSION_NOT_FOUND',
+    EL_BOARD_UART_SESSION_TEMPORARILY_UNAVAILABLE: 'EL_BOARD_UART_SESSION_TEMPORARILY_UNAVAILABLE',
+    EL_BOARD_UART_READONLY_SESSION: 'EL_BOARD_UART_READONLY_SESSION',
+    EL_BOARD_UART_SUSPENDED: 'EL_BOARD_UART_SUSPENDED',
+    EL_TFTP_UPLOAD_FAILED: 'EL_TFTP_UPLOAD_FAILED',
+    EL_TFTP_VERIFY_FAILED: 'EL_TFTP_VERIFY_FAILED',
+    EL_TFTP_DISABLED: 'EL_TFTP_DISABLED',
+    EL_TFTP_SERVER_ALREADY_RUNNING: 'EL_TFTP_SERVER_ALREADY_RUNNING',
+    EL_TFTP_SERVER_START_FAILED: 'EL_TFTP_SERVER_START_FAILED',
+    EL_UBOOT_BREAK_TIMEOUT: 'EL_UBOOT_BREAK_TIMEOUT',
+    EL_UBOOT_CMD_FAILED: 'EL_UBOOT_CMD_FAILED',
+    EL_FLASH_WRITE_FAILED: 'EL_FLASH_WRITE_FAILED',
+    EL_FLASH_VERIFY_FAILED: 'EL_FLASH_VERIFY_FAILED',
+    EL_REBOOT_TIMEOUT: 'EL_REBOOT_TIMEOUT',
+    EL_SSH_CONNECT_FAILED: 'EL_SSH_CONNECT_FAILED',
+    EL_SSH_TUNNEL_BROKEN: 'EL_SSH_TUNNEL_BROKEN',
+    EL_NFS_DISABLED: 'EL_NFS_DISABLED',
+};
+export const DefaultTimeouts = {
+    boardUart: { open: 3000, read: 5000, write: 5000 },
+    tftp: { upload: 120000 },
+    uboot: { break: 5000, cmd: 10000 },
+    flash: { write: 300000 },
+    reboot: { wait: 60000 },
+    ssh: { connect: 15000 },
+};
+export function error(code, message, data) {
+    const fullMessage = `[${code}] ${message}`;
+    const e = new Error(fullMessage);
+    e.code = code;
+    if (data)
+        e.data = data;
+    return e;
+}

package/dist/core/log_stream.js

@@ -0,0 +1,26 @@
+const MAX_LOG_BUFFER = 1000;
+const agentLogBuf = [];
+const hostLogBuf = [];
+const listeners = new Set();
+function pushBounded(buf, entry) {
+    buf.push(entry);
+    if (buf.length > MAX_LOG_BUFFER)
+        buf.splice(0, buf.length - MAX_LOG_BUFFER);
+}
+export function publishAgentLog(entry) {
+    pushBounded(agentLogBuf, entry);
+    for (const l of listeners)
+        l('agent', entry);
+}
+export function publishHostLog(entry) {
+    pushBounded(hostLogBuf, entry);
+    for (const l of listeners)
+        l('host', entry);
+}
+export function getLogSnapshot(source) {
+    return source === 'agent' ? [...agentLogBuf] : [...hostLogBuf];
+}
+export function subscribeLogs(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/files/__tests__/files_manager.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { FilesManager } from '../files_manager.js';
+import fs from 'fs/promises';
+import path from 'path';
+describe('FilesManager', () => {
+    let filesManager;
+    let testDir;
+    let config;
+    beforeEach(async () => {
+        // 创建临时测试目录
+        testDir = path.join(process.cwd(), 'test-files-' + Date.now());
+        config = {
+            rootDir: testDir,
+            maxFileSize: 1024 * 1024, // 1MB
+            allowedPaths: [testDir]
+        };
+        filesManager = new FilesManager(config);
+        // 确保测试目录存在
+        await fs.mkdir(testDir, { recursive: true });
+    });
+    afterEach(async () => {
+        // 清理测试目录
+        try {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            // 忽略清理错误
+        }
+    });
+    describe('putFile', () => {
+        it('should upload a file successfully', async () => {
+            // 创建测试文件
+            const testFile = path.join(testDir, 'source.txt');
+            await fs.writeFile(testFile, 'Hello, World!');
+            // 上传文件
+            const result = await filesManager.putFile(testFile, 'uploaded.txt');
+            expect(result.name).toBe('uploaded.txt');
+            expect(result.path).toBe('uploaded.txt');
+            expect(result.size).toBe(13); // "Hello, World!" 的长度
+            expect(result.isFile).toBe(true);
+            expect(result.isDirectory).toBe(false);
+            // 验证文件确实存在
+            const uploadedFile = path.join(testDir, 'uploaded.txt');
+            const content = await fs.readFile(uploadedFile, 'utf-8');
+            expect(content).toBe('Hello, World!');
+        });
+        it('should use original filename when destination not specified', async () => {
+            const testFile = path.join(testDir, 'original.txt');
+            await fs.writeFile(testFile, 'Test content');
+            const result = await filesManager.putFile(testFile);
+            expect(result.name).toBe('original.txt');
+            expect(result.path).toBe('original.txt');
+        });
+        it('should reject files exceeding max size', async () => {
+            // 创建一个超过限制的大文件
+            const testFile = path.join(testDir, 'large.txt');
+            const largeContent = 'x'.repeat(config.maxFileSize + 1);
+            await fs.writeFile(testFile, largeContent);
+            await expect(filesManager.putFile(testFile)).rejects.toThrow('exceeds maximum allowed size');
+        });
+        it('should create subdirectories when needed', async () => {
+            const testFile = path.join(testDir, 'source.txt');
+            await fs.writeFile(testFile, 'Test content');
+            const result = await filesManager.putFile(testFile, 'subdir/nested.txt');
+            expect(result.path).toBe('subdir/nested.txt');
+            // 验证子目录和文件都存在
+            const nestedFile = path.join(testDir, 'subdir/nested.txt');
+            const exists = await fs.access(nestedFile).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+        });
+    });
+    describe('getFile', () => {
+        it('should retrieve file content successfully', async () => {
+            // 创建测试文件
+            const testFile = path.join(testDir, 'test.txt');
+            const testContent = 'Test file content';
+            await fs.writeFile(testFile, testContent);
+            const result = await filesManager.getFile('test.txt');
+            expect(result.toString()).toBe(testContent);
+        });
+        it('should throw error for non-existent file', async () => {
+            await expect(filesManager.getFile('nonexistent.txt')).rejects.toThrow('File not found');
+        });
+        it('should throw error for directory path', async () => {
+            const testDir = path.join(config.rootDir, 'testdir');
+            await fs.mkdir(testDir);
+            await expect(filesManager.getFile('testdir')).rejects.toThrow('is not a file');
+        });
+    });
+    describe('listDir', () => {
+        beforeEach(async () => {
+            // 创建测试文件和目录结构
+            await fs.writeFile(path.join(testDir, 'file1.txt'), 'content1');
+            await fs.writeFile(path.join(testDir, 'file2.txt'), 'content2');
+            await fs.mkdir(path.join(testDir, 'subdir'));
+            await fs.writeFile(path.join(testDir, 'subdir', 'nested.txt'), 'nested content');
+            await fs.writeFile(path.join(testDir, '.hidden'), 'hidden content');
+        });
+        it('should list directory contents', async () => {
+            const result = await filesManager.listDir();
+            expect(result).toHaveLength(3); // file1.txt, file2.txt, subdir
+            expect(result.map(e => e.name)).toContain('file1.txt');
+            expect(result.map(e => e.name)).toContain('file2.txt');
+            expect(result.map(e => e.name)).toContain('subdir');
+        });
+        it('should include hidden files when all option is true', async () => {
+            const result = await filesManager.listDir(undefined, { all: true });
+            expect(result).toHaveLength(4); // 包括 .hidden
+            expect(result.map(e => e.name)).toContain('.hidden');
+        });
+        it('should list recursively when recursive option is true', async () => {
+            const result = await filesManager.listDir(undefined, { recursive: true });
+            expect(result.length).toBeGreaterThan(3);
+            expect(result.map(e => e.name)).toContain('nested.txt');
+        });
+        it('should filter by pattern', async () => {
+            const result = await filesManager.listDir(undefined, { pattern: 'file*.txt' });
+            expect(result).toHaveLength(2);
+            expect(result.map(e => e.name)).toContain('file1.txt');
+            expect(result.map(e => e.name)).toContain('file2.txt');
+        });
+    });
+    describe('remove', () => {
+        beforeEach(async () => {
+            // 创建测试文件和目录
+            await fs.writeFile(path.join(testDir, 'to-delete.txt'), 'content');
+            await fs.mkdir(path.join(testDir, 'empty-dir'));
+            await fs.mkdir(path.join(testDir, 'non-empty'));
+            await fs.writeFile(path.join(testDir, 'non-empty', 'file.txt'), 'content');
+        });
+        it('should delete a file successfully', async () => {
+            await filesManager.remove('to-delete.txt');
+            const exists = await fs.access(path.join(testDir, 'to-delete.txt'))
+                .then(() => true).catch(() => false);
+            expect(exists).toBe(false);
+        });
+        it('should delete empty directory successfully', async () => {
+            await filesManager.remove('empty-dir');
+            const exists = await fs.access(path.join(testDir, 'empty-dir'))
+                .then(() => true).catch(() => false);
+            expect(exists).toBe(false);
+        });
+        it('should delete non-empty directory when recursive is true', async () => {
+            await filesManager.remove('non-empty', true);
+            const exists = await fs.access(path.join(testDir, 'non-empty'))
+                .then(() => true).catch(() => false);
+            expect(exists).toBe(false);
+        });
+        it('should throw error for non-empty directory when recursive is false', async () => {
+            await expect(filesManager.remove('non-empty', false))
+                .rejects.toThrow('Directory is not empty');
+        });
+        it('should handle non-existent paths gracefully', async () => {
+            await expect(filesManager.remove('non-existent')).resolves.not.toThrow();
+        });
+    });
+    describe('makeDir', () => {
+        it('should create directory successfully', async () => {
+            await filesManager.makeDir('new-dir');
+            const dirPath = path.join(testDir, 'new-dir');
+            const stat = await fs.stat(dirPath);
+            expect(stat.isDirectory()).toBe(true);
+        });
+        it('should create nested directories when parents is true', async () => {
+            await filesManager.makeDir('nested/deep/dir', true);
+            const dirPath = path.join(testDir, 'nested/deep/dir');
+            const stat = await fs.stat(dirPath);
+            expect(stat.isDirectory()).toBe(true);
+        });
+        it('should handle existing directory gracefully', async () => {
+            await fs.mkdir(path.join(testDir, 'existing'));
+            await expect(filesManager.makeDir('existing')).resolves.not.toThrow();
+        });
+    });
+    describe('getStat', () => {
+        beforeEach(async () => {
+            await fs.writeFile(path.join(testDir, 'test.txt'), 'file content');
+            await fs.mkdir(path.join(testDir, 'testdir'));
+        });
+        it('should get file stats successfully', async () => {
+            const result = await filesManager.getStat('test.txt');
+            expect(result.name).toBe('test.txt');
+            expect(result.path).toBe('test.txt');
+            expect(result.isFile).toBe(true);
+            expect(result.isDirectory).toBe(false);
+            expect(result.size).toBe(12); // "file content" 的长度
+        });
+        it('should get directory stats successfully', async () => {
+            const result = await filesManager.getStat('testdir');
+            expect(result.name).toBe('testdir');
+            expect(result.path).toBe('testdir');
+            expect(result.isFile).toBe(false);
+            expect(result.isDirectory).toBe(true);
+        });
+        it('should throw error for non-existent path', async () => {
+            await expect(filesManager.getStat('nonexistent')).rejects.toThrow('Path not found');
+        });
+    });
+    describe('path security', () => {
+        it('should prevent directory traversal attacks', async () => {
+            await expect(filesManager.getFile('../../../etc/passwd'))
+                .rejects.toThrow('Access denied');
+        });
+        it('should prevent access outside allowed paths', async () => {
+            await expect(filesManager.getFile('/etc/passwd'))
+                .rejects.toThrow('Access denied');
+        });
+    });
+});