openkbs 0.0.53 → 0.0.59

package/src/index.js

@@ -13,7 +13,12 @@ const {
     deleteFileAction,
     describeAction, deployAction, createByTemplateAction, initByTemplateAction,
     logoutAction, installFrontendPackageAction, modifyAction, downloadModifyAction,
-    updateKnowledgeAction, updateCliAction, publishAction, unpublishAction
+    updateKnowledgeAction, updateCliAction, publishAction, unpublishAction,
+    fnAction,
+    siteAction,
+    storageAction,
+    postgresAction,
+    pulseAction
 } = require('./actions');
 
 
@@ -197,4 +202,75 @@ Examples:
   This will unpublish your KB from the domain example.com
 `);
 
+program
+    .command('fn [subCommand] [args...]')
+    .description('Manage Elastic Functions (serverless Lambda functions)')
+    .allowUnknownOption()
+    .action((subCommand, args) => fnAction(subCommand, args))
+    .addHelpText('after', `
+Examples:
+  $ openkbs fn list                           List all functions
+  $ openkbs fn deploy hello --region us-east-1  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
+    .command('site [subCommand] [args...]')
+    .description('Manage static site files for whitelabel domains')
+    .action((subCommand, args) => siteAction(subCommand, args))
+    .addHelpText('after', `
+Examples:
+  $ openkbs site deploy                       Deploy all files to S3
+
+Run from a directory containing settings.json with kbId.
+Files are uploaded to the whitelabel domain's files bucket.
+`);
+
+program
+    .command('storage [subCommand] [args...]')
+    .description('Manage Elastic Storage (S3 buckets for persistent file storage)')
+    .action((subCommand, args) => storageAction(subCommand, args))
+    .addHelpText('after', `
+Examples:
+  $ openkbs storage enable                    Enable storage for current KB
+  $ openkbs storage status                    Show storage status
+  $ openkbs storage ls [prefix]               List objects in bucket
+  $ openkbs storage put <file> <key>          Upload a file
+  $ openkbs storage get <key> <file>          Download a file
+  $ openkbs storage rm <key>                  Delete an object
+  $ openkbs storage disable                   Disable storage (delete bucket)
+  $ openkbs storage cloudfront media          Add storage to CloudFront at /media/*
+  $ openkbs storage cloudfront remove media   Remove storage from CloudFront
+`);
+
+program
+    .command('postgres [subCommand]')
+    .description('Manage Elastic Postgres (Neon PostgreSQL database)')
+    .action((subCommand) => postgresAction(subCommand))
+    .addHelpText('after', `
+Examples:
+  $ openkbs postgres enable                   Enable Postgres for current KB
+  $ openkbs postgres status                   Show Postgres status
+  $ openkbs postgres connection               Show connection string
+  $ openkbs postgres disable                  Disable Postgres (delete database)
+`);
+
+program
+    .command('pulse [subCommand] [args...]')
+    .description('Manage Elastic Pulse (real-time WebSocket pub/sub)')
+    .action((subCommand, args) => pulseAction(subCommand, args))
+    .addHelpText('after', `
+Examples:
+  $ openkbs pulse enable                      Enable Pulse for current KB
+  $ openkbs pulse status                      Show Pulse status and endpoint
+  $ openkbs pulse channels                    List active channels
+  $ openkbs pulse presence chat               Show clients connected to 'chat' channel
+  $ openkbs pulse publish chat "Hello!"       Send message to 'chat' channel
+  $ openkbs pulse disable                     Disable Pulse
+`);
+
 program.parse(process.argv);

package/src/utils.js

@@ -164,8 +164,11 @@ function makePostRequest(url, data) {
                     resolve(data);
                 } else {
                     try {
-                        if (JSON.parse(body).error) {
-                            console.red(JSON.parse(body).error);
+                        const parsed = JSON.parse(body);
+                        if (parsed.error) {
+                            console.red(parsed.error);
+                        } else if (parsed.message) {
+                            console.red(parsed.message);
                         } else {
                             console.red(`Invalid Request`);
                         }

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 {

package/templates/.openkbs/knowledge/examples/ai-copywriter-agent/src/Frontend/contentRender.js

@@ -1,6 +1,11 @@
 import React, { useEffect } from "react";
 import JsonView from '@uiw/react-json-view';
-import { Chip } from '@mui/material';
+import { Box, Tooltip, Chip } from '@mui/material';
+import SearchIcon from '@mui/icons-material/Search';
+import LanguageIcon from '@mui/icons-material/Language';
+import ImageIcon from '@mui/icons-material/Image';
+import YouTubeIcon from '@mui/icons-material/YouTube';
+import ArticleIcon from '@mui/icons-material/Article';
 
 const extractJSONFromText = (text) => {
     let braceCount = 0, startIndex = text.indexOf('{');
@@ -19,24 +24,102 @@ const extractJSONFromText = (text) => {
     return null;
 }
 
-const parseCommands = (text) => {
-    return text.match(/\/\w+\("([^"]+)"\)/g) || [];
-}
+// Command patterns for XML+JSON format
+const COMMAND_PATTERNS = [
+    /<googleSearch>[\s\S]*?<\/googleSearch>/,
+    /<youtubeSearch>[\s\S]*?<\/youtubeSearch>/,
+    /<googleImageSearch>[\s\S]*?<\/googleImageSearch>/,
+    /<webpageToText>[\s\S]*?<\/webpageToText>/,
+    /<documentToText>[\s\S]*?<\/documentToText>/,
+    /<imageToText>[\s\S]*?<\/imageToText>/
+];
+
+// Icon mapping for commands
+const commandIcons = {
+    googleSearch: SearchIcon,
+    youtubeSearch: YouTubeIcon,
+    googleImageSearch: ImageIcon,
+    webpageToText: LanguageIcon,
+    documentToText: ArticleIcon,
+    imageToText: ImageIcon
+};
+
+// Parse commands from content
+const parseCommands = (content) => {
+    const commands = [];
+    const regex = /<(\w+)>([\s\S]*?)<\/\1>/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        try {
+            commands.push({
+                name: match[1],
+                data: JSON.parse(match[2].trim())
+            });
+        } catch (e) {
+            commands.push({ name: match[1], data: match[2].trim() });
+        }
+    }
+    return commands;
+};
+
+// Render command as icon with tooltip
+const CommandIcon = ({ command }) => {
+    const Icon = commandIcons[command.name] || SearchIcon;
+    return (
+        <Tooltip
+            title={
+                <Box sx={{ p: 1 }}>
+                    <Box sx={{ fontWeight: 'bold', color: '#4CAF50', mb: 0.5 }}>{command.name}</Box>
+                    <pre style={{ margin: 0, fontSize: '10px' }}>
+                        {typeof command.data === 'object'
+                            ? JSON.stringify(command.data, null, 2)
+                            : command.data}
+                    </pre>
+                </Box>
+            }
+            arrow
+        >
+            <Box sx={{
+                display: 'inline-flex',
+                width: 32, height: 32,
+                borderRadius: '50%',
+                backgroundColor: 'rgba(76, 175, 80, 0.1)',
+                border: '2px solid rgba(76, 175, 80, 0.3)',
+                alignItems: 'center',
+                justifyContent: 'center',
+                mx: 0.5,
+                cursor: 'pointer',
+                '&:hover': {
+                    backgroundColor: 'rgba(76, 175, 80, 0.2)',
+                    transform: 'scale(1.1)'
+                },
+                transition: 'all 0.2s'
+            }}>
+                <Icon sx={{ fontSize: 16, color: '#4CAF50' }} />
+            </Box>
+        </Tooltip>
+    );
+};
 
 // do NOT useState() directly in this function, it is not a React component
 const onRenderChatMessage = async (params) => {
     const { content } = params.messages[params.msgIndex];
     const JSONData = extractJSONFromText(content);
-    const commands = parseCommands(content);
-    
+
+    // Render JOB_COMPLETED as JSON view
     if (JSONData?.type === 'JOB_COMPLETED') {
         return <JsonView value={JSONData} />
     }
-    
-    if (commands.length > 0) {
-        return commands.map((cmd, i) => (
-            <Chip key={i} label={cmd} size="small" />
-        ));
+
+    // Check for commands in content
+    const hasCommand = COMMAND_PATTERNS.some(p => p.test(content));
+    if (hasCommand) {
+        const commands = parseCommands(content);
+        return (
+            <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.5 }}>
+                {commands.map((cmd, i) => <CommandIcon key={i} command={cmd} />)}
+            </Box>
+        );
     }
 
     // return undefined to use default message render
@@ -61,4 +144,4 @@ const Header = ({ setRenderSettings }) => {
 
 const exports = { onRenderChatMessage, Header };
 window.contentRender = exports;
-export default exports;
+export default exports;

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/README.md

@@ -0,0 +1,64 @@
+# AI Marketing Agent
+
+A comprehensive AI marketing assistant that can create content, generate images and videos, search the web, send emails, and schedule tasks.
+
+## Features
+
+- **AI Image Generation**: Gemini 2.5 Flash Image and GPT-Image-1 models
+- **AI Video Generation**: Sora 2 and Sora 2 Pro models
+- **Web Search**: Google Search and Image Search
+- **Email Marketing**: Send emails directly from chat
+- **Task Scheduling**: Schedule future reminders and tasks
+- **Web Publishing**: Create and publish HTML landing pages
+- **Memory System**: Persistent storage for user preferences and content
+
+## Command Format
+
+All commands use XML tags with JSON content:
+
+```xml
+<commandName>
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</commandName>
+```
+
+## Available Commands
+
+### Content Creation
+- `<createAIImage>` - Generate images with AI
+- `<createAIVideo>` - Generate videos with Sora 2
+- `<publishWebPage>` - Publish HTML landing pages
+
+### Search & Research
+- `<googleSearch>` - Web search
+- `<googleImageSearch>` - Image search
+- `<webpageToText>` - Extract text from webpages
+- `<viewImage>` - View image in context
+
+### Communication
+- `<sendMail>` - Send emails
+
+### Task Management
+- `<scheduleTask>` - Schedule future tasks
+- `<getScheduledTasks/>` - List scheduled tasks
+
+### Memory
+- `<setMemory>` - Save to memory
+- `<deleteItem>` - Delete from memory
+
+## Architecture
+
+- `src/Events/actions.js` - Command implementations
+- `src/Events/onRequest.js` - User message handler
+- `src/Events/onResponse.js` - LLM response handler
+- `src/Frontend/contentRender.js` - UI customization
+- `app/instructions.txt` - LLM instructions
+
+## Deployment
+
+```bash
+openkbs push
+```