@aj-archipelago/cortex 1.4.5 → 1.4.7

package/helper-apps/cortex-file-handler/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@aj-archipelago/cortex-file-handler",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@aj-archipelago/cortex-file-handler",
-      "version": "2.6.2",
+      "version": "2.6.3",
       "dependencies": {
         "@azure/storage-blob": "^12.13.0",
         "@distube/ytdl-core": "^4.14.3",

package/helper-apps/cortex-file-handler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex-file-handler",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "description": "File handling service for Cortex - handles file uploads, media chunking, and document processing",
   "type": "module",
   "main": "src/index.js",

package/helper-apps/cortex-file-handler/src/blobHandler.js

@@ -16,7 +16,16 @@ import {
   generateBlobName,
 } from "./utils/filenameUtils.js";
 import { publicFolder, port, ipAddress } from "./start.js";
-import { CONVERTED_EXTENSIONS, AZURITE_ACCOUNT_NAME } from "./constants.js";
+import { 
+  CONVERTED_EXTENSIONS, 
+  AZURITE_ACCOUNT_NAME,
+  parseContainerNames,
+  getCurrentContainerNames,
+  AZURE_STORAGE_CONTAINER_NAMES,
+  getDefaultContainerName,
+  GCS_BUCKETNAME,
+  isValidContainerName
+} from "./constants.js";
 import { FileConversionService } from "./services/FileConversionService.js";
 import { StorageFactory } from "./services/storage/StorageFactory.js";
 
@@ -70,28 +79,6 @@ if (!GCP_PROJECT_ID || !GCP_SERVICE_ACCOUNT) {
   }
 }
 
-// Parse comma-separated container names from environment variable
-const parseContainerNames = () => {
-  const containerStr = process.env.AZURE_STORAGE_CONTAINER_NAME || "whispertempfiles";
-  return containerStr.split(',').map(name => name.trim());
-};
-
-// Helper function to get current container names at runtime
-export const getCurrentContainerNames = () => {
-  return parseContainerNames();
-};
-
-export const AZURE_STORAGE_CONTAINER_NAMES = parseContainerNames();
-export const DEFAULT_AZURE_STORAGE_CONTAINER_NAME = AZURE_STORAGE_CONTAINER_NAMES[0];
-export const GCS_BUCKETNAME = process.env.GCS_BUCKETNAME || "cortextempfiles";
-
-// Validate if a container name is allowed
-export const isValidContainerName = (containerName) => {
-  // Read from environment at runtime to support dynamically changing env in tests
-  const currentContainerNames = getCurrentContainerNames();
-  return currentContainerNames.includes(containerName);
-};
-
 function isEncoded(str) {
   // Checks for any percent-encoded sequence
   return /%[0-9A-Fa-f]{2}/.test(str);
@@ -194,7 +181,7 @@ async function downloadFromGCS(gcsUrl, destinationPath) {
 
 export const getBlobClient = async (containerName = null) => {
   const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
-  const finalContainerName = containerName || DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+  const finalContainerName = containerName || getDefaultContainerName();
 
   // Validate container name is in whitelist
   if (!isValidContainerName(finalContainerName)) {
@@ -350,10 +337,12 @@ function uploadBlob(
             
             if (errorOccurred) return; // Check again after waiting
 
-            await processFile(fieldname, file, info);
+            // Capture containerName value to avoid closure issues
+            const capturedContainerName = containerName;
+            await processFile(fieldname, file, info, capturedContainerName);
           });
 
-          const processFile = async (fieldname, file, info) => {
+          const processFile = async (fieldname, file, info, capturedContainerName) => {
             if (errorOccurred) return;
 
             // Validate file
@@ -449,7 +438,7 @@ function uploadBlob(
                 context,
                 uploadName,
                 azureStream,
-                containerName,
+                capturedContainerName,
               ).catch(async (err) => {
                 cloudUploadError = err;
                 // Fallback: try from disk if available
@@ -459,7 +448,7 @@ function uploadBlob(
                     highWaterMark: 1024 * 1024,
                     autoClose: true,
                   });
-                  return saveToAzureStorage(context, uploadName, diskStream, containerName);
+                  return saveToAzureStorage(context, uploadName, diskStream, capturedContainerName);
                 }
                 throw err;
               });
@@ -511,6 +500,7 @@ function uploadBlob(
                 }, {}),
               };
               if (hash) result.hash = hash;
+              if (capturedContainerName) result.container = capturedContainerName;
 
               // If saving locally, wait for disk write to finish and then move to public folder
               if (saveToLocal) {
@@ -582,7 +572,7 @@ function uploadBlob(
                         conversion.convertedPath,
                         requestId,
                         null,
-                        containerName,
+                        capturedContainerName,
                       );
 
                     // Optionally save to GCS
@@ -827,6 +817,10 @@ async function uploadFile(
     if (hash) {
       result.hash = hash;
     }
+    
+    if (containerName) {
+      result.container = containerName;
+    }
 
     // Initialize conversion service
     const conversionService = new FileConversionService(context, !saveToLocal);
@@ -1156,4 +1150,10 @@ export {
   gcs,
   uploadChunkToGCS,
   downloadFromGCS,
+  // Re-export container constants for backward compatibility
+  getCurrentContainerNames,
+  AZURE_STORAGE_CONTAINER_NAMES,
+  getDefaultContainerName,
+  GCS_BUCKETNAME,
+  isValidContainerName,
 };

package/helper-apps/cortex-file-handler/src/constants.js

@@ -132,3 +132,33 @@ export const CONVERTED_EXTENSIONS = [
 
 // Azure Storage constants
 export const AZURITE_ACCOUNT_NAME = "devstoreaccount1";
+
+// Parse comma-separated container names from environment variable
+export const parseContainerNames = () => {
+  const containerStr = process.env.AZURE_STORAGE_CONTAINER_NAME || "whispertempfiles";
+  return containerStr.split(',').map(name => name.trim());
+};
+
+// Helper function to get current container names at runtime
+// Useful for runtime validation when env vars might change (e.g., in tests)
+export const getCurrentContainerNames = () => {
+  return parseContainerNames();
+};
+
+export const AZURE_STORAGE_CONTAINER_NAMES = parseContainerNames();
+
+// Helper function to get the default container name at runtime
+// This allows tests to change the environment variable and have the correct default
+export const getDefaultContainerName = () => {
+  return process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME || getCurrentContainerNames()[0];
+};
+
+export const DEFAULT_AZURE_STORAGE_CONTAINER_NAME = process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME || AZURE_STORAGE_CONTAINER_NAMES[0];
+export const GCS_BUCKETNAME = process.env.GCS_BUCKETNAME || "cortextempfiles";
+
+// Validate if a container name is allowed
+export const isValidContainerName = (containerName) => {
+  // Read from environment at runtime to support dynamically changing env in tests
+  const currentContainerNames = getCurrentContainerNames();
+  return currentContainerNames.includes(containerName);
+};

package/helper-apps/cortex-file-handler/src/index.js

@@ -14,6 +14,7 @@ import {
   removeFromFileStoreMap,
   setFileStoreMap,
   cleanupRedisFileStoreMapAge,
+  getScopedHashKey,
 } from "./redis.js";
 import { FileConversionService } from "./services/FileConversionService.js";
 import { StorageService } from "./services/storage/StorageService.js";
@@ -46,6 +47,27 @@ async function cleanupInactive(context) {
 }
 
 async function CortexFileHandler(context, req) {
+  // Parse body if it's a string (Azure Functions sometimes doesn't auto-parse DELETE bodies)
+  let parsedBody = req.body;
+  if (typeof req.body === 'string' && req.body.length > 0) {
+    try {
+      parsedBody = JSON.parse(req.body);
+    } catch (e) {
+      // If parsing fails, treat as empty object
+      parsedBody = {};
+    }
+  }
+  
+  // For GET requests, prioritize query string. For other methods, check body first, then query
+  // Also check if parsedBody actually has content (not just empty object)
+  const hasBodyContent = parsedBody && typeof parsedBody === 'object' && Object.keys(parsedBody).length > 0;
+  const bodySource = hasBodyContent ? (parsedBody.params || parsedBody) : {};
+  const querySource = req.query || {};
+  
+  // Merge sources: for GET, query takes priority; for others, body takes priority
+  const isGet = req.method?.toLowerCase() === 'get';
+  const source = isGet ? { ...bodySource, ...querySource } : { ...querySource, ...bodySource };
+  
   const {
     uri,
     requestId,
@@ -58,7 +80,7 @@ async function CortexFileHandler(context, req) {
     load,
     restore,
     container,
-  } = req.body?.params || req.query;
+  } = source;
 
   // Normalize boolean parameters
   const shouldSave = save === true || save === "true";
@@ -135,13 +157,15 @@ async function CortexFileHandler(context, req) {
   // 1. Delete multiple files by requestId (existing behavior)
   // 2. Delete single file by hash (new behavior)
   if (operation === "delete") {
-    const deleteRequestId = req.query.requestId || requestId;
-    const deleteHash = req.query.hash || hash;
+    // Check both query string and body params for delete parameters
+    // Handle both req.body.params.hash and req.body.hash formats
+    const deleteRequestId = req.query.requestId || parsedBody?.params?.requestId || parsedBody?.requestId || requestId;
+    const deleteHash = req.query.hash || parsedBody?.params?.hash || parsedBody?.hash || hash;
     
     // If only hash is provided, delete single file by hash
     if (deleteHash && !deleteRequestId) {
       try {
-        const deleted = await storageService.deleteFileByHash(deleteHash);
+        const deleted = await storageService.deleteFileByHash(deleteHash, container);
         context.res = {
           status: 200,
           body: { 
@@ -163,17 +187,18 @@ async function CortexFileHandler(context, req) {
     if (!deleteRequestId) {
       context.res = {
         status: 400,
-        body: "Please pass either a requestId or hash on the query string",
+        body: "Please pass either a requestId or hash in the query string or request body",
       };
       return;
     }
 
     // First, get the hash from the map if it exists
     if (deleteHash) {
-      const hashResult = await getFileStoreMap(deleteHash);
+      const scopedHash = getScopedHashKey(deleteHash, container);
+      const hashResult = await getFileStoreMap(scopedHash);
       if (hashResult) {
-        context.log(`Found hash in map for deletion: ${deleteHash}`);
-        await removeFromFileStoreMap(deleteHash);
+        context.log(`Found hash in map for deletion: ${deleteHash} (scoped key: ${scopedHash})`);
+        await removeFromFileStoreMap(scopedHash);
       }
     }
 
@@ -201,7 +226,8 @@ async function CortexFileHandler(context, req) {
       }
 
       // Check if file already exists (using hash or URL as the key)
-      const cacheKey = hash || remoteUrl;
+      // If hash is provided, scope it by container; otherwise use URL as-is
+      const cacheKey = hash ? getScopedHashKey(hash, container) : remoteUrl;
       const exists = await getFileStoreMap(cacheKey);
       if (exists) {
         context.res = {
@@ -255,9 +281,10 @@ async function CortexFileHandler(context, req) {
 
   if (hash && clearHash) {
     try {
-      const hashValue = await getFileStoreMap(hash);
+      const scopedHash = getScopedHashKey(hash, container);
+      const hashValue = await getFileStoreMap(scopedHash);
       if (hashValue) {
-        await removeFromFileStoreMap(hash);
+        await removeFromFileStoreMap(scopedHash);
         context.res = {
           status: 200,
           body: `Hash ${hash} removed`,
@@ -279,10 +306,11 @@ async function CortexFileHandler(context, req) {
   }
 
   if (hash && checkHash) {
-    let hashResult = await getFileStoreMap(hash, true); // Skip lazy cleanup to handle it ourselves
+    const scopedHash = getScopedHashKey(hash, container);
+    let hashResult = await getFileStoreMap(scopedHash, true); // Skip lazy cleanup to handle it ourselves
 
     if (hashResult) {
-      context.log(`File exists in map: ${hash}`);
+      context.log(`File exists in map: ${hash} (scoped key: ${scopedHash})`);
 
       // Log the URL retrieved from Redis before checking existence
       context.log(`Checking existence of URL from Redis: ${hashResult?.url}`);
@@ -301,7 +329,7 @@ async function CortexFileHandler(context, req) {
           context.log(
             `File not found in any storage. Removing from map: ${hash}`,
           );
-          await removeFromFileStoreMap(hash);
+          await removeFromFileStoreMap(scopedHash);
           context.res = {
             status: 404,
             body: `Hash ${hash} not found in storage`,
@@ -320,7 +348,7 @@ async function CortexFileHandler(context, req) {
           } catch (error) {
             context.log(`Error restoring to GCS: ${error}`);
             // If restoration fails, remove the hash from the map
-            await removeFromFileStoreMap(hash);
+            await removeFromFileStoreMap(scopedHash);
             context.res = {
               status: 404,
               body: `Hash ${hash} not found`,
@@ -378,7 +406,7 @@ async function CortexFileHandler(context, req) {
           } catch (error) {
             console.error("Error restoring from GCS:", error);
             // If restoration fails, remove the hash from the map
-            await removeFromFileStoreMap(hash);
+            await removeFromFileStoreMap(scopedHash);
             context.res = {
               status: 404,
               body: `Hash ${hash} not found`,
@@ -396,7 +424,7 @@ async function CortexFileHandler(context, req) {
           : false;
         if (!finalPrimaryCheck && !finalGCSCheck) {
           context.log(`Failed to restore file. Removing from map: ${hash}`);
-          await removeFromFileStoreMap(hash);
+          await removeFromFileStoreMap(scopedHash);
           context.res = {
             status: 404,
             body: `Hash ${hash} not found`,
@@ -498,7 +526,7 @@ async function CortexFileHandler(context, req) {
         }
 
         //update redis timestamp with current time
-        await setFileStoreMap(hash, hashResult);
+        await setFileStoreMap(scopedHash, hashResult);
 
         context.res = {
           status: 200,
@@ -508,7 +536,7 @@ async function CortexFileHandler(context, req) {
       } catch (error) {
         context.log(`Error checking file existence: ${error}`);
         // If there's an error checking file existence, remove the hash from the map
-        await removeFromFileStoreMap(hash);
+        await removeFromFileStoreMap(scopedHash);
         context.res = {
           status: 404,
           body: `Hash ${hash} not found`,
@@ -532,7 +560,8 @@ async function CortexFileHandler(context, req) {
     // Use uploadBlob to handle multipart/form-data
     const result = await uploadBlob(context, req, saveToLocal, null, hash, container);
     if (result?.hash && context?.res?.body) {
-      await setFileStoreMap(result.hash, context.res.body);
+      const scopedHash = getScopedHashKey(result.hash, result.container || container);
+      await setFileStoreMap(scopedHash, context.res.body);
     }
     return;
   }

package/helper-apps/cortex-file-handler/src/redis.js

@@ -1,7 +1,28 @@
 import redis from "ioredis";
+import { getDefaultContainerName } from "./constants.js";
 
 const connectionString = process.env["REDIS_CONNECTION_STRING"];
 
+/**
+ * Generate a scoped hash key for Redis storage
+ * Always includes the container name in the format hash:container
+ * @param {string} hash - The file hash
+ * @param {string} containerName - The container name (optional, defaults to default container)
+ * @returns {string} The scoped hash key
+ */
+export const getScopedHashKey = (hash, containerName = null) => {
+  if (!hash) return hash;
+  
+  // Get the default container name at runtime to support dynamic env changes in tests
+  const defaultContainerName = getDefaultContainerName();
+  
+  // Use default container if not provided
+  const container = containerName || defaultContainerName;
+  
+  // Always scope by container
+  return `${hash}:${container}`;
+};
+
 // Create a mock client for test environment when Redis is not configured
 const createMockClient = () => {
   const store = new Map();
@@ -123,7 +144,28 @@ const setFileStoreMap = async (key, value) => {
 
 const getFileStoreMap = async (key, skipLazyCleanup = false) => {
   try {
-    const value = await client.hget("FileStoreMap", key);
+    let value = await client.hget("FileStoreMap", key);
+    
+    // Backwards compatibility: if not found and key is for default container, try legacy key
+    if (!value && key && key.includes(':')) {
+      const [hash, containerName] = key.split(':', 2);
+      const defaultContainerName = getDefaultContainerName();
+      
+      // If this is the default container, try the legacy key (hash without container)
+      if (containerName === defaultContainerName) {
+        console.log(`Key ${key} not found, trying legacy key ${hash} for backwards compatibility`);
+        value = await client.hget("FileStoreMap", hash);
+        
+        // If found with legacy key, migrate it to the new scoped key
+        if (value) {
+          console.log(`Found value with legacy key ${hash}, migrating to new key ${key}`);
+          await client.hset("FileStoreMap", key, value);
+          // Optionally remove the old key after migration
+          // await client.hdel("FileStoreMap", hash);
+        }
+      }
+    }
+    
     if (value) {
       try {
         // parse the value back to an object before returning

package/helper-apps/cortex-file-handler/src/services/storage/AzureStorageProvider.js

@@ -119,6 +119,11 @@ export class AzureStorageProvider extends StorageProvider {
       blobName = generateBlobName(requestId, `${shortId}${fileExtension}`);
     }
 
+    // Validate blobName is not empty
+    if (!blobName || blobName.trim().length === 0) {
+      throw new Error(`Invalid blob name generated: blobName="${blobName}", requestId="${requestId}", filename="${filename}"`);
+    }
+
     // Create a read stream for the file
     const fileStream = fs.createReadStream(filePath);
 
@@ -134,8 +139,20 @@ export class AzureStorageProvider extends StorageProvider {
     // Generate SAS token after successful upload
     const sasToken = this.generateSASToken(containerClient, blobName);
 
+    const url = `${blockBlobClient.url}?${sasToken}`;
+    
+    // Validate that the URL contains a blob name (not just container)
+    // Azure blob URLs should be: https://account.blob.core.windows.net/container/blobname
+    // Container-only URLs end with /container/ or /container
+    const urlObj = new URL(url);
+    const pathParts = urlObj.pathname.split('/').filter(p => p.length > 0);
+    if (pathParts.length <= 1) {
+      // Only container name, no blob name - this is invalid
+      throw new Error(`Generated invalid Azure URL (container-only): ${url}, blobName: ${blobName}`);
+    }
+
     return {
-      url: `${blockBlobClient.url}?${sasToken}`,
+      url: url,
       blobName: blobName,
     };
   }
@@ -148,6 +165,11 @@ export class AzureStorageProvider extends StorageProvider {
     let blobName = sanitizeFilename(encodedFilename);
     blobName = encodeURIComponent(blobName);
 
+    // Validate blobName is not empty
+    if (!blobName || blobName.trim().length === 0) {
+      throw new Error(`Invalid blob name generated from encodedFilename: "${encodedFilename}"`);
+    }
+
     const options = {
       blobHTTPHeaders: {
         ...(contentType ? { blobContentType: contentType } : {}),
@@ -163,7 +185,16 @@ export class AzureStorageProvider extends StorageProvider {
     await blockBlobClient.uploadStream(stream, undefined, undefined, options);
     const sasToken = this.generateSASToken(containerClient, blobName);
     
-    return `${blockBlobClient.url}?${sasToken}`;
+    const url = `${blockBlobClient.url}?${sasToken}`;
+    
+    // Validate that the URL contains a blob name (not just container)
+    const urlObj = new URL(url);
+    const pathParts = urlObj.pathname.split('/').filter(p => p.length > 0);
+    if (pathParts.length <= 1) {
+      throw new Error(`Generated invalid Azure URL (container-only) from uploadStream: ${url}, blobName: ${blobName}`);
+    }
+    
+    return url;
   }
 
   async deleteFiles(requestId) {
@@ -204,19 +235,52 @@ export class AzureStorageProvider extends StorageProvider {
       const urlObj = new URL(url);
       let blobName = urlObj.pathname.substring(1); // Remove leading slash
       
-      // Handle Azurite URLs which include account name in path: /devstoreaccount1/container/blob
+      // Handle different URL formats:
+      // 1. Azurite: /devstoreaccount1/container/blobname (3 segments)
+      // 2. Standard Azure: /container/blobname (2 segments)
+      // 3. Container-only: /container or /container/ (invalid)
+      
       if (blobName.includes('/')) {
-        const pathSegments = blobName.split('/');
-        if (pathSegments.length >= 2) {
-          // For Azurite: devstoreaccount1/container/blobname -> blobname
+        const pathSegments = blobName.split('/').filter(segment => segment.length > 0);
+        
+        if (pathSegments.length === 1) {
+          // Only container name, no blob name - this is invalid
+          console.warn(`Invalid blob URL (container-only): ${url}`);
+          return null;
+        } else if (pathSegments.length === 2) {
+          // Standard Azure format: container/blobname
+          // Check if first segment matches container name
+          if (pathSegments[0] === this.containerName) {
+            blobName = pathSegments[1];
+          } else {
+            // Container name doesn't match, but assume second segment is blob name
+            blobName = pathSegments[1];
+          }
+        } else if (pathSegments.length >= 3) {
+          // Azurite format: devstoreaccount1/container/blobname
           // Skip the account and container segments to get the actual blob name
-          blobName = pathSegments.slice(2).join('/');
+          // Check if second segment matches container name
+          if (pathSegments[1] === this.containerName) {
+            blobName = pathSegments.slice(2).join('/');
+          } else {
+            // Container name doesn't match, but assume remaining segments are blob name
+            blobName = pathSegments.slice(2).join('/');
+          }
+        }
+      } else {
+        // No slashes - could be just container name or just blob name
+        if (blobName === this.containerName || blobName === this.containerName + '/') {
+          // URL is just the container name - invalid blob URL
+          console.warn(`Invalid blob URL (container-only): ${url}`);
+          return null;
         }
+        // Otherwise assume it's a blob name at root level (unlikely but possible)
       }
       
-      // Remove container name prefix if present (for non-Azurite URLs)
-      if (blobName.startsWith(this.containerName + '/')) {
-        blobName = blobName.substring(this.containerName.length + 1);
+      // Validate that we have a non-empty blob name
+      if (!blobName || blobName.trim().length === 0) {
+        console.warn(`Invalid blob URL (empty blob name): ${url}`);
+        return null;
       }
       
       const blockBlobClient = containerClient.getBlockBlobClient(blobName);

package/helper-apps/cortex-file-handler/src/services/storage/StorageFactory.js

@@ -1,18 +1,10 @@
 import { AzureStorageProvider } from "./AzureStorageProvider.js";
 import { GCSStorageProvider } from "./GCSStorageProvider.js";
 import { LocalStorageProvider } from "./LocalStorageProvider.js";
+import { getCurrentContainerNames, GCS_BUCKETNAME } from "../../constants.js";
 import path from "path";
 import { fileURLToPath } from "url";
 
-// Lazy-load blob handler constants to avoid blocking module import
-let blobHandlerConstants = null;
-async function getBlobHandlerConstants() {
-  if (!blobHandlerConstants) {
-    blobHandlerConstants = await import("../../blobHandler.js");
-  }
-  return blobHandlerConstants;
-}
-
 // Singleton instance for provider caching across the application
 let storageFactoryInstance = null;
 
@@ -49,7 +41,6 @@ export class StorageFactory {
 
   async getAzureProvider(containerName = null) {
     // Read container names from environment directly to get current values
-    const { getCurrentContainerNames } = await getBlobHandlerConstants();
     const azureStorageContainerNames = getCurrentContainerNames();
     const defaultAzureStorageContainerName = azureStorageContainerNames[0];
     
@@ -82,7 +73,7 @@ export class StorageFactory {
       }
       const provider = new GCSStorageProvider(
         credentials,
-        process.env.GCS_BUCKETNAME || "cortextempfiles",
+        GCS_BUCKETNAME,
       );
       this.providers.set(key, provider);
     }

package/helper-apps/cortex-file-handler/src/services/storage/StorageService.js

@@ -163,9 +163,10 @@ export class StorageService {
   /**
    * Delete a single file by its hash from both primary and backup storage
    * @param {string} hash - The hash of the file to delete
+   * @param {string} containerName - Optional container name for scoping the hash
    * @returns {Promise<Object>} Object containing deletion results and file info
    */
-  async deleteFileByHash(hash) {
+  async deleteFileByHash(hash, containerName = null) {
     await this._initialize();
     
     if (!hash) {
@@ -175,11 +176,27 @@ export class StorageService {
     const results = [];
 
     // Get and remove file information from Redis map (non-atomic operations)
-    const { getFileStoreMap, removeFromFileStoreMap } = await import("../../redis.js");
-    const hashResult = await getFileStoreMap(hash);
+    const { getFileStoreMap, removeFromFileStoreMap, getScopedHashKey, getDefaultContainerName } = await import("../../redis.js");
+    const { getDefaultContainerName: getDefaultContainerNameFromConstants } = await import("../../constants.js");
+    const scopedHash = getScopedHashKey(hash, containerName);
+    const hashResult = await getFileStoreMap(scopedHash);
     
     if (hashResult) {
-      await removeFromFileStoreMap(hash);
+      // Remove from scoped key
+      await removeFromFileStoreMap(scopedHash);
+      
+      // Also check and remove legacy key (unscoped) if this is the default container
+      // This handles backwards compatibility with old entries stored without container scoping
+      const defaultContainerName = getDefaultContainerNameFromConstants();
+      const effectiveContainer = containerName || defaultContainerName;
+      if (effectiveContainer === defaultContainerName && scopedHash.includes(':')) {
+        const [legacyHash] = scopedHash.split(':', 2);
+        // Try to remove legacy key - only attempt if it exists to avoid unnecessary "does not exist" logs
+        const legacyExists = await getFileStoreMap(legacyHash);
+        if (legacyExists) {
+          await removeFromFileStoreMap(legacyHash);
+        }
+      }
     }
     
     if (!hashResult) {
@@ -189,9 +206,16 @@ export class StorageService {
     // Delete from primary storage
     if (hashResult.url) {
       try {
+        // Log the URL being deleted for debugging
+        console.log(`Deleting file from primary storage - hash: ${hash}, url: ${hashResult.url}`);
         const primaryResult = await this.deleteFile(hashResult.url);
         if (primaryResult) {
+          console.log(`Successfully deleted from primary storage - hash: ${hash}, result: ${primaryResult}`);
           results.push({ provider: 'primary', result: primaryResult });
+        } else {
+          // deleteFile returned null, which means the URL was invalid
+          console.warn(`Invalid or empty URL for hash ${hash}: ${hashResult.url}`);
+          results.push({ provider: 'primary', error: 'Invalid URL (container-only or empty blob name)' });
         }
       } catch (error) {
         console.error(`Error deleting file from primary storage:`, error);
@@ -202,14 +226,25 @@ export class StorageService {
     // Delete from backup storage (GCS)
     if (hashResult.gcs && this.backupProvider) {
       try {
+        console.log(`Deleting file from backup storage - hash: ${hash}, gcs: ${hashResult.gcs}`);
         const backupResult = await this.deleteFileFromBackup(hashResult.gcs);
         if (backupResult) {
+          console.log(`Successfully deleted from backup storage - hash: ${hash}, result: ${backupResult}`);
           results.push({ provider: 'backup', result: backupResult });
+        } else {
+          console.warn(`Backup deletion returned null for hash ${hash}: ${hashResult.gcs}`);
+          results.push({ provider: 'backup', error: 'Deletion returned null' });
         }
       } catch (error) {
         console.error(`Error deleting file from backup storage:`, error);
         results.push({ provider: 'backup', error: error.message });
       }
+    } else {
+      if (!hashResult.gcs) {
+        console.log(`No GCS URL found for hash ${hash}, skipping backup deletion`);
+      } else if (!this.backupProvider) {
+        console.log(`Backup provider not configured, skipping backup deletion for hash ${hash}`);
+      }
     }
 
     // Note: Hash was already removed from Redis atomically at the beginning