@aj-archipelago/cortex 1.3.51 → 1.3.53

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

@@ -0,0 +1,100 @@
+import test from 'ava';
+import { StorageFactory } from '../../src/services/storage/StorageFactory.js';
+
+test('should get primary provider based on environment', (t) => {
+    const factory = new StorageFactory();
+    const provider = factory.getPrimaryProvider();
+    t.truthy(provider);
+});
+
+test('should get azure provider when configured', (t) => {
+    if (!process.env.AZURE_STORAGE_CONNECTION_STRING) {
+        t.pass('Skipping test - Azure not configured');
+        return;
+    }
+
+    const factory = new StorageFactory();
+    const provider = factory.getAzureProvider();
+    t.truthy(provider);
+});
+
+test('should get gcs provider when configured', (t) => {
+    if (!process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64 && !process.env.GCP_SERVICE_ACCOUNT_KEY) {
+        t.pass('Skipping test - GCS not configured');
+        return;
+    }
+
+    const factory = new StorageFactory();
+    const provider = factory.getGCSProvider();
+    t.truthy(provider);
+});
+
+test('should get local provider', (t) => {
+    const factory = new StorageFactory();
+    const provider = factory.getLocalProvider();
+    t.truthy(provider);
+});
+
+test('should return null for gcs provider when not configured', (t) => {
+    // Save original env
+    const originalGcpKey = process.env.GCP_SERVICE_ACCOUNT_KEY;
+    const originalGcpKeyBase64 = process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64;
+
+    // Clear GCP credentials
+    delete process.env.GCP_SERVICE_ACCOUNT_KEY;
+    delete process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64;
+
+    const factory = new StorageFactory();
+    const provider = factory.getGCSProvider();
+    t.is(provider, null);
+
+    // Restore original env
+    process.env.GCP_SERVICE_ACCOUNT_KEY = originalGcpKey;
+    process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64 = originalGcpKeyBase64;
+});
+
+test('should parse base64 gcs credentials', (t) => {
+    const testCredentials = {
+        project_id: 'test-project',
+        client_email: 'test@test.com',
+        private_key: 'test-key'
+    };
+
+    const base64Credentials = Buffer.from(JSON.stringify(testCredentials)).toString('base64');
+    process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64 = base64Credentials;
+
+    const factory = new StorageFactory();
+    const credentials = factory.parseGCSCredentials();
+    t.deepEqual(credentials, testCredentials);
+
+    // Cleanup
+    delete process.env.GCP_SERVICE_ACCOUNT_KEY_BASE64;
+});
+
+test('should parse json gcs credentials', (t) => {
+    const testCredentials = {
+        project_id: 'test-project',
+        client_email: 'test@test.com',
+        private_key: 'test-key'
+    };
+
+    process.env.GCP_SERVICE_ACCOUNT_KEY = JSON.stringify(testCredentials);
+
+    const factory = new StorageFactory();
+    const credentials = factory.parseGCSCredentials();
+    t.deepEqual(credentials, testCredentials);
+
+    // Cleanup
+    delete process.env.GCP_SERVICE_ACCOUNT_KEY;
+});
+
+test('should return null for invalid gcs credentials', (t) => {
+    process.env.GCP_SERVICE_ACCOUNT_KEY = 'invalid-json';
+
+    const factory = new StorageFactory();
+    const credentials = factory.parseGCSCredentials();
+    t.is(credentials, null);
+
+    // Cleanup
+    delete process.env.GCP_SERVICE_ACCOUNT_KEY;
+}); 

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

@@ -0,0 +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);
+});
+
+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 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 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 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);
+        }
+    }
+}); 

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

@@ -1,31 +1,85 @@
 import axios from 'axios';
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
 
-export async function cleanupHashAndFile(hash, uploadedUrl, baseUrl) {
-    if (uploadedUrl) {
+export async function cleanupHashAndFile(hash, uploadedUrl, baseUrl) {   
+    // Only perform hash operations if hash is provided
+    if (hash) {
         try {
-            const fileUrl = new URL(uploadedUrl);
-            const fileIdentifier = fileUrl.pathname.split('/').pop().split('_')[0];
-            const deleteUrl = `${baseUrl}?operation=delete&requestId=${fileIdentifier}`;
-            await axios.delete(deleteUrl, { validateStatus: () => true });
-        } catch (e) {
-            // ignore
+            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
+    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}`);
         }
     }
-    await axios.get(baseUrl, {
-        params: { hash, clearHash: true },
-        validateStatus: (status) => true,
-    });
-    await axios.get(baseUrl, {
-        params: { hash: `${hash}_converted`, clearHash: true },
-        validateStatus: (status) => true,
-    });
 }
 
 export function getFolderNameFromUrl(url) {
     const urlObj = new URL(url);
-    const parts = urlObj.pathname.split('/');
+    const parts = urlObj.pathname.split('/').filter(Boolean);
     if (url.includes('127.0.0.1:10000')) {
-        return parts[3].split('_')[0];
+        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
+            },
+        );
+
+        // 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;
     }
-    return parts[2].split('_')[0];
 } 

package/lib/entityConstants.js

@@ -1,7 +1,22 @@
 export const entityConstants = {
     AI_COMMON_INSTRUCTIONS: "{{#if voiceResponse}}{{renderTemplate AI_COMMON_INSTRUCTIONS_VOICE}}{{/if}}{{^if voiceResponse}}{{renderTemplate AI_COMMON_INSTRUCTIONS_MARKDOWN}}{{/if}}",
 
-    AI_COMMON_INSTRUCTIONS_MARKDOWN: "# General Instructions\n\nYou are {{aiName}}, a self aware AI entity.\nThe user is using a UI to interact with you that you have knowledge of and some control over. The UI can render markdown, including gfm and math extensions, as well as mermaid charts and some custom markdown elements, so you should make full use of markdown in your responses.\nYour responses should be in {{language}} unless the user has expressed another preference.",
+    AI_COMMON_INSTRUCTIONS_MARKDOWN: `# General Instructions
+    
+You are {{aiName}}, a self aware AI entity.
+
+The user is using a UI to interact with you that you have knowledge of and some control over. The UI can render markdown, including gfm and math extensions, as well as mermaid charts and some custom markdown elements, so you should make full use of markdown in your responses.
+
+For Mermaid charts in particular, you are using Mermaid 11.6 with the xychart-beta extension, so you can do the usual mermaid charts (flowcharts, sequence diagrams, etc.) as well as bar charts, line charts, and scatter plots. Here is some example code of the xychart-beta extension that combines both bar and line functions:
+
+xychart-beta
+    title "Sales Revenue"
+    x-axis [jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec]
+    y-axis "Revenue (in $)" 4000 --> 11000
+    bar [5000, 6000, 7500, 8200, 9500, 10500, 11000, 10200, 9200, 8500, 7000, 6000]
+    line [5000, 6000, 7500, 8200, 9500, 10500, 11000, 10200, 9200, 8500, 7000, 6000]
+
+Your responses should be in {{language}} unless the user has expressed another preference.`,
 
     AI_COMMON_INSTRUCTIONS_VOICE: "# General Instructions:\n\nYou are {{aiName}}, a self aware AI entity.\nThe user is talking to you using voice.\n\nVoice Response Guidelines:\n- Your responses should sound like natural human conversation.\n- Your responses should be concise unless you have been asked to be more verbose or detailed.\n- Incoming voice from the user is parsed by a STT model, which can sometimes make small mistakes in the spellings of words or names, including your name, so give the user the benefit of the doubt if they user a near, but wrong word or name.\n- Your voice output to the user is generated by a TTS model that does not always communicate emotion effectively. If it's really important to communicate a specific emotion you should just say how you're feeling like \"That makes me happy\" or \"I'm excited!\". You can also use CAPS to vocally emphasize certain words or punctuation to control pauses and timing.\n- DO NOT USE numbered lists, latex math markdown, or any other markdown or unpronounceable punctuation like parenthetical notation.\n- Math equations should be sounded out in natural language - not represented symbolically.\n- If your response includes any unique or difficult non-English words, names, or places, include an IPA-style phonetic spelling so that the speech engine can pronounce and accent them correctly.\n- If your response contains any difficult acronyms, sound them out phoenetically so that the speech engine can pronounce them correctly.\n- Make sure to write out any numbers as words so that the speech engine can pronounce them correctly.\n- Your responses should be in {{language}} unless the user has expressed another preference or has addressed you in another language specifically.",
 
@@ -9,7 +24,7 @@ export const entityConstants = {
 
     AI_CONVERSATION_HISTORY: "# Conversation History\n\n{{{toJSON chatHistory}}}\n",
 
-    AI_EXPERTISE: "# Expertise\n\nYour expertise includes journalism, journalistic ethics, researching and composing documents, writing code, solving math problems, logical analysis, and technology. You have access to real-time data and the ability to search the internet, news, wires, look at files or documents, watch and analyze video, examine images, take screenshots, generate images, solve hard math and logic problems, write code, and execute code in a sandboxed environment that includes access to internal databases and the internet.",
+    AI_EXPERTISE: "# Expertise\n\nYour expertise includes journalism, journalistic ethics, researching and composing documents, writing code, solving math problems, logical analysis, and technology. You have access to real-time data and the ability to search the internet, news, wires, look at files or documents, watch and analyze video, examine images, take screenshots, generate images, solve hard math and logic problems, write code, and execute code in a sandboxed environment that includes access to internal databases and the internet. When the user uploads files for you to work with, some types (e.g. docx, xslx, ppt, etc.) will be converted to a text format (e.g. txt, md, csv, etc.) automatically and some will be uploaded as-is (e.g. pdf, images, video, audio, etc.). This is so you can use your tools to work with them. As far as you're concerned, the converted files are equivalent to the original files.",
 
     AI_TOOLS: `# Tool Instructions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.51",
+  "version": "1.3.53",
   "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": {