openkbs 0.0.52 → 0.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkbs",
-  "version": "0.0.52",
+  "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

@@ -10,7 +10,7 @@ const {
     fetchAndSaveSettings, downloadFiles, downloadIcon, updateKB, uploadFiles, generateKey, generateMnemonic,
     reset, bold, red, yellow, green, createKB, saveLocalKBData, listKBs, deleteKBFile,
     deleteKB, buildPackage, replacePlaceholderInFiles, buildNodePackage, initByTemplateAction, modifyKB,
-    listKBsSharedWithMe, downloadTemplates
+    listKBsSharedWithMe, downloadTemplates, KB_API_URL, makePostRequest
 } = require("./utils");
 
 const TEMPLATE_DIR = path.join(os.homedir(), '.openkbs', 'templates');
@@ -618,18 +618,18 @@ async function updateCliAction() {
     try {
         const packageJson = require('../package.json');
         const currentVersion = packageJson.version;
-        
+
         console.log(`Current OpenKBS CLI version: ${currentVersion}`);
         console.log('Checking for updates...');
-        
+
         // Check remote version from S3
         const https = require('https');
         const bucket = 'openkbs-downloads';
         const versionMetadataKey = 'cli/version.json';
-        
+
         let remoteVersionData = null;
         let cliUpdateAvailable = false;
-        
+
         try {
             const fileUrl = `https://${bucket}.s3.amazonaws.com/${versionMetadataKey}`;
             const remoteVersionContent = await new Promise((resolve, reject) => {
@@ -643,25 +643,25 @@ async function updateCliAction() {
                     res.on('end', () => resolve(data));
                 }).on('error', reject);
             });
-            
+
             remoteVersionData = JSON.parse(remoteVersionContent);
             const remoteVersion = remoteVersionData.version;
-            
+
             // Compare versions using semantic versioning
             if (compareVersions(currentVersion, remoteVersion) < 0) {
                 cliUpdateAvailable = true;
                 console.log(`New CLI version available: ${remoteVersion}`);
                 console.log('Updating automatically...');
-                
+
                 // Spawn npm update as detached child process
                 const { spawn } = require('child_process');
                 const updateProcess = spawn('npm', ['update', '-g', 'openkbs'], {
                     detached: true,
                     stdio: 'inherit'
                 });
-                
+
                 updateProcess.unref(); // Allow parent to exit
-                
+
                 console.green(`Update started! OpenKBS CLI will be updated to version ${remoteVersion}.`);
                 console.log('The update will complete in the background.');
             } else {
@@ -670,15 +670,63 @@ async function updateCliAction() {
         } catch (error) {
             console.red('Error fetching CLI version metadata:', error.message);
         }
-        
+
         // Also update knowledge base silently if it exists
         await updateKnowledgeAction(true);
-        
+
     } catch (error) {
         console.red('Error updating CLI:', error.message);
     }
 }
 
+async function publishAction(domain) {
+    try {
+        const localKBData = await fetchLocalKBData();
+        const { kbId } = localKBData;
+        if (!kbId) return console.red('No KB found. Please push the KB first using the command "openkbs push".');
+
+        console.log(`Publishing KB ${kbId} to domain ${domain}...`);
+        const res = await fetchKBJWT(kbId);
+
+        if (!res?.kbToken) return console.red(`KB ${kbId} does not exist on the remote service`);
+
+        const response = await makePostRequest(KB_API_URL, {
+            token: res.kbToken,
+            action: 'publish',
+            domain: domain
+        });
+
+        console.green(`KB ${kbId} successfully published to ${domain}`);
+        return response;
+    } catch (error) {
+        console.red('Error during publish operation:', error.message);
+    }
+}
+
+async function unpublishAction(domain) {
+    try {
+        const localKBData = await fetchLocalKBData();
+        const { kbId } = localKBData;
+        if (!kbId) return console.red('No KB found. Please push the KB first using the command "openkbs push".');
+
+        console.log(`Unpublishing KB ${kbId} from domain ${domain}...`);
+        const res = await fetchKBJWT(kbId);
+
+        if (!res?.kbToken) return console.red(`KB ${kbId} does not exist on the remote service`);
+
+        const response = await makePostRequest(KB_API_URL, {
+            token: res.kbToken,
+            action: 'unpublish',
+            domain: domain
+        });
+
+        console.green(`KB ${kbId} successfully unpublished from ${domain}`);
+        return response;
+    } catch (error) {
+        console.red('Error during unpublish operation:', error.message);
+    }
+}
+
 function compareVersions(version1, version2) {
     const parts1 = version1.split('.').map(Number);
     const parts2 = version2.split('.').map(Number);
@@ -789,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,
@@ -807,5 +1198,8 @@ module.exports = {
     modifyAction,
     downloadModifyAction,
     updateKnowledgeAction,
-    updateCliAction
+    updateCliAction,
+    publishAction,
+    unpublishAction,
+    fnAction
 };

package/src/index.js

@@ -13,7 +13,8 @@ const {
     deleteFileAction,
     describeAction, deployAction, createByTemplateAction, initByTemplateAction,
     logoutAction, installFrontendPackageAction, modifyAction, downloadModifyAction,
-    updateKnowledgeAction, updateCliAction
+    updateKnowledgeAction, updateCliAction, publishAction, unpublishAction,
+    fnAction
 } = require('./actions');
 
 
@@ -171,10 +172,45 @@ program
 Examples:
   $ openkbs update
   This will check for CLI updates and install them if available.
-  
+
   $ openkbs update knowledge
   This will check if your local .openkbs/knowledge directory is up to date with the remote repository
   and update it if necessary.
 `);
 
+program
+    .command('publish <domain>')
+    .description('Publish KB to a custom domain')
+    .action(publishAction)
+    .addHelpText('after', `
+Examples:
+  $ openkbs publish example.com
+  This will publish your KB to the domain example.com
+`);
+
+program
+    .command('unpublish <domain>')
+    .description('Unpublish KB from a custom domain')
+    .action(unpublishAction)
+    .addHelpText('after', `
+Examples:
+  $ openkbs unpublish example.com
+  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/src/utils.js

@@ -1167,5 +1167,5 @@ module.exports = {
     listFiles, getUserProfile, getKB, fetchAndSaveSettings, downloadIcon, downloadFiles, updateKB, uploadFiles, generateKey,
     generateMnemonic, reset, bold, red, yellow, green, cyan, createKB, getClientJWT, saveLocalKBData, listKBs, deleteKBFile,
     deleteKB, buildPackage, replacePlaceholderInFiles, buildNodePackage, initByTemplateAction, modifyKB, listKBsSharedWithMe,
-    downloadTemplates
+    downloadTemplates, makePostRequest
 }

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.
+"""