@sstar/embedlink_agent 0.1.0

package/dist/files/files_manager.js

@@ -0,0 +1,511 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createReadStream, createWriteStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import { FileType } from './types.js';
+import { FileOperationLogger, FileOperationEvent } from './file_operation_logger.js';
+export class FilesManager {
+    constructor(config, agentLogger, agentConfig) {
+        this.rootDir = path.resolve(config.rootDir || './files');
+        this.maxFileSize = config.maxFileSize || 100 * 1024 * 1024; // 默认 100MB
+        this.maxTotalBytes = config.maxTotalBytes || 5 * 1024 * 1024 * 1024; // 默认 5GB
+        this.maxTotalFiles = config.maxTotalFiles || 50000;
+        this.allowedPaths = config.allowedPaths || [this.rootDir];
+        this.agentConfig = agentConfig;
+        // 如果启用了文件操作日志，创建FileOperationLogger
+        if (agentLogger && agentConfig?.logging?.files?.enabled) {
+            this.fileLogger = new FileOperationLogger(agentLogger, agentConfig.agent?.id || 'unknown');
+        }
+        // 确保根目录存在
+        this.ensureDirectory(this.rootDir);
+    }
+    // ============ 公开接口 - 对应 MCP 工具 ============
+    /**
+     * 上传文件到 Agent
+     */
+    async putFile(srcPath, dstPath, requestId) {
+        // 如果没有传入requestId，开始一个新的操作记录
+        if (!requestId && this.fileLogger) {
+            requestId = this.fileLogger.startOperation('put', {
+                originalSourcePath: srcPath,
+                agentReceivedTargetPath: dstPath,
+            });
+        }
+        try {
+            if (this.fileLogger && requestId) {
+                // 记录路径解析开始
+                this.fileLogger.logDebug(requestId, FileOperationEvent.PATH_RESOLUTION_START, {
+                    agentReceivedTargetPath: dstPath,
+                    inputPath: dstPath || path.basename(srcPath),
+                });
+            }
+            // 验证并解析目标路径
+            let targetPath;
+            let inputPath;
+            if (dstPath && dstPath.trim()) {
+                targetPath = this.resolvePath(dstPath);
+                inputPath = dstPath;
+            }
+            else {
+                const baseName = path.basename(srcPath);
+                inputPath = baseName;
+                if (!baseName) {
+                    // 如果srcPath是根目录或空路径，使用当前目录
+                    targetPath = this.rootDir;
+                }
+                else {
+                    targetPath = this.resolvePath(baseName);
+                }
+            }
+            // 详细记录路径转换过程
+            let pathTransformation;
+            if (this.fileLogger && requestId && this.agentConfig?.logging?.files?.pathResolution) {
+                pathTransformation = this.fileLogger.logPathTransformation(requestId, inputPath, this.rootDir);
+            }
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logDebug(requestId, FileOperationEvent.PATH_RESOLUTION_SUCCESS, {
+                    agentReceivedTargetPath: dstPath,
+                    resolvedTargetPath: targetPath,
+                    pathTransformation,
+                });
+            }
+            // 安全检查记录
+            if (this.fileLogger && requestId && this.agentConfig?.logging?.files?.securityChecks) {
+                this.fileLogger.logDebug(requestId, FileOperationEvent.SECURITY_CHECK_START, {
+                    resolvedTargetPath: targetPath,
+                });
+                const securityResult = await this.performSecurityChecks(targetPath, srcPath);
+                this.fileLogger.logDebug(requestId, FileOperationEvent.SECURITY_CHECK_SUCCESS, {
+                    resolvedTargetPath: targetPath,
+                    securityChecks: securityResult,
+                });
+            }
+            // 检查文件大小
+            const stats = await fs.stat(srcPath);
+            if (stats.size > this.maxFileSize) {
+                const error = new Error(`File size ${stats.size} exceeds maximum allowed size ${this.maxFileSize}`);
+                if (this.fileLogger && requestId) {
+                    this.fileLogger.logError(requestId, error, {
+                        originalSourcePath: srcPath,
+                        agentReceivedTargetPath: dstPath,
+                        fileSize: stats.size,
+                        maxSize: this.maxFileSize,
+                    });
+                }
+                throw error;
+            }
+            // 记录文件复制开始
+            const actualStoragePath = await this.copyFileWithLogging(srcPath, targetPath, requestId);
+            // 获取文件信息
+            const fileInfo = await this.getFileInfo(actualStoragePath);
+            // 记录操作成功
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logSuccess(requestId, {
+                    originalSourcePath: srcPath,
+                    agentReceivedTargetPath: dstPath,
+                    resolvedTargetPath: targetPath,
+                    actualStoragePath: actualStoragePath,
+                    pathTransformation,
+                    fileSize: stats.size,
+                    fileType: stats.isFile() ? 'file' : 'directory',
+                });
+            }
+            return fileInfo;
+        }
+        catch (error) {
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logError(requestId, error, {
+                    originalSourcePath: srcPath,
+                    agentReceivedTargetPath: dstPath,
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * 从 Agent 获取文件内容
+     */
+    async getFile(srcPath, requestId) {
+        // 如果没有传入requestId，开始一个新的操作记录
+        if (!requestId && this.fileLogger) {
+            requestId = this.fileLogger.startOperation('get', {
+                agentReceivedTargetPath: srcPath,
+            });
+        }
+        try {
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logDebug(requestId, FileOperationEvent.GET_VALIDATION_START, {
+                    agentReceivedTargetPath: srcPath,
+                });
+            }
+            const fullPath = this.resolvePath(srcPath);
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logDebug(requestId, FileOperationEvent.GET_VALIDATION_SUCCESS, {
+                    agentReceivedTargetPath: srcPath,
+                    resolvedTargetPath: fullPath,
+                });
+            }
+            const stats = await fs.stat(fullPath);
+            if (!stats.isFile()) {
+                const error = new Error(`Path is not a file: ${srcPath}`);
+                if (this.fileLogger && requestId) {
+                    this.fileLogger.logError(requestId, error, {
+                        agentReceivedTargetPath: srcPath,
+                        resolvedTargetPath: fullPath,
+                    });
+                }
+                throw error;
+            }
+            const content = await fs.readFile(fullPath);
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logSuccess(requestId, {
+                    agentReceivedTargetPath: srcPath,
+                    resolvedTargetPath: fullPath,
+                    fileSize: content.length,
+                    fileType: 'file',
+                });
+            }
+            return content;
+        }
+        catch (error) {
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logError(requestId, error, {
+                    agentReceivedTargetPath: srcPath,
+                });
+            }
+            if (error.code === 'ENOENT') {
+                throw new Error(`File not found: ${srcPath}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * 创建文件的可读流（用于大文件传输）
+     */
+    async createFileReadStream(srcPath) {
+        const fullPath = this.resolvePath(srcPath);
+        try {
+            const stats = await fs.stat(fullPath);
+            if (!stats.isFile()) {
+                throw new Error(`Path is not a file: ${srcPath}`);
+            }
+            return createReadStream(fullPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`File not found: ${srcPath}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * 从流保存文件
+     */
+    async saveFileFromStream(dstPath, stream) {
+        const fullPath = this.resolvePath(dstPath);
+        // 确保目标目录存在
+        await this.ensureDirectory(path.dirname(fullPath));
+        // 创建写入流
+        const writeStream = createWriteStream(fullPath);
+        try {
+            await pipeline(stream, writeStream);
+            return await this.getFileInfo(fullPath);
+        }
+        catch (error) {
+            // 如果失败，清理部分写入的文件
+            try {
+                await fs.unlink(fullPath);
+            }
+            catch {
+                // 忽略删除错误
+            }
+            throw error;
+        }
+    }
+    // ============ 内部实现 - 不暴露为 MCP 工具 ============
+    /**
+     * 列出目录内容
+     */
+    async listDir(dirPath, options) {
+        const targetPath = dirPath ? this.resolvePath(dirPath) : this.rootDir;
+        try {
+            const entries = await fs.readdir(targetPath, { withFileTypes: true });
+            const result = [];
+            for (const entry of entries) {
+                // 跳过隐藏文件（除非要求显示所有文件）
+                if (!options?.all && entry.name.startsWith('.')) {
+                    continue;
+                }
+                // 模式匹配过滤
+                if (options?.pattern && !this.matchPattern(entry.name, options.pattern)) {
+                    continue;
+                }
+                const fullPath = path.join(targetPath, entry.name);
+                const stats = await fs.stat(fullPath);
+                const fileEntry = {
+                    name: entry.name,
+                    path: path.relative(this.rootDir, fullPath),
+                    type: entry.isDirectory() ? FileType.DIRECTORY : FileType.FILE,
+                    size: stats.size,
+                    mtime: stats.mtimeMs,
+                };
+                result.push(fileEntry);
+                // 递归处理子目录
+                if (options?.recursive && entry.isDirectory()) {
+                    const subEntries = await this.listDir(path.relative(this.rootDir, fullPath), options);
+                    result.push(...subEntries);
+                }
+            }
+            return result.sort((a, b) => {
+                // 目录优先，然后按名称排序
+                if (a.type !== b.type) {
+                    return a.type === FileType.DIRECTORY ? -1 : 1;
+                }
+                return a.name.localeCompare(b.name);
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Directory not found: ${dirPath || 'root'}`);
+            }
+            if (error.code === 'ENOTDIR') {
+                throw new Error(`Path is not a directory: ${dirPath || 'root'}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * 删除文件或目录
+     */
+    async remove(targetPath, recursive = false) {
+        const fullPath = this.resolvePath(targetPath);
+        try {
+            const stats = await fs.stat(fullPath);
+            if (stats.isDirectory()) {
+                if (recursive) {
+                    await fs.rm(fullPath, { recursive: true });
+                }
+                else {
+                    // 检查目录是否为空
+                    const entries = await fs.readdir(fullPath);
+                    if (entries.length > 0) {
+                        throw new Error(`Directory is not empty: ${targetPath}. Use recursive=true to delete non-empty directories.`);
+                    }
+                    await fs.rm(fullPath);
+                }
+            }
+            else {
+                await fs.unlink(fullPath);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // 文件不存在，视为成功
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * 创建目录
+     */
+    async makeDir(dirPath, parents = false) {
+        const fullPath = this.resolvePath(dirPath);
+        try {
+            await fs.mkdir(fullPath, { recursive: parents });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                // 目录已存在，视为成功
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * 获取文件状态信息
+     */
+    async getStat(targetPath) {
+        const fullPath = this.resolvePath(targetPath);
+        try {
+            const stats = await fs.stat(fullPath);
+            const relativePath = path.relative(this.rootDir, fullPath);
+            return {
+                path: relativePath,
+                name: path.basename(fullPath),
+                size: stats.size,
+                isFile: stats.isFile(),
+                isDirectory: stats.isDirectory(),
+                modifiedAt: stats.mtimeMs,
+                permissions: stats.mode.toString(8),
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Path not found: ${targetPath}`);
+            }
+            throw error;
+        }
+    }
+    // ============ 私有辅助方法 ============
+    /**
+     * 解析并验证路径安全性
+     */
+    resolvePath(relativePath) {
+        if (!relativePath || typeof relativePath !== 'string') {
+            throw new Error(`Invalid path: expected string, got ${typeof relativePath}`);
+        }
+        // 清理路径，防止目录遍历攻击
+        const cleanPath = path.normalize(relativePath).replace(/^(\.\.[\/\\])+/, '');
+        const fullPath = path.join(this.rootDir, cleanPath);
+        // 确保路径在允许的范围内
+        const resolvedPath = path.resolve(fullPath);
+        const isAllowed = this.allowedPaths.some((allowedPath) => resolvedPath.startsWith(path.resolve(allowedPath)));
+        if (!isAllowed) {
+            throw new Error(`Access denied: Path '${relativePath}' is outside allowed directories`);
+        }
+        return resolvedPath;
+    }
+    /**
+     * 确保目录存在
+     */
+    async ensureDirectory(dirPath) {
+        if (!dirPath || typeof dirPath !== 'string') {
+            throw new Error(`Invalid directory path: expected string, got ${typeof dirPath}`);
+        }
+        try {
+            await fs.mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+    }
+    /**
+     * 获取文件信息
+     */
+    async getFileInfo(fullPath) {
+        const stats = await fs.stat(fullPath);
+        const relativePath = path.relative(this.rootDir, fullPath);
+        return {
+            path: relativePath,
+            name: path.basename(fullPath),
+            size: stats.size,
+            mtime: stats.mtimeMs,
+            isFile: stats.isFile(),
+            isDirectory: stats.isDirectory(),
+        };
+    }
+    /**
+     * 执行安全检查
+     */
+    async performSecurityChecks(targetPath, srcPath) {
+        const checks = {
+            pathTraversal: true,
+            sizeLimit: true,
+            permission: true,
+            diskSpace: true,
+        };
+        try {
+            // 1. 路径遍历检查（已在resolvePath中完成）
+            // 这里只是再次确认
+            const resolvedPath = path.resolve(targetPath);
+            const isAllowed = this.allowedPaths.some((allowedPath) => resolvedPath.startsWith(path.resolve(allowedPath)));
+            checks.pathTraversal = isAllowed;
+            // 2. 文件大小检查（如果提供了源路径）
+            if (srcPath) {
+                try {
+                    const stats = await fs.stat(srcPath);
+                    checks.sizeLimit = stats.size <= this.maxFileSize;
+                }
+                catch {
+                    checks.sizeLimit = false;
+                }
+            }
+            // 3. 权限检查
+            try {
+                // 检查目标目录的写权限
+                const targetDir = path.dirname(targetPath);
+                await fs.access(targetDir, fs.constants.W_OK);
+                checks.permission = true;
+            }
+            catch {
+                checks.permission = false;
+            }
+            // 4. 磁盘空间检查（简化版）
+            try {
+                // 获取根目录的磁盘空间信息（需要额外的库，这里简化为总是通过）
+                checks.diskSpace = true;
+            }
+            catch {
+                checks.diskSpace = false;
+            }
+        }
+        catch (error) {
+            // 如果检查过程中出现错误，标记为失败
+            checks.permission = false;
+        }
+        return checks;
+    }
+    /**
+     * 带日志的文件复制
+     */
+    async copyFileWithLogging(srcPath, dstPath, requestId) {
+        if (this.fileLogger && requestId) {
+            this.fileLogger.logDebug(requestId, FileOperationEvent.COPY_START, {
+                sourcePath: srcPath,
+                destinationPath: dstPath,
+            });
+        }
+        try {
+            // 确保目标目录存在
+            const targetDir = path.dirname(dstPath);
+            await this.ensureDirectory(targetDir);
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logDebug(requestId, FileOperationEvent.DIRECTORY_CREATED, {
+                    directory: targetDir,
+                });
+            }
+            // 执行文件复制
+            await fs.copyFile(srcPath, dstPath);
+            // 验证文件确实存在
+            const stats = await fs.stat(dstPath);
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logDebug(requestId, FileOperationEvent.COPY_SUCCESS, {
+                    sourcePath: srcPath,
+                    actualStoragePath: dstPath,
+                    fileSize: stats.size,
+                    fileModified: stats.mtime,
+                    fileExists: true,
+                });
+            }
+            return dstPath;
+        }
+        catch (error) {
+            if (this.fileLogger && requestId) {
+                this.fileLogger.logDebug(requestId, 'files.copy.error', {
+                    sourcePath: srcPath,
+                    destinationPath: dstPath,
+                    error: error.message,
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * 简单的文件名模式匹配
+     */
+    matchPattern(fileName, pattern) {
+        // 简单的 glob 风格匹配实现
+        const regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+        return new RegExp(`^${regexPattern}$`).test(fileName);
+    }
+    getLimits() {
+        return {
+            maxFileSize: this.maxFileSize,
+            maxTotalBytes: this.maxTotalBytes,
+            maxTotalFiles: this.maxTotalFiles,
+        };
+    }
+}

package/dist/files/index.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { exec } from 'node:child_process';
+import util from 'node:util';
+const execAsync = util.promisify(exec);
+async function getDrives() {
+    if (os.platform() !== 'win32') {
+        return [{ name: '/', path: '/', type: 'dir', size: 0 }];
+    }
+    try {
+        const { stdout } = await execAsync('wmic logicaldisk get name');
+        const lines = stdout.split('\r\n').filter((l) => l.trim());
+        const drives = [];
+        // Skip header "Name"
+        for (let i = 1; i < lines.length; i++) {
+            const drive = lines[i].trim();
+            if (drive && /^[A-Z]:$/.test(drive)) {
+                drives.push({ name: drive, path: drive + '\\', type: 'dir', size: 0 });
+            }
+        }
+        return drives;
+    }
+    catch {
+        return [{ name: 'C:\\', path: 'C:\\', type: 'dir', size: 0 }];
+    }
+}
+export async function listFiles(targetPath) {
+    // Check if we need to list drives (empty path on Windows)
+    const isWin = os.platform() === 'win32';
+    if (!targetPath || targetPath.trim() === '') {
+        if (isWin) {
+            const drives = await getDrives();
+            return { ok: true, files: drives, current: '' };
+        }
+        // Unix: default to root
+        targetPath = '/';
+    }
+    const resolved = path.resolve(targetPath);
+    try {
+        const st = await fs.stat(resolved);
+        if (!st.isDirectory()) {
+            return { ok: false, files: [], current: resolved, error: 'Not a directory' };
+        }
+        const entries = await fs.readdir(resolved, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            try {
+                const fullPath = path.join(resolved, entry.name);
+                // Basic filter: ignore dotfiles if needed, but usually we want to see them
+                // Let's rely on stat for correct type/size
+                const stat = await fs.stat(fullPath);
+                files.push({
+                    name: entry.name,
+                    path: fullPath,
+                    type: stat.isDirectory() ? 'dir' : 'file',
+                    size: stat.size,
+                });
+            }
+            catch {
+                // Ignore files we can't stat (permission denied etc)
+            }
+        }
+        // Sort: Directories first, then files
+        files.sort((a, b) => {
+            if (a.type === b.type)
+                return a.name.localeCompare(b.name);
+            return a.type === 'dir' ? -1 : 1;
+        });
+        const parent = path.dirname(resolved);
+        const hasParent = parent !== resolved;
+        return {
+            ok: true,
+            files,
+            current: resolved,
+            parent: hasParent ? parent : undefined,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            files: [],
+            current: resolved,
+            error: e.message || String(e),
+        };
+    }
+}

package/dist/files/types.js

@@ -0,0 +1,5 @@
+export var FileType;
+(function (FileType) {
+    FileType["FILE"] = "FILE";
+    FileType["DIRECTORY"] = "DIRECTORY";
+})(FileType || (FileType = {}));