@sstar/embedlink_agent 0.1.0

package/dist/files/artifact_manager.js

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import path from 'path';
+import { EventEmitter } from 'events';
+import { TftpServer } from '../tftp/server.js';
+export class ArtifactManager extends EventEmitter {
+    constructor() {
+        super();
+        this.tftpServer = null;
+        // Default staging dir
+        this.stagingDir = path.join(process.cwd(), 'staging_artifacts');
+        if (!fs.existsSync(this.stagingDir)) {
+            fs.mkdirSync(this.stagingDir, { recursive: true });
+        }
+    }
+    static getInstance() {
+        if (!ArtifactManager.instance) {
+            ArtifactManager.instance = new ArtifactManager();
+        }
+        return ArtifactManager.instance;
+    }
+    getStagingDir() {
+        return this.stagingDir;
+    }
+    async initServers(cfg) {
+        // If config is provided, update stagingDir to match tftp.dir (or default)
+        if (cfg && cfg.tftp && cfg.tftp.dir) {
+            this.stagingDir = cfg.tftp.dir;
+            if (!fs.existsSync(this.stagingDir)) {
+                try {
+                    fs.mkdirSync(this.stagingDir, { recursive: true });
+                }
+                catch (e) {
+                    console.warn(`[ArtifactManager] Failed to create staging dir ${this.stagingDir}: ${e}`);
+                }
+            }
+        }
+        // 1. Start TFTP
+        // TftpServer takes config.
+        this.tftpServer = new TftpServer({
+            rootDir: this.stagingDir,
+            port: 69, // Default
+        });
+        // TftpServer.start() ? Need to check implementation
+        try {
+            await this.tftpServer.start();
+            console.log(`[ArtifactManager] TFTP server started on port 69, root: ${this.stagingDir}`);
+        }
+        catch (e) {
+            console.warn(`[ArtifactManager] Failed to start TFTP server: ${e}`);
+        }
+        // 2. Start NFS
+        // NFS server is not embedded. We assume OS NFS server is configured if needed.
+        // Or we rely on the fact that we just write files to disk, and if the user
+        // wants to mount it, they must have set up /etc/exports.
+        console.log(`[ArtifactManager] NFS Staging: Files are in ${this.stagingDir}. Ensure this directory is exported if using NFS.`);
+    }
+    async saveArtifactStream(fileName, stream) {
+        const filePath = path.join(this.stagingDir, fileName);
+        const writeStream = fs.createWriteStream(filePath);
+        for await (const chunk of stream) {
+            if (!writeStream.write(chunk)) {
+                await new Promise(resolve => writeStream.once('drain', () => resolve()));
+            }
+        }
+        writeStream.end();
+        return filePath;
+    }
+}

package/dist/files/file_operation_logger.js

@@ -0,0 +1,271 @@
+import path from 'node:path';
+import { LogLevel, logAgentDebug } from '../logger.js';
+// 文件操作日志事件类型
+export var FileOperationEvent;
+(function (FileOperationEvent) {
+    // 通用事件
+    FileOperationEvent["OPERATION_START"] = "files.operation.start";
+    FileOperationEvent["OPERATION_SUCCESS"] = "files.operation.success";
+    FileOperationEvent["OPERATION_ERROR"] = "files.operation.error";
+    // PUT操作事件
+    FileOperationEvent["PUT_VALIDATION_START"] = "files.put.validation.start";
+    FileOperationEvent["PUT_VALIDATION_SUCCESS"] = "files.put.validation.success";
+    FileOperationEvent["PUT_META_SENT"] = "files.put.meta.sent";
+    FileOperationEvent["PUT_FILE_START"] = "files.put.file.start";
+    FileOperationEvent["PUT_FILE_PROGRESS"] = "files.put.file.progress";
+    FileOperationEvent["PUT_FILE_SUCCESS"] = "files.put.file.success";
+    FileOperationEvent["PUT_CLEANUP"] = "files.put.cleanup";
+    // GET操作事件
+    FileOperationEvent["GET_VALIDATION_START"] = "files.get.validation.start";
+    FileOperationEvent["GET_VALIDATION_SUCCESS"] = "files.get.validation.success";
+    FileOperationEvent["GET_REQUEST_SENT"] = "files.get.request.sent";
+    FileOperationEvent["GET_FILE_START"] = "files.get.file.start";
+    FileOperationEvent["GET_FILE_PROGRESS"] = "files.get.file.progress";
+    FileOperationEvent["GET_FILE_SUCCESS"] = "files.get.file.success";
+    // 路径解析和安全检查
+    FileOperationEvent["PATH_RESOLUTION_START"] = "files.path.resolution.start";
+    FileOperationEvent["PATH_RESOLUTION_SUCCESS"] = "files.path.resolution.success";
+    FileOperationEvent["PATH_NORMALIZATION"] = "files.path.normalization";
+    FileOperationEvent["PATH_SECURITY_CHECK"] = "files.path.security_check";
+    FileOperationEvent["PATH_FINAL_CONSTRUCTION"] = "files.path.final_construction";
+    FileOperationEvent["SECURITY_CHECK_START"] = "files.security.check.start";
+    FileOperationEvent["SECURITY_CHECK_SUCCESS"] = "files.security.check.success";
+    FileOperationEvent["SECURITY_CHECK_FAILED"] = "files.security.check.failed";
+    // 文件操作过程
+    FileOperationEvent["COPY_START"] = "files.copy.start";
+    FileOperationEvent["COPY_SUCCESS"] = "files.copy.success";
+    FileOperationEvent["DIRECTORY_CREATED"] = "files.directory.created";
+    // 重试和错误处理
+    FileOperationEvent["RETRY_ATTEMPT"] = "files.retry.attempt";
+    FileOperationEvent["RETRY_SUCCESS"] = "files.retry.success";
+    FileOperationEvent["RETRY_EXHAUSTED"] = "files.retry.exhausted";
+    FileOperationEvent["RESOURCE_CLEANUP"] = "files.resource.cleanup";
+    // 其他操作
+    FileOperationEvent["LIST_START"] = "files.list.start";
+    FileOperationEvent["LIST_SUCCESS"] = "files.list.success";
+    FileOperationEvent["MKDIR_START"] = "files.mkdir.start";
+    FileOperationEvent["MKDIR_SUCCESS"] = "files.mkdir.success";
+    FileOperationEvent["RM_START"] = "files.rm.start";
+    FileOperationEvent["RM_SUCCESS"] = "files.rm.success";
+})(FileOperationEvent || (FileOperationEvent = {}));
+// 文件操作上下文管理
+export class FileOperationContext {
+    constructor(requestId, operation, initialData = {}) {
+        this.completed = false;
+        this.success = false;
+        this.requestId = requestId;
+        this.operation = operation;
+        this.startTime = Date.now();
+        this.agentPid = process.pid;
+        this.data = {
+            ...initialData,
+            operation,
+            requestId,
+            startTime: this.startTime,
+            agentPid: this.agentPid,
+            stage: 'started',
+        };
+    }
+    // 更新上下文数据
+    update(newData) {
+        this.data = { ...this.data, ...newData };
+    }
+    // 标记操作成功
+    markSuccess() {
+        this.completed = true;
+        this.success = true;
+        this.data.duration = Date.now() - this.startTime;
+        this.data.stage = 'success';
+    }
+    // 标记操作失败
+    markError(error) {
+        this.completed = true;
+        this.success = false;
+        this.error = error;
+        this.data.duration = Date.now() - this.startTime;
+        this.data.stage = 'error';
+        this.data.errorCode = error.name;
+        this.data.errorMessage = error.message;
+        this.data.errorStack = error.stack;
+    }
+    // 转换为日志数据格式
+    toLogData() {
+        return {
+            operation: this.operation,
+            requestId: this.requestId,
+            startTime: this.startTime,
+            agentPid: this.agentPid,
+            duration: this.data.duration,
+            stage: this.data.stage || 'unknown',
+            ...this.data,
+        };
+    }
+    // 检查是否已完成
+    isCompleted() {
+        return this.completed;
+    }
+    // 检查是否成功
+    isSuccess() {
+        return this.success;
+    }
+    // 获取错误信息
+    getError() {
+        return this.error;
+    }
+}
+// 文件操作日志记录器
+export class FileOperationLogger {
+    constructor(agentLogger, agentId = 'unknown') {
+        this.activeOperations = new Map();
+        this.agentLogger = agentLogger;
+        this.agentId = agentId;
+    }
+    // 开始操作记录
+    startOperation(operation, data = {}) {
+        const requestId = this.generateRequestId();
+        const context = new FileOperationContext(requestId, operation, {
+            ...data,
+            agentId: this.agentId,
+        });
+        this.activeOperations.set(requestId, context);
+        this.agentLogger.write(LogLevel.DEBUG, FileOperationEvent.OPERATION_START, {
+            ...context.toLogData(),
+            stage: 'start',
+        });
+        return requestId;
+    }
+    // 记录操作成功
+    logSuccess(requestId, data = {}) {
+        const context = this.activeOperations.get(requestId);
+        if (!context) {
+            logAgentDebug('file_operation.logger', {
+                warning: 'Attempted to log success for unknown requestId',
+                requestId,
+            });
+            return;
+        }
+        context.update(data);
+        context.markSuccess();
+        this.agentLogger.write(LogLevel.INFO, FileOperationEvent.OPERATION_SUCCESS, {
+            ...context.toLogData(),
+            stage: 'success',
+        });
+        this.activeOperations.delete(requestId);
+    }
+    // 记录操作失败
+    logError(requestId, error, data = {}) {
+        const context = this.activeOperations.get(requestId);
+        if (!context) {
+            logAgentDebug('file_operation.logger', {
+                warning: 'Attempted to log error for unknown requestId',
+                requestId,
+                errorMessage: error.message,
+            });
+            return;
+        }
+        context.update(data);
+        context.markError(error);
+        this.agentLogger.write(LogLevel.ERROR, FileOperationEvent.OPERATION_ERROR, {
+            ...context.toLogData(),
+            stage: 'error',
+            errorCode: error.name,
+            errorMessage: error.message,
+            errorStack: error.stack,
+        });
+        this.activeOperations.delete(requestId);
+    }
+    // 记录调试信息
+    logDebug(requestId, event, data = {}) {
+        const context = this.activeOperations.get(requestId);
+        if (!context) {
+            logAgentDebug('file_operation.logger', {
+                warning: 'Attempted to log debug for unknown requestId',
+                requestId,
+                event,
+            });
+            return;
+        }
+        context.update(data);
+        this.agentLogger.write(LogLevel.DEBUG, event, {
+            ...context.toLogData(),
+            stage: 'debug',
+        });
+    }
+    // 记录路径转换过程
+    logPathTransformation(requestId, inputPath, rootDir) {
+        const transformation = {
+            input: inputPath,
+            normalized: '',
+            securityChecked: '',
+            final: '',
+        };
+        // 1. 路径标准化
+        transformation.normalized = path.normalize(inputPath);
+        this.logDebug(requestId, FileOperationEvent.PATH_NORMALIZATION, {
+            input: transformation.input,
+            normalized: transformation.normalized,
+            debugInfo: {
+                explanation: 'path.normalize() applied to remove redundant separators and resolve relative references',
+            },
+        });
+        // 2. 安全路径检查
+        transformation.securityChecked = transformation.normalized.replace(/^(\.\.[\/\\])+/, '');
+        this.logDebug(requestId, FileOperationEvent.PATH_SECURITY_CHECK, {
+            normalized: transformation.normalized,
+            securityChecked: transformation.securityChecked,
+            debugInfo: {
+                explanation: 'Removed potential directory traversal patterns',
+            },
+        });
+        // 3. 最终路径构建
+        transformation.final = path.join(rootDir, transformation.securityChecked);
+        this.logDebug(requestId, FileOperationEvent.PATH_FINAL_CONSTRUCTION, {
+            rootDir: rootDir,
+            securityChecked: transformation.securityChecked,
+            final: transformation.final,
+            debugInfo: {
+                explanation: `Joined with root directory: ${rootDir}`,
+            },
+        });
+        return transformation;
+    }
+    // 生成唯一请求ID
+    generateRequestId() {
+        return `files_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    // 获取活跃操作数量
+    getActiveOperationCount() {
+        return this.activeOperations.size;
+    }
+    // 获取指定操作的上下文
+    getOperationContext(requestId) {
+        return this.activeOperations.get(requestId);
+    }
+    // 清理超时操作（防止内存泄漏）
+    cleanupTimeoutOperations(timeoutMs = 300000) {
+        // 默认5分钟超时
+        const now = Date.now();
+        const timeoutIds = [];
+        for (const [requestId, context] of this.activeOperations.entries()) {
+            if (now - context.startTime > timeoutMs) {
+                timeoutIds.push(requestId);
+            }
+        }
+        for (const requestId of timeoutIds) {
+            const context = this.activeOperations.get(requestId);
+            if (context) {
+                this.logDebug(requestId, 'files.operation.timeout', {
+                    warning: 'Operation timed out and cleaned up',
+                    duration: now - context.startTime,
+                });
+                this.activeOperations.delete(requestId);
+            }
+        }
+        if (timeoutIds.length > 0) {
+            logAgentDebug('file_operation.logger', {
+                message: `Cleaned up ${timeoutIds.length} timeout operations`,
+                timeoutIds,
+            });
+        }
+    }
+}