@aj-archipelago/cortex 1.3.62 → 1.3.63

package/helper-apps/cortex-file-converter/README.md

@@ -0,0 +1,93 @@
+# Keynote to PDF Conversion Utilities
+
+This directory contains utilities related to converting Apple Keynote (`.key`) files to PDF format, particularly focusing on processing files stored in Azure Blob Storage.
+
+## `process_azure_keynotes.py`
+
+### Purpose
+
+This script connects to an Azure Blob Storage container (specified by the `AZURE_STORAGE_CONTAINER` environment variable), searches for Keynote (`.key`) files, converts them to PDF format if a PDF version doesn't already exist, and uploads the resulting PDF back to the same location in the container.
+
+### Functionality
+
+1.  **Connects** to the Azure Blob Storage account specified by the `AZURE_STORAGE_CONNECTION_STRING` environment variable.
+2.  **Lists** all blobs within the container specified by the `AZURE_STORAGE_CONTAINER` environment variable.
+3.  **Identifies** `.key` files.
+4.  **Checks** if a corresponding `.pdf` file (with the same base name) already exists in the container.
+5.  **Skips** processing if the `.pdf` file already exists.
+6.  **Downloads** the `.key` file to a temporary local directory if no `.pdf` exists.
+7.  **Converts** the downloaded `.key` file to PDF using an embedded AppleScript function (adapted from `key_to_pdf.py`). This conversion uses the "Good" image quality setting to potentially reduce file size.
+8.  **Uploads** the generated `.pdf` file back to the original path within the Azure container, replacing the `.key` extension with `.pdf`.
+9.  **Logs** progress, skips, and any errors encountered during the process.
+10. **Prints** a summary report upon completion.
+
+### Prerequisites
+
+*   **macOS:** The script relies on AppleScript to interact with the Keynote application.
+*   **Keynote Application:** Apple Keynote must be installed.
+*   **Python 3.x:** The script is written for Python 3.
+*   **Python Libraries:** Requires the `azure-storage-blob` library. Install dependencies using the main `requirements.txt` file in the project root: `pip install -r ../../requirements.txt` (adjust path as necessary relative to the main project root).
+*   **Azure Connection String:** The environment variable `AZURE_STORAGE_CONNECTION_STRING` must be set to a valid connection string for the Azure Storage account containing the target container.
+*   **Azure Container Name:** The environment variable `AZURE_STORAGE_CONTAINER` must be set to the name of the target container.
+*   **Automation Permissions:** You might need to grant permission for your terminal application (e.g., Terminal, iTerm) or Python itself to control Keynote. Check `System Settings` > `Privacy & Security` > `Automation`.
+
+### Usage
+
+1.  Ensure all prerequisites are met.
+2.  Navigate to the main project root directory in your terminal.
+3.  Set the Azure connection string environment variable:
+    ```bash
+    export AZURE_STORAGE_CONNECTION_STRING="<your_azure_storage_connection_string>"
+    export AZURE_STORAGE_CONTAINER="<your_target_container_name>"
+    ```
+4.  Run the script:
+    ```bash
+    python helper-apps/cortex-file-converter/process_azure_keynotes.py
+    ```
+
+## `key_to_pdf.py`
+
+This is a standalone command-line utility for converting a single local Keynote file to PDF using AppleScript. It was the basis for the conversion logic now embedded within `process_azure_keynotes.py`.
+
+### Usage (Standalone)
+
+```bash
+python helper-apps/cortex-file-converter/key_to_pdf.py <input_keynote_file.key> [-o <output_pdf_file.pdf>]
+```
+
+If the output path (`-o`) is omitted, the PDF will be saved in the same directory as the input file with a `.pdf` extension.
+
+## `list_blob_extensions.py`
+
+### Purpose
+
+This script connects to an Azure Blob Storage container (specified by the `AZURE_STORAGE_CONTAINER` environment variable), lists all the blobs within it, and reports the unique file extensions found. It also marks extensions known to be typically unsupported for content cracking by the default Azure Cognitive Search indexer configuration.
+
+### Functionality
+
+1.  **Connects** to the Azure Blob Storage account specified by the `AZURE_STORAGE_CONNECTION_STRING` environment variable and the container specified by `AZURE_STORAGE_CONTAINER`.
+2.  **Lists** all blobs within the specified container.
+3.  **Extracts** the file extension from each blob name.
+4.  **Collects** all unique extensions found.
+5.  **Prints** a list of unique extensions, marking those present in its predefined `UNSUPPORTED_EXTENSIONS_KNOWN` set.
+
+### Prerequisites
+
+*   **Python 3.x:** The script is written for Python 3.
+*   **Python Libraries:** Requires the `azure-storage-blob` library. Install dependencies using: `pip install -r requirements.txt`.
+*   **Azure Connection String:** The environment variable `AZURE_STORAGE_CONNECTION_STRING` must be set.
+*   **Azure Container Name:** The environment variable `AZURE_STORAGE_CONTAINER` must be set to the name of the target container.
+
+### Usage
+
+1.  Ensure all prerequisites are met.
+2.  Navigate to the `helper-apps/cortex-file-converter` directory in your terminal.
+3.  Set the required environment variables:
+    ```bash
+    export AZURE_STORAGE_CONNECTION_STRING="<your_azure_storage_connection_string>"
+    export AZURE_STORAGE_CONTAINER="<your_target_container_name>"
+    ```
+4.  Run the script:
+    ```bash
+    python list_blob_extensions.py
+    ``` 

package/helper-apps/cortex-file-converter/key_to_pdf.py

@@ -0,0 +1,104 @@
+import argparse
+import subprocess
+import os
+import sys
+
+def convert_key_to_pdf(key_path, pdf_path):
+    """
+    Converts a Keynote file (.key) to PDF using AppleScript.
+    """
+    if not os.path.exists(key_path):
+        print(f"Error: Input file not found: {key_path}", file=sys.stderr)
+        sys.exit(1)
+
+    # Ensure the output directory exists
+    output_dir = os.path.dirname(pdf_path)
+    if output_dir and not os.path.exists(output_dir):
+        try:
+            os.makedirs(output_dir)
+        except OSError as e:
+            print(f"Error creating output directory {output_dir}: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Check if output PDF exists and delete it
+    if os.path.exists(pdf_path):
+        try:
+            os.remove(pdf_path)
+            print(f"Removed existing output file: {pdf_path}")
+        except OSError as e:
+            print(f"Error removing existing output file {pdf_path}: {e}", file=sys.stderr)
+            # Decide if this should be fatal or just a warning
+            # sys.exit(1) 
+
+    applescript = f'''
+    tell application "Keynote"
+        try
+            set theDocument to open POSIX file "{key_path}"
+            if not (exists theDocument) then error "Failed to open document."
+
+            set pdf_export_settings to {{PDF image quality:Good}} -- Define settings as record (escaped braces)
+
+            with timeout of 1200 seconds -- Allow 20 minutes for export
+                 export theDocument to POSIX file "{pdf_path}" as PDF with properties pdf_export_settings -- Use settings record
+            end timeout
+
+            close theDocument saving no
+            log "Successfully exported {key_path} to {pdf_path}"
+        on error errMsg number errNum
+            log "AppleScript Error: " & errMsg & " (Number: " & errNum & ")"
+            # Try to quit Keynote even if there was an error during export/close
+            try
+                if exists theDocument then
+                    close theDocument saving no
+                end if
+            end try
+            error "Keynote conversion failed: " & errMsg number errNum
+        end try
+        -- Optional: Quit Keynote after conversion
+        -- quit
+    end tell
+    '''
+
+    try:
+        # Using osascript to run the AppleScript
+        process = subprocess.run(['osascript', '-e', applescript], 
+                                 capture_output=True, text=True, check=True, timeout=1260) # Add a slightly longer timeout for the process itself
+        print(f"Successfully converted '{key_path}' to '{pdf_path}'")
+        # Print Keynote's log messages if needed
+        # print("AppleScript Output:\n", process.stdout)
+        # print("AppleScript Errors:\n", process.stderr) # osascript might put log messages here too
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing AppleScript: {e}", file=sys.stderr)
+        print(f"stdout:\n{e.stdout}", file=sys.stderr)
+        print(f"stderr:\n{e.stderr}", file=sys.stderr)
+        sys.exit(1)
+    except subprocess.TimeoutExpired:
+        print(f"Error: AppleScript execution timed out for {key_path}", file=sys.stderr)
+        # It's hard to reliably kill the Keynote process started by AppleScript here,
+        # as Keynote might still be hung. Manual intervention might be needed.
+        sys.exit(1)
+    except Exception as e:
+        print(f"An unexpected Python error occurred: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Keynote (.key) files to PDF.")
+    parser.add_argument("input_key_file", help="Path to the input Keynote file.")
+    parser.add_argument("-o", "--output", help="Path for the output PDF file. Defaults to the same name as the input file but with a .pdf extension.")
+
+    args = parser.parse_args()
+
+    input_path = os.path.abspath(args.input_key_file)
+    
+    if args.output:
+        output_path = os.path.abspath(args.output)
+    else:
+        # Default output path
+        base_name = os.path.splitext(input_path)[0]
+        output_path = base_name + ".pdf"
+
+    convert_key_to_pdf(input_path, output_path)
+
+if __name__ == "__main__":
+    main() 

package/helper-apps/cortex-file-converter/list_blob_extensions.py

@@ -0,0 +1,89 @@
+import os
+import sys
+from azure.storage.blob import BlobServiceClient
+from pathlib import Path
+
+# Set of known extensions typically NOT supported for content cracking by Azure Cognitive Search (default configuration)
+# Check Azure docs for the official list of *supported* formats.
+# This list focuses on common formats often not processed for text content.
+UNSUPPORTED_EXTENSIONS_KNOWN = {
+    'key',   # Apple Keynote (as requested)
+    'zip',   # Archive formats often need specific skills/configurations
+    'rar',
+    'gz',   
+    'tar',
+    '7z',
+    'pkg',
+    'dmg',   # Disk images
+    'iso',
+    'exe',   # Executables
+    'dll',
+    'mp4',   # Video formats
+    'mov',
+    'avi',
+    'wmv',
+    'mp3',   # Audio formats
+    'wav',
+    'aac',
+    'pyc',   # Compiled Python
+    'class', # Compiled Java
+    'o',     # Compiled C/C++ object files
+    'a',     # Static libraries
+    'so',    # Shared libraries (Linux)
+    # Add other known unsupported types if needed
+}
+
+def main():
+    # --- Configuration ---
+    try:
+        connection_string = os.environ["AZURE_STORAGE_CONNECTION_STRING"]
+        container_name = os.environ["AZURE_STORAGE_CONTAINER"]
+    except KeyError as e:
+        print(f"Error: Required environment variable {e} is not set.", file=sys.stderr)
+        sys.exit(1)
+        
+    # ---------------------
+
+    print(f"Connecting to Azure Blob Storage container: {container_name}")
+    try:
+        blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+        container_client = blob_service_client.get_container_client(container_name)
+        # Check if container exists
+        container_client.get_container_properties() 
+    except Exception as e:
+        print(f"Error connecting to or accessing container '{container_name}': {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print("Listing blobs and collecting extensions...")
+    unique_extensions = set()
+    blob_count = 0
+    try:
+        blob_list = container_client.list_blobs()
+        for blob in blob_list:
+            blob_count += 1
+            suffix = Path(blob.name).suffix.lower()
+            if suffix: # Only process if there is an extension
+                # Store extension without the leading dot
+                extension = suffix[1:]
+                unique_extensions.add(extension)
+            if blob_count % 10000 == 0:
+                 print(f"  Processed {blob_count} blobs...")
+
+        print(f"Finished processing {blob_count} blobs.")
+    except Exception as e:
+        print(f"Error listing blobs in container '{container_name}': {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print("\n" + "-"*30)
+    print(f"Found {len(unique_extensions)} unique file extensions:")
+    print("" + "-"*30)
+    
+    # Sort extensions for consistent output
+    sorted_extensions = sorted(list(unique_extensions))
+    
+    for ext in sorted_extensions:
+        marker = "(Unsupported by Indexer)" if ext in UNSUPPORTED_EXTENSIONS_KNOWN else ""
+        print(f".{ext} {marker}")
+
+if __name__ == "__main__":
+    main() 

package/helper-apps/cortex-file-converter/process_azure_keynotes.py

@@ -0,0 +1,181 @@
+import os
+import subprocess
+import sys
+import tempfile
+from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient
+from pathlib import Path
+
+# --- Conversion Function (Adapted from key_to_pdf.py) ---
+class ConversionError(Exception):
+    """Custom exception for conversion failures."""
+    pass
+
+def convert_key_to_pdf(key_path, pdf_path):
+    """
+    Converts a Keynote file (.key) to PDF using AppleScript.
+    Raises FileNotFoundError if input doesn't exist.
+    Raises ConversionError if AppleScript execution fails.
+    """
+    if not os.path.exists(key_path):
+        raise FileNotFoundError(f"Input Keynote file not found: {key_path}")
+
+    # Ensure the output directory exists
+    output_dir = os.path.dirname(pdf_path)
+    if output_dir and not os.path.exists(output_dir):
+        try:
+            os.makedirs(output_dir)
+        except OSError as e:
+            # Raise an error if we can't create the output dir
+            raise ConversionError(f"Cannot create output directory {output_dir}: {e}") 
+
+    # Check if output PDF exists and delete it (optional, might be handled by caller)
+    # if os.path.exists(pdf_path):
+    #     try:
+    #         os.remove(pdf_path)
+    #     except OSError as e:
+    #         raise ConversionError(f"Cannot remove existing output file {pdf_path}: {e}")
+
+    applescript = f'''
+    tell application "Keynote"
+        try
+            set theDocument to open POSIX file "{key_path}"
+            if not (exists theDocument) then error "Failed to open document."
+
+            set pdf_export_settings to {{PDF image quality:Good}} -- Define settings as record (escaped braces)
+
+            with timeout of 1200 seconds -- Allow 20 minutes for export
+                 export theDocument to POSIX file "{pdf_path}" as PDF with properties pdf_export_settings -- Use settings record
+            end timeout
+
+            close theDocument saving no
+            -- log "Successfully exported {key_path} to {pdf_path}" -- Logging handled by caller
+        on error errMsg number errNum
+            -- log "AppleScript Error: " & errMsg & " (Number: " & errNum & ")" -- Log detail in exception
+            -- Try to quit Keynote even if there was an error during export/close
+            try
+                if exists theDocument then
+                    close theDocument saving no
+                end if
+            end try
+            error "Keynote conversion failed: " & errMsg number errNum
+        end try
+        -- Optional: Quit Keynote after conversion
+        -- quit
+    end tell
+    '''
+
+    try:
+        # Using osascript to run the AppleScript
+        process = subprocess.run(['osascript', '-e', applescript], 
+                                 capture_output=True, text=True, check=False, timeout=1260) # check=False
+        
+        if process.returncode != 0:
+            # Raise an error with details from AppleScript failure
+            raise ConversionError(f"AppleScript execution failed (Code {process.returncode}) for {key_path}. stderr: {process.stderr.strip()}")
+
+        # Final check if PDF exists after successful run
+        if not os.path.exists(pdf_path):
+            raise ConversionError(f"Conversion reported success but output PDF not found: {pdf_path}")
+
+    except subprocess.TimeoutExpired:
+        raise ConversionError(f"AppleScript execution timed out for {key_path}")
+    except Exception as e:
+        # Catch any other unexpected Python errors during subprocess handling
+        raise ConversionError(f"An unexpected error occurred during conversion process for {key_path}: {e}")
+
+# --- Main Azure Processing Logic ---
+
+def main():
+    # --- Configuration ---
+    try:
+        connection_string = os.environ["AZURE_STORAGE_CONNECTION_STRING"]
+        container_name = os.environ["AZURE_STORAGE_CONTAINER"]
+    except KeyError as e:
+        print(f"Error: Required environment variable {e} is not set.", file=sys.stderr)
+        sys.exit(1)
+        
+
+    print(f"Connecting to Azure Blob Storage container: {container_name}")
+    try:
+        blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+        container_client = blob_service_client.get_container_client(container_name)
+        # Check if container exists by trying to get properties
+        container_client.get_container_properties() 
+    except Exception as e:
+        print(f"Error connecting to or accessing container '{container_name}': {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print("Listing blobs...")
+    all_blob_names = set()
+    try:
+        blob_list = container_client.list_blobs()
+        for blob in blob_list:
+            all_blob_names.add(blob.name)
+        print(f"Found {len(all_blob_names)} blobs in total.")
+    except Exception as e:
+        print(f"Error listing blobs in container '{container_name}': {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print("Starting processing...")
+    processed_count = 0
+    skipped_count = 0
+    error_count = 0
+
+    for blob_name in all_blob_names:
+        if blob_name.lower().endswith(".key"):
+            print(f"Found Keynote file: {blob_name}")
+            pdf_blob_name = Path(blob_name).with_suffix(".pdf").as_posix() # Generate corresponding PDF name
+
+            if pdf_blob_name in all_blob_names:
+                print(f"  -> PDF version already exists: {pdf_blob_name}. Skipping.")
+                skipped_count += 1
+                continue
+            
+            print(f"  -> PDF version not found. Attempting conversion.")
+            
+            # Use a temporary directory for download and conversion
+            with tempfile.TemporaryDirectory() as temp_dir:
+                local_key_path = os.path.join(temp_dir, os.path.basename(blob_name))
+                local_pdf_path = Path(local_key_path).with_suffix(".pdf").as_posix()
+                
+                try:
+                    # 1. Download .key file
+                    print(f"    Downloading {blob_name} to {local_key_path}...")
+                    blob_client = container_client.get_blob_client(blob_name)
+                    with open(local_key_path, "wb") as download_file:
+                        download_stream = blob_client.download_blob()
+                        download_file.write(download_stream.readall())
+                    print("    Download complete.")
+
+                    # 2. Convert .key to .pdf (using local function)
+                    print(f"    Converting {local_key_path} to {local_pdf_path}...")
+                    try:
+                        convert_key_to_pdf(local_key_path, local_pdf_path)
+                        print("    Conversion successful.")
+                    except (FileNotFoundError, ConversionError) as convert_err:
+                        print(f"    ERROR: Conversion failed for {local_key_path}: {convert_err}", file=sys.stderr)
+                        error_count += 1
+                        continue # Skip upload if conversion failed
+                    
+                    # 3. Upload .pdf file
+                    print(f"    Uploading {local_pdf_path} to {pdf_blob_name}...")
+                    pdf_blob_client = container_client.get_blob_client(pdf_blob_name)
+                    with open(local_pdf_path, "rb") as upload_file:
+                        pdf_blob_client.upload_blob(upload_file, overwrite=True, timeout=600) # Increased timeout to 10 mins
+                    print("    Upload complete.")
+                    processed_count += 1
+
+                except Exception as e:
+                    print(f"    ERROR processing file {blob_name}: {e}", file=sys.stderr)
+                    error_count += 1
+                
+                # Temporary directory and its contents are automatically cleaned up here
+
+    print("-"*30)
+    print("Processing complete.")
+    print(f"Successfully converted and uploaded: {processed_count}")
+    print(f"Skipped (PDF already exists):      {skipped_count}")
+    print(f"Errors encountered:                 {error_count}")
+
+if __name__ == "__main__":
+    main() 

package/helper-apps/cortex-file-converter/requirements.txt

@@ -0,0 +1 @@
+azure-storage-blob 

package/helper-apps/cortex-file-handler/.env.test.azure.ci

@@ -0,0 +1,7 @@
+# Test environment configuration for Azure tests
+REDIS_CONNECTION_STRING=redis://default:redispw@localhost:32768
+AZURE_STORAGE_CONNECTION_STRING=UseDevelopmentStorage=true
+AZURE_STORAGE_CONTAINER_NAME=default,test-container,test1,test2,test3,container1,container2,container3
+NODE_ENV=test
+PORT=7072  # Different port for testing 
+MARKITDOWN_CONVERT_URL= #cortex-markitdown url

package/helper-apps/cortex-file-handler/.env.test.azure.sample

@@ -1,7 +1,7 @@
 # Test environment configuration for Azure tests
 REDIS_CONNECTION_STRING=redis://default:redispw@localhost:32768
 AZURE_STORAGE_CONNECTION_STRING=UseDevelopmentStorage=true
-AZURE_STORAGE_CONTAINER_NAME=test-container
+AZURE_STORAGE_CONTAINER_NAME=default,test-container,test1,test2,test3,container1,container2,container3
 NODE_ENV=test
 PORT=7072  # Different port for testing 
 MARKITDOWN_CONVERT_URL= #cortex-markitdown url

package/helper-apps/cortex-file-handler/.env.test.gcs.ci

@@ -0,0 +1,10 @@
+# Test environment configuration for Azure tests
+REDIS_CONNECTION_STRING=redis://default:redispw@localhost:32768
+STORAGE_EMULATOR_HOST=http://localhost:4443
+GCP_SERVICE_ACCOUNT_KEY={"project_id":"test-project"}
+GCS_BUCKETNAME=cortextempfiles
+AZURE_STORAGE_CONNECTION_STRING=UseDevelopmentStorage=true
+AZURE_STORAGE_CONTAINER_NAME=default,test-container,test1,test2,test3,container1,container2,container3
+NODE_ENV=test
+PORT=7072  # Different port for testing 
+MARKITDOWN_CONVERT_URL= #cortex-markitdown url

package/helper-apps/cortex-file-handler/.env.test.gcs.sample

@@ -1,10 +1,10 @@
 # Test environment configuration for Azure tests
 REDIS_CONNECTION_STRING=redis://default:redispw@localhost:32768
-GCP_SERVICE_ACCOUNT_KEY={"project_id":"test-project"}
 STORAGE_EMULATOR_HOST=http://localhost:4443
+GCP_SERVICE_ACCOUNT_KEY={"project_id":"test-project"}
 GCS_BUCKETNAME=cortextempfiles
 AZURE_STORAGE_CONNECTION_STRING=UseDevelopmentStorage=true
-AZURE_STORAGE_CONTAINER_NAME=test-container
+AZURE_STORAGE_CONTAINER_NAME=default,test-container,test1,test2,test3,container1,container2,container3
 NODE_ENV=test
 PORT=7072  # Different port for testing 
 MARKITDOWN_CONVERT_URL= #cortex-markitdown url

package/helper-apps/cortex-file-handler/INTERFACE.md

@@ -43,6 +43,11 @@ The Cortex File Handler is a service that processes files through various operat
   - `hash` (optional): Unique identifier for the file
   - `checkHash` (optional): Check if hash exists
   - `clearHash` (optional): Remove hash from storage
+  - `generateShortLived` (optional): Generate a short-lived URL for an existing hash
+    - Requires `hash` parameter
+    - Generates a new SAS token with short expiration time
+    - Returns a temporary URL for secure sharing
+  - `shortLivedMinutes` (optional): Duration in minutes for short-lived URLs (default: 5)
   - `fetch`/`load`/`restore` (optional): URL to fetch remote file (these are aliases - any of the three parameters will trigger the same remote file processing behavior)
     - Does not require `requestId`
     - Uses Redis caching
@@ -73,6 +78,12 @@ The Cortex File Handler is a service that processes files through various operat
     - Updates Redis timestamp on subsequent requests
     - Truncates filenames longer than 200 characters
     - Ensures correct file extension based on content type
+  - For checkHash (`checkHash=true`):
+    - Requires valid `hash` parameter
+    - Checks if file exists in storage and restores if needed
+    - Always generates new SAS token with short expiration (default: 5 minutes)
+    - Returns file information with temporary URL and expiration information
+    - Updates Redis timestamp
 
 ### DELETE
 
@@ -172,6 +183,36 @@ The Cortex File Handler is a service that processes files through various operat
   - After successful processing
   - On error conditions
 
+## Usage Examples
+
+### Check Hash (Always Returns Short-Lived URL)
+
+```bash
+# Check hash with 5-minute short-lived URL (default)
+GET /file-handler?hash=abc123&checkHash=true
+
+# Check hash with 10-minute short-lived URL
+GET /file-handler?hash=abc123&checkHash=true&shortLivedMinutes=10
+```
+
+**Response (always includes short-lived URL):**
+```json
+{
+  "message": "File 'document.pdf' uploaded successfully.",
+  "filename": "document.pdf",
+  "url": "https://storage.blob.core.windows.net/container/file.pdf?original-sas-token",
+  "gcs": "gs://bucket/file.pdf",
+  "hash": "abc123",
+  "shortLivedUrl": "https://storage.blob.core.windows.net/container/file.pdf?sv=2023-11-03&se=2024-01-15T10%3A15%3A00Z&sr=b&sp=r&sig=...",
+  "expiresInMinutes": 5,
+  "timestamp": "2024-01-15T10:10:00.000Z",
+  "converted": {
+    "url": "https://storage.blob.core.windows.net/container/converted.pdf",
+    "gcs": "gs://bucket/converted.pdf"
+  }
+}
+```
+
 ## Error Handling
 
 - **400 Bad Request**:

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

@@ -45,7 +45,7 @@
       "!tests/test-docs/**/*",
       "!tests/mocks/**/*"
     ],
-    "timeout": "1m",
+    "timeout": "10m",
     "nodeArguments": [
       "--experimental-modules"
     ],

package/helper-apps/cortex-file-handler/scripts/setup-azure-container.js

@@ -1,25 +1,49 @@
 import { BlobServiceClient } from "@azure/storage-blob";
 
-async function createContainer() {
+async function createContainers() {
   try {
-    const blobServiceClient = BlobServiceClient.fromConnectionString(
-      "UseDevelopmentStorage=true",
-    );
-    const containerClient =
-      blobServiceClient.getContainerClient("test-container");
+    // Check if required environment variables are set
+    const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
+    const containerNames = process.env.AZURE_STORAGE_CONTAINER_NAME;
+    
+    if (!connectionString) {
+      throw new Error("AZURE_STORAGE_CONNECTION_STRING environment variable is required");
+    }
+    
+    if (!containerNames) {
+      throw new Error("AZURE_STORAGE_CONTAINER_NAME environment variable is required");
+    }
 
-    console.log("Creating container...");
-    await containerClient.create();
-    console.log("Container created successfully");
-  } catch (error) {
-    // Ignore if container already exists
-    if (error.statusCode === 409) {
-      console.log("Container already exists");
-    } else {
-      console.error("Error creating container:", error);
-      process.exit(1);
+    const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+    
+    // Parse container names from environment variable
+    const containers = containerNames.split(',').map(name => name.trim());
+    console.log(`Creating containers: ${containers.join(', ')}`);
+
+    // Create each container
+    for (const containerName of containers) {
+      if (!containerName) continue; // Skip empty names
+      
+      try {
+        const containerClient = blobServiceClient.getContainerClient(containerName);
+        await containerClient.create();
+        console.log(`✅ Container '${containerName}' created successfully`);
+      } catch (error) {
+        // Ignore if container already exists
+        if (error.statusCode === 409) {
+          console.log(`✅ Container '${containerName}' already exists`);
+        } else {
+          console.error(`❌ Error creating container '${containerName}':`, error.message);
+          throw error;
+        }
+      }
     }
+    
+    console.log("🎉 All containers setup completed");
+  } catch (error) {
+    console.error("❌ Container setup failed:", error.message);
+    process.exit(1);
   }
 }
 
-createContainer();
+createContainers();