indusagi-coding-agent 0.1.59 → 0.1.60

package/dist/helpers/path-validator.d.ts

@@ -1,603 +0,0 @@
-/**
- * @fileoverview Path Validation and Normalization Utilities
- *
- * **SECURITY FOCUSED**: This module provides secure path handling to prevent
- * common path traversal and directory escape vulnerabilities.
- *
- * Common Path Vulnerabilities Addressed:
- * - Directory traversal (../../) attacks
- * - Symlink following (TOCTOU - Time-of-Check-Time-of-Use)
- * - Path normalization bypasses
- * - Null byte injection (\0)
- * - Mixed slash handling (Windows vs Unix)
- * - Relative path escape patterns
- *
- * SECURITY PRINCIPLES:
- * 1. Always validate and normalize paths before file operations
- * 2. Prevent directory traversal with ".." and "." resolution
- * 3. Resolve symlinks to detect jail breaks
- * 4. Whitelist allowed directories when possible
- * 5. Never trust user-supplied paths directly
- *
- * This module provides type-safe, well-tested functions for:
- * - Path safety validation and sanitization
- * - Secure path resolution and normalization
- * - Path component extraction
- * - Cross-platform path handling
- * - Symlink and traversal detection
- *
- * @example
- * // SAFE: Validate before use
- * if (isPathSafe(userPath, baseDir)) {
- *   const fullPath = joinSafe(baseDir, userPath);
- *   // Safe to use fullPath
- * }
- *
- * @example
- * // UNSAFE: Direct concatenation - vulnerable to path traversal
- * const fullPath = baseDir + '/' + userPath; // DON'T DO THIS
- *
- * @example
- * // SAFE: Use validation helpers
- * validatePath(userPath, { allowRelative: true, base: '/app/uploads' });
- * const dir = getDirName(path);
- * const name = getFileName(path);
- */
-/**
- * Path validation options
- */
-export interface PathValidationOptions {
-    /** Base directory for relative path resolution */
-    base?: string;
-    /** Allow relative paths (default: false) */
-    allowRelative?: boolean;
-    /** Allow symlinks (default: false - security) */
-    allowSymlinks?: boolean;
-    /** Allow hidden files starting with . (default: false) */
-    allowHidden?: boolean;
-    /** Maximum allowed path length in characters (default: 4096) */
-    maxLength?: number;
-}
-/**
- * Path validation result with detailed information
- */
-export interface PathValidationResult {
-    /** Whether the path is valid */
-    valid: boolean;
-    /** Error message if invalid */
-    error?: string;
-    /** Resolved absolute path */
-    resolved?: string;
-    /** Whether path contains symlinks */
-    hasSymlinks?: boolean;
-    /** Whether path is within allowed base */
-    isWithinBase?: boolean;
-}
-/**
- * SECURITY: Checks if a path is safe for operations
- *
- * This is the primary security function - use before ANY file operation.
- * Prevents:
- * - Directory traversal (../../etc/passwd)
- * - Absolute path bypass
- * - Symlink attacks
- * - Path normalization bypass
- *
- * @param pathStr - Path to validate
- * @param baseDir - Optional base directory for restriction
- * @returns true if path is safe, false otherwise
- *
- * @example
- * // SAFE: Check user-supplied path
- * const userInput = req.query.file;
- * if (isPathSafe(userInput, '/app/uploads')) {
- *   const fullPath = path.join('/app/uploads', userInput);
- *   const data = fs.readFileSync(fullPath); // Safe
- * }
- *
- * @example
- * // UNSAFE: Allows directory traversal
- * const fullPath = path.join('/app/uploads', userInput); // DON'T - no validation
- * const data = fs.readFileSync(fullPath);
- *
- * @example
- * // UNSAFE PATHS (returns false)
- * isPathSafe('../../../etc/passwd') // true -> prevents escape
- * isPathSafe('/etc/passwd', '/app') // false -> absolute outside base
- * isPathSafe('../../file.txt') // false -> traversal attempt
- * isPathSafe('./file.txt', '/app') // true -> safe relative
- *
- * @edge-cases
- * - Empty path returns true (cwd)
- * - Resolves .. but only within base directory
- * - Strips null bytes (\0) - potential injection
- * - Windows paths with backslashes normalized to forward slashes
- *
- * @security-notes
- * - Use this function BEFORE every file operation with user input
- * - Does NOT check file existence
- * - For maximum security, use with baseDir parameter
- * - Be aware of TOCTOU: file can change between check and use
- */
-export declare function isPathSafe(pathStr: string, baseDir?: string): boolean;
-/**
- * SECURITY: Comprehensive path validation with detailed results
- *
- * Use this for detailed validation and error reporting.
- * Returns structured result with specific error information.
- *
- * @param pathStr - Path to validate
- * @param options - Validation options
- * @returns Detailed validation result
- *
- * @example
- * // Validate with full options
- * const result = validatePath(userPath, {
- *   base: '/app/uploads',
- *   allowRelative: true,
- *   allowSymlinks: false,
- *   maxLength: 255,
- * });
- *
- * if (!result.valid) {
- *   console.error(result.error);
- *   // Reject the request
- * }
- *
- * @example
- * // Check for symlinks and traversal
- * const result = validatePath('../../secret.txt', {
- *   base: '/app/data',
- *   allowSymlinks: false,
- * });
- * // result.valid === false
- * // result.error mentions directory traversal
- *
- * @edge-cases
- * - Symlink detection requires filesystem access
- * - May be expensive for deeply nested paths
- * - Resolved path is provided even if invalid (for debugging)
- */
-export declare function validatePath(pathStr: string, options?: PathValidationOptions): PathValidationResult;
-/**
- * SECURITY: Normalizes a path to prevent traversal bypass
- *
- * Removes redundant separators and resolves . and .. patterns.
- * Critical for preventing normalized path bypass attacks.
- *
- * @param pathStr - Path to normalize
- * @returns Normalized path
- *
- * @example
- * normalizePath('./foo/../bar') // "bar"
- * normalizePath('foo//bar') // "foo/bar"
- * normalizePath('foo/./bar') // "foo/bar"
- * normalizePath('\\foo\\bar') // "foo/bar" (Windows)
- * normalizePath('') // "."
- * normalizePath('/absolute/./path') // "/absolute/path"
- * normalizePath('foo/../../bar') // "../bar"
- *
- * @edge-cases
- * - Normalizes both forward and backslashes (Windows/Unix)
- * - Preserves absolute path status
- * - Collapses .. patterns (may escape if outside boundary)
- * - Use isPathSafe() to prevent escape with .. patterns
- *
- * @security-notes
- * - This ALONE doesn't prevent attacks
- * - Use with isPathSafe() for full protection
- * - Directory traversal requires checking against base dir
- */
-export declare function normalizePath(pathStr: string): string;
-/**
- * SECURITY: Safely joins path segments with base directory
- *
- * Validates each segment against directory traversal before joining.
- * Preferred over path.join() for security-sensitive code.
- *
- * @param base - Base directory (absolute path)
- * @param ...segments - Path segments to join
- * @returns Safely joined path, or throws if unsafe
- *
- * @example
- * // SAFE: Returns '/app/uploads/user-file.txt'
- * joinSafe('/app/uploads', 'user-file.txt')
- *
- * @example
- * // UNSAFE: Throws error
- * try {
- *   joinSafe('/app/uploads', '../../etc/passwd')
- * } catch (e) {
- *   console.log('Traversal attempt blocked')
- * }
- *
- * @example
- * // SAFE: Multiple segments
- * joinSafe('/app', 'uploads', 'users', 'file.txt')
- * // -> '/app/uploads/users/file.txt'
- *
- * @example
- * // UNSAFE: Symlink in path (if allowSymlinks: false)
- * joinSafe('/app', './link-to-escape')
- * // throws if link escapes /app
- *
- * @throws Error if any segment is unsafe for the given base
- *
- * @security-notes
- * - Base directory must be absolute
- * - Each segment is validated independently
- * - Throws on traversal attempts (fail-safe)
- * - Suitable for file server implementations
- */
-export declare function joinSafe(base: string, ...segments: string[]): string;
-/**
- * SECURITY: Resolves a path safely relative to a base directory
- *
- * Like joinSafe but returns resolved path. Better for cases
- * where the target path must be within base (sandboxing).
- *
- * @param pathStr - Path to resolve
- * @param baseDir - Base directory for restriction
- * @returns Resolved absolute path
- *
- * @example
- * resolvePath('uploads/file.txt', '/app')
- * // -> '/app/uploads/file.txt'
- *
- * @example
- * // Throws: attempts escape
- * resolvePath('../../etc/passwd', '/app')
- *
- * @throws Error if path attempts to escape base directory
- *
- * @security-notes
- * - For sandboxing / jail implementations
- * - Always validate user input
- * - Return error, don't expose real paths
- */
-export declare function resolvePath(pathStr: string, baseDir: string): string;
-/**
- * Returns whether a path is absolute (not relative)
- *
- * Works consistently across Windows and Unix.
- *
- * @param pathStr - Path to check
- * @returns true if absolute, false if relative
- *
- * @example
- * isAbsolutePath('/home/user') // true
- * isAbsolutePath('C:\\Users\\User') // true (Windows)
- * isAbsolutePath('./relative') // false
- * isAbsolutePath('relative/path') // false
- * isAbsolutePath('') // false
- *
- * @edge-cases
- * - Windows drive letters (C:\) are absolute
- * - UNC paths (\\server\share) are absolute
- * - Relative paths with ./ prefix are still relative
- */
-export declare function isAbsolutePath(pathStr: string): boolean;
-/**
- * Returns whether a path is relative (not absolute)
- *
- * Inverse of isAbsolutePath.
- *
- * @param pathStr - Path to check
- * @returns true if relative, false if absolute
- *
- * @example
- * isRelativePath('./file') // true
- * isRelativePath('file.txt') // true
- * isRelativePath('dir/file') // true
- * isRelativePath('/absolute') // false
- * isRelativePath('') // true
- *
- * @edge-cases
- * - Relative paths may escape with .. patterns
- * - Empty string is technically relative
- */
-export declare function isRelativePath(pathStr: string): boolean;
-/**
- * Extracts the file name from a path (including extension)
- *
- * Safe extraction of filename from path.
- *
- * @param pathStr - Full path
- * @returns File name without directory
- *
- * @example
- * getFileName('/home/user/file.txt') // "file.txt"
- * getFileName('file.txt') // "file.txt"
- * getFileName('/home/user/') // "" (directory path)
- * getFileName('/home/user/doc.tar.gz') // "doc.tar.gz"
- * getFileName('') // ""
- * getFileName('.gitignore') // ".gitignore"
- *
- * @edge-cases
- * - Returns empty string for directory paths
- * - Preserves multiple extensions
- */
-export declare function getFileName(pathStr: string): string;
-/**
- * Extracts the directory path without the file name
- *
- * Returns the directory containing the file.
- *
- * @param pathStr - Full path
- * @returns Directory path
- *
- * @example
- * getDirName('/home/user/file.txt') // "/home/user"
- * getDirName('file.txt') // "." (current directory)
- * getDirName('/home/user/') // "/home/user"
- * getDirName('') // "."
- * getDirName('/') // "/" (root)
- *
- * @edge-cases
- * - Returns "." for relative paths without directory
- * - Trailing slashes are normalized
- */
-export declare function getDirName(pathStr: string): string;
-/**
- * Extracts the file extension (without the dot)
- *
- * Gets the extension of a file.
- *
- * @param pathStr - File path
- * @returns Extension without dot, or empty string
- *
- * @example
- * getFileExtension('/home/user/file.txt') // "txt"
- * getFileExtension('archive.tar.gz') // "gz"
- * getFileExtension('file') // ""
- * getFileExtension('.gitignore') // ""
- * getFileExtension('/path/.hidden') // ""
- * getFileExtension('') // ""
- *
- * @edge-cases
- * - Hidden files starting with . don't have extension
- * - Returns only the last extension (use custom parser for .tar.gz)
- * - Case preserved (not lowercased)
- */
-export declare function getFileExtension(pathStr: string): string;
-/**
- * Gets file name without extension
- *
- * Returns just the base file name.
- *
- * @param pathStr - File path
- * @returns File name without extension
- *
- * @example
- * getBaseName('/home/user/file.txt') // "file"
- * getBaseName('document.pdf') // "document"
- * getBaseName('archive.tar.gz') // "archive.tar" (only removes last ext)
- * getBaseName('noextension') // "noextension"
- * getBaseName('') // ""
- *
- * @edge-cases
- * - Only removes the last extension
- * - For .tar.gz, returns "archive.tar"
- */
-export declare function getBaseName(pathStr: string): string;
-/**
- * SECURITY: Compares two paths for equality
- *
- * Safe comparison that handles path variations (normalization, case sensitivity).
- * Important for security checks.
- *
- * @param pathA - First path
- * @param pathB - Second path
- * @param caseSensitive - Case-sensitive comparison (default: true on Unix, false on Windows)
- * @returns true if paths refer to the same location
- *
- * @example
- * comparePaths('/home/user', '/home/user') // true
- * comparePaths('/home/user/', '/home/user') // true (trailing slash removed)
- * comparePaths('./file', 'file') // true (when run from same directory)
- * comparePaths('/HOME/user', '/home/user', false) // true (case-insensitive)
- * comparePaths('/home/user', '/other/path') // false
- *
- * @edge-cases
- * - Normalizes paths before comparison
- * - Case sensitivity depends on filesystem
- * - Relative paths resolved to current directory
- *
- * @security-notes
- * - Use for validating against whitelists
- * - Prevents bypass via path normalization tricks
- */
-export declare function comparePaths(pathA: string, pathB: string, caseSensitive?: boolean): boolean;
-/**
- * Checks if a path is contained within a base directory
- *
- * Useful for sandboxing and access control.
- *
- * @param pathStr - Path to check
- * @param baseDir - Base directory
- * @returns true if pathStr is within baseDir
- *
- * @example
- * isPathWithinBase('/home/user/file.txt', '/home/user') // true
- * isPathWithinBase('/home/user/docs/file.txt', '/home/user') // true
- * isPathWithinBase('/home/user', '/home/user/subdir') // false
- * isPathWithinBase('/etc/passwd', '/home/user') // false
- * isPathWithinBase('/home/user/../etc/passwd', '/home/user') // false
- *
- * @edge-cases
- * - Resolves paths before comparison
- * - Trailing slashes ignored
- * - Case-insensitive on Windows
- *
- * @security-notes
- * - Critical for file upload handlers
- * - Prevents directory traversal in validation
- * - Use with normalizePath() for defense in depth
- */
-export declare function isPathWithinBase(pathStr: string, baseDir: string): boolean;
-/**
- * Detects if a path contains directory traversal patterns
- *
- * Simple pattern-based detection for common attack vectors.
- *
- * @param pathStr - Path to check
- * @returns true if path contains traversal patterns
- *
- * @example
- * hasTraversalPattern('../../etc/passwd') // true
- * hasTraversalPattern('file.txt') // false
- * hasTraversalPattern('./file.txt') // false
- * hasTraversalPattern('..\\..\\windows\\system32') // true (Windows)
- * hasTraversalPattern('foo/..') // true
- * hasTraversalPattern('') // false
- *
- * @edge-cases
- * - Detects both / and \ separators
- * - Catches .. patterns anywhere in path
- * - May have false positives (validate with isPathSafe)
- *
- * @security-notes
- * - Use as quick check before detailed validation
- * - Not sufficient alone - use isPathSafe() for security
- */
-export declare function hasTraversalPattern(pathStr: string): boolean;
-/**
- * Detects if a path contains null bytes (injection attempt)
- *
- * Null bytes can truncate paths in C string libraries.
- * Critical security check for some codebases.
- *
- * @param pathStr - Path to check
- * @returns true if path contains null bytes
- *
- * @example
- * hasNullBytes('file.txt') // false
- * hasNullBytes('file.txt\0.jsp') // true
- * hasNullBytes('') // false
- *
- * @edge-cases
- * - Only relevant for C-based systems
- * - Node.js handles this automatically in most cases
- */
-export declare function hasNullBytes(pathStr: string): boolean;
-/**
- * Sanitizes a path by removing dangerous characters
- *
- * Removes null bytes, excess whitespace, and potentially problematic characters.
- * Use for defensive programming.
- *
- * @param pathStr - Path to sanitize
- * @returns Sanitized path
- *
- * @example
- * sanitizePath('file.txt') // "file.txt"
- * sanitizePath('file.txt\0.jsp') // "file.txt.jsp"
- * sanitizePath('file  name.txt') // "file  name.txt"
- * sanitizePath('') // ""
- *
- * @edge-cases
- * - Doesn't validate path, only removes dangerous chars
- * - Use with isPathSafe() for full validation
- */
-export declare function sanitizePath(pathStr: string): string;
-/**
- * Gets the relative path between two paths
- *
- * Safe version of path.relative with error handling.
- *
- * @param from - Starting path
- * @param to - Target path
- * @returns Relative path from 'from' to 'to'
- *
- * @example
- * getRelativePath('/home/user', '/home/user/file.txt')
- * // "file.txt"
- *
- * getRelativePath('/home/user/docs', '/home/user/file.txt')
- * // "../file.txt"
- *
- * getRelativePath('/home', '/var')
- * // "../../var"
- *
- * @edge-cases
- * - Empty paths treated as current directory
- * - May produce .. patterns
- */
-export declare function getRelativePath(from: string, to: string): string;
-/**
- * Configuration for path list operations
- */
-export interface PathListOptions {
-    /** Base directory for validation */
-    base?: string;
-    /** Filter out unsafe paths (default: true) */
-    filterUnsafe?: boolean;
-    /** Normalize paths (default: true) */
-    normalize?: boolean;
-}
-/**
- * SECURITY: Validates a list of paths
- *
- * Batch validation useful for multi-file operations.
- *
- * @param paths - Array of paths to validate
- * @param options - Validation options
- * @returns Array of valid paths
- *
- * @example
- * validatePaths(userPaths, {
- *   base: '/app/uploads',
- *   filterUnsafe: true,
- * })
- *
- * @edge-cases
- * - Filters out duplicates if normalize: true
- * - Returns empty array if no valid paths
- */
-export declare function validatePaths(paths: string[], options?: PathListOptions): string[];
-/**
- * Creates a pattern to detect path variations
- *
- * Useful for accepting different path formats.
- *
- * @param pathStr - Base path
- * @returns Test function for path equivalence
- *
- * @example
- * const isSameFile = createPathMatcher('/home/user/file.txt');
- * isSameFile('/home/user/file.txt') // true
- * isSameFile('/home/user//file.txt') // true
- * isSameFile('/home/user/./file.txt') // true
- * isSameFile('~/file.txt') // false (if ~ not expanded)
- *
- * @edge-cases
- * - Doesn't expand ~ (home directory)
- * - Case-sensitive on Unix, insensitive on Windows
- */
-export declare function createPathMatcher(pathStr: string): (other: string) => boolean;
-/**
- * Checks if a file path looks like a suspicious upload
- *
- * Detects common file upload attack patterns.
- *
- * @param pathStr - File path to check
- * @returns Array of detected issues (empty if safe)
- *
- * @example
- * detectUploadThreats('shell.php.txt') // ['suspicious_extension_combo']
- * detectUploadThreats('../../../etc/passwd') // ['traversal_pattern']
- * detectUploadThreats('file.txt') // []
- * detectUploadThreats('.htaccess') // ['hidden_file']
- *
- * @edge-cases
- * - Uses heuristics, not definitive
- * - May have false positives
- * - Combine with extension whitelisting
- *
- * @security-notes
- * - Use as additional layer, not primary validation
- * - Always validate against whitelist of extensions
- * - Store uploads outside web root
- */
-export declare function detectUploadThreats(pathStr: string): string[];
-//# sourceMappingURL=path-validator.d.ts.map

package/dist/helpers/path-validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-validator.d.ts","sourceRoot":"","sources":["../../app/helpers/path-validator.ts"],"names":[],"mappings":"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"}