@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/utils/CleanupManager.js

@@ -0,0 +1,262 @@
+import logger from '../services/LoggingService.js';
+
+/**
+ * Cleanup Manager
+ * Centralizes and coordinates cleanup of resources during graceful shutdown
+ * Ensures resources are cleaned up in reverse order of registration (LIFO)
+ */
+export class CleanupManager {
+  constructor() {
+    /**
+     * Array of registered resources
+     * @type {Array<{name: string, resource: any, cleanupFn: Function}>}
+     */
+    this.resources = [];
+
+    /**
+     * Flag to prevent concurrent cleanup
+     * @type {boolean}
+     */
+    this.cleanupInProgress = false;
+
+    /**
+     * Timestamp when cleanup started
+     * @type {number|null}
+     */
+    this.cleanupStartTime = null;
+
+    /**
+     * Cleanup timeout duration (30 seconds)
+     * @type {number}
+     */
+    this.cleanupTimeout = 30000;
+
+    /**
+     * Results of cleanup operations
+     * @type {Array<{name: string, success: boolean, duration: number, error: string|null}>}
+     */
+    this.cleanupResults = [];
+  }
+
+  /**
+   * Register a resource to be cleaned up during shutdown
+   * Resources are cleaned up in reverse order (LIFO)
+   * @param {string} name - Name of the resource
+   * @param {any} resource - The resource object
+   * @param {Function} cleanupFn - Async function to clean up the resource
+   * @returns {void}
+   */
+  registerResource(name, resource, cleanupFn) {
+    if (!name || typeof name !== 'string') {
+      logger.warn('CleanupManager: Resource name must be a non-empty string');
+      return;
+    }
+
+    if (typeof cleanupFn !== 'function') {
+      logger.warn(
+        `CleanupManager: Cleanup function for "${name}" is not a function`,
+      );
+      return;
+    }
+
+    this.resources.push({
+      name,
+      resource,
+      cleanupFn,
+    });
+
+    logger.debug(`CleanupManager: Registered resource "${name}"`);
+  }
+
+  /**
+   * Perform cleanup of all registered resources in reverse order
+   * @param {string} reason - Reason for cleanup (e.g., 'SIGINT', 'SIGTERM')
+   * @returns {Promise<Object>} Cleanup results
+   */
+  async performCleanup(reason = 'unknown') {
+    // Prevent concurrent cleanup operations
+    if (this.cleanupInProgress) {
+      logger.warn(
+        `CleanupManager: Cleanup already in progress, skipping new cleanup request`,
+      );
+      return {
+        success: false,
+        reason: 'Cleanup already in progress',
+        results: this.cleanupResults,
+      };
+    }
+
+    this.cleanupInProgress = true;
+    this.cleanupStartTime = Date.now();
+    this.cleanupResults = [];
+
+    logger.info(
+      `CleanupManager: Starting cleanup sequence (reason: ${reason})`,
+    );
+
+    // Set timeout for cleanup
+    const cleanupTimeoutId = setTimeout(() => {
+      logger.error('CleanupManager: Cleanup timeout reached, forcing exit');
+    }, this.cleanupTimeout);
+
+    // Clean up resources in reverse order (LIFO)
+    for (let i = this.resources.length - 1; i >= 0; i--) {
+      const { name, cleanupFn } = this.resources[i];
+      const startTime = Date.now();
+
+      try {
+        logger.debug(`CleanupManager: Cleaning up resource "${name}"...`);
+
+        // Execute cleanup function
+        const result = cleanupFn();
+
+        // Handle both sync and async cleanup functions
+        if (result && typeof result.catch === 'function') {
+          await result;
+        }
+
+        const duration = Date.now() - startTime;
+        this.cleanupResults.push({
+          name,
+          success: true,
+          duration,
+          error: null,
+        });
+
+        logger.info(
+          `CleanupManager: Successfully cleaned up "${name}" (${duration}ms)`,
+        );
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        this.cleanupResults.push({
+          name,
+          success: false,
+          duration,
+          error: error.message,
+        });
+
+        logger.error(
+          `CleanupManager: Error cleaning up "${name}": ${error.message}`,
+        );
+      }
+    }
+
+    // Clear timeout
+    clearTimeout(cleanupTimeoutId);
+
+    const totalDuration = Date.now() - this.cleanupStartTime;
+    const successCount = this.cleanupResults.filter((r) => r.success).length;
+    const failureCount = this.cleanupResults.filter((r) => !r.success).length;
+
+    logger.info(
+      `CleanupManager: Cleanup complete (${totalDuration}ms, ${successCount} successful, ${failureCount} failed)`,
+    );
+
+    return {
+      success: failureCount === 0,
+      reason,
+      totalDuration,
+      successCount,
+      failureCount,
+      results: this.cleanupResults,
+    };
+  }
+
+  /**
+   * Clear all registered resources without cleaning them up
+   * Use this for resetting the cleanup manager
+   * @returns {void}
+   */
+  clearResources() {
+    const count = this.resources.length;
+    this.resources = [];
+    logger.debug(`CleanupManager: Cleared ${count} registered resources`);
+  }
+
+  /**
+   * Get the number of registered resources
+   * @returns {number} Number of registered resources
+   */
+  getResourceCount() {
+    return this.resources.length;
+  }
+
+  /**
+   * Get details of all registered resources
+   * @returns {Array<string>} Array of resource names
+   */
+  getResourceNames() {
+    return this.resources.map((r) => r.name);
+  }
+
+  /**
+   * Check if cleanup is in progress
+   * @returns {boolean} True if cleanup is currently running
+   */
+  isCleanupInProgress() {
+    return this.cleanupInProgress;
+  }
+
+  /**
+   * Get cleanup results from last operation
+   * @returns {Array<Object>} Array of cleanup results
+   */
+  getCleanupResults() {
+    return [...this.cleanupResults];
+  }
+
+  /**
+   * Generate a formatted report of the cleanup operation
+   * @returns {string} Formatted cleanup report
+   */
+  generateCleanupReport() {
+    if (this.cleanupResults.length === 0) {
+      return 'No cleanup operations recorded';
+    }
+
+    const totalDuration = this.cleanupStartTime
+      ? Date.now() - this.cleanupStartTime
+      : 0;
+
+    let report =
+      '\n═══════════════════════════════════════════════════════════\n';
+    report += 'CLEANUP OPERATION REPORT\n';
+    report += '═══════════════════════════════════════════════════════════\n\n';
+
+    for (const result of this.cleanupResults) {
+      const status = result.success ? '✅' : '❌';
+      report += `${status} ${result.name}\n`;
+      report += `   Duration: ${result.duration}ms\n`;
+      if (result.error) {
+        report += `   Error: ${result.error}\n`;
+      }
+      report += '\n';
+    }
+
+    const successCount = this.cleanupResults.filter((r) => r.success).length;
+    const failureCount = this.cleanupResults.filter((r) => !r.success).length;
+
+    report += '─────────────────────────────────────────────────────────────\n';
+    report += `Total Duration: ${totalDuration}ms\n`;
+    report += `Successful: ${successCount}\n`;
+    report += `Failed: ${failureCount}\n`;
+    report += '═══════════════════════════════════════════════════════════\n';
+
+    return report;
+  }
+
+  /**
+   * Reset cleanup state (useful for testing)
+   * @returns {void}
+   */
+  reset() {
+    this.cleanupInProgress = false;
+    this.cleanupStartTime = null;
+    this.cleanupResults = [];
+    logger.debug('CleanupManager: Reset to initial state');
+  }
+}
+
+// Export singleton instance
+export const cleanupManager = new CleanupManager();
+export default cleanupManager;

package/.claude/worktrees/agent-multi-profile/src/utils/FileOperations.js

@@ -0,0 +1,192 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * File Operations Utility
+ * Provides optimized file system operations with batching
+ */
+export class FileOperations {
+  /**
+   * Batch read file stats for multiple files
+   * @param {string[]} filePaths - Array of file paths
+   * @returns {Array} Array of results with path, stats, and error
+   */
+  static batchReadFileStats(filePaths) {
+    const results = [];
+
+    for (const filePath of filePaths) {
+      try {
+        const stats = fs.statSync(filePath);
+        results.push({ path: filePath, stats, error: null });
+      } catch (error) {
+        results.push({ path: filePath, stats: null, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Check if file exists synchronously
+   * @param {string} filePath - Path to file
+   * @returns {boolean} True if file exists
+   */
+  static fileExists(filePath) {
+    try {
+      return fs.existsSync(filePath);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get file size safely
+   * @param {string} filePath - Path to file
+   * @returns {number|null} File size in bytes or null if error
+   */
+  static getFileSize(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.size;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get file modification time
+   * @param {string} filePath - Path to file
+   * @returns {Date|null} Modification time or null if error
+   */
+  static getFileModTime(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.mtime;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get file stats
+   * @param {string} filePath - Path to file
+   * @returns {Object|null} File stats or null if error
+   */
+  static getFileStats(filePath) {
+    try {
+      return fs.statSync(filePath);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Create directory recursively if it doesn't exist
+   * @param {string} dirPath - Directory path
+   * @returns {boolean} True if successful
+   */
+  static ensureDirectory(dirPath) {
+    try {
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Read file with error handling
+   * @param {string} filePath - Path to file
+   * @param {string} encoding - File encoding (default: 'utf-8')
+   * @returns {string|null} File content or null if error
+   */
+  static readFileContent(filePath, encoding = 'utf-8') {
+    try {
+      return fs.readFileSync(filePath, encoding);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Write file with error handling and directory creation
+   * @param {string} filePath - Path to file
+   * @param {string} content - Content to write
+   * @param {string} encoding - File encoding (default: 'utf-8')
+   * @returns {boolean} True if successful
+   */
+  static writeFileContent(filePath, content, encoding = 'utf-8') {
+    try {
+      const dir = path.dirname(filePath);
+      this.ensureDirectory(dir);
+      fs.writeFileSync(filePath, content, encoding);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Append to file with error handling
+   * @param {string} filePath - Path to file
+   * @param {string} content - Content to append
+   * @param {string} encoding - File encoding (default: 'utf-8')
+   * @returns {boolean} True if successful
+   */
+  static appendToFile(filePath, content, encoding = 'utf-8') {
+    try {
+      fs.appendFileSync(filePath, content, encoding);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * List all files in a directory (non-recursive)
+   * @param {string} dirPath - Directory path
+   * @param {Object} options - Options { excludePattern, onlyPdf }
+   * @returns {Array} Array of file paths
+   */
+  static listFilesInDirectory(dirPath, options = {}) {
+    try {
+      const {
+        excludePattern = /(^|[\/\\])\.|node_modules|\.git/,
+        onlyPdf = false,
+      } = options;
+
+      if (!fs.existsSync(dirPath)) {
+        return [];
+      }
+
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const files = [];
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+
+        // Skip excluded patterns
+        if (excludePattern && excludePattern.test(fullPath)) {
+          continue;
+        }
+
+        // Only include files, not directories
+        if (entry.isFile()) {
+          // If onlyPdf is true, filter for PDF files
+          if (onlyPdf && !entry.name.toLowerCase().endsWith('.pdf')) {
+            continue;
+          }
+          files.push(fullPath);
+        }
+      }
+
+      return files;
+    } catch (error) {
+      return [];
+    }
+  }
+}
+
+export default FileOperations;

package/.claude/worktrees/agent-multi-profile/src/utils/FileSanitizer.js

@@ -0,0 +1,99 @@
+import path from 'path';
+
+/**
+ * File Sanitization Utility
+ * Handles filename sanitization with caching for performance
+ */
+export class FileSanitizer {
+  constructor() {
+    this.cache = new Map();
+    this.patterns = [
+      [/[áàâäãåāăą]/gi, 'a'],
+      [/[éèêëēĕėę]/gi, 'e'],
+      [/[íìîïīĭį]/gi, 'i'],
+      [/[óòôöõōŏő]/gi, 'o'],
+      [/[úùûüūŭů]/gi, 'u'],
+      [/[ñň]/gi, 'n'],
+      [/[ç]/gi, 'c'],
+      [/[ý]/gi, 'y'],
+      [/[멕]/g, 'meok'],
+      [/[시]/g, 'si'],
+      [/[코]/g, 'ko'],
+      [/[용]/g, 'yong'],
+      [/[가-힣]/g, 'kr'],
+      [/[\u0300-\u036f]/g, ''],
+      [/[\\?%*:|"<>[\]~`^]/g, '-'],
+      [/[{}]/g, '-'],
+      [/[&]/g, 'and'],
+      [/[()]/g, ''],
+      [/\s+/g, '-'],
+      [/-+/g, '-'],
+      [/^-+|-+$/g, ''],
+      [/^\.+/, ''],
+      [/[^\w.-]/g, ''],
+    ];
+  }
+
+  /**
+   * Sanitize a filename for safe storage
+   * @param {string} fileName - Original filename
+   * @returns {string} Sanitized filename
+   */
+  sanitizeFileName(fileName) {
+    if (this.cache.has(fileName)) {
+      return this.cache.get(fileName);
+    }
+
+    const ext = path.extname(fileName);
+    const nameWithoutExt = path.basename(fileName, ext);
+
+    // If already clean, return as-is
+    if (/^[a-zA-Z0-9._-]+$/.test(nameWithoutExt)) {
+      const result = fileName;
+      this.cache.set(fileName, result);
+      return result;
+    }
+
+    let sanitized = nameWithoutExt.normalize('NFD');
+
+    // Apply all sanitization patterns
+    for (const [pattern, replacement] of this.patterns) {
+      sanitized = sanitized.replace(pattern, replacement);
+    }
+
+    // Additional cleanup
+    sanitized = sanitized
+      .replace(/~/g, '-')
+      .replace(/\s+/g, '-')
+      .replace(/\.+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '');
+
+    if (!sanitized) {
+      sanitized = 'unnamed_file';
+    }
+
+    const result = sanitized + ext;
+    this.cache.set(fileName, result);
+    return result;
+  }
+
+  /**
+   * Clear the sanitization cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  /**
+   * Get cache size for monitoring
+   * @returns {number} Number of cached entries
+   */
+  getCacheSize() {
+    return this.cache.size;
+  }
+}
+
+// Export singleton instance
+export const fileSanitizer = new FileSanitizer();
+export default fileSanitizer;