@aj-archipelago/cortex 1.4.2 → 1.4.3

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

@@ -1,12 +1,12 @@
 {
   "name": "@aj-archipelago/cortex-file-handler",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@aj-archipelago/cortex-file-handler",
-      "version": "2.6.1",
+      "version": "2.6.2",
       "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.1",
+  "version": "2.6.2",
   "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/scripts/setup-test-containers.js

@@ -7,13 +7,12 @@ async function createAzureContainers() {
       "UseDevelopmentStorage=true",
     );
     
-    // Get container names from environment variable
-    const containerStr = process.env.AZURE_STORAGE_CONTAINER_NAME || "default,test-container,test1,test2,test3,container1,container2,container3";
-    const containerNames = containerStr.split(',').map(name => name.trim()).filter(name => name.length > 0);
+    // Always create all possible test containers to support dynamic test environments
+    const allTestContainers = ["default", "test-container", "test1", "test2", "test3", "container1", "container2", "container3"];
     
-    console.log(`Creating Azure containers: ${containerNames.join(', ')}`);
+    console.log(`Creating Azure containers: ${allTestContainers.join(', ')}`);
     
-    for (const containerName of containerNames) {
+    for (const containerName of allTestContainers) {
       try {
         const containerClient = blobServiceClient.getContainerClient(containerName);
         await containerClient.create();

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

@@ -6,13 +6,8 @@ import { pipeline as _pipeline } from "stream";
 import { v4 as uuidv4 } from "uuid";
 import Busboy from "busboy";
 import { PassThrough } from "stream";
-import mime from "mime-types";
 import { Storage } from "@google-cloud/storage";
-import {
-  generateBlobSASQueryParameters,
-  StorageSharedKeyCredential,
-  BlobServiceClient,
-} from "@azure/storage-blob";
+import { BlobServiceClient } from "@azure/storage-blob";
 import axios from "axios";
 
 import {
@@ -23,6 +18,7 @@ import {
 import { publicFolder, port, ipAddress } from "./start.js";
 import { CONVERTED_EXTENSIONS, AZURITE_ACCOUNT_NAME } from "./constants.js";
 import { FileConversionService } from "./services/FileConversionService.js";
+import { StorageFactory } from "./services/storage/StorageFactory.js";
 
 const pipeline = promisify(_pipeline);
 
@@ -80,13 +76,20 @@ const parseContainerNames = () => {
   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) => {
-  return AZURE_STORAGE_CONTAINER_NAMES.includes(containerName);
+  // Read from environment at runtime to support dynamically changing env in tests
+  const currentContainerNames = getCurrentContainerNames();
+  return currentContainerNames.includes(containerName);
 };
 
 function isEncoded(str) {
@@ -221,95 +224,12 @@ export const getBlobClient = async (containerName = null) => {
 };
 
 async function saveFileToBlob(chunkPath, requestId, filename = null, containerName = null) {
-  const { containerClient } = await getBlobClient(containerName);
-  // Use provided filename or generate LLM-friendly naming
-  let blobName;
-  if (filename) {
-    blobName = generateBlobName(requestId, filename);
-  } else {
-    const fileExtension = path.extname(chunkPath);
-    const shortId = generateShortId();
-    blobName = generateBlobName(requestId, `${shortId}${fileExtension}`);
-  }
-
-  // Create a read stream for the chunk file
-  const fileStream = fs.createReadStream(chunkPath);
-
-  // Upload the chunk to Azure Blob Storage using the stream
-  const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-  await blockBlobClient.uploadStream(fileStream);
-
-  // Generate SAS token after successful upload
-  const sasToken = generateSASToken(containerClient, blobName);
-
-  // Return an object with the URL property
-  return {
-    url: `${blockBlobClient.url}?${sasToken}`,
-    blobName: blobName,
-  };
+  // Use provider for consistency with cache control headers
+  const storageFactory = StorageFactory.getInstance();
+  const provider = await storageFactory.getAzureProvider(containerName);
+  return await provider.uploadFile({}, chunkPath, requestId, null, filename);
 }
 
-const generateSASToken = (
-  containerClient,
-  blobName,
-  options = {},
-) => {
-  // Handle Azurite (development storage) credentials with fallback
-  let accountName, accountKey;
-  
-  if (containerClient.credential && containerClient.credential.accountName) {
-    // Regular Azure Storage credentials
-    accountName = containerClient.credential.accountName;
-    
-    // Handle Buffer case (Azurite) vs string case (real Azure)
-    if (Buffer.isBuffer(containerClient.credential.accountKey)) {
-      accountKey = containerClient.credential.accountKey.toString('base64');
-    } else {
-      accountKey = containerClient.credential.accountKey;
-    }
-  } else {
-    // Azurite development storage fallback
-    accountName = AZURITE_ACCOUNT_NAME;
-    accountKey = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==";
-  }
-  
-  const sharedKeyCredential = new StorageSharedKeyCredential(
-    accountName,
-    accountKey,
-  );
-
-  // Support custom duration: minutes, hours, or fall back to default
-  let expirationTime;
-  if (options.minutes) {
-    expirationTime = new Date(new Date().valueOf() + options.minutes * 60 * 1000);
-  } else if (options.hours) {
-    expirationTime = new Date(new Date().valueOf() + options.hours * 60 * 60 * 1000);
-  } else if (options.days) {
-    expirationTime = new Date(new Date().valueOf() + options.days * 24 * 60 * 60 * 1000);
-  } else if (options.expiryTimeSeconds !== undefined) {
-    // Legacy support for existing parameter
-    expirationTime = new Date(new Date().valueOf() + options.expiryTimeSeconds * 1000);
-  } else {
-    // Default to SAS_TOKEN_LIFE_DAYS environment variable
-    const defaultExpirySeconds = parseInt(SAS_TOKEN_LIFE_DAYS) * 24 * 60 * 60;
-    expirationTime = new Date(new Date().valueOf() + defaultExpirySeconds * 1000);
-  }
-
-  const sasOptions = {
-    containerName: containerClient.containerName,
-    blobName: blobName,
-    permissions: options.permissions || "r", // Read permission
-    startsOn: new Date(),
-    expiresOn: expirationTime,
-  };
-
-  const sasToken = generateBlobSASQueryParameters(
-    sasOptions,
-    sharedKeyCredential,
-  ).toString();
-  return sasToken;
-};
-
 //deletes blob that has the requestId
 async function deleteBlob(requestId, containerName = null) {
   if (!requestId) throw new Error("Missing requestId parameter");
@@ -396,8 +316,10 @@ function uploadBlob(
               hash = value;
             } else if (fieldname === "container") {
               if (value && !isValidContainerName(value)) {
+                // Read current containers from env for error message
+                const currentContainerNames = getCurrentContainerNames();
                 errorOccurred = true;
-                const err = new Error(`Invalid container name '${value}'. Allowed containers: ${AZURE_STORAGE_CONTAINER_NAMES.join(', ')}`);
+                const err = new Error(`Invalid container name '${value}'. Allowed containers: ${currentContainerNames.join(', ')}`);
                 err.status = 400;
                 reject(err);
                 return;
@@ -767,57 +689,17 @@ function uploadBlob(
 
 // Helper function to handle local file storage
 async function saveToLocalStorage(context, requestId, encodedFilename, file) {
-  const localPath = path.join(publicFolder, requestId);
-  fs.mkdirSync(localPath, { recursive: true });
-
-  // Sanitize filename by removing invalid characters
-  const sanitizedFilename = sanitizeFilename(encodedFilename);
-  const destinationPath = `${localPath}/${sanitizedFilename}`;
-
-  await pipeline(file, fs.createWriteStream(destinationPath));
-  return `http://${ipAddress}:${port}/files/${requestId}/${sanitizedFilename}`;
+  const storageFactory = StorageFactory.getInstance();
+  const localProvider = storageFactory.getLocalProvider();
+  const contextWithRequestId = { ...context, requestId };
+  return await localProvider.uploadStream(contextWithRequestId, encodedFilename, file);
 }
 
 // Helper function to handle Azure blob storage
 async function saveToAzureStorage(context, encodedFilename, file, containerName = null) {
-  const { containerClient } = await getBlobClient(containerName);
-  const contentType = mime.lookup(encodedFilename);
-
-  // Create a safe blob name that is URI-encoded once (no double encoding)
-  let blobName = sanitizeFilename(encodedFilename);
-  blobName = encodeURIComponent(blobName);
-
-  const options = {
-    blobHTTPHeaders: contentType ? { blobContentType: contentType } : {},
-    maxConcurrency: 50,
-    blockSize: 8 * 1024 * 1024,
-  };
-
-  const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-  console.log("Uploading to container:", containerName || "default");
-  context.log(`Uploading to Azure... ${blobName}`);
-  await blockBlobClient.uploadStream(file, undefined, undefined, options);
-  const sasToken = generateSASToken(containerClient, blobName);
-  return `${blockBlobClient.url}?${sasToken}`;
-}
-
-// Helper function to upload a file to Google Cloud Storage
-async function uploadToGCS(context, file, filename) {
-  const objectName = sanitizeFilename(filename);
-  const gcsFile = gcs.bucket(GCS_BUCKETNAME).file(objectName);
-  const writeStream = gcsFile.createWriteStream({
-    resumable: true,
-    validation: false,
-    metadata: {
-      contentType: mime.lookup(objectName) || "application/octet-stream",
-    },
-    chunkSize: 8 * 1024 * 1024,
-    numRetries: 3,
-    retryDelay: 1000,
-  });
-  context.log(`Uploading to GCS... ${objectName}`);
-  await pipeline(file, writeStream);
-  return `gs://${GCS_BUCKETNAME}/${objectName}`;
+  const storageFactory = StorageFactory.getInstance();
+  const provider = await storageFactory.getAzureProvider(containerName);
+  return await provider.uploadStream(context, encodedFilename, file);
 }
 
 // Wrapper that checks if GCS is configured
@@ -825,7 +707,12 @@ async function saveToGoogleStorage(context, encodedFilename, file) {
   if (!gcs) {
     throw new Error("Google Cloud Storage is not initialized");
   }
-  return uploadToGCS(context, file, encodedFilename);
+  const storageFactory = StorageFactory.getInstance();
+  const gcsProvider = storageFactory.getGCSProvider();
+  if (!gcsProvider) {
+    throw new Error("GCS provider not available");
+  }
+  return await gcsProvider.uploadStream(context, encodedFilename, file);
 }
 
 async function uploadFile(
@@ -1229,7 +1116,12 @@ async function ensureGCSUpload(context, existingFile) {
       url: existingFile.url,
       responseType: "stream",
     });
-    existingFile.gcs = await uploadToGCS(context, response.data, fileName);
+    
+    const storageFactory = StorageFactory.getInstance();
+    const gcsProvider = storageFactory.getGCSProvider();
+    if (gcsProvider) {
+      existingFile.gcs = await gcsProvider.uploadStream(context, fileName, response.data);
+    }
   }
   return existingFile;
 }

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

@@ -3,7 +3,7 @@ import { getFileStoreMap, setFileStoreMap } from "../redis.js";
 import { urlExists } from "../helper.js";
 import { gcsUrlExists, uploadChunkToGCS, gcs } from "../blobHandler.js";
 import { downloadFile } from "../fileChunker.js";
-import { saveFileToBlob } from "../blobHandler.js";
+import { StorageFactory } from "./storage/StorageFactory.js";
 import { moveFileToPublicFolder } from "../localFileHandler.js";
 import { v4 as uuidv4 } from "uuid";
 
@@ -11,6 +11,7 @@ export class FileConversionService extends ConversionService {
   constructor(context, useAzure = true) {
     super(context);
     this.useAzure = useAzure;
+    this.storageFactory = StorageFactory.getInstance();
   }
 
   async _getFileStoreMap(key) {
@@ -39,8 +40,9 @@ export class FileConversionService extends ConversionService {
 
     let fileUrl;
     if (this.useAzure) {
-      const savedBlob = await saveFileToBlob(filePath, reqId, filename, containerName);
-      fileUrl = savedBlob.url;
+      const provider = await this.storageFactory.getAzureProvider(containerName);
+      const result = await provider.uploadFile({}, filePath, reqId, null, filename);
+      fileUrl = result.url;
     } else {
       fileUrl = await moveFileToPublicFolder(filePath, reqId);
     }

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

@@ -5,12 +5,14 @@ import {
 } from "@azure/storage-blob";
 import fs from "fs";
 import path from "path";
+import mime from "mime-types";
 
 import { StorageProvider } from "./StorageProvider.js";
 import { AZURITE_ACCOUNT_NAME } from "../../constants.js";
 import {
   generateShortId,
   generateBlobName,
+  sanitizeFilename,
 } from "../../utils/filenameUtils.js";
 
 export class AzureStorageProvider extends StorageProvider {
@@ -122,7 +124,12 @@ export class AzureStorageProvider extends StorageProvider {
 
     // Upload the file to Azure Blob Storage using the stream
     const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-    await blockBlobClient.uploadStream(fileStream);
+    const uploadOptions = {
+      blobHTTPHeaders: {
+        blobCacheControl: 'public, max-age=2592000, immutable',
+      },
+    };
+    await blockBlobClient.uploadStream(fileStream, undefined, undefined, uploadOptions);
 
     // Generate SAS token after successful upload
     const sasToken = this.generateSASToken(containerClient, blobName);
@@ -133,6 +140,32 @@ export class AzureStorageProvider extends StorageProvider {
     };
   }
 
+  async uploadStream(context, encodedFilename, stream) {
+    const { containerClient } = await this.getBlobClient();
+    const contentType = mime.lookup(encodedFilename);
+
+    // Normalize the blob name: sanitizeFilename decodes, cleans, then we encode for Azure
+    let blobName = sanitizeFilename(encodedFilename);
+    blobName = encodeURIComponent(blobName);
+
+    const options = {
+      blobHTTPHeaders: {
+        ...(contentType ? { blobContentType: contentType } : {}),
+        blobCacheControl: 'public, max-age=2592000, immutable',
+      },
+      maxConcurrency: 50,
+      blockSize: 8 * 1024 * 1024,
+    };
+
+    const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+    if (context.log) context.log(`Uploading to Azure... ${blobName}`);
+    
+    await blockBlobClient.uploadStream(stream, undefined, undefined, options);
+    const sasToken = this.generateSASToken(containerClient, blobName);
+    
+    return `${blockBlobClient.url}?${sasToken}`;
+  }
+
   async deleteFiles(requestId) {
     if (!requestId) throw new Error("Missing requestId parameter");
     const { containerClient } = await this.getBlobClient();

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

@@ -4,6 +4,7 @@ import path from "path";
 import {
   generateShortId,
   generateBlobName,
+  sanitizeFilename,
 } from "../../utils/filenameUtils.js";
 import axios from "axios";
 
@@ -72,6 +73,27 @@ export class GCSStorageProvider extends StorageProvider {
     };
   }
 
+  async uploadStream(context, encodedFilename, stream) {
+    const bucket = this.storage.bucket(this.bucketName);
+    const blobName = sanitizeFilename(encodedFilename);
+
+    const file = bucket.file(blobName);
+    const writeStream = file.createWriteStream({
+      metadata: {
+        contentType: this.getContentType(encodedFilename) || "application/octet-stream",
+      },
+      resumable: false,
+    });
+
+    await new Promise((resolve, reject) => {
+      stream.pipe(writeStream)
+        .on('finish', resolve)
+        .on('error', reject);
+    });
+
+    return `gs://${this.bucketName}/${blobName}`;
+  }
+
   async deleteFiles(requestId) {
     if (!requestId) throw new Error("Missing requestId parameter");
 

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

@@ -1,10 +1,14 @@
 import fs from "fs";
 import path from "path";
-import { generateShortId } from "../../utils/filenameUtils.js";
+import { promisify } from "util";
+import { pipeline as _pipeline } from "stream";
+import { generateShortId, sanitizeFilename } from "../../utils/filenameUtils.js";
 import { ipAddress, port } from "../../start.js";
 
 import { StorageProvider } from "./StorageProvider.js";
 
+const pipeline = promisify(_pipeline);
+
 export class LocalStorageProvider extends StorageProvider {
   constructor(publicFolder) {
     super();
@@ -52,6 +56,29 @@ export class LocalStorageProvider extends StorageProvider {
     };
   }
 
+  async uploadStream(context, encodedFilename, stream) {
+    // For local storage, we need a requestId to create a folder
+    // Extract from context or generate one
+    const requestId = context.requestId || "default";
+    
+    // Create request folder if it doesn't exist
+    const requestFolder = path.join(this.publicFolder, requestId);
+    if (!fs.existsSync(requestFolder)) {
+      fs.mkdirSync(requestFolder, { recursive: true });
+    }
+
+    const sanitizedFilename = sanitizeFilename(encodedFilename);
+    const destinationPath = path.join(requestFolder, sanitizedFilename);
+    const writeStream = fs.createWriteStream(destinationPath);
+
+    await pipeline(stream, writeStream);
+
+    // Generate full URL
+    const url = `http://${ipAddress}:${port}/files/${requestId}/${sanitizedFilename}`;
+
+    return url;
+  }
+
   async deleteFiles(requestId) {
     if (!requestId) throw new Error("Missing requestId parameter");
 

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

@@ -13,11 +13,33 @@ async function getBlobHandlerConstants() {
   return blobHandlerConstants;
 }
 
+// Singleton instance for provider caching across the application
+let storageFactoryInstance = null;
+
 export class StorageFactory {
   constructor() {
     this.providers = new Map();
   }
 
+  /**
+   * Get the singleton instance of StorageFactory
+   * This ensures provider caching works across the entire application
+   */
+  static getInstance() {
+    if (!storageFactoryInstance) {
+      storageFactoryInstance = new StorageFactory();
+    }
+    return storageFactoryInstance;
+  }
+
+  /**
+   * Reset the singleton instance (useful for testing)
+   * @internal
+   */
+  static resetInstance() {
+    storageFactoryInstance = null;
+  }
+
   async getPrimaryProvider(containerName = null) {
     if (process.env.AZURE_STORAGE_CONNECTION_STRING) {
       return await this.getAzureProvider(containerName);
@@ -26,14 +48,17 @@ export class StorageFactory {
   }
 
   async getAzureProvider(containerName = null) {
-    const { AZURE_STORAGE_CONTAINER_NAMES, DEFAULT_AZURE_STORAGE_CONTAINER_NAME, isValidContainerName } = await getBlobHandlerConstants();
+    // Read container names from environment directly to get current values
+    const { getCurrentContainerNames } = await getBlobHandlerConstants();
+    const azureStorageContainerNames = getCurrentContainerNames();
+    const defaultAzureStorageContainerName = azureStorageContainerNames[0];
     
     // Use provided container name or default to first in whitelist
-    const finalContainerName = containerName || DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+    const finalContainerName = containerName || defaultAzureStorageContainerName;
     
     // Validate container name
-    if (!isValidContainerName(finalContainerName)) {
-      throw new Error(`Invalid container name '${finalContainerName}'. Allowed containers: ${AZURE_STORAGE_CONTAINER_NAMES.join(', ')}`);
+    if (!azureStorageContainerNames.includes(finalContainerName)) {
+      throw new Error(`Invalid container name '${finalContainerName}'. Allowed containers: ${azureStorageContainerNames.join(', ')}`);
     }
     
     // Create unique key for each container

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

@@ -15,6 +15,17 @@ export class StorageProvider {
     throw new Error("Method not implemented");
   }
 
+  /**
+   * Upload a stream to storage
+   * @param {Object} context - The context object
+   * @param {string} encodedFilename - The filename for the uploaded file
+   * @param {stream.Readable} stream - The stream to upload
+   * @returns {Promise<string>} The URL of the uploaded file with SAS token
+   */
+  async uploadStream(context, encodedFilename, stream) {
+    throw new Error("Method not implemented");
+  }
+
   /**
    * Delete files associated with a request ID
    * @param {string} requestId - The request ID to delete files for

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

@@ -6,7 +6,7 @@ import { generateShortId } from "../../utils/filenameUtils.js";
 
 export class StorageService {
   constructor(factory) {
-    this.factory = factory || new StorageFactory();
+    this.factory = factory || StorageFactory.getInstance();
     this.primaryProvider = null;
     this.backupProvider = null;
     this._initialized = false;

package/helper-apps/cortex-file-handler/tests/blobHandler.test.js

@@ -337,8 +337,9 @@ test("DEFAULT_AZURE_STORAGE_CONTAINER_NAME should be the first container", (t) =
 });
 
 test("isValidContainerName should validate container names correctly", (t) => {
-  // All configured containers should be valid
-  AZURE_STORAGE_CONTAINER_NAMES.forEach(containerName => {
+  // All configured containers should be valid (getCurrentContainerNames reads from env at runtime)
+  const currentContainers = AZURE_STORAGE_CONTAINER_NAMES;
+  currentContainers.forEach(containerName => {
     t.true(isValidContainerName(containerName), `${containerName} should be valid`);
   });
   

package/helper-apps/cortex-file-handler/tests/checkHashShortLived.test.js

@@ -404,6 +404,12 @@ test.serial("checkHash should maintain consistent behavior across multiple calls
 
       t.is(checkResponse.status, 200, `checkHash call ${i + 1} should succeed`);
       responses.push(checkResponse.data);
+      
+      // Add small delay to ensure different timestamps in SAS tokens
+      // Azure SAS tokens have second-level precision
+      if (i < 2 && isUsingAzureStorage()) {
+        await new Promise(resolve => setTimeout(resolve, 1100));
+      }
     }
 
     // All responses should have the required fields
@@ -415,8 +421,9 @@ test.serial("checkHash should maintain consistent behavior across multiple calls
       t.truthy(response.url, `Response ${index + 1} should have original URL`);
     }
 
-    if (isAzureConfigured()) {
+    if (isUsingAzureStorage()) {
       // All shortLivedUrls should be different (new SAS tokens each time)
+      // Azure (including Azurite) generates new SAS tokens with current timestamp
       const shortLivedUrls = responses.map(r => r.shortLivedUrl);
       const uniqueUrls = new Set(shortLivedUrls);
       t.is(uniqueUrls.size, shortLivedUrls.length, "Each call should generate unique short-lived URL with Azure");

package/helper-apps/cortex-file-handler/tests/containerConversionFlow.test.js

@@ -394,8 +394,11 @@ test("Conversion should use default container when no container specified", asyn
 
     // Verify the URL indicates it was uploaded to the default container
     const containerFromUrl = getContainerFromUrl(result.url);
-    t.is(containerFromUrl, AZURE_STORAGE_CONTAINER_NAMES[0],
-      `File should be uploaded to default container ${AZURE_STORAGE_CONTAINER_NAMES[0]}, but was uploaded to ${containerFromUrl}`);
+    // Read current default from environment (not the cached module value)
+    const currentContainerStr = process.env.AZURE_STORAGE_CONTAINER_NAME || "whispertempfiles";
+    const currentDefaultContainer = currentContainerStr.split(',').map(name => name.trim())[0];
+    t.is(containerFromUrl, currentDefaultContainer,
+      `File should be uploaded to default container ${currentDefaultContainer}, but was uploaded to ${containerFromUrl}`);
 
     // Cleanup
     await cleanupHashAndFile(null, result.url, baseUrl);

package/helper-apps/cortex-file-handler/tests/containerNameParsing.test.js

@@ -2,7 +2,8 @@ import test from "ava";
 import { 
   AZURE_STORAGE_CONTAINER_NAMES, 
   DEFAULT_AZURE_STORAGE_CONTAINER_NAME,
-  isValidContainerName 
+  isValidContainerName,
+  getCurrentContainerNames
 } from "../src/blobHandler.js";
 
 // Mock environment variables for testing
@@ -130,8 +131,11 @@ test("DEFAULT_AZURE_STORAGE_CONTAINER_NAME should be the first container in the
 });
 
 test("isValidContainerName should return true for valid container names", (t) => {
+  // Get current container names at runtime (not cached)
+  const currentContainers = getCurrentContainerNames();
+  
   // Test with each container name from the current configuration
-  AZURE_STORAGE_CONTAINER_NAMES.forEach(containerName => {
+  currentContainers.forEach(containerName => {
     t.true(isValidContainerName(containerName), `Container name '${containerName}' should be valid`);
   });
 });
@@ -163,12 +167,14 @@ test("isValidContainerName should handle edge cases", (t) => {
 });
 
 test("container configuration should have at least one container", (t) => {
-  t.true(AZURE_STORAGE_CONTAINER_NAMES.length > 0, "Should have at least one container configured");
-  t.truthy(AZURE_STORAGE_CONTAINER_NAMES[0], "First container should not be empty");
+  const currentContainers = getCurrentContainerNames();
+  t.true(currentContainers.length > 0, "Should have at least one container configured");
+  t.truthy(currentContainers[0], "First container should not be empty");
 });
 
 test("all configured container names should be non-empty strings", (t) => {
-  AZURE_STORAGE_CONTAINER_NAMES.forEach((containerName, index) => {
+  const currentContainers = getCurrentContainerNames();
+  currentContainers.forEach((containerName, index) => {
     t.is(typeof containerName, 'string', `Container at index ${index} should be a string`);
     t.true(containerName.length > 0, `Container at index ${index} should not be empty`);
     t.true(containerName.trim().length > 0, `Container at index ${index} should not be only whitespace`);
@@ -176,8 +182,9 @@ test("all configured container names should be non-empty strings", (t) => {
 });
 
 test("container names should not contain duplicates", (t) => {
-  const uniqueNames = new Set(AZURE_STORAGE_CONTAINER_NAMES);
-  t.is(uniqueNames.size, AZURE_STORAGE_CONTAINER_NAMES.length, "Container names should be unique");
+  const currentContainers = getCurrentContainerNames();
+  const uniqueNames = new Set(currentContainers);
+  t.is(uniqueNames.size, currentContainers.length, "Container names should be unique");
 });
 
 // Integration test with actual environment simulation