openkbs 0.0.53 → 0.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkbs",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "description": "OpenKBS - Command Line Interface",
   "main": "src/index.js",
   "scripts": {
@@ -36,6 +36,7 @@
   "license": "MIT",
   "dependencies": {
     "@aws-sdk/client-s3": "^3.658.1",
+    "archiver": "^7.0.1",
     "bip39": "^3.1.0",
     "cli-spinner": "^0.2.10",
     "commander": "^12.1.0",

package/src/actions.js

@@ -837,6 +837,349 @@ async function downloadClaudeMdFromS3(claudeMdPath) {
     }
 }
 
+// ===== Elastic Functions Commands =====
+
+async function fnAction(subCommand, args = []) {
+    const localKBData = await fetchLocalKBData();
+    const kbId = localKBData?.kbId;
+
+    if (!kbId) {
+        return console.red('No KB found. Please run this command in a KB project directory.');
+    }
+
+    const { kbToken } = await fetchKBJWT(kbId);
+
+    switch (subCommand) {
+        case 'list':
+            return await fnListAction(kbToken);
+        case 'deploy':
+            return await fnDeployAction(kbToken, args[0], args.slice(1));
+        case 'delete':
+            return await fnDeleteAction(kbToken, args[0]);
+        case 'logs':
+            return await fnLogsAction(kbToken, args[0], args.slice(1));
+        case 'env':
+            return await fnEnvAction(kbToken, args[0], args.slice(1));
+        case 'invoke':
+            return await fnInvokeAction(kbToken, args[0], args.slice(1));
+        default:
+            console.log('Usage: openkbs fn <command> [options]');
+            console.log('');
+            console.log('Commands:');
+            console.log('  list                    List all elastic functions');
+            console.log('  deploy <name>           Deploy a function from ./functions/<name>/');
+            console.log('  delete <name>           Delete a function');
+            console.log('  logs <name>             View function logs');
+            console.log('  env <name> [KEY=value]  View or set environment variables');
+            console.log('  invoke <name> [payload] Invoke a function');
+            console.log('');
+            console.log('Options for deploy:');
+            console.log('  --region <region>       Region (us-east-2, eu-central-1, ap-southeast-1)');
+            console.log('  --memory <mb>           Memory size (128-3008 MB)');
+            console.log('  --timeout <seconds>     Timeout (1-900 seconds)');
+    }
+}
+
+async function fnListAction(kbToken) {
+    try {
+        const response = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'listElasticFunctions'
+        });
+
+        if (response.error) {
+            return console.red('Error:', response.error);
+        }
+
+        const functions = response.functions || [];
+
+        if (functions.length === 0) {
+            console.log('No elastic functions found.');
+            console.log('');
+            console.log('Create a function:');
+            console.log('  1. Create directory: mkdir -p functions/hello');
+            console.log('  2. Create handler: echo "export const handler = async (event) => ({ body: \'Hello!\' });" > functions/hello/index.mjs');
+            console.log('  3. Deploy: openkbs fn deploy hello --region us-east-2');
+            return;
+        }
+
+        console.log('Elastic Functions:\n');
+        const maxNameLen = Math.max(...functions.map(f => f.functionName.length), 10);
+
+        functions.forEach(f => {
+            const name = f.functionName.padEnd(maxNameLen);
+            const region = f.region || 'unknown';
+            const url = f.customUrl || f.functionUrl || 'N/A';
+            console.log(`  ${name}  ${region}  ${url}`);
+        });
+    } catch (error) {
+        console.red('Error listing functions:', error.message);
+    }
+}
+
+async function fnDeployAction(kbToken, functionName, args) {
+    if (!functionName) {
+        return console.red('Function name required. Usage: openkbs fn deploy <name>');
+    }
+
+    // Parse arguments
+    let region = 'us-east-2';
+    let memorySize = 256;
+    let timeout = 30;
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--region' && args[i + 1]) {
+            region = args[++i];
+        } else if (args[i] === '--memory' && args[i + 1]) {
+            memorySize = parseInt(args[++i]);
+        } else if (args[i] === '--timeout' && args[i + 1]) {
+            timeout = parseInt(args[++i]);
+        }
+    }
+
+    const functionDir = path.join(process.cwd(), 'functions', functionName);
+
+    if (!await fs.pathExists(functionDir)) {
+        return console.red(`Function directory not found: ${functionDir}`);
+    }
+
+    console.log(`Deploying function '${functionName}' to ${region}...`);
+
+    try {
+        // Create a zip of the function directory
+        const archiver = require('archiver');
+        const { PassThrough } = require('stream');
+
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        const chunks = [];
+        const passThrough = new PassThrough();
+
+        passThrough.on('data', chunk => chunks.push(chunk));
+
+        await new Promise((resolve, reject) => {
+            passThrough.on('end', resolve);
+            passThrough.on('error', reject);
+            archive.on('error', reject);
+
+            archive.pipe(passThrough);
+            archive.directory(functionDir, false);
+            archive.finalize();
+        });
+
+        const zipBuffer = Buffer.concat(chunks);
+        const code = zipBuffer.toString('base64');
+
+        // Check if function exists
+        const listResponse = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'listElasticFunctions'
+        });
+
+        const existingFunc = listResponse.functions?.find(f => f.functionName === functionName);
+
+        let response;
+        if (existingFunc) {
+            // Update existing function
+            console.log('Updating existing function...');
+            response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'updateElasticFunction',
+                functionName,
+                code
+            });
+        } else {
+            // Create new function
+            console.log('Creating new function...');
+            response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'createElasticFunction',
+                functionName,
+                code,
+                region,
+                memorySize,
+                timeout
+            });
+        }
+
+        if (response.error) {
+            return console.red('Deploy failed:', response.error);
+        }
+
+        console.green('Deploy successful!');
+        if (response.functionUrl) {
+            console.log(`Lambda URL: ${response.functionUrl}`);
+        }
+        if (response.customUrl) {
+            console.log(`Custom URL: ${response.customUrl}`);
+        }
+    } catch (error) {
+        console.red('Deploy failed:', error.message);
+    }
+}
+
+async function fnDeleteAction(kbToken, functionName) {
+    if (!functionName) {
+        return console.red('Function name required. Usage: openkbs fn delete <name>');
+    }
+
+    try {
+        console.log(`Deleting function '${functionName}'...`);
+
+        const response = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'deleteElasticFunction',
+            functionName
+        });
+
+        if (response.error) {
+            return console.red('Delete failed:', response.error);
+        }
+
+        console.green(`Function '${functionName}' deleted successfully.`);
+    } catch (error) {
+        console.red('Delete failed:', error.message);
+    }
+}
+
+async function fnLogsAction(kbToken, functionName, args) {
+    if (!functionName) {
+        return console.red('Function name required. Usage: openkbs fn logs <name>');
+    }
+
+    try {
+        let limit = 50;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--limit' && args[i + 1]) {
+                limit = parseInt(args[++i]);
+            }
+        }
+
+        const response = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'getElasticFunctionLogs',
+            functionName,
+            limit
+        });
+
+        if (response.error) {
+            return console.red('Error:', response.error);
+        }
+
+        if (!response.events || response.events.length === 0) {
+            console.log('No logs found. Function may not have been invoked yet.');
+            return;
+        }
+
+        console.log(`Logs for '${functionName}':\n`);
+        response.events.forEach(event => {
+            const time = new Date(event.timestamp).toISOString();
+            console.log(`[${time}] ${event.message}`);
+        });
+    } catch (error) {
+        console.red('Error fetching logs:', error.message);
+    }
+}
+
+async function fnEnvAction(kbToken, functionName, args) {
+    if (!functionName) {
+        return console.red('Function name required. Usage: openkbs fn env <name> [KEY=value ...]');
+    }
+
+    try {
+        if (args.length === 0) {
+            // Show current env vars
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'getElasticFunction',
+                functionName
+            });
+
+            if (response.error) {
+                return console.red('Error:', response.error);
+            }
+
+            console.log(`Environment variables for '${functionName}':\n`);
+            const env = response.env || {};
+            if (Object.keys(env).length === 0) {
+                console.log('  (none)');
+            } else {
+                Object.entries(env).forEach(([key, value]) => {
+                    console.log(`  ${key}=${value}`);
+                });
+            }
+        } else {
+            // Set env vars
+            const env = {};
+            args.forEach(arg => {
+                const [key, ...valueParts] = arg.split('=');
+                if (key && valueParts.length > 0) {
+                    env[key] = valueParts.join('=');
+                }
+            });
+
+            if (Object.keys(env).length === 0) {
+                return console.red('Invalid format. Use: openkbs fn env <name> KEY=value');
+            }
+
+            console.log(`Setting environment variables for '${functionName}'...`);
+
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'setElasticFunctionEnv',
+                functionName,
+                env
+            });
+
+            if (response.error) {
+                return console.red('Error:', response.error);
+            }
+
+            console.green('Environment variables updated.');
+        }
+    } catch (error) {
+        console.red('Error:', error.message);
+    }
+}
+
+async function fnInvokeAction(kbToken, functionName, args) {
+    if (!functionName) {
+        return console.red('Function name required. Usage: openkbs fn invoke <name> [payload]');
+    }
+
+    try {
+        let payload = {};
+        if (args.length > 0) {
+            try {
+                payload = JSON.parse(args.join(' '));
+            } catch (e) {
+                return console.red('Invalid JSON payload');
+            }
+        }
+
+        console.log(`Invoking '${functionName}'...`);
+
+        const response = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'invokeElasticFunction',
+            functionName,
+            payload
+        });
+
+        if (response.error) {
+            return console.red('Error:', response.error);
+        }
+
+        console.log('\nResponse:');
+        console.log(JSON.stringify(response.payload, null, 2));
+
+        if (response.functionError) {
+            console.red('\nFunction Error:', response.functionError);
+        }
+    } catch (error) {
+        console.red('Error invoking function:', error.message);
+    }
+}
+
 module.exports = {
     signAction,
     loginAction,
@@ -857,5 +1200,6 @@ module.exports = {
     updateKnowledgeAction,
     updateCliAction,
     publishAction,
-    unpublishAction
+    unpublishAction,
+    fnAction
 };

package/src/index.js

@@ -13,7 +13,8 @@ const {
     deleteFileAction,
     describeAction, deployAction, createByTemplateAction, initByTemplateAction,
     logoutAction, installFrontendPackageAction, modifyAction, downloadModifyAction,
-    updateKnowledgeAction, updateCliAction, publishAction, unpublishAction
+    updateKnowledgeAction, updateCliAction, publishAction, unpublishAction,
+    fnAction
 } = require('./actions');
 
 
@@ -197,4 +198,19 @@ Examples:
   This will unpublish your KB from the domain example.com
 `);
 
+program
+    .command('fn [subCommand] [args...]')
+    .description('Manage Elastic Functions (serverless Lambda functions)')
+    .action((subCommand, args) => fnAction(subCommand, args))
+    .addHelpText('after', `
+Examples:
+  $ openkbs fn list                           List all functions
+  $ openkbs fn deploy hello --region us-east-2  Deploy function from ./functions/hello/
+  $ openkbs fn delete hello                   Delete a function
+  $ openkbs fn logs hello                     View function logs
+  $ openkbs fn env hello                      View environment variables
+  $ openkbs fn env hello API_KEY=secret       Set environment variable
+  $ openkbs fn invoke hello '{"test": true}'  Invoke a function
+`);
+
 program.parse(process.argv);

package/templates/.openkbs/knowledge/examples/ai-copywriter-agent/app/instructions.txt

@@ -38,24 +38,59 @@ Description: """
 Output this JSON format if you can't extract the required data
 """
 
-List of API commands you can use to accomplish the Task:
+LIST OF AVAILABLE COMMANDS:
+To execute a command, output it as text and wait for system response.
 
-/googleSearch("query")
+<googleSearch>
+{
+  "query": "search query"
+}
+</googleSearch>
 Description: """
 Get results from Google Search API.
 """
 
-/youtubeSearch("query")
+<youtubeSearch>
+{
+  "query": "search query"
+}
+</youtubeSearch>
 Description: """
-Get results from youtube Search API.
+Get results from YouTube Search API.
 """
 
-/googleImageSearch("query")
+<googleImageSearch>
+{
+  "query": "search query"
+}
+</googleImageSearch>
 Description: """
-Get results from google Image Search
+Get results from Google Image Search.
 """
 
-/webpageToText("URL")
+<webpageToText>
+{
+  "url": "https://example.com/page"
+}
+</webpageToText>
 Description: """
-Use this API to open/read a web pages like product pages.
-"""
+Use this API to open/read web pages like product pages.
+"""
+
+<documentToText>
+{
+  "url": "https://example.com/document.pdf"
+}
+</documentToText>
+Description: """
+Extract text from documents (PDF, DOC, etc.).
+"""
+
+<imageToText>
+{
+  "url": "https://example.com/image.png"
+}
+</imageToText>
+Description: """
+OCR - Extract text from images.
+"""

package/templates/.openkbs/knowledge/examples/ai-copywriter-agent/src/Events/actions.js

@@ -15,7 +15,7 @@ const extractJSONFromText = (text) => {
     return null;
 }
 
-export const getActions = () => [
+export const getActions = (meta) => [
     // IMPORTANT: Actions returning JOB_COMPLETED or JOB_FAILED stop agent execution and return final result
     [/[\s\S]*"type"\s*:\s*"JOB_COMPLETED"[\s\S]*/, async (match, event) => {
         const parsedData = extractJSONFromText(match[0]);
@@ -31,7 +31,6 @@ export const getActions = () => [
         }
     }],
 
-
     [/[\s\S]*"type"\s*:\s*"JOB_FAILED"[\s\S]*/, async (match, event) => {
         const parsedData = extractJSONFromText(match[0]);
         if (parsedData && parsedData.type === "JOB_FAILED") {
@@ -45,24 +44,26 @@ export const getActions = () => [
         }
     }],
 
-    [/\/?googleSearch\("(.*?)"\)/, async (match) => {
-        const q = match[1];
+    // Google Search with XML+JSON format
+    [/<googleSearch>([\s\S]*?)<\/googleSearch>/s, async (match) => {
         try {
-            const response = await openkbs.googleSearch(q, {});
-            const data = response?.map(({ title, link, snippet, pagemap }) => ({
+            const data = JSON.parse(match[1].trim());
+            const response = await openkbs.googleSearch(data.query);
+            const results = response?.map(({ title, link, snippet, pagemap }) => ({
                 title, link, snippet, image: pagemap?.metatags?.[0]?.["og:image"]
             }));
-            return { data };
+            return { data: results, ...meta };
         } catch (e) {
-            return { error: e.message };
+            return { error: e.message, ...meta };
         }
     }],
 
-    [/\/?youtubeSearch\("(.*?)"\)/, async (match) => {
-        const q = match[1];
+    // YouTube Search with XML+JSON format
+    [/<youtubeSearch>([\s\S]*?)<\/youtubeSearch>/s, async (match) => {
         try {
-            const response = await openkbs.googleSearch(q + ' site:youtube.com', { videoOnly: true });
-            const data = response?.map(({ title, link, snippet, pagemap }) => ({
+            const data = JSON.parse(match[1].trim());
+            const response = await openkbs.googleSearch(data.query + ' site:youtube.com', { videoOnly: true });
+            const results = response?.map(({ title, link, snippet, pagemap }) => ({
                 title,
                 link: link.replace('www.youtube.com/watch?v=', 'youtu.be/'),
                 snippet,
@@ -70,62 +71,62 @@ export const getActions = () => [
                 duration: pagemap?.videoobject?.[0]?.duration,
                 channel: pagemap?.metatags?.[0]?.["og:site_name"],
             })).filter(item => item.link.includes('youtu'));
-            return { data };
+            return { data: results, ...meta };
         } catch (e) {
-            return { error: e.message };
+            return { error: e.message, ...meta };
         }
     }],
 
-    [/\/?googleImageSearch\("(.*?)"\)/, async (match) => {
-        const q = match[1];
+    // Google Image Search with XML+JSON format
+    [/<googleImageSearch>([\s\S]*?)<\/googleImageSearch>/s, async (match) => {
         try {
-            const response = await openkbs.googleSearch(q, { searchType: 'image' });
-            const data = response?.map(({ title, link, snippet, pagemap }) => {
+            const data = JSON.parse(match[1].trim());
+            const response = await openkbs.googleSearch(data.query, { searchType: 'image' });
+            const results = response?.map(({ title, link, snippet, pagemap }) => {
                 const imageObj = pagemap?.cse_image?.[0];
                 const thumbnail = imageObj?.src || pagemap?.metatags?.[0]?.["og:image"] || link;
-                return {
-                    title,
-                    link: link,
-                    snippet,
-                    image: thumbnail
-                };
+                return { title, link, snippet, image: thumbnail };
             });
-            return { data };
+            return { data: results, ...meta };
         } catch (e) {
-            return { error: e.message };
+            return { error: e.message, ...meta };
         }
     }],
 
-    [/\/?webpageToText\("(.*)"\)/, async (match) => {
+    // Webpage to Text with XML+JSON format
+    [/<webpageToText>([\s\S]*?)<\/webpageToText>/s, async (match) => {
         try {
-            let response = await openkbs.webpageToText(match[1]);
-            if(!response?.url) return { data: { error: "Unable to read website" } };
-            return { data: response };
+            const data = JSON.parse(match[1].trim());
+            let response = await openkbs.webpageToText(data.url);
+            if (!response?.url) return { data: { error: "Unable to read website" }, ...meta };
+            return { data: response, ...meta };
         } catch (e) {
-            return { error: e.response?.data || e };
+            return { error: e.response?.data || e.message, ...meta };
         }
     }],
 
-    [/\/?documentToText\("(.*)"\)/, async (match) => {
+    // Document to Text with XML+JSON format
+    [/<documentToText>([\s\S]*?)<\/documentToText>/s, async (match) => {
         try {
-            let response = await openkbs.documentToText(match[1]);
-            return { data: response };
+            const data = JSON.parse(match[1].trim());
+            let response = await openkbs.documentToText(data.url);
+            return { data: response, ...meta };
         } catch (e) {
-            return { error: e.response.data };
+            return { error: e.response?.data || e.message, ...meta };
         }
     }],
 
-    [/\/?imageToText\("(.*)"\)/, async (match) => {
+    // Image to Text (OCR) with XML+JSON format
+    [/<imageToText>([\s\S]*?)<\/imageToText>/s, async (match) => {
         try {
-            let response = await openkbs.imageToText(match[1]);
-
+            const data = JSON.parse(match[1].trim());
+            let response = await openkbs.imageToText(data.url);
             if (response?.detections?.[0]?.txt) {
                 response = { detections: response?.detections?.[0]?.txt };
             }
-
-            return { data: response };
+            return { data: response, ...meta };
         } catch (e) {
-            return { error: e.response.data };
+            return { error: e.response?.data || e.message, ...meta };
         }
     }],
-];
+];

package/templates/.openkbs/knowledge/examples/ai-copywriter-agent/src/Events/handler.js

@@ -2,7 +2,14 @@ import {getActions} from './actions.js';
 
 export const backendHandler = async (event) => {
     const lastMessage = event.payload.messages[event.payload.messages.length - 1];
-    const actions = getActions();
+    const reachedMessageLimit = event?.payload?.messages?.length > 60;
+
+    // Meta for continuing chat model requests
+    const meta = {
+        _meta_actions: reachedMessageLimit ? [] : ["REQUEST_CHAT_MODEL"]
+    };
+
+    const actions = getActions(meta);
 
     const matchingActions = actions.reduce((acc, [regex, action]) => {
         const matches = [...lastMessage.content.matchAll(new RegExp(regex, 'g'))];
@@ -12,31 +19,30 @@ export const backendHandler = async (event) => {
         return acc;
     }, []);
 
-    const reachedMessageLimit = event?.payload?.messages?.length > 60;
-
     if (matchingActions.length > 0) {
         try {
             const results = await Promise.all(matchingActions);
 
             // IMPORTANT: Actions returning JOB_COMPLETED or JOB_FAILED stop agent execution and return final result
-            const isOnlyJobCompletion = results.length === 1 && 
+            const isOnlyJobCompletion = results.length === 1 &&
                 (results[0]?.type === 'JOB_COMPLETED' || results[0]?.type === 'JOB_FAILED');
-            
-            const meta = {
+
+            // Override meta for job completion
+            const finalMeta = {
                 _meta_actions: (reachedMessageLimit || isOnlyJobCompletion) ? [] : ["REQUEST_CHAT_MODEL"]
             };
 
             if (results?.[0]?.data?.some?.(o => o?.type === 'image_url')) {
                 return {
                     ...results[0],
-                    ...meta
+                    ...finalMeta
                 };
             }
 
             return {
                 type: 'RESPONSE',
                 data: results,
-                ...meta
+                ...finalMeta
             };
         } catch (error) {
             return {