@aj-archipelago/cortex 1.3.57 → 1.3.59

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

@@ -1,182 +1,184 @@
-import fs from 'fs';
-import path from 'path';
-import { v4 as uuidv4 } from 'uuid';
-import { fileURLToPath } from 'url';
-import { ipAddress, port } from '../../start.js';
-import { sanitizeFilename } from '../../utils/filenameUtils.js';
+import fs from "fs";
+import path from "path";
+import { generateShortId } from "../../utils/filenameUtils.js";
+import { ipAddress, port } from "../../start.js";
 
-import { StorageProvider } from './StorageProvider.js';
+import { StorageProvider } from "./StorageProvider.js";
 
 export class LocalStorageProvider extends StorageProvider {
-    constructor(publicFolder) {
-        super();
-        if (!publicFolder) {
-            throw new Error('Missing public folder path');
-        }
-        this.publicFolder = publicFolder;
-        this.ensurePublicFolder();
+  constructor(publicFolder) {
+    super();
+    if (!publicFolder) {
+      throw new Error("Missing public folder path");
     }
+    this.publicFolder = publicFolder;
+    this.ensurePublicFolder();
+  }
 
-    ensurePublicFolder() {
-        if (!fs.existsSync(this.publicFolder)) {
-            fs.mkdirSync(this.publicFolder, { recursive: true });
-        }
+  ensurePublicFolder() {
+    if (!fs.existsSync(this.publicFolder)) {
+      fs.mkdirSync(this.publicFolder, { recursive: true });
     }
+  }
 
-    async uploadFile(context, filePath, requestId, hash = null) {
-        // Create request folder if it doesn't exist
-        const requestFolder = path.join(this.publicFolder, requestId);
-        if (!fs.existsSync(requestFolder)) {
-            fs.mkdirSync(requestFolder, { recursive: true });
-        }
-
-        // Generate unique filename
-        let baseName = sanitizeFilename(path.basename(filePath));
-        // Local storage URLs shouldn't be double-encoded, so leave the name raw in the FS path,
-        // but use encodeURIComponent when building the external URL so browsers read it fine.
-        const encodedForUrl = encodeURIComponent(baseName);
-        const uniqueFileName = `${uuidv4()}_${encodedForUrl}`;
-        const destinationPath = path.join(requestFolder, uniqueFileName);
-
-        // Copy file to public folder
-        await fs.promises.copyFile(filePath, destinationPath);
-
-        // Generate full URL
-        const url = `http://${ipAddress}:${port}/files/${requestId}/${uniqueFileName}`;
-        
-        return {
-            url,
-            blobName: path.join(requestId, uniqueFileName)
-        };
+  async uploadFile(context, filePath, requestId, hash = null, filename = null) {
+    // Create request folder if it doesn't exist
+    const requestFolder = path.join(this.publicFolder, requestId);
+    if (!fs.existsSync(requestFolder)) {
+      fs.mkdirSync(requestFolder, { recursive: true });
     }
 
-    async deleteFiles(requestId) {
-        if (!requestId) throw new Error('Missing requestId parameter');
-        
-        const requestFolder = path.join(this.publicFolder, requestId);
-        const result = [];
-        
-        if (fs.existsSync(requestFolder)) {
-            const files = await fs.promises.readdir(requestFolder);
-            for (const file of files) {
-                const filePath = path.join(requestFolder, file);
-                await fs.promises.unlink(filePath);
-                // Return the full path relative to the public folder
-                result.push(path.join(requestId, file));
-            }
-            await fs.promises.rmdir(requestFolder);
-        }
-        
-        return result;
+    // Use provided filename or generate LLM-friendly naming
+    let uniqueFileName;
+    if (filename) {
+      uniqueFileName = filename;
+    } else {
+      const fileExtension = path.extname(filePath);
+      const shortId = generateShortId();
+      uniqueFileName = `${shortId}${fileExtension}`;
     }
 
-    async deleteFile(url) {
-        if (!url) throw new Error('Missing URL parameter');
-        
-        const filePath = this.urlToFilePath(url);
-        if (!filePath) {
-            throw new Error('Invalid URL');
-        }
-        
-        if (fs.existsSync(filePath)) {
-            await fs.promises.unlink(filePath);
-            // Try to remove the parent directory if it's empty
-            const parentDir = path.dirname(filePath);
-            try {
-                await fs.promises.rmdir(parentDir);
-            } catch (error) {
-                // Ignore error if directory is not empty
-            }
-            return path.relative(this.publicFolder, filePath);
-        }
-        
-        return null;
+    const destinationPath = path.join(requestFolder, uniqueFileName);
+
+    // Copy file to public folder
+    await fs.promises.copyFile(filePath, destinationPath);
+
+    // Generate full URL
+    const url = `http://${ipAddress}:${port}/files/${requestId}/${uniqueFileName}`;
+
+    return {
+      url,
+      blobName: path.join(requestId, uniqueFileName),
+    };
+  }
+
+  async deleteFiles(requestId) {
+    if (!requestId) throw new Error("Missing requestId parameter");
+
+    const requestFolder = path.join(this.publicFolder, requestId);
+    const result = [];
+
+    if (fs.existsSync(requestFolder)) {
+      const files = await fs.promises.readdir(requestFolder);
+      for (const file of files) {
+        const filePath = path.join(requestFolder, file);
+        await fs.promises.unlink(filePath);
+        // Return the full path relative to the public folder
+        result.push(path.join(requestId, file));
+      }
+      await fs.promises.rmdir(requestFolder);
     }
 
-    async fileExists(url) {
-        try {
-            if (!url) {
-                return false;
-            }
-
-            const filePath = this.urlToFilePath(url);
-            if (!filePath) {
-                return false;
-            }
-
-            // Check if file exists and is accessible
-            try {
-                await fs.promises.access(filePath, fs.constants.R_OK);
-                return true;
-            } catch (error) {
-                return false;
-            }
-        } catch (error) {
-            console.error('Error checking if file exists:', error);
-            return false;
-        }
+    return result;
+  }
+
+  async deleteFile(url) {
+    if (!url) throw new Error("Missing URL parameter");
+
+    const filePath = this.urlToFilePath(url);
+    if (!filePath) {
+      throw new Error("Invalid URL");
     }
 
-    async downloadFile(url, destinationPath) {
-        const sourcePath = this.urlToFilePath(url);
-        if (!fs.existsSync(sourcePath)) {
-            throw new Error('File not found');
-        }
-        await fs.promises.copyFile(sourcePath, destinationPath);
+    if (fs.existsSync(filePath)) {
+      await fs.promises.unlink(filePath);
+      // Try to remove the parent directory if it's empty
+      const parentDir = path.dirname(filePath);
+      try {
+        await fs.promises.rmdir(parentDir);
+      } catch (error) {
+        // Ignore error if directory is not empty
+      }
+      return path.relative(this.publicFolder, filePath);
     }
 
-    async cleanup(urls) {
-        if (!urls || !urls.length) return;
-        
-        const result = [];
-        for (const url of urls) {
-            try {
-                const filePath = this.urlToFilePath(url);
-                if (fs.existsSync(filePath)) {
-                    await fs.promises.unlink(filePath);
-                    result.push(path.relative(this.publicFolder, filePath));
-                }
-            } catch (error) {
-                console.error(`Error cleaning up file ${url}:`, error);
-            }
-        }
-        
-        return result;
+    return null;
+  }
+
+  async fileExists(url) {
+    try {
+      if (!url) {
+        return false;
+      }
+
+      const filePath = this.urlToFilePath(url);
+      if (!filePath) {
+        return false;
+      }
+
+      // Check if file exists and is accessible
+      try {
+        await fs.promises.access(filePath, fs.constants.R_OK);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    } catch (error) {
+      console.error("Error checking if file exists:", error);
+      return false;
     }
+  }
 
-    isEncoded(str) {
-        return /%[0-9A-Fa-f]{2}/.test(str);
+  async downloadFile(url, destinationPath) {
+    const sourcePath = this.urlToFilePath(url);
+    if (!fs.existsSync(sourcePath)) {
+      throw new Error("File not found");
     }
+    await fs.promises.copyFile(sourcePath, destinationPath);
+  }
+
+  async cleanup(urls) {
+    if (!urls || !urls.length) return;
 
-    urlToFilePath(url) {
-        try {
-            // If it's a full URL, extract the pathname
-            let urlPath = url;
-            if (url.startsWith('http://') || url.startsWith('https://')) {
-                const urlObj = new URL(url);
-                urlPath = urlObj.pathname;
-            }
-
-            // Remove leading slash if present
-            if (urlPath.startsWith('/')) {
-                urlPath = urlPath.substring(1);
-            }
-
-            // Split into parts and decode each part
-            const parts = urlPath.split('/');
-            const decodedParts = parts.map(part => decodeURIComponent(part));
-
-            // If the URL path starts with 'files', remove that segment because
-            // our publicFolder already represents the root of '/files'.
-            if (decodedParts.length && decodedParts[0] === 'files') {
-                decodedParts.shift();
-            }
-
-            // Join with the public folder path
-            return path.join(this.publicFolder, ...decodedParts);
-        } catch (error) {
-            console.error('Error converting URL to file path:', error);
-            return null;
+    const result = [];
+    for (const url of urls) {
+      try {
+        const filePath = this.urlToFilePath(url);
+        if (fs.existsSync(filePath)) {
+          await fs.promises.unlink(filePath);
+          result.push(path.relative(this.publicFolder, filePath));
         }
+      } catch (error) {
+        console.error(`Error cleaning up file ${url}:`, error);
+      }
+    }
+
+    return result;
+  }
+
+  isEncoded(str) {
+    return /%[0-9A-Fa-f]{2}/.test(str);
+  }
+
+  urlToFilePath(url) {
+    try {
+      // If it's a full URL, extract the pathname
+      let urlPath = url;
+      if (url.startsWith("http://") || url.startsWith("https://")) {
+        const urlObj = new URL(url);
+        urlPath = urlObj.pathname;
+      }
+
+      // Remove leading slash if present
+      if (urlPath.startsWith("/")) {
+        urlPath = urlPath.substring(1);
+      }
+
+      // Split into parts and decode each part
+      const parts = urlPath.split("/");
+      const decodedParts = parts.map((part) => decodeURIComponent(part));
+
+      // If the URL path starts with 'files', remove that segment because
+      // our publicFolder already represents the root of '/files'.
+      if (decodedParts.length && decodedParts[0] === "files") {
+        decodedParts.shift();
+      }
+
+      // Join with the public folder path
+      return path.join(this.publicFolder, ...decodedParts);
+    } catch (error) {
+      console.error("Error converting URL to file path:", error);
+      return null;
     }
-} 
+  }
+}

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

@@ -1,86 +1,88 @@
-import { AzureStorageProvider } from './AzureStorageProvider.js';
-import { GCSStorageProvider } from './GCSStorageProvider.js';
-import { LocalStorageProvider } from './LocalStorageProvider.js';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { AzureStorageProvider } from "./AzureStorageProvider.js";
+import { GCSStorageProvider } from "./GCSStorageProvider.js";
+import { LocalStorageProvider } from "./LocalStorageProvider.js";
+import path from "path";
+import { fileURLToPath } from "url";
 
 export class StorageFactory {
-    constructor() {
-        this.providers = new Map();
-    }
+  constructor() {
+    this.providers = new Map();
+  }
 
-    getPrimaryProvider() {
-        if (process.env.AZURE_STORAGE_CONNECTION_STRING) {
-            return this.getAzureProvider();
-        }
-        return this.getLocalProvider();
+  getPrimaryProvider() {
+    if (process.env.AZURE_STORAGE_CONNECTION_STRING) {
+      return this.getAzureProvider();
     }
+    return this.getLocalProvider();
+  }
 
-    getAzureProvider() {
-        const key = 'azure';
-        if (!this.providers.has(key)) {
-            const provider = new AzureStorageProvider(
-                process.env.AZURE_STORAGE_CONNECTION_STRING,
-                process.env.AZURE_STORAGE_CONTAINER_NAME || 'whispertempfiles'
-            );
-            this.providers.set(key, provider);
-        }
-        return this.providers.get(key);
+  getAzureProvider() {
+    const key = "azure";
+    if (!this.providers.has(key)) {
+      const provider = new AzureStorageProvider(
+        process.env.AZURE_STORAGE_CONNECTION_STRING,
+        process.env.AZURE_STORAGE_CONTAINER_NAME || "whispertempfiles",
+      );
+      this.providers.set(key, provider);
     }
+    return this.providers.get(key);
+  }
 
-    getGCSProvider() {
-        const key = 'gcs';
-        if (!this.providers.has(key)) {
-            const credentials = this.parseGCSCredentials();
-            if (!credentials) {
-                return null;
-            }
-            const provider = new GCSStorageProvider(
-                credentials,
-                process.env.GCS_BUCKETNAME || 'cortextempfiles'
-            );
-            this.providers.set(key, provider);
-        }
-        return this.providers.get(key);
+  getGCSProvider() {
+    const key = "gcs";
+    if (!this.providers.has(key)) {
+      const credentials = this.parseGCSCredentials();
+      if (!credentials) {
+        return null;
+      }
+      const provider = new GCSStorageProvider(
+        credentials,
+        process.env.GCS_BUCKETNAME || "cortextempfiles",
+      );
+      this.providers.set(key, provider);
     }
+    return this.providers.get(key);
+  }
 
-    getLocalProvider() {
-        const key = 'local';
-        if (!this.providers.has(key)) {
-            let folder = process.env.PUBLIC_FOLDER;
-            if (!folder) {
-                // Compute src/files relative to current directory
-                const __dirname = path.dirname(fileURLToPath(import.meta.url));
-                folder = path.join(__dirname, '..', '..', 'files');
-            }
-            const provider = new LocalStorageProvider(folder);
-            this.providers.set(key, provider);
-        }
-        return this.providers.get(key);
+  getLocalProvider() {
+    const key = "local";
+    if (!this.providers.has(key)) {
+      let folder = process.env.PUBLIC_FOLDER;
+      if (!folder) {
+        // Compute src/files relative to current directory
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        folder = path.join(__dirname, "..", "..", "files");
+      }
+      const provider = new LocalStorageProvider(folder);
+      this.providers.set(key, provider);
     }
+    return this.providers.get(key);
+  }
 
-    parseGCSCredentials() {
-        const key = process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64 || process.env.GCP_SERVICE_ACCOUNT_KEY;
-        if (!key) {
-            return null;
-        }
+  parseGCSCredentials() {
+    const key =
+      process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64 ||
+      process.env.GCP_SERVICE_ACCOUNT_KEY;
+    if (!key) {
+      return null;
+    }
 
-        try {
-            if (this.isBase64(key)) {
-                return JSON.parse(Buffer.from(key, 'base64').toString());
-            }
-            return JSON.parse(key);
-        } catch (error) {
-            console.error('Error parsing GCS credentials:', error);
-            return null;
-        }
+    try {
+      if (this.isBase64(key)) {
+        return JSON.parse(Buffer.from(key, "base64").toString());
+      }
+      return JSON.parse(key);
+    } catch (error) {
+      console.error("Error parsing GCS credentials:", error);
+      return null;
     }
+  }
 
-    isBase64(str) {
-        try {
-            return btoa(atob(str)) === str;
-        } catch (err) {
-            return false;
-        }
+  isBase64(str) {
+    try {
+      return btoa(atob(str)) === str;
+    } catch (err) {
+      return false;
     }
-} 
+  }
+}

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

@@ -2,52 +2,53 @@
  * Base interface for storage providers
  */
 export class StorageProvider {
-    /**
-     * Upload a file to storage
-     * @param {Object} context - The context object
-     * @param {string} filePath - Path to the file to upload
-     * @param {string} requestId - Unique identifier for the request
-     * @param {string} [hash] - Optional hash of the file
-     * @returns {Promise<{url: string, blobName: string}>} The URL and blob name of the uploaded file
-     */
-    async uploadFile(context, filePath, requestId, hash = null) {
-        throw new Error('Method not implemented');
-    }
+  /**
+   * Upload a file to storage
+   * @param {Object} context - The context object
+   * @param {string} filePath - Path to the file to upload
+   * @param {string} requestId - Unique identifier for the request
+   * @param {string} [hash] - Optional hash of the file
+   * @param {string} [filename] - Optional filename to use (if not provided, provider will generate one)
+   * @returns {Promise<{url: string, blobName: string}>} The URL and blob name of the uploaded file
+   */
+  async uploadFile(context, filePath, requestId, hash = null, filename = null) {
+    throw new Error("Method not implemented");
+  }
 
-    /**
-     * Delete files associated with a request ID
-     * @param {string} requestId - The request ID to delete files for
-     * @returns {Promise<string[]>} Array of deleted file URLs
-     */
-    async deleteFiles(requestId) {
-        throw new Error('Method not implemented');
-    }
+  /**
+   * Delete files associated with a request ID
+   * @param {string} requestId - The request ID to delete files for
+   * @returns {Promise<string[]>} Array of deleted file URLs
+   */
+  async deleteFiles(requestId) {
+    throw new Error("Method not implemented");
+  }
 
-    /**
-     * Check if a file exists at the given URL
-     * @param {string} url - The URL to check
-     * @returns {Promise<boolean>} Whether the file exists
-     */
-    async fileExists(url) {
-        throw new Error('Method not implemented');
-    }
+  /**
+   * Check if a file exists at the given URL
+   * @param {string} url - The URL to check
+   * @returns {Promise<boolean>} Whether the file exists
+   */
+  async fileExists(url) {
+    throw new Error("Method not implemented");
+  }
 
-    /**
-     * Download a file from storage
-     * @param {string} url - The URL of the file to download
-     * @param {string} destinationPath - Where to save the downloaded file
-     * @returns {Promise<void>}
-     */
-    async downloadFile(url, destinationPath) {
-        throw new Error('Method not implemented');
-    }
+  /**
+   * Download a file from storage
+   * @param {string} url - The URL of the file to download
+   * @param {string} destinationPath - Where to save the downloaded file
+   * @returns {Promise<void>}
+   */
+  async downloadFile(url, destinationPath) {
+    throw new Error("Method not implemented");
+  }
 
-    /**
-     * Clean up files by their URLs
-     * @param {string[]} urls - Array of URLs to clean up
-     * @returns {Promise<void>}
-     */
-    async cleanup(urls) {
-        throw new Error('Method not implemented');
-    }
-} 
+  /**
+   * Clean up files by their URLs
+   * @param {string[]} urls - Array of URLs to clean up
+   * @returns {Promise<void>}
+   */
+  async cleanup(urls) {
+    throw new Error("Method not implemented");
+  }
+}