Feature/engg 3986 local workspace file names should be readable (#210)

Author: iostreamer-X

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "requestly",
   "productName": "Requestly",
-  "version": "25.10.3",
+  "version": "25.10.8",
   "main": "src/main/main.ts",
   "private": true,
   "description": "Intercept & Modify HTTP Requests",
@@ -343,4 +343,4 @@
       "pre-commit": "lint-staged"
     }
   }
-}
+}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "requestly",
   "productName": "Requestly",
-  "version": "25.10.3",
+  "version": "25.10.8",
   "private": true,
   "description": "Intercept & Modify HTTP Requests",
   "main": "./dist/main/main.js",
@@ -34,4 +34,4 @@
     "bufferutil": "4.0.3",
     "utf-8-validate": "5.0.6"
   }
-}
+}

release/app/package-lock.json

@@ -8,6 +8,7 @@ import {
   FileTypeEnum,
   FsResource,
 } from "./types";
+import { fileIndex } from "./file-index";
 
 export class FsResourceCreationError extends Error {
   path: string;
@@ -32,6 +33,7 @@ export function createFsResource<T extends FsResource["type"]>(params: {
   rootPath: string;
   path: string;
   type: T;
+  exposedWorkspacePaths?: Map<string, unknown>,
 }): FsResource & { type: T } {
   try {
     const { rootPath, type } = params;
@@ -47,12 +49,11 @@ export function createFsResource<T extends FsResource["type"]>(params: {
       );
     }
 
-    const normalizedRootPath = getNormalizedPath(rootPath);
-    const pathRootSlice = path.slice(0, normalizedRootPath.length);
-
-    if (normalizedRootPath !== pathRootSlice) {
+    const normalizedRootPaths = new Set<string>().add(getNormalizedPath(rootPath));
+    params.exposedWorkspacePaths?.keys().forEach(path => normalizedRootPaths.add(getNormalizedPath(path)));
+    if (!normalizedRootPaths.values().some(rootPath => path.startsWith(rootPath))) {
       throw new Error(
-        `Can not create fs resource reference! Path '${path}' lies outside workspace path '${rootPath}'`
+        `Can not create fs resource reference! Path '${path}' lies outside workspace paths!`
       );
     }
 
@@ -124,7 +125,8 @@ export function parseJsonContent<T extends TSchema>(
 }
 
 export function getIdFromPath(path: string) {
-  return path;
+  const id = fileIndex.getId(path);
+  return id;
 }
 
 export function mapSuccessWrite<
@@ -217,3 +219,156 @@ export function createFileSystemError(
     },
   };
 }
+
+/**
+ * WARNING: Genrated by Claude
+ *
+ * Sanitizes a string to be safe for use as a filename or folder name across all platforms
+ * (Windows, macOS, Linux)
+ * 
+ * @param input - The input string to sanitize
+ * @param maxLength - Maximum length for the filename (default: 100)
+ * @param replacement - Character to replace invalid characters with (default: '_')
+ * @returns A sanitized filename safe for all platforms
+ */
+export function sanitizeFsResourceName(
+  input: string, 
+  maxLength: number = 100, 
+  replacement: string = '_'
+): string {
+  if (!input || typeof input !== 'string') {
+    return 'Untitled';
+  }
+
+  // Trim whitespace
+  let sanitized = input.trim();
+
+  // If empty after trim, return default
+  if (!sanitized) {
+    return 'Untitled';
+  }
+
+  // Reserved names on Windows (case-insensitive)
+  const reservedNames = new Set([
+    'CON', 'PRN', 'AUX', 'NUL',
+    'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+    'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'
+  ]);
+
+  // Characters that are invalid in filenames across platforms
+  // Windows: < > : " | ? * \ /
+  // macOS: : (converted to /) 
+  // Linux: / and null character
+  // We'll be conservative and exclude all problematic characters
+  const invalidCharsRegex = /[<>:"/\\|?*\x00-\x1F\x7F]/g;
+
+  // Replace invalid characters
+  sanitized = sanitized.replace(invalidCharsRegex, replacement);
+
+  // Remove or replace problematic characters at start/end
+  // Can't start or end with spaces or dots on Windows
+  sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, replacement);
+
+  // Handle multiple consecutive replacement characters
+  if (replacement) {
+    const replacementRegex = new RegExp(`${escapeRegex(replacement)}+`, 'g');
+    sanitized = sanitized.replace(replacementRegex, replacement);
+  }
+
+  // Check if it's a reserved name (Windows)
+  const nameWithoutExt = sanitized.split('.')[0].toUpperCase();
+  if (reservedNames.has(nameWithoutExt)) {
+    sanitized = `${replacement}${sanitized}`;
+  }
+
+  // Ensure it doesn't start with a dash (can cause issues with command line tools)
+  if (sanitized.startsWith('-')) {
+    sanitized = replacement + sanitized.slice(1);
+  }
+
+  // Limit length while preserving file extension if present
+  if (sanitized.length > maxLength) {
+    const lastDotIndex = sanitized.lastIndexOf('.');
+    if (lastDotIndex > 0 && lastDotIndex > sanitized.length - 10) {
+      // Has extension, preserve it
+      const extension = sanitized.slice(lastDotIndex);
+      const nameOnly = sanitized.slice(0, lastDotIndex);
+      const maxNameLength = maxLength - extension.length;
+      sanitized = nameOnly.slice(0, maxNameLength) + extension;
+    } else {
+      // No extension or extension is too far back
+      sanitized = sanitized.slice(0, maxLength);
+    }
+  }
+
+  // Final cleanup - remove trailing dots and spaces again (in case truncation caused issues)
+  sanitized = sanitized.replace(/[.\s]+$/, '');
+
+  // If we ended up with an empty string, return default
+  if (!sanitized) {
+    return 'Untitled';
+  }
+
+  return sanitized;
+}
+
+/**
+ * Helper function to escape special regex characters
+ */
+function escapeRegex(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Detects if a given name corresponds to a 'new' entity based on a base string pattern.
+ * Matches exact base string or base string followed by a number.
+ * 
+ * @param name - The name to check (e.g., 'Untitled', 'Untitled1', 'Untitled42')
+ * @param baseString - The base string to match against (e.g., 'Untitled', 'New Environment')
+ * @returns true if the name matches the pattern, false otherwise
+ */
+export function isNewEntityName(name: string, baseString: string): boolean {
+  // Escape special regex characters in the base string
+  const escapedBase = baseString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  
+  // Pattern: exact match OR base string followed by one or more digits
+  const pattern = new RegExp(`^${escapedBase}(\\d+)?$`);
+  
+  return pattern.test(name);
+}
+
+/**
+ * Pure function that generates the next available name variant.
+ * Always starts with baseName + "1" and increments until finding an available name.
+ * 
+ * @param baseName - The base name to generate alternatives for
+ * @param existingNames - Array of existing names to avoid conflicts with
+ * @returns The next available name variant (e.g., 'Untitled1', 'Untitled2')
+ */
+export function getAlternateName(baseName: string, existingNames: Set<string>): string {
+  if(!existingNames.has(baseName)) {
+    return baseName;
+  }
+  let counter = 1;
+  let candidateName = `${baseName}${counter}`;
+  
+  while (existingNames.has(candidateName)) {
+    counter++;
+    candidateName = `${baseName}${counter}`;
+  }
+  
+  return candidateName;
+}
+
+export function getNewNameIfQuickCreate(params: {
+  name: string,
+  baseName: string,
+  parentPath: string,
+}) {
+  if(!isNewEntityName(params.name, params.baseName)) {
+    return params.name;
+  }
+  const children = fileIndex.getImmediateChildren(params.parentPath);
+
+  return getAlternateName(params.baseName, children);
+}