@aj-archipelago/cortex 1.3.58 → 1.3.59

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

@@ -1,113 +1,113 @@
-import test from 'ava';
-import { StorageService } from '../../src/services/storage/StorageService.js';
-import { StorageFactory } from '../../src/services/storage/StorageFactory.js';
-import path from 'path';
-import os from 'os';
-import fs from 'fs';
-
-test('should create storage service with factory', (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    t.truthy(service);
+import test from "ava";
+import { StorageService } from "../../src/services/storage/StorageService.js";
+import { StorageFactory } from "../../src/services/storage/StorageFactory.js";
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+test("should create storage service with factory", (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  t.truthy(service);
+});
+
+test("should get primary provider", (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  const provider = service.getPrimaryProvider();
+  t.truthy(provider);
 });
 
-test('should get primary provider', (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    const provider = service.getPrimaryProvider();
+test("should get backup provider", (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  const provider = service.getBackupProvider();
+  if (!provider) {
+    t.log("GCS not configured, skipping test");
+    t.pass();
+  } else {
     t.truthy(provider);
+  }
 });
 
-test('should get backup provider', (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    const provider = service.getBackupProvider();
-    if (!provider) {
-        t.log('GCS not configured, skipping test');
-        t.pass();
-    } else {
-        t.truthy(provider);
-    }
+test("should upload file to primary storage", async (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  const testContent = "test content";
+  const buffer = Buffer.from(testContent);
+
+  const result = await service.uploadFile(buffer, "test.txt");
+  t.truthy(result.url);
+
+  // Cleanup
+  await service.deleteFile(result.url);
 });
 
-test('should upload file to primary storage', async (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    const testContent = 'test content';
-    const buffer = Buffer.from(testContent);
-    
-    const result = await service.uploadFile(buffer, 'test.txt');
-    t.truthy(result.url);
-    
-    // Cleanup
-    await service.deleteFile(result.url);
+test("should upload file to backup storage", async (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  const provider = service.getBackupProvider();
+  if (!provider) {
+    t.log("GCS not configured, skipping test");
+    t.pass();
+    return;
+  }
+  const testContent = "test content";
+  const buffer = Buffer.from(testContent);
+
+  const result = await service.uploadFileToBackup(buffer, "test.txt");
+  t.truthy(result.url);
+
+  // Cleanup
+  await service.deleteFileFromBackup(result.url);
 });
 
-test('should upload file to backup storage', async (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    const provider = service.getBackupProvider();
-    if (!provider) {
-        t.log('GCS not configured, skipping test');
-        t.pass();
-        return;
-    }
-    const testContent = 'test content';
-    const buffer = Buffer.from(testContent);
-    
-    const result = await service.uploadFileToBackup(buffer, 'test.txt');
-    t.truthy(result.url);
-    
-    // Cleanup
-    await service.deleteFileFromBackup(result.url);
+test("should download file from primary storage", async (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  const testContent = "test content";
+  const buffer = Buffer.from(testContent);
+
+  // Upload first
+  const uploadResult = await service.uploadFile(buffer, "test.txt");
+
+  // Download
+  const downloadResult = await service.downloadFile(uploadResult.url);
+  t.deepEqual(downloadResult, buffer);
+
+  // Cleanup
+  await service.deleteFile(uploadResult.url);
 });
 
-test('should download file from primary storage', async (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    const testContent = 'test content';
-    const buffer = Buffer.from(testContent);
-    
-    // Upload first
-    const uploadResult = await service.uploadFile(buffer, 'test.txt');
-    
+test("should download file from backup storage", async (t) => {
+  const factory = new StorageFactory();
+  const service = new StorageService(factory);
+  const provider = service.getBackupProvider();
+  if (!provider) {
+    t.log("GCS not configured, skipping test");
+    t.pass();
+    return;
+  }
+  const testContent = "test content";
+  const buffer = Buffer.from(testContent);
+
+  // Upload first
+  const uploadResult = await service.uploadFileToBackup(buffer, "test.txt");
+
+  // Create temp file for download
+  const tempFile = path.join(os.tmpdir(), "test-download.txt");
+  try {
     // Download
-    const downloadResult = await service.downloadFile(uploadResult.url);
-    t.deepEqual(downloadResult, buffer);
-    
-    // Cleanup
-    await service.deleteFile(uploadResult.url);
-});
+    await service.downloadFileFromBackup(uploadResult.url, tempFile);
+    const downloadedContent = await fs.promises.readFile(tempFile);
+    t.deepEqual(downloadedContent, buffer);
 
-test('should download file from backup storage', async (t) => {
-    const factory = new StorageFactory();
-    const service = new StorageService(factory);
-    const provider = service.getBackupProvider();
-    if (!provider) {
-        t.log('GCS not configured, skipping test');
-        t.pass();
-        return;
-    }
-    const testContent = 'test content';
-    const buffer = Buffer.from(testContent);
-    
-    // Upload first
-    const uploadResult = await service.uploadFileToBackup(buffer, 'test.txt');
-    
-    // Create temp file for download
-    const tempFile = path.join(os.tmpdir(), 'test-download.txt');
-    try {
-        // Download
-        await service.downloadFileFromBackup(uploadResult.url, tempFile);
-        const downloadedContent = await fs.promises.readFile(tempFile);
-        t.deepEqual(downloadedContent, buffer);
-        
-        // Cleanup
-        await service.deleteFileFromBackup(uploadResult.url);
-    } finally {
-        // Cleanup temp file
-        if (fs.existsSync(tempFile)) {
-            fs.unlinkSync(tempFile);
-        }
+    // Cleanup
+    await service.deleteFileFromBackup(uploadResult.url);
+  } finally {
+    // Cleanup temp file
+    if (fs.existsSync(tempFile)) {
+      fs.unlinkSync(tempFile);
     }
-}); 
+  }
+});

package/helper-apps/cortex-file-handler/tests/testUtils.helper.js

@@ -1,85 +1,89 @@
-import axios from 'axios';
-import { execSync } from 'child_process';
-import fs from 'fs/promises';
+import axios from "axios";
+import { execSync } from "child_process";
+import fs from "fs/promises";
 
-export async function cleanupHashAndFile(hash, uploadedUrl, baseUrl) {   
-    // Only perform hash operations if hash is provided
-    if (hash) {
-        try {
-            const clearResponse = await axios.get(
-                `${baseUrl}?hash=${hash}&clearHash=true`,
-                {
-                    validateStatus: (status) => true,
-                    timeout: 10000,
-                },
-            );
-        } catch (error) {
-            console.error(`[cleanupHashAndFile] Error clearing hash: ${error.message}`);
-        }
-    }
-
-    // Then delete the file
+export async function cleanupHashAndFile(hash, uploadedUrl, baseUrl) {
+  // Only perform hash operations if hash is provided
+  if (hash) {
     try {
-        const folderName = getFolderNameFromUrl(uploadedUrl);
-        const deleteResponse = await axios.delete(
-            `${baseUrl}?operation=delete&requestId=${folderName}`,
-            {
-                validateStatus: (status) => true,
-                timeout: 10000,
-            },
-        );
+      const clearResponse = await axios.get(
+        `${baseUrl}?hash=${hash}&clearHash=true`,
+        {
+          validateStatus: (status) => true,
+          timeout: 10000,
+        },
+      );
     } catch (error) {
-        console.error(`[cleanupHashAndFile] Error deleting file: ${error.message}`);
+      console.error(
+        `[cleanupHashAndFile] Error clearing hash: ${error.message}`,
+      );
     }
+  }
+
+  // Then delete the file
+  try {
+    const folderName = getFolderNameFromUrl(uploadedUrl);
+    const deleteResponse = await axios.delete(
+      `${baseUrl}?operation=delete&requestId=${folderName}`,
+      {
+        validateStatus: (status) => true,
+        timeout: 10000,
+      },
+    );
+  } catch (error) {
+    console.error(`[cleanupHashAndFile] Error deleting file: ${error.message}`);
+  }
 
-    // Only verify hash if hash was provided
-    if (hash) {
-        try {
-            const verifyResponse = await axios.get(
-                `${baseUrl}?hash=${hash}&checkHash=true`,
-                {
-                    validateStatus: (status) => true,
-                    timeout: 10000,
-                },
-            );
-        } catch (error) {
-            console.error(`[cleanupHashAndFile] Error verifying hash: ${error.message}`);
-        }
+  // Only verify hash if hash was provided
+  if (hash) {
+    try {
+      const verifyResponse = await axios.get(
+        `${baseUrl}?hash=${hash}&checkHash=true`,
+        {
+          validateStatus: (status) => true,
+          timeout: 10000,
+        },
+      );
+    } catch (error) {
+      console.error(
+        `[cleanupHashAndFile] Error verifying hash: ${error.message}`,
+      );
     }
+  }
 }
 
 export function getFolderNameFromUrl(url) {
-    const urlObj = new URL(url);
-    const parts = urlObj.pathname.split('/').filter(Boolean);
-    if (url.includes('127.0.0.1:10000')) {
-        return parts[2].split('_')[0];
-    }
-    return parts[1].split('_')[0];
+  const urlObj = new URL(url);
+  const parts = urlObj.pathname.split("/").filter(Boolean);
+  if (url.includes("127.0.0.1:10000")) {
+    return parts[2].split("_")[0];
+  }
+  return parts[1].split("_")[0];
 }
 
 // Helper function to create a test media (audio) file of specified duration using ffmpeg
 export async function createTestMediaFile(filepath, durationSeconds = 10) {
-    try {
-        console.log(`Creating test file: ${filepath} (${durationSeconds}s)`);
-        // Generate silence using ffmpeg (mono, 44.1kHz)
-        execSync(
-            `ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t ${durationSeconds} -q:a 9 -acodec libmp3lame "${filepath}"`,
-            {
-                stdio: ['ignore', 'pipe', 'pipe'], // Capture stdout and stderr
-            },
-        );
+  try {
+    console.log(`Creating test file: ${filepath} (${durationSeconds}s)`);
+    // Generate silence using ffmpeg (mono, 44.1kHz)
+    execSync(
+      `ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t ${durationSeconds} -q:a 9 -acodec libmp3lame "${filepath}"`,
+      {
+        stdio: ["ignore", "pipe", "pipe"], // Capture stdout and stderr
+      },
+    );
 
-        // Verify the file was created and has content
-        const stats = await fs.stat(filepath);
-        if (stats.size === 0) {
-            throw new Error('Generated file is empty');
-        }
-        console.log(
-            `Successfully created ${filepath} (${(stats.size / 1024 / 1024).toFixed(2)}MB)`,
-        );
-    } catch (error) {
-        console.error(`Error creating test file ${filepath}:`, error.message);
-        if (error.stderr) console.error('ffmpeg error:', error.stderr.toString());
-        throw error;
+    // Verify the file was created and has content
+    const stats = await fs.stat(filepath);
+    if (stats.size === 0) {
+      throw new Error("Generated file is empty");
     }
-} 
+    console.log(
+      `Successfully created ${filepath} (${(stats.size / 1024 / 1024).toFixed(2)}MB)`,
+    );
+  } catch (error) {
+    console.error(`Error creating test file ${filepath}:`, error.message);
+    if (error.stderr) console.error("ffmpeg error:", error.stderr.toString());
+    throw error;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.58",
+  "version": "1.3.59",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {

package/pathways/translate_subtitle.js

@@ -37,7 +37,9 @@ export function selectBestTranslation(translations, startIndex, endIndex) {
     
     // For multiple translations, prefer the one whose identifier is closest to the middle
     // of the requested range
-    const targetValue = (Number(startIndex) + Number(endIndex)) / 2;
+    const startNum = Number(startIndex);
+    const endNum = Number(endIndex);
+    const targetValue = (isNaN(startNum) || isNaN(endNum)) ? 0 : (startNum + endNum) / 2;
     
     return translations.reduce((best, current) => {
       try {
@@ -82,7 +84,7 @@ export async function translateChunk(chunk, args, maxRetries = 3) {
       const content = match[1].trim();
 
       const parsed = parse(content, { preserveIndexes: true });
-      return parsed.cues;
+      return parsed.cues || [];
       
     } catch (e) {
       logger.error(`Error translating chunk ${chunk.startIndex}-${chunk.endIndex} (attempt ${attempt + 1}): ${e}`);
@@ -105,9 +107,11 @@ export default {
   model: "oai-gpt4o",
   enableDuplicateRequests: false,
   timeout: 3600,
-  executePathway: async ({args}) => {
+  executePathway: async ({args, resolver}) => {
     try {
-      const { text, format = 'vtt' } = args;
+      const combinedArgs = { ...resolver?.pathway?.inputParameters, ...args };
+      const { text, format = 'vtt' } = combinedArgs;
+
       const parsed = parse(text, { format, preserveIndexes: true });
       const captions = parsed.cues;
   
@@ -120,13 +124,16 @@ export default {
       logger.info(`Split subtitles into ${chunks.length} overlapping chunks`);
       
       // Translate all chunks in parallel
-      const chunkPromises = chunks.map(chunk => translateChunk(chunk, args));
+      const chunkPromises = chunks.map(chunk => translateChunk(chunk, combinedArgs));
       const translatedChunks = await Promise.all(chunkPromises);
       
       // Create a map of caption index to all its translations
       const translationMap = new Map();
       translatedChunks.flat().forEach(caption => {
-        const identifier = caption.identifier || caption.index;
+        // Skip null/undefined captions
+        if (!caption) return;
+        
+        const identifier = String(caption.identifier || caption.index || 'unknown');
         if (!translationMap.has(identifier)) {
           translationMap.set(identifier, []);
         }
@@ -135,10 +142,10 @@ export default {
       
       // Select best translation for each caption
       const finalCaptions = captions.map(caption => {
-        const identifier = caption.identifier || caption.index;
+        const identifier = String(caption.identifier || caption.index || 'unknown');
         const translations = translationMap.get(identifier) || [caption];
         const bestTranslation = selectBestTranslation(translations, identifier, identifier);
-        const text = bestTranslation?.text || caption?.text;
+        const text = bestTranslation?.text || caption?.text || '';
         return { ...caption, text };
       });