openkbs 0.0.66 → 0.0.70

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/memoryHelpers.js

@@ -0,0 +1,91 @@
+// Memory Helpers - Atomic operations
+
+async function _upsertItem(itemType, itemId, body) {
+    try {
+        await openkbs.updateItem({ itemType, itemId, body });
+    } catch (e) {
+        await openkbs.createItem({ itemType, itemId, body });
+    }
+    return { success: true, itemId };
+}
+
+export async function setMemoryValue(itemId, value, expirationInMinutes = null) {
+    if (!itemId.startsWith('memory_')) {
+        throw new Error(`itemId must start with "memory_"`);
+    }
+
+    const body = {
+        value,
+        updatedAt: new Date().toISOString()
+    };
+
+    if (expirationInMinutes != null) {
+        body.exp = new Date(Date.now() + expirationInMinutes * 60 * 1000).toISOString();
+    }
+
+    return _upsertItem('memory', itemId, body);
+}
+
+export async function deleteItem(itemId) {
+    try {
+        await openkbs.deleteItem(itemId);
+        return { success: true };
+    } catch (e) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function setAgentSetting(itemId, value) {
+    if (!itemId.startsWith('agent_')) {
+        itemId = `agent_${itemId}`;
+    }
+    return _upsertItem('agent', itemId, { value, updatedAt: new Date().toISOString() });
+}
+
+export async function getAgentSetting(itemId) {
+    try {
+        const item = await openkbs.getItem(itemId);
+        return item?.item?.body?.value;
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function storeTelegramMessage(messageId, data) {
+    const itemId = `telegram_${messageId.toString().padStart(12, '0')}`;
+    const body = { ...data, storedAt: new Date().toISOString() };
+    return _upsertItem('telegram', itemId, body);
+}
+
+export async function getTelegramMessage(messageId) {
+    const itemId = `telegram_${messageId.toString().padStart(12, '0')}`;
+    try {
+        const result = await openkbs.getItem(itemId);
+        return result?.item?.body;
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function deleteTelegramMessage(itemId) {
+    return deleteItem(itemId);
+}
+
+export async function cleanupExpiredMemory() {
+    try {
+        const items = await openkbs.fetchItems({
+            beginsWith: 'memory_',
+            limit: 100
+        });
+
+        const now = new Date();
+        for (const item of items?.items || []) {
+            const exp = item.item?.body?.exp;
+            if (exp && new Date(exp) < now) {
+                await deleteItem(item.meta.itemId);
+            }
+        }
+    } catch (e) {
+        console.error('Cleanup error:', e.message);
+    }
+}

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/onCronjob.js

@@ -0,0 +1,105 @@
+import { getAgentSetting, setMemoryValue, cleanupExpiredMemory } from './memoryHelpers.js';
+
+async function shouldExecute() {
+    try {
+        // Check sleep mode
+        const sleepUntil = await getAgentSetting('agent_sleepUntil');
+        if (sleepUntil) {
+            if (new Date(sleepUntil) > new Date()) {
+                return { execute: false, reason: 'sleeping' };
+            }
+        }
+
+        // Check pulse interval
+        const pulseInterval = (await getAgentSetting('agent_pulseInterval')) || 1;
+        const currentMinute = new Date().getMinutes();
+
+        if (currentMinute % pulseInterval !== 0) {
+            return { execute: false, reason: 'pulse_interval' };
+        }
+
+        return { execute: true, interval: pulseInterval };
+    } catch (e) {
+        return { execute: true, interval: 1 };
+    }
+}
+
+export const handler = async (event) => {
+    try {
+        // Cleanup expired memory
+        await cleanupExpiredMemory();
+
+        // Check if should execute
+        const status = await shouldExecute();
+        if (!status.execute) {
+            return { success: true, skipped: true, reason: status.reason };
+        }
+
+        // Build monitoring message
+        const message = [];
+
+        message.push({
+            type: "text",
+            text: "PROCESS_MONITORING_CHECK"
+        });
+
+        // === ADD YOUR DATA SOURCES HERE ===
+        // Example: Fetch from API
+        // const data = await axios.get('https://api.example.com/status');
+        // message.push({ type: "text", text: `API Status: ${data.status}` });
+
+        // Example: Add images
+        // message.push({ type: "image_url", image_url: { url: "https://..." } });
+
+        // Inject reference images from memory
+        try {
+            const imageMemories = await openkbs.fetchItems({
+                beginsWith: 'memory_with_image_',
+                limit: 20,
+                field: 'itemId'
+            });
+
+            if (imageMemories?.items?.length > 0) {
+                message.push({
+                    type: "text",
+                    text: `\n📸 REFERENCE IMAGES (${imageMemories.items.length})`
+                });
+
+                for (const item of imageMemories.items) {
+                    const value = item.item?.body?.value;
+                    if (value?.imageUrl) {
+                        message.push({
+                            type: "text",
+                            text: `\n🏷️ ${value.description || 'Reference'}`
+                        });
+                        message.push({
+                            type: "image_url",
+                            image_url: { url: value.imageUrl }
+                        });
+                    }
+                }
+            }
+        } catch (e) {
+            console.error('Failed to fetch reference images:', e.message);
+        }
+
+        // Create chat
+        const now = new Date();
+        const timeStr = now.toLocaleTimeString('en-GB', {
+            hour: '2-digit',
+            minute: '2-digit'
+        });
+
+        await openkbs.chats({
+            chatTitle: `Monitoring - ${timeStr}`,
+            message: JSON.stringify(message)
+        });
+
+        return { success: true, timestamp: now.toISOString() };
+
+    } catch (error) {
+        return { success: false, error: error.message };
+    }
+};
+
+handler.CRON_SCHEDULE = "* * * * *";

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/onPublicAPIRequest.js

@@ -0,0 +1,165 @@
+import {
+    setAgentSetting,
+    getAgentSetting,
+    storeTelegramMessage,
+    getTelegramMessage,
+    deleteTelegramMessage
+} from './memoryHelpers.js';
+
+const AUTONOMOUS_CHAT_RULES = `**Autonomous Chat Rules:**
+This chat has NO USER listening. ONLY output commands.
+To communicate: Use sendToTelegramChannel command.
+Plain text "END" to finish.`;
+
+const BOT_TOKEN = '{{secrets.telegramBotToken}}';
+
+async function getChannelId() {
+    const secretsId = '{{secrets.telegramChannelID}}';
+    if (secretsId && !secretsId.includes('{{')) return secretsId;
+    return await getAgentSetting('agent_telegramChannelID');
+}
+
+export const handler = async ({ payload, queryStringParameters, headers }) => {
+    try {
+        let CHANNEL_ID = await getChannelId();
+
+        // Webhook setup
+        if (queryStringParameters?.setupTelegramWebhook === 'true') {
+            const existing = await getAgentSetting('agent_telegramWebhookSetup');
+            if (existing) {
+                return { ok: false, error: 'Already configured', setupDate: existing };
+            }
+
+            const SECRET_TOKEN = crypto.createHash('sha256')
+                .update(BOT_TOKEN).digest('hex').substring(0, 32);
+
+            const WEBHOOK_URL = `https://chat.openkbs.com/publicAPIRequest?kbId=${openkbs.kbId}&source=telegram`;
+
+            await axios.post(`https://api.telegram.org/bot${BOT_TOKEN}/deleteWebhook`);
+            const response = await axios.post(`https://api.telegram.org/bot${BOT_TOKEN}/setWebhook`, {
+                url: WEBHOOK_URL,
+                allowed_updates: ['message', 'channel_post', 'edited_message', 'edited_channel_post'],
+                drop_pending_updates: true,
+                secret_token: SECRET_TOKEN
+            });
+
+            if (!response.data.ok) throw new Error(response.data.description);
+
+            const setupDate = new Date().toISOString();
+            await setAgentSetting('agent_telegramWebhookSetup', setupDate);
+
+            return { ok: true, webhookUrl: WEBHOOK_URL, setupDate };
+        }
+
+        // Webhook removal
+        if (queryStringParameters?.removeTelegramWebhook === 'true') {
+            const existing = await getAgentSetting('agent_telegramWebhookSetup');
+            if (existing) {
+                return { ok: false, error: 'Remove internally first' };
+            }
+            await axios.post(`https://api.telegram.org/bot${BOT_TOKEN}/deleteWebhook`);
+            return { ok: true, message: 'Removed' };
+        }
+
+        // Validate secret token
+        const expectedToken = crypto.createHash('sha256')
+            .update(BOT_TOKEN).digest('hex').substring(0, 32);
+        const receivedToken = headers?.[
+            Object.keys(headers || {}).find(k => k.toLowerCase() === 'x-telegram-bot-api-secret-token')
+        ];
+        if (receivedToken && receivedToken !== expectedToken) {
+            return { ok: false, error: 'Invalid token' };
+        }
+
+        const { message, channel_post, edited_message, edited_channel_post } = payload;
+
+        // Handle channel post
+        if (channel_post) {
+            const text = channel_post.text || channel_post.caption || '';
+            const messageId = channel_post.message_id;
+            const chatId = channel_post.chat.id;
+
+            if (!CHANNEL_ID) {
+                await setAgentSetting('agent_telegramChannelID', chatId.toString());
+            }
+
+            const existing = await getTelegramMessage(messageId);
+            if (existing) return { ok: true, duplicate: true };
+
+            const senderName = channel_post.from?.username ||
+                               channel_post.author_signature ||
+                               'Unknown';
+
+            await storeTelegramMessage(messageId, {
+                text: text.substring(0, 50000),
+                date: channel_post.date,
+                from: senderName,
+                chatId
+            });
+
+            const timeStr = new Date(channel_post.date * 1000)
+                .toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+
+            await openkbs.chats({
+                chatTitle: `TG: ${senderName} - ${timeStr}`,
+                message: `PROCESS_TELEGRAM_MESSAGE from ${senderName}\n\n"${text}"\n\n${AUTONOMOUS_CHAT_RULES}`
+            });
+
+            return { ok: true, processed: 'channel_post' };
+        }
+
+        // Handle direct message
+        if (message) {
+            const text = message.text || '';
+            const messageId = message.message_id;
+            const userName = message.from.username || message.from.first_name;
+
+            const existing = await getTelegramMessage(messageId);
+            if (existing) return { ok: true, duplicate: true };
+
+            await storeTelegramMessage(messageId, {
+                text: text.substring(0, 20000),
+                date: message.date,
+                from: userName,
+                chatId: message.chat.id
+            });
+
+            await openkbs.chats({
+                chatTitle: `TG DM: ${userName}`,
+                message: `TELEGRAM DM from ${userName}\n\n"${text}"\n\n${AUTONOMOUS_CHAT_RULES}`
+            });
+
+            return { ok: true, processed: 'message' };
+        }
+
+        // Handle edits
+        if (edited_channel_post || edited_message) {
+            const edited = edited_channel_post || edited_message;
+            const messageId = edited.message_id;
+            const newText = edited.text;
+
+            const existing = await getTelegramMessage(messageId);
+            if (!existing) return { ok: true, note: 'Not found' };
+
+            const itemId = `telegram_${messageId.toString().padStart(12, '0')}`;
+
+            if (newText?.trim().toLowerCase().startsWith('_delete')) {
+                await deleteTelegramMessage(itemId);
+                return { ok: true, action: 'deleted' };
+            }
+
+            await storeTelegramMessage(messageId, {
+                ...existing,
+                text: newText,
+                edited: true
+            });
+
+            return { ok: true, action: 'edited' };
+        }
+
+        return { ok: true, message: 'Not handled' };
+
+    } catch (error) {
+        return { ok: true, error: error.message };
+    }
+};

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/onRequest.js

@@ -0,0 +1,2 @@
+import { handler } from './handler.js';
+export { handler };

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/onResponse.js

@@ -0,0 +1,2 @@
+import { handler } from './handler.js';
+export { handler };

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Frontend/contentRender.js

@@ -0,0 +1,74 @@
+const Header = () => {
+    const [status, setStatus] = React.useState(null);
+
+    React.useEffect(() => {
+        const fetchStatus = async () => {
+            try {
+                const [sleepUntil, pulseInterval] = await Promise.all([
+                    openkbs.items({ action: 'getItem', itemId: 'agent_sleepUntil' }),
+                    openkbs.items({ action: 'getItem', itemId: 'agent_pulseInterval' })
+                ]);
+                setStatus({
+                    sleeping: sleepUntil?.item?.body?.value,
+                    interval: pulseInterval?.item?.body?.value || 1
+                });
+            } catch (e) {}
+        };
+        fetchStatus();
+        const interval = setInterval(fetchStatus, 30000);
+        return () => clearInterval(interval);
+    }, []);
+
+    if (!status) return null;
+
+    const isSleeping = status.sleeping && new Date(status.sleeping) > new Date();
+
+    return (
+        <div style={{
+            padding: '8px 16px',
+            background: isSleeping ? '#ff9800' : '#4caf50',
+            color: 'white',
+            fontSize: '12px',
+            display: 'flex',
+            justifyContent: 'space-between'
+        }}>
+            <span>{isSleeping ? '😴 SLEEPING' : '🟢 ACTIVE'}</span>
+            <span>Pulse: every {status.interval} min</span>
+        </div>
+    );
+};
+
+const onRenderChatMessage = (params) => {
+    const { content } = params;
+
+    // Try to parse as JSON
+    let data;
+    try {
+        data = typeof content === 'string' ? JSON.parse(content) : content;
+    } catch (e) {
+        return null; // Use default rendering
+    }
+
+    // Handle command results
+    if (data?.type) {
+        const isError = data.type.includes('ERROR');
+        return (
+            <div style={{
+                padding: '12px',
+                margin: '8px 0',
+                borderRadius: '8px',
+                background: isError ? '#ffebee' : '#e8f5e9',
+                border: `1px solid ${isError ? '#ef5350' : '#66bb6a'}`
+            }}>
+                <strong>{data.type}</strong>
+                {data.error && <div style={{ color: '#c62828' }}>{data.error}</div>}
+                {data.itemId && <div>Item: {data.itemId}</div>}
+                {data.messageId && <div>Message ID: {data.messageId}</div>}
+            </div>
+        );
+    }
+
+    return null;
+};
+
+window.contentRender = { Header, onRenderChatMessage };

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Frontend/contentRender.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": {}
+}

package/templates/.claude/skills/openkbs/examples/nodejs-demo/functions/auth/index.mjs

@@ -0,0 +1,228 @@
+import pg from 'pg';
+import crypto from 'crypto';
+const { Client } = pg;
+
+const db = new Client({ connectionString: process.env.DATABASE_URL });
+let dbConnected = false;
+
+async function connectDB() {
+    if (!dbConnected) {
+        await db.connect();
+        dbConnected = true;
+
+        // Create users table with private_channel for secure messaging
+        await db.query(`
+            CREATE TABLE IF NOT EXISTS users (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(255) NOT NULL,
+                email VARCHAR(255) UNIQUE NOT NULL,
+                password VARCHAR(255) NOT NULL,
+                private_channel VARCHAR(64) UNIQUE NOT NULL,
+                avatar_color VARCHAR(7) DEFAULT '#007bff',
+                created_at TIMESTAMP DEFAULT NOW()
+            )
+        `);
+
+        // Add private_channel column if missing (migration)
+        await db.query(`
+            ALTER TABLE users ADD COLUMN IF NOT EXISTS private_channel VARCHAR(64) UNIQUE
+        `);
+        await db.query(`
+            ALTER TABLE users ADD COLUMN IF NOT EXISTS avatar_color VARCHAR(7) DEFAULT '#007bff'
+        `);
+    }
+}
+
+// Generate unpredictable channel ID for secure private messaging
+function generatePrivateChannel() {
+    return crypto.randomBytes(32).toString('hex');
+}
+
+// Generate random avatar color
+function generateAvatarColor() {
+    const colors = ['#e91e63', '#9c27b0', '#673ab7', '#3f51b5', '#2196f3', '#00bcd4', '#009688', '#4caf50', '#ff9800', '#ff5722'];
+    return colors[Math.floor(Math.random() * colors.length)];
+}
+
+/**
+ * Get a Pulse token for WebSocket authentication
+ * Calls lambda-kb to get a signed JWT token
+ * Uses OPENKBS_API_KEY for authentication
+ */
+async function getPulseToken(userId) {
+    const kbId = process.env.OPENKBS_KB_ID || process.env.PULSE_KB_ID;
+    const apiKey = process.env.OPENKBS_API_KEY;
+
+    if (!kbId) {
+        console.log('OPENKBS_KB_ID not set, skipping pulse token');
+        return null;
+    }
+
+    if (!apiKey) {
+        console.log('OPENKBS_API_KEY not set, skipping pulse token');
+        return null;
+    }
+
+    try {
+        const response = await fetch('https://kb.openkbs.com', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'createPulseToken',
+                kbId,
+                apiKey,
+                userId: String(userId)
+            })
+        });
+
+        const data = await response.json();
+        if (data.error) {
+            console.error('Pulse token error:', data.error);
+            return null;
+        }
+        return data;
+    } catch (e) {
+        console.error('Failed to get pulse token:', e);
+        return null;
+    }
+}
+
+export async function handler(event) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': 'Content-Type'
+    };
+
+    // Handle OPTIONS preflight
+    if (event.requestContext?.http?.method === 'OPTIONS') {
+        return { statusCode: 200, headers, body: '' };
+    }
+
+    try {
+        await connectDB();
+
+        const body = JSON.parse(event.body || '{}');
+        const { action, email, password, name } = body;
+
+        if (action === 'register') {
+            // Check if user exists
+            const existing = await db.query('SELECT id FROM users WHERE email = $1', [email]);
+            if (existing.rows.length > 0) {
+                return {
+                    statusCode: 400,
+                    headers,
+                    body: JSON.stringify({ error: 'Email already registered' })
+                };
+            }
+
+            // Generate unique private channel for secure messaging
+            const privateChannel = generatePrivateChannel();
+            const avatarColor = generateAvatarColor();
+
+            // Create user with private channel
+            const result = await db.query(
+                'INSERT INTO users (name, email, password, private_channel, avatar_color) VALUES ($1, $2, $3, $4, $5) RETURNING id, name, email, private_channel, avatar_color, created_at',
+                [name, email, password, privateChannel, avatarColor]
+            );
+
+            const user = result.rows[0];
+
+            // Get Pulse token for real-time features
+            const pulseData = await getPulseToken(user.id);
+
+            return {
+                statusCode: 200,
+                headers,
+                body: JSON.stringify({
+                    user: {
+                        id: user.id,
+                        name: user.name,
+                        email: user.email,
+                        avatarColor: user.avatar_color,
+                        // Private channel is SECRET - only this user knows it
+                        privateChannel: user.private_channel,
+                        pulseToken: pulseData?.token || null,
+                        pulseEndpoint: pulseData?.endpoint || null
+                    }
+                })
+            };
+        }
+
+        if (action === 'login') {
+            const result = await db.query(
+                'SELECT id, name, email, private_channel, avatar_color FROM users WHERE email = $1 AND password = $2',
+                [email, password]
+            );
+
+            if (result.rows.length === 0) {
+                return {
+                    statusCode: 401,
+                    headers,
+                    body: JSON.stringify({ error: 'Invalid email or password' })
+                };
+            }
+
+            const user = result.rows[0];
+
+            // Generate private channel if missing (for existing users)
+            let privateChannel = user.private_channel;
+            if (!privateChannel) {
+                privateChannel = generatePrivateChannel();
+                await db.query('UPDATE users SET private_channel = $1 WHERE id = $2', [privateChannel, user.id]);
+            }
+
+            // Get Pulse token for real-time features
+            const pulseData = await getPulseToken(user.id);
+
+            return {
+                statusCode: 200,
+                headers,
+                body: JSON.stringify({
+                    user: {
+                        id: user.id,
+                        name: user.name,
+                        email: user.email,
+                        avatarColor: user.avatar_color || '#007bff',
+                        privateChannel: privateChannel,
+                        pulseToken: pulseData?.token || null,
+                        pulseEndpoint: pulseData?.endpoint || null
+                    }
+                })
+            };
+        }
+
+        // Get list of users (for chat) - WITHOUT exposing private channels
+        if (action === 'users') {
+            const result = await db.query(
+                'SELECT id, name, avatar_color FROM users ORDER BY name'
+            );
+
+            return {
+                statusCode: 200,
+                headers,
+                body: JSON.stringify({
+                    users: result.rows.map(u => ({
+                        id: u.id,
+                        name: u.name,
+                        avatarColor: u.avatar_color || '#007bff'
+                    }))
+                })
+            };
+        }
+
+        return {
+            statusCode: 400,
+            headers,
+            body: JSON.stringify({ error: 'Invalid action' })
+        };
+
+    } catch (error) {
+        console.error('Auth error:', error);
+        return {
+            statusCode: 500,
+            headers,
+            body: JSON.stringify({ error: error.message })
+        };
+    }
+}

package/templates/.claude/skills/openkbs/examples/nodejs-demo/functions/auth/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "auth",
+  "type": "module",
+  "dependencies": {
+    "pg": "^8.11.3"
+  }
+}