@within-7/minto 0.4.2 → 0.4.3

package/dist/utils/safePath.js

@@ -1,132 +0,0 @@
-import { realpathSync, existsSync, lstatSync } from "fs";
-import { resolve, isAbsolute, relative, sep, join } from "path";
-function safeResolvePath(inputPath, cwd, allowedRoot) {
-  try {
-    const absolutePath = isAbsolute(inputPath) ? resolve(inputPath) : resolve(cwd, inputPath);
-    let isSymlink = false;
-    let realPath = absolutePath;
-    if (existsSync(absolutePath)) {
-      try {
-        isSymlink = lstatSync(absolutePath).isSymbolicLink();
-        realPath = realpathSync(absolutePath);
-      } catch (e) {
-        realPath = absolutePath;
-      }
-    } else {
-      realPath = findRealPathForNonexistent(absolutePath);
-    }
-    return validateBoundary(realPath, allowedRoot, isSymlink);
-  } catch (e) {
-    return {
-      valid: false,
-      resolvedPath: inputPath,
-      isSymlink: false,
-      error: `Failed to validate path: ${e instanceof Error ? e.message : String(e)}`
-    };
-  }
-}
-function findRealPathForNonexistent(filePath) {
-  try {
-    let currentPath = filePath;
-    let depth = 0;
-    const maxDepth = 50;
-    while (!existsSync(currentPath) && depth < maxDepth) {
-      const parent = resolve(currentPath, "..");
-      if (parent === currentPath) break;
-      currentPath = parent;
-      depth++;
-    }
-    if (existsSync(currentPath)) {
-      const realParent = realpathSync(currentPath);
-      let remaining = filePath.slice(currentPath.length);
-      if (remaining.startsWith(sep)) {
-        remaining = remaining.slice(1);
-      }
-      return remaining ? join(realParent, remaining) : realParent;
-    }
-    return resolve(filePath);
-  } catch (e) {
-    return resolve(filePath);
-  }
-}
-function validateBoundary(resolvedPath, allowedRoot, isSymlink) {
-  let normalizedRoot;
-  try {
-    if (existsSync(allowedRoot)) {
-      normalizedRoot = realpathSync(allowedRoot);
-    } else {
-      normalizedRoot = resolve(allowedRoot);
-    }
-  } catch (e) {
-    normalizedRoot = resolve(allowedRoot);
-  }
-  normalizedRoot = normalizePath(normalizedRoot);
-  const normalizedResolved = normalizePath(resolvedPath);
-  const rel = relative(normalizedRoot, normalizedResolved);
-  if (rel.startsWith("..")) {
-    return {
-      valid: false,
-      resolvedPath,
-      isSymlink,
-      error: `Path escapes sandbox boundary: ${resolvedPath} is outside ${normalizedRoot}`
-    };
-  }
-  if (isAbsolute(rel)) {
-    return {
-      valid: false,
-      resolvedPath,
-      isSymlink,
-      error: `Path is on different drive or root: ${resolvedPath}`
-    };
-  }
-  return {
-    valid: true,
-    resolvedPath,
-    isSymlink
-  };
-}
-function normalizePath(p) {
-  const resolved = resolve(p);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-function hasSymlinksInPath(filePath) {
-  try {
-    const absolutePath = isAbsolute(filePath) ? filePath : resolve(filePath);
-    const parts = absolutePath.split(sep).filter((p) => p);
-    let currentPath = "";
-    for (const part of parts) {
-      if (currentPath) {
-        currentPath = resolve(currentPath, part);
-      } else {
-        currentPath = sep === "\\" ? `${part}\\` : `/${part}`;
-      }
-      if (!existsSync(currentPath)) break;
-      try {
-        if (lstatSync(currentPath).isSymbolicLink()) {
-          return true;
-        }
-      } catch (e) {
-      }
-    }
-    return false;
-  } catch (e) {
-    return false;
-  }
-}
-function getRealPath(filePath) {
-  try {
-    const absolutePath = isAbsolute(filePath) ? filePath : resolve(filePath);
-    if (existsSync(absolutePath)) {
-      return realpathSync(absolutePath);
-    }
-    return absolutePath;
-  } catch (e) {
-    return filePath;
-  }
-}
-export {
-  getRealPath,
-  hasSymlinksInPath,
-  safeResolvePath
-};
-//# sourceMappingURL=safePath.js.map

package/dist/utils/safePath.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/safePath.ts"],
-  "sourcesContent": ["/**\n * Safe Path Resolution Utility\n *\n * Provides secure path resolution with symbolic link tracking and boundary validation.\n * Prevents attackers from escaping sandbox boundaries using symlinks.\n */\n\nimport { realpathSync, existsSync, lstatSync } from 'fs'\nimport { resolve, isAbsolute, relative, sep, join } from 'path'\n\n/**\n * Result of a path validation operation\n */\nexport interface PathValidationResult {\n  /** Whether the path is valid and within boundaries */\n  valid: boolean\n  /** The resolved real path (after following symlinks) */\n  resolvedPath: string\n  /** Whether the path itself is a symbolic link */\n  isSymlink: boolean\n  /** Error message if validation failed */\n  error?: string\n}\n\n/**\n * Safely resolves a path to its real location, tracking symbolic links.\n * Validates that the final resolved path stays within the allowed boundary.\n *\n * @param inputPath The path to resolve (relative or absolute)\n * @param cwd Current working directory for relative path resolution\n * @param allowedRoot The root directory boundary that must not be escaped\n * @returns PathValidationResult with validation status and resolved path\n *\n * @example\n * const result = safeResolvePath('./file.txt', '/project', '/project')\n * if (result.valid) {\n *   // Path is valid and doesn't escape boundary\n *   console.log(result.resolvedPath)\n * }\n */\nexport function safeResolvePath(\n  inputPath: string,\n  cwd: string,\n  allowedRoot: string,\n): PathValidationResult {\n  try {\n    // 1. Resolve to absolute path\n    const absolutePath = isAbsolute(inputPath)\n      ? resolve(inputPath)\n      : resolve(cwd, inputPath)\n\n    // 2. Determine if path is a symlink and get real path\n    let isSymlink = false\n    let realPath = absolutePath\n\n    if (existsSync(absolutePath)) {\n      // Path exists - check if it's a symlink and follow to real location\n      try {\n        isSymlink = lstatSync(absolutePath).isSymbolicLink()\n        realPath = realpathSync(absolutePath)\n      } catch (e) {\n        // If stat/realpath fails, use absolute path\n        realPath = absolutePath\n      }\n    } else {\n      // Path doesn't exist - try to resolve via parents to detect symlink escapes\n      realPath = findRealPathForNonexistent(absolutePath)\n    }\n\n    // 3. Validate that realPath is within allowed boundary\n    return validateBoundary(realPath, allowedRoot, isSymlink)\n  } catch (e) {\n    return {\n      valid: false,\n      resolvedPath: inputPath,\n      isSymlink: false,\n      error: `Failed to validate path: ${e instanceof Error ? e.message : String(e)}`,\n    }\n  }\n}\n\n/**\n * Attempts to resolve a non-existent path by resolving existing parents.\n * This helps detect symlink escapes for paths that don't yet exist.\n */\nfunction findRealPathForNonexistent(filePath: string): string {\n  try {\n    // Walk up the path to find the first existing parent\n    let currentPath = filePath\n    let depth = 0\n    const maxDepth = 50 // Prevent infinite loops\n\n    while (!existsSync(currentPath) && depth < maxDepth) {\n      const parent = resolve(currentPath, '..')\n      if (parent === currentPath) break // Reached filesystem root\n      currentPath = parent\n      depth++\n    }\n\n    // If we found an existing path, resolve it and reconstruct\n    if (existsSync(currentPath)) {\n      const realParent = realpathSync(currentPath)\n      // Remove the parent path and any leading separator from the remaining portion\n      let remaining = filePath.slice(currentPath.length)\n      if (remaining.startsWith(sep)) {\n        remaining = remaining.slice(1)\n      }\n      return remaining ? join(realParent, remaining) : realParent\n    }\n\n    // Fallback: just return resolved path\n    return resolve(filePath)\n  } catch (e) {\n    return resolve(filePath)\n  }\n}\n\n/**\n * Validates that a resolved path stays within the allowed boundary.\n *\n * @param resolvedPath The absolute path to validate\n * @param allowedRoot The boundary root directory\n * @param isSymlink Whether the original path was a symlink\n * @returns PathValidationResult indicating if boundary is respected\n */\nfunction validateBoundary(\n  resolvedPath: string,\n  allowedRoot: string,\n  isSymlink: boolean,\n): PathValidationResult {\n  let normalizedRoot: string\n\n  try {\n    // Resolve the boundary root to its real path\n    if (existsSync(allowedRoot)) {\n      normalizedRoot = realpathSync(allowedRoot)\n    } else {\n      normalizedRoot = resolve(allowedRoot)\n    }\n  } catch (e) {\n    normalizedRoot = resolve(allowedRoot)\n  }\n\n  // Normalize both paths for comparison (handle case sensitivity)\n  normalizedRoot = normalizePath(normalizedRoot)\n  const normalizedResolved = normalizePath(resolvedPath)\n\n  // Check if the resolved path is within the boundary\n  const rel = relative(normalizedRoot, normalizedResolved)\n\n  // Validation fails if:\n  // 1. Path goes up to parent directory (..)\n  if (rel.startsWith('..')) {\n    return {\n      valid: false,\n      resolvedPath,\n      isSymlink,\n      error: `Path escapes sandbox boundary: ${resolvedPath} is outside ${normalizedRoot}`,\n    }\n  }\n\n  // 2. Relative path is absolute (different drive on Windows)\n  if (isAbsolute(rel)) {\n    return {\n      valid: false,\n      resolvedPath,\n      isSymlink,\n      error: `Path is on different drive or root: ${resolvedPath}`,\n    }\n  }\n\n  return {\n    valid: true,\n    resolvedPath,\n    isSymlink,\n  }\n}\n\n/**\n * Normalizes a path for platform-consistent comparison.\n * On Windows, converts to lowercase for case-insensitive comparison.\n *\n * @param p The path to normalize\n * @returns Normalized path string\n */\nfunction normalizePath(p: string): string {\n  const resolved = resolve(p)\n  return process.platform === 'win32' ? resolved.toLowerCase() : resolved\n}\n\n/**\n * Checks if a path contains any symlinks in its chain.\n * This is useful for detecting potential symlink attacks.\n *\n * @param filePath The path to check\n * @returns true if any component in the path is a symlink, false otherwise\n *\n * @example\n * const hasSymlinks = hasSymlinksInPath('/path/to/file')\n * if (hasSymlinks) {\n *   console.log('Path contains one or more symlinks')\n * }\n */\nexport function hasSymlinksInPath(filePath: string): boolean {\n  try {\n    const absolutePath = isAbsolute(filePath) ? filePath : resolve(filePath)\n    const parts = absolutePath.split(sep).filter(p => p)\n    let currentPath = ''\n\n    for (const part of parts) {\n      if (currentPath) {\n        currentPath = resolve(currentPath, part)\n      } else {\n        // Handle root directory\n        currentPath = sep === '\\\\' ? `${part}\\\\` : `/${part}`\n      }\n\n      if (!existsSync(currentPath)) break\n\n      try {\n        if (lstatSync(currentPath).isSymbolicLink()) {\n          return true\n        }\n      } catch (e) {\n        // If we can't stat it, continue\n      }\n    }\n\n    return false\n  } catch (e) {\n    return false\n  }\n}\n\n/**\n * Gets the real path of a file, following symlinks.\n * Returns the original path if it can't be resolved.\n *\n * @param filePath The path to resolve\n * @returns The real path, or the input path if resolution fails\n */\nexport function getRealPath(filePath: string): string {\n  try {\n    const absolutePath = isAbsolute(filePath) ? filePath : resolve(filePath)\n    if (existsSync(absolutePath)) {\n      return realpathSync(absolutePath)\n    }\n    return absolutePath\n  } catch (e) {\n    return filePath\n  }\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/sanitizeInput.js

@@ -1,32 +0,0 @@
-function sanitizeInput(input) {
-  if (!input) return input;
-  let sanitized = input;
-  sanitized = sanitized.replace(/\x1b{2,}/g, "");
-  sanitized = sanitized.replace(/\x1b[c78#]/g, "");
-  sanitized = sanitized.replace(
-    /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g,
-    ""
-  );
-  sanitized = sanitized.replace(/\x1b\].*?(?:\x1b\\|\x07|\x9c)/g, "");
-  sanitized = sanitized.replace(/\x1bP.*?(?:\x1b\\|\x9c)/g, "");
-  sanitized = sanitized.replace(/\x1b\^.*?(?:\x1b\\|\x9c)/g, "");
-  sanitized = sanitized.replace(/\x1b_.*?(?:\x1b\\|\x9c)/g, "");
-  sanitized = sanitized.replace(/\x1bX.*?(?:\x1b\\|\x9c)/g, "");
-  sanitized = sanitized.replace(/\x1b(?![[\]PO^_X])/g, "");
-  sanitized = sanitized.replace(
-    /[\x00-\x08\x0B\x0C\x0E-\x1A\x1C-\x1F\x7F]/g,
-    ""
-  );
-  return sanitized;
-}
-function containsDangerousSequences(input) {
-  if (!input) return false;
-  if (input.includes("\x1B")) return true;
-  if (/[\x00-\x08\x0B\x0C\x0E-\x1A\x1C-\x1F\x7F]/.test(input)) return true;
-  return false;
-}
-export {
-  containsDangerousSequences,
-  sanitizeInput
-};
-//# sourceMappingURL=sanitizeInput.js.map

package/dist/utils/sanitizeInput.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/sanitizeInput.ts"],
-  "sourcesContent": ["/**\n * Sanitize input text to remove dangerous ANSI escape sequences\n * that could affect terminal rendering or cause unexpected behavior.\n *\n * This is particularly important for:\n * - History entries loaded from storage (may contain corrupted data)\n * - User input that might accidentally contain escape sequences\n *\n * Dangerous sequences include:\n * - ESC c (0x1B 0x63): RIS - Reset Initial State (clears screen, resets terminal)\n * - ESC [ ... sequences that could manipulate cursor/screen\n */\n\n/**\n * Remove dangerous ANSI escape sequences from input text.\n * Preserves normal text content while stripping control sequences.\n *\n * @param input - The input string to sanitize\n * @returns Sanitized string with dangerous escape sequences removed\n */\nexport function sanitizeInput(input: string): string {\n  if (!input) return input\n\n  // Remove ESC character (0x1B) sequences that are dangerous\n  // Pattern matches:\n  // - ESC followed by any single character (like ESC c for RIS)\n  // - ESC [ followed by any CSI sequence (control sequence introducer)\n  // - ESC ] followed by OSC sequence (operating system command)\n  // - ESC ( or ESC ) for character set selection\n  // - Multiple consecutive ESC characters\n  let sanitized = input\n\n  // Remove multiple consecutive ESC characters (often accidental)\n  sanitized = sanitized.replace(/\\x1b{2,}/g, '')\n\n  // Remove dangerous single-character escape sequences\n  // ESC c = RIS (Reset Initial State) - THIS IS THE BUG CAUSE\n  // ESC 7 = DECSC (save cursor)\n  // ESC 8 = DECRC (restore cursor)\n  // ESC # followed by digit for line attributes\n  sanitized = sanitized.replace(/\\x1b[c78#]/g, '')\n\n  // Remove CSI (Control Sequence Introducer) sequences: ESC [ ... final_byte\n  // These can manipulate cursor, erase screen, change colors, etc.\n  // Final byte is in range 0x40-0x7E (@ through ~)\n  sanitized = sanitized.replace(\n    /\\x1b\\[[\\x30-\\x3f]*[\\x20-\\x2f]*[\\x40-\\x7e]/g,\n    '',\n  )\n\n  // Remove OSC (Operating System Command) sequences: ESC ] ... ST or BEL\n  // ST (String Terminator) is ESC \\ or 0x9C\n  // BEL is 0x07\n  sanitized = sanitized.replace(/\\x1b\\].*?(?:\\x1b\\\\|\\x07|\\x9c)/g, '')\n\n  // Remove DCS (Device Control String): ESC P ... ST\n  sanitized = sanitized.replace(/\\x1bP.*?(?:\\x1b\\\\|\\x9c)/g, '')\n\n  // Remove PM (Privacy Message): ESC ^ ... ST\n  sanitized = sanitized.replace(/\\x1b\\^.*?(?:\\x1b\\\\|\\x9c)/g, '')\n\n  // Remove APC (Application Program Command): ESC _ ... ST\n  sanitized = sanitized.replace(/\\x1b_.*?(?:\\x1b\\\\|\\x9c)/g, '')\n\n  // Remove SOS (Start of String): ESC X ... ST\n  sanitized = sanitized.replace(/\\x1bX.*?(?:\\x1b\\\\|\\x9c)/g, '')\n\n  // Remove any remaining standalone ESC characters\n  // that don't form a recognized sequence\n  sanitized = sanitized.replace(/\\x1b(?![[\\]PO^_X])/g, '')\n\n  // Remove other control characters that shouldn't be in user input\n  // Keep common ones: tab (0x09), newline (0x0A), carriage return (0x0D)\n  sanitized = sanitized.replace(\n    /[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1A\\x1C-\\x1F\\x7F]/g,\n    '',\n  )\n\n  return sanitized\n}\n\n/**\n * Check if input contains potentially dangerous escape sequences\n *\n * @param input - The input string to check\n * @returns true if input contains dangerous sequences\n */\nexport function containsDangerousSequences(input: string): boolean {\n  if (!input) return false\n\n  // Check for ESC character\n  if (input.includes('\\x1b')) return true\n\n  // Check for other control characters (excluding tab, newline, CR)\n  if (/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1A\\x1C-\\x1F\\x7F]/.test(input)) return true\n\n  return false\n}\n"],
-  "mappings": "AAoBO,SAAS,cAAc,OAAuB;AACnD,MAAI,CAAC,MAAO,QAAO;AASnB,MAAI,YAAY;AAGhB,cAAY,UAAU,QAAQ,aAAa,EAAE;AAO7C,cAAY,UAAU,QAAQ,eAAe,EAAE;AAK/C,cAAY,UAAU;AAAA,IACpB;AAAA,IACA;AAAA,EACF;AAKA,cAAY,UAAU,QAAQ,kCAAkC,EAAE;AAGlE,cAAY,UAAU,QAAQ,4BAA4B,EAAE;AAG5D,cAAY,UAAU,QAAQ,6BAA6B,EAAE;AAG7D,cAAY,UAAU,QAAQ,4BAA4B,EAAE;AAG5D,cAAY,UAAU,QAAQ,4BAA4B,EAAE;AAI5D,cAAY,UAAU,QAAQ,uBAAuB,EAAE;AAIvD,cAAY,UAAU;AAAA,IACpB;AAAA,IACA;AAAA,EACF;AAEA,SAAO;AACT;AAQO,SAAS,2BAA2B,OAAwB;AACjE,MAAI,CAAC,MAAO,QAAO;AAGnB,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AAGnC,MAAI,4CAA4C,KAAK,KAAK,EAAG,QAAO;AAEpE,SAAO;AACT;",
-  "names": []
-}