@dexto/core 1.1.11 → 1.2.0

package/dist/filesystem/filesystem-service.cjs

@@ -0,0 +1,482 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filesystem_service_exports = {};
+__export(filesystem_service_exports, {
+  FileSystemService: () => FileSystemService
+});
+module.exports = __toCommonJS(filesystem_service_exports);
+var fs = __toESM(require("node:fs/promises"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_glob = require("glob");
+var import_path_validator = require("./path-validator.js");
+var import_errors = require("./errors.js");
+var import_logger = require("../logger/index.js");
+const DEFAULT_ENCODING = "utf-8";
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_MAX_RESULTS = 1e3;
+const DEFAULT_MAX_SEARCH_RESULTS = 100;
+class FileSystemService {
+  config;
+  pathValidator;
+  initialized = false;
+  constructor(config = {}) {
+    this.config = {
+      allowedPaths: config.allowedPaths || ["."],
+      blockedPaths: config.blockedPaths || [".git", "node_modules/.bin", ".env"],
+      blockedExtensions: config.blockedExtensions || [".exe", ".dll", ".so"],
+      maxFileSize: config.maxFileSize || DEFAULT_MAX_FILE_SIZE,
+      enableBackups: config.enableBackups ?? true,
+      backupPath: config.backupPath || ".dexto/backups",
+      backupRetentionDays: config.backupRetentionDays || 7,
+      workingDirectory: config.workingDirectory
+    };
+    this.pathValidator = new import_path_validator.PathValidator(this.config);
+  }
+  /**
+   * Initialize the service
+   */
+  async initialize() {
+    if (this.initialized) {
+      import_logger.logger.debug("FileSystemService already initialized");
+      return;
+    }
+    if (this.config.enableBackups) {
+      try {
+        const backupDir = path.resolve(
+          this.config.workingDirectory || process.cwd(),
+          this.config.backupPath
+        );
+        await fs.mkdir(backupDir, { recursive: true });
+        import_logger.logger.debug(`Backup directory created/verified: ${backupDir}`);
+      } catch (error) {
+        import_logger.logger.warn(
+          `Failed to create backup directory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    this.initialized = true;
+    import_logger.logger.info("FileSystemService initialized successfully");
+  }
+  /**
+   * Read a file with validation and size limits
+   */
+  async readFile(filePath, options = {}) {
+    if (!this.initialized) {
+      throw import_errors.FileSystemError.notInitialized();
+    }
+    const validation = this.pathValidator.validatePath(filePath);
+    if (!validation.isValid || !validation.normalizedPath) {
+      throw import_errors.FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
+    }
+    const normalizedPath = validation.normalizedPath;
+    try {
+      const stats = await fs.stat(normalizedPath);
+      if (!stats.isFile()) {
+        throw import_errors.FileSystemError.invalidPath(normalizedPath, "Path is not a file");
+      }
+      if (stats.size > this.config.maxFileSize) {
+        throw import_errors.FileSystemError.fileTooLarge(
+          normalizedPath,
+          stats.size,
+          this.config.maxFileSize
+        );
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw import_errors.FileSystemError.fileNotFound(normalizedPath);
+      }
+      if (error.code === "EACCES") {
+        throw import_errors.FileSystemError.permissionDenied(normalizedPath, "read");
+      }
+      throw import_errors.FileSystemError.readFailed(
+        normalizedPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    try {
+      const encoding = options.encoding || DEFAULT_ENCODING;
+      const content = await fs.readFile(normalizedPath, encoding);
+      const lines = content.split("\n");
+      const limit = options.limit;
+      const offset1 = options.offset;
+      let selectedLines;
+      let truncated = false;
+      if (offset1 && offset1 > 0 || limit !== void 0) {
+        const start = offset1 && offset1 > 0 ? Math.max(0, offset1 - 1) : 0;
+        const end = limit !== void 0 ? start + limit : lines.length;
+        selectedLines = lines.slice(start, end);
+        truncated = end < lines.length;
+      } else {
+        selectedLines = lines;
+      }
+      return {
+        content: selectedLines.join("\n"),
+        lines: selectedLines.length,
+        encoding,
+        truncated,
+        size: Buffer.byteLength(content, encoding)
+      };
+    } catch (error) {
+      throw import_errors.FileSystemError.readFailed(
+        normalizedPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Find files matching a glob pattern
+   */
+  async globFiles(pattern, options = {}) {
+    if (!this.initialized) {
+      throw import_errors.FileSystemError.notInitialized();
+    }
+    const cwd = options.cwd || this.config.workingDirectory || process.cwd();
+    const maxResults = options.maxResults || DEFAULT_MAX_RESULTS;
+    try {
+      const files = await (0, import_glob.glob)(pattern, {
+        cwd,
+        absolute: true,
+        nodir: true,
+        // Only files
+        follow: false
+        // Don't follow symlinks
+      });
+      const validFiles = [];
+      for (const file of files) {
+        const validation = this.pathValidator.validatePath(file);
+        if (!validation.isValid || !validation.normalizedPath) {
+          import_logger.logger.debug(`Skipping invalid path: ${file}`);
+          continue;
+        }
+        if (options.includeMetadata !== false) {
+          try {
+            const stats = await fs.stat(validation.normalizedPath);
+            validFiles.push({
+              path: validation.normalizedPath,
+              size: stats.size,
+              modified: stats.mtime,
+              isDirectory: stats.isDirectory()
+            });
+          } catch (error) {
+            import_logger.logger.debug(
+              `Failed to stat file ${file}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        } else {
+          validFiles.push({
+            path: validation.normalizedPath,
+            size: 0,
+            modified: /* @__PURE__ */ new Date(),
+            isDirectory: false
+          });
+        }
+        if (validFiles.length >= maxResults) {
+          break;
+        }
+      }
+      const limited = validFiles.length >= maxResults;
+      return {
+        files: validFiles,
+        truncated: limited,
+        totalFound: validFiles.length
+      };
+    } catch (error) {
+      throw import_errors.FileSystemError.globFailed(
+        pattern,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Search for content in files (grep-like functionality)
+   */
+  async searchContent(pattern, options = {}) {
+    if (!this.initialized) {
+      throw import_errors.FileSystemError.notInitialized();
+    }
+    const searchPath = options.path || this.config.workingDirectory || process.cwd();
+    const globPattern = options.glob || "**/*";
+    const maxResults = options.maxResults || DEFAULT_MAX_SEARCH_RESULTS;
+    const contextLines = options.contextLines || 0;
+    try {
+      const flags = options.caseInsensitive ? "i" : "";
+      const regex = new RegExp(pattern, flags);
+      const globResult = await this.globFiles(globPattern, {
+        cwd: searchPath,
+        maxResults: 1e4
+        // Search more files, but limit results
+      });
+      const matches = [];
+      let filesSearched = 0;
+      for (const fileInfo of globResult.files) {
+        try {
+          const fileContent = await this.readFile(fileInfo.path);
+          const lines = fileContent.content.split("\n");
+          filesSearched++;
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (regex.test(line)) {
+              let context;
+              if (contextLines > 0) {
+                const before = [];
+                const after = [];
+                for (let j = Math.max(0, i - contextLines); j < i; j++) {
+                  before.push(lines[j]);
+                }
+                for (let j = i + 1; j < Math.min(lines.length, i + contextLines + 1); j++) {
+                  after.push(lines[j]);
+                }
+                context = { before, after };
+              }
+              matches.push({
+                file: fileInfo.path,
+                lineNumber: i + 1,
+                // 1-based line numbers
+                line,
+                ...context !== void 0 && { context }
+              });
+              if (matches.length >= maxResults) {
+                return {
+                  matches,
+                  totalMatches: matches.length,
+                  truncated: true,
+                  filesSearched
+                };
+              }
+            }
+          }
+        } catch (error) {
+          import_logger.logger.debug(
+            `Skipping file ${fileInfo.path}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return {
+        matches,
+        totalMatches: matches.length,
+        truncated: false,
+        filesSearched
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Invalid regular expression")) {
+        throw import_errors.FileSystemError.invalidPattern(pattern, "Invalid regular expression syntax");
+      }
+      throw import_errors.FileSystemError.searchFailed(
+        pattern,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Write content to a file
+   */
+  async writeFile(filePath, content, options = {}) {
+    if (!this.initialized) {
+      throw import_errors.FileSystemError.notInitialized();
+    }
+    const validation = this.pathValidator.validatePath(filePath);
+    if (!validation.isValid || !validation.normalizedPath) {
+      throw import_errors.FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
+    }
+    const normalizedPath = validation.normalizedPath;
+    const encoding = options.encoding || DEFAULT_ENCODING;
+    let backupPath;
+    let fileExists = false;
+    try {
+      await fs.access(normalizedPath);
+      fileExists = true;
+    } catch {
+    }
+    if (fileExists && (options.backup ?? this.config.enableBackups)) {
+      backupPath = await this.createBackup(normalizedPath);
+    }
+    try {
+      if (options.createDirs) {
+        const dir = path.dirname(normalizedPath);
+        await fs.mkdir(dir, { recursive: true });
+      }
+      await fs.writeFile(normalizedPath, content, encoding);
+      const bytesWritten = Buffer.byteLength(content, encoding);
+      import_logger.logger.debug(`File written: ${normalizedPath} (${bytesWritten} bytes)`);
+      return {
+        success: true,
+        path: normalizedPath,
+        bytesWritten,
+        backupPath
+      };
+    } catch (error) {
+      throw import_errors.FileSystemError.writeFailed(
+        normalizedPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Edit a file by replacing text
+   */
+  async editFile(filePath, operation, options = {}) {
+    if (!this.initialized) {
+      throw import_errors.FileSystemError.notInitialized();
+    }
+    const validation = this.pathValidator.validatePath(filePath);
+    if (!validation.isValid || !validation.normalizedPath) {
+      throw import_errors.FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
+    }
+    const normalizedPath = validation.normalizedPath;
+    const fileContent = await this.readFile(normalizedPath);
+    let content = fileContent.content;
+    const occurrences = (content.match(
+      new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")
+    ) || []).length;
+    if (occurrences === 0) {
+      throw import_errors.FileSystemError.stringNotFound(normalizedPath, operation.oldString);
+    }
+    if (!operation.replaceAll && occurrences > 1) {
+      throw import_errors.FileSystemError.stringNotUnique(normalizedPath, operation.oldString, occurrences);
+    }
+    let backupPath;
+    if (options.backup ?? this.config.enableBackups) {
+      backupPath = await this.createBackup(normalizedPath);
+    }
+    try {
+      if (operation.replaceAll) {
+        content = content.replace(
+          new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+          operation.newString
+        );
+      } else {
+        content = content.replace(operation.oldString, operation.newString);
+      }
+      await fs.writeFile(normalizedPath, content, options.encoding || DEFAULT_ENCODING);
+      import_logger.logger.debug(`File edited: ${normalizedPath} (${occurrences} replacements)`);
+      return {
+        success: true,
+        path: normalizedPath,
+        changesCount: occurrences,
+        backupPath
+      };
+    } catch (error) {
+      throw import_errors.FileSystemError.editFailed(
+        normalizedPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Create a backup of a file
+   */
+  async createBackup(filePath) {
+    const backupDir = path.resolve(
+      this.config.workingDirectory || process.cwd(),
+      this.config.backupPath
+    );
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const basename = path.basename(filePath);
+    const backupFilename = `${basename}.${timestamp}.backup`;
+    const backupPath = path.join(backupDir, backupFilename);
+    try {
+      await fs.mkdir(backupDir, { recursive: true });
+      await fs.copyFile(filePath, backupPath);
+      import_logger.logger.debug(`Backup created: ${backupPath}`);
+      await this.cleanupOldBackups();
+      return backupPath;
+    } catch (error) {
+      throw import_errors.FileSystemError.backupFailed(
+        filePath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Clean up old backup files based on retention policy
+   */
+  async cleanupOldBackups() {
+    if (!this.config.enableBackups) {
+      return 0;
+    }
+    const backupDir = path.resolve(
+      this.config.workingDirectory || process.cwd(),
+      this.config.backupPath
+    );
+    try {
+      await fs.access(backupDir);
+    } catch {
+      return 0;
+    }
+    const cutoffDate = new Date(
+      Date.now() - this.config.backupRetentionDays * 24 * 60 * 60 * 1e3
+    );
+    let deletedCount = 0;
+    try {
+      const files = await fs.readdir(backupDir);
+      const backupFiles = files.filter((file) => file.endsWith(".backup"));
+      for (const file of backupFiles) {
+        const filePath = path.join(backupDir, file);
+        try {
+          const stats = await fs.stat(filePath);
+          if (stats.mtime < cutoffDate) {
+            await fs.unlink(filePath);
+            deletedCount++;
+            import_logger.logger.debug(`Cleaned up old backup: ${file}`);
+          }
+        } catch (error) {
+          import_logger.logger.warn(
+            `Failed to process backup file ${file}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      if (deletedCount > 0) {
+        import_logger.logger.info(`Backup cleanup: removed ${deletedCount} old backup files`);
+      }
+      return deletedCount;
+    } catch (error) {
+      import_logger.logger.warn(
+        `Failed to cleanup backup directory: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return 0;
+    }
+  }
+  /**
+   * Get service configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Check if a path is allowed
+   */
+  isPathAllowed(filePath) {
+    const validation = this.pathValidator.validatePath(filePath);
+    return validation.isValid;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSystemService
+});

package/dist/filesystem/filesystem-service.d.ts

@@ -0,0 +1,57 @@
+/**
+ * FileSystem Service
+ *
+ * Secure file system operations for Dexto internal tools
+ */
+import { FileSystemConfig, FileContent, ReadFileOptions, GlobOptions, GlobResult, GrepOptions, SearchResult, WriteFileOptions, WriteResult, EditFileOptions, EditResult, EditOperation } from './types.js';
+/**
+ * FileSystemService - Handles all file system operations with security checks
+ * TODO: Add tests for this class
+ */
+export declare class FileSystemService {
+    private config;
+    private pathValidator;
+    private initialized;
+    constructor(config?: Partial<FileSystemConfig>);
+    /**
+     * Initialize the service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Read a file with validation and size limits
+     */
+    readFile(filePath: string, options?: ReadFileOptions): Promise<FileContent>;
+    /**
+     * Find files matching a glob pattern
+     */
+    globFiles(pattern: string, options?: GlobOptions): Promise<GlobResult>;
+    /**
+     * Search for content in files (grep-like functionality)
+     */
+    searchContent(pattern: string, options?: GrepOptions): Promise<SearchResult>;
+    /**
+     * Write content to a file
+     */
+    writeFile(filePath: string, content: string, options?: WriteFileOptions): Promise<WriteResult>;
+    /**
+     * Edit a file by replacing text
+     */
+    editFile(filePath: string, operation: EditOperation, options?: EditFileOptions): Promise<EditResult>;
+    /**
+     * Create a backup of a file
+     */
+    private createBackup;
+    /**
+     * Clean up old backup files based on retention policy
+     */
+    cleanupOldBackups(): Promise<number>;
+    /**
+     * Get service configuration
+     */
+    getConfig(): Readonly<FileSystemConfig>;
+    /**
+     * Check if a path is allowed
+     */
+    isPathAllowed(filePath: string): boolean;
+}
+//# sourceMappingURL=filesystem-service.d.ts.map

package/dist/filesystem/filesystem-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-service.d.ts","sourceRoot":"","sources":["../../src/filesystem/filesystem-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EACH,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EAEZ,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,aAAa,EAGhB,MAAM,YAAY,CAAC;AAUpB;;;GAGG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,WAAW,CAAkB;gBAEzB,MAAM,GAAE,OAAO,CAAC,gBAAgB,CAAM;IAgBlD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BjC;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,WAAW,CAAC;IA+ErF;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAwEhF;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAqGtF;;OAEG;IACG,SAAS,CACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC/B,OAAO,CAAC,WAAW,CAAC;IA0DvB;;OAEG;IACG,QAAQ,CACV,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,aAAa,EACxB,OAAO,GAAE,eAAoB,GAC9B,OAAO,CAAC,UAAU,CAAC;IAoEtB;;OAEG;YACW,YAAY;IA6B1B;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAwD1C;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,gBAAgB,CAAC;IAIvC;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAI3C"}