npm - openkbs - Versions diffs - 0.0.67 → 0.0.70 - Mend

openkbs 0.0.67 → 0.0.70

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

package/README.md CHANGED Viewed

@@ -1,5 +1,6 @@
 # OpenKBS &middot; [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/open-kbs/openkbs-chat/blob/main/LICENSE) [![npm version](https://img.shields.io/badge/npm-v0.0.20-orange.svg)](https://www.npmjs.com/package/openkbs)
 OpenKBS is an extendable AI service designed to build,
 deploy and integrate AI agents and applications.

package/elastic/README.md CHANGED Viewed

@@ -908,7 +908,7 @@ openkbs pulse enable
 Install:
 ```html
-<script src="https://unpkg.com/openkbs-pulse@2.0.1/pulse.js"></script>
+<script src="https://unpkg.com/openkbs-pulse/pulse.js"></script>
 ```
 Or with npm:

package/elastic/functions.md CHANGED Viewed

@@ -131,7 +131,7 @@ cd functions/api && npm install && cd ../..
 openkbs fn push api
 ```
-Your function is live at `https://your-kb.openkbs.com/api`.
+Your function is live at `https://yourdomain.com/api`.
 ## Test Your Function
@@ -157,7 +157,7 @@ console.log(data); // { message: "Hello, OpenKBS!" }
 ### With curl
 ```bash
-curl -X POST https://your-kb.openkbs.com/api \
+curl -X POST https://yourdomain.com/api \
   -H "Content-Type: application/json" \
   -d '{"action":"hello","name":"OpenKBS"}'
 ```
@@ -286,9 +286,9 @@ openkbs fn list
 Output:
 ```
 Functions:
-  api      128MB  30s  https://your-kb.openkbs.com/api
-  auth     256MB  30s  https://your-kb.openkbs.com/auth
-  posts    512MB  60s  https://your-kb.openkbs.com/posts
+  api      128MB  30s  https://yourdomain.com/api
+  auth     256MB  30s  https://yourdomain.com/auth
+  posts    512MB  60s  https://yourdomain.com/posts
 ```
 ## Delete Function

package/elastic/pulse.md CHANGED Viewed

@@ -34,7 +34,7 @@ openkbs pulse enable
 ### Install
 ```html
-<script src="https://unpkg.com/openkbs-pulse@2.0.1/pulse.js"></script>
+<script src="https://unpkg.com/openkbs-pulse/pulse.js"></script>
 ```
 Or with npm:
@@ -263,7 +263,7 @@ export async function handler(event) {
 <html>
 <head>
     <title>Live Posts</title>
-    <script src="https://unpkg.com/openkbs-pulse@2.0.1/pulse.js"></script>
+    <script src="https://unpkg.com/openkbs-pulse/pulse.js"></script>
 </head>
 <body>
     <div id="online">Online: 0</div>

package/package.json CHANGED Viewed

@@ -1,11 +1,11 @@
 {
   "name": "openkbs",
-  "version": "0.0.67",
+  "version": "0.0.70",
   "description": "OpenKBS - Command Line Interface",
   "main": "src/index.js",
   "scripts": {
     "build": "pkg .",
-    "deploy": "npm run build && npm run deploy:linux && npm run deploy:macos && npm run deploy:win && npm run deploy:templates && npm run deploy:version",
+    "deploy": "node scripts/deploy.js",
     "deploy:linux": "aws s3 cp build/openkbs-linux-x64 s3://openkbs-downloads/cli/linux/openkbs && aws s3 cp build/openkbs-linux-arm64 s3://openkbs-downloads/cli/linux/openkbs-arm64",
     "deploy:macos": "aws s3 cp build/openkbs-macos-arm64 s3://openkbs-downloads/cli/macos/openkbs && aws s3 cp build/openkbs-macos-x64 s3://openkbs-downloads/cli/macos/openkbs-x64",
     "deploy:win": "aws s3 cp build/openkbs-win-x64.exe s3://openkbs-downloads/cli/windows/openkbs.exe && aws s3 cp build/openkbs-win-arm64.exe s3://openkbs-downloads/cli/windows/openkbs-arm64.exe",

package/scripts/deploy.js ADDED Viewed

@@ -0,0 +1,68 @@
+const { execSync } = require('child_process');
+const readline = require('readline');
+function askOTP() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question('Enter NPM OTP code: ', (otp) => {
+            rl.close();
+            resolve(otp?.trim() || '');
+        });
+    });
+}
+async function deploy() {
+    try {
+        // Check npm login status
+        console.log('\n🔐 Checking npm login...');
+        try {
+            execSync('npm whoami', { stdio: 'pipe' });
+            console.log('✓ Logged in to npm');
+        } catch {
+            console.log('Not logged in. Please login to npm:');
+            execSync('npm login', { stdio: 'inherit' });
+        }
+        // Version bump
+        console.log('\n📦 Bumping version...');
+        execSync('npm version patch --no-git-tag-version', { stdio: 'inherit' });
+        // Build
+        console.log('\n🔨 Building...');
+        execSync('npm run build', { stdio: 'inherit' });
+        // Deploy binaries
+        console.log('\n☁️  Deploying binaries...');
+        execSync('npm run deploy:linux', { stdio: 'inherit' });
+        execSync('npm run deploy:macos', { stdio: 'inherit' });
+        execSync('npm run deploy:win', { stdio: 'inherit' });
+        // Deploy templates
+        console.log('\n📄 Deploying templates...');
+        execSync('npm run deploy:templates', { stdio: 'inherit' });
+        // Deploy version
+        console.log('\n🏷️  Deploying version...');
+        execSync('npm run deploy:version', { stdio: 'inherit' });
+        // Ask for OTP right before publish
+        console.log('\n🚀 Ready to publish to npm...');
+        const otp = await askOTP();
+        if (otp) {
+            execSync(`npm publish --otp=${otp}`, { stdio: 'inherit' });
+            console.log('\n✅ Deploy complete!');
+        } else {
+            console.log('\n⚠️  Skipped npm publish (no OTP provided)');
+            console.log('✅ S3 deploy complete!');
+        }
+    } catch (error) {
+        console.error('\n❌ Deploy failed:', error.message);
+        process.exit(1);
+    }
+}
+deploy();

package/src/actions.js CHANGED Viewed

@@ -2462,6 +2462,13 @@ async function stackCreateAction(name) {
         // Copy platform template
         fs.copySync(platformTemplateDir, targetDir);
+        // Copy .claude folder with skills
+        const claudeTemplateDir = path.join(TEMPLATE_DIR, '.claude');
+        const claudeTargetDir = path.join(targetDir, '.claude');
+        if (fs.existsSync(claudeTemplateDir)) {
+            fs.copySync(claudeTemplateDir, claudeTargetDir);
+        }
         // Replace placeholders in all files
         replacePlaceholderInFiles(targetDir, name);

package/templates/.claude/skills/openkbs/SKILL.md CHANGED Viewed

@@ -32,7 +32,7 @@ Platform mode extends agent capabilities with:
 - **Elastic Pulse**: Real-time WebSocket pub/sub
 - **Whitelabel**: Custom domains (`example.com`) with static site (`site/` folder)
-**Architecture Note**: The whitelabel itself is a KB with its own `kbId` (a service agent, not user-facing). This "parent" kbId is used throughout the stack for elastic services. Each agent in `agents/` has its own separate `kbId`. All agents share the platform's elastic services via the parent kbId.
+**Architecture Note**: The whitelabel itself is an app with its own `kbId` (a service agent, not user-facing). This "parent" kbId is used throughout the stack for elastic services. Each agent in `agents/` has its own separate `kbId`.
 ## Project Structure
@@ -52,7 +52,7 @@ my-agent/
 │   └── Frontend/
 │       ├── contentRender.js    # Custom React UI
 │       └── contentRender.json  # Frontend dependencies
-└── openkbs.json            # Elastic services config
+│
 ```
 ### Platform Structure
@@ -89,7 +89,7 @@ my-platform/
     "storage": true,
     "pulse": true,
     "functions": {
-      "api": { "runtime": "nodejs22.x", "memory": 512 }
+      "api": { "runtime": "nodejs24.x", "memory": 512 }
     }
   }
 }
@@ -177,8 +177,37 @@ Priority items are auto-injected into LLM context.
 ## Additional Resources
-- For backend SDK methods, see [reference/backend-sdk.md](reference/backend-sdk.md)
-- For frontend React patterns, see [reference/frontend-sdk.md](reference/frontend-sdk.md)
-- For XML command definitions, see [reference/commands.md](reference/commands.md)
-- For elastic services, see [reference/elastic-services.md](reference/elastic-services.md)
-- For complete examples, see [examples/](examples/)
+### Reference Documentation
+- [reference/backend-sdk.md](reference/backend-sdk.md) - Backend SDK methods (openkbs.*)
+- [reference/frontend-sdk.md](reference/frontend-sdk.md) - Frontend React patterns
+- [reference/commands.md](reference/commands.md) - XML command definitions
+- [reference/elastic-services.md](reference/elastic-services.md) - Functions, Postgres, Storage, Pulse
+### Ready-to-Use Patterns
+Production-tested code blocks for common tasks:
+**Content & Media:**
+- [patterns/image-generation.md](patterns/image-generation.md) - AI image generation with upload
+- [patterns/video-generation.md](patterns/video-generation.md) - Async video generation with polling
+- [patterns/file-upload.md](patterns/file-upload.md) - Presigned URL file uploads
+- [patterns/web-publishing.md](patterns/web-publishing.md) - HTML page publishing
+**Memory & Storage:**
+- [patterns/memory-system.md](patterns/memory-system.md) - Memory CRUD with settings.json config
+- [patterns/vectordb-archive.md](patterns/vectordb-archive.md) - Long-term archive with semantic search
+**Scheduling & Automation:**
+- [patterns/scheduled-tasks.md](patterns/scheduled-tasks.md) - Task scheduling (one-time & recurring)
+- [patterns/cronjob-batch-processing.md](patterns/cronjob-batch-processing.md) - Batch file processing with state
+- [patterns/cronjob-monitoring.md](patterns/cronjob-monitoring.md) - Continuous monitoring with pulse control
+**External Integrations:**
+- [patterns/telegram.md](patterns/telegram.md) - Telegram bot commands (send messages)
+- [patterns/telegram-webhook.md](patterns/telegram-webhook.md) - Telegram webhook (receive messages)
+- [patterns/public-api-item-proxy.md](patterns/public-api-item-proxy.md) - Public API with geolocation
+### Complete Examples
+- [examples/ai-copywriter-agent/](examples/ai-copywriter-agent/) - Content generation agent
+- [examples/ai-marketing-agent/](examples/ai-marketing-agent/) - Marketing automation agent
+- [examples/monitoring-bot/](examples/monitoring-bot/) - Cronjob + Telegram monitoring agent
+- [examples/nodejs-demo/](examples/nodejs-demo/) - Platform with elastic functions

package/templates/.claude/skills/openkbs/examples/monitoring-bot/README.md ADDED Viewed

@@ -0,0 +1,55 @@
+# Monitoring Bot Example
+A simplified monitoring agent that demonstrates:
+- **Cronjob** with pulse interval control
+- **Telegram webhook** integration
+- **Memory system** with reference images
+- **Weather API** integration
+## Features
+- Monitors external data sources every N minutes
+- Receives commands via Telegram
+- Stores reference images for comparison
+- Hibernation/sleep mode
+- Weather data injection
+## Quick Start
+```bash
+cd monitoring-bot
+openkbs push
+```
+Then setup Telegram webhook:
+```
+https://chat.openkbs.com/publicAPIRequest?kbId=YOUR_KB_ID&setupTelegramWebhook=true
+```
+## File Structure
+```
+monitoring-bot/
+├── app/
+│   ├── settings.json       # Agent config
+│   └── instructions.txt    # System prompt
+├── src/
+│   ├── Events/
+│   │   ├── actions.js      # Command handlers
+│   │   ├── onCronjob.js    # Scheduled monitoring
+│   │   ├── onPublicAPIRequest.js  # Telegram webhook
+│   │   ├── memoryHelpers.js       # Memory utilities
+│   │   ├── handler.js      # Response parser
+│   │   ├── onRequest.js
+│   │   └── onResponse.js
+│   └── Frontend/
+│       └── contentRender.js
+└── openkbs.json
+```
+## Commands
+- `<setMemory>` - Store values
+- `<hibernateAgent>` - Sleep until time
+- `<setAgentSettings>` - Change pulse interval
+- `<sendToTelegramChannel>` - Send messages

package/templates/.claude/skills/openkbs/examples/monitoring-bot/app/instructions.txt ADDED Viewed

@@ -0,0 +1,40 @@
+You are a monitoring assistant that analyzes data from external sources.
+## Modes
+### PROCESS_MONITORING_CHECK
+Triggered automatically by cronjob. Analyze the provided data and report findings.
+### PROCESS_TELEGRAM_MESSAGE
+User message from Telegram. Respond using sendToTelegramChannel command.
+Remember: This chat has no user listening - only output commands!
+## Commands
+### Memory
+<setMemory>{"itemId": "memory_xyz", "value": "data", "expirationInMinutes": 60}</setMemory>
+<deleteItem>{"itemId": "memory_xyz"}</deleteItem>
+### Store reference image
+<setMemory>{
+  "itemId": "memory_with_image_description",
+  "value": {
+    "imageUrl": "https://...",
+    "description": "Reference description"
+  }
+}</setMemory>
+### Agent control
+<hibernateAgent>{"hours": 24}</hibernateAgent>
+<hibernateAgent>{"until": "2025-01-15T08:00:00Z"}</hibernateAgent>
+<setAgentSettings>{"pulseInterval": 5}</setAgentSettings>
+<setAgentSettings>{"wakeUp": true}</setAgentSettings>
+### Communication
+<sendToTelegramChannel>{"message": "*Bold* message"}</sendToTelegramChannel>
+<sendPhotoToTelegramChannel>{"photoUrl": "https://...", "caption": "Caption"}</sendPhotoToTelegramChannel>
+## Response Format
+For monitoring checks, provide a brief status report.
+For Telegram messages, respond via sendToTelegramChannel only.

package/templates/.claude/skills/openkbs/examples/monitoring-bot/app/settings.json ADDED Viewed

@@ -0,0 +1,41 @@
+{
+  "AIChatModel": "gemini-2.5-pro-preview-05-06",
+  "chatVendor": "Google",
+  "title": "Monitoring Bot",
+  "description": "Automated monitoring agent with Telegram integration",
+  "category": "automation",
+  "active": true,
+  "embeddingModel": "text-embedding-3-large",
+  "embeddingDimension": 3072,
+  "searchEngine": "VectorDB",
+  "itemTypes": {
+    "memory": {
+      "attributes": [
+        { "attrName": "itemId", "attrType": "itemId", "encrypted": false },
+        { "attrName": "body", "attrType": "body", "encrypted": true }
+      ]
+    },
+    "telegram": {
+      "attributes": [
+        { "attrName": "itemId", "attrType": "itemId", "encrypted": false },
+        { "attrName": "body", "attrType": "body", "encrypted": true }
+      ]
+    },
+    "agent": {
+      "attributes": [
+        { "attrName": "itemId", "attrType": "itemId", "encrypted": false },
+        { "attrName": "body", "attrType": "body", "encrypted": true }
+      ]
+    }
+  },
+  "options": {
+    "priorityItems": [
+      { "limit": 100, "prefix": "memory" },
+      { "limit": 50, "prefix": "agent" },
+      { "limit": 50, "prefix": "telegram" }
+    ],
+    "vectorDBMaxTokens": 25000,
+    "vectorDBTopK": 30,
+    "vectorDBMinScore": 90
+  }
+}

package/templates/.claude/skills/openkbs/examples/monitoring-bot/openkbs.json ADDED Viewed

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

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/actions.js ADDED Viewed

@@ -0,0 +1,141 @@
+import { setMemoryValue, deleteItem, setAgentSetting, getAgentSetting } from './memoryHelpers.js';
+const meta = { _meta_actions: ["REQUEST_CHAT_MODEL"] };
+const TELEGRAM_BOT_TOKEN = '{{secrets.telegramBotToken}}';
+async function getTelegramChannelId() {
+    const secretsId = '{{secrets.telegramChannelID}}';
+    if (secretsId && !secretsId.includes('{{')) return secretsId;
+    return await getAgentSetting('agent_telegramChannelID');
+}
+export default [
+    // Set memory
+    [/<setMemory>([\s\S]*?)<\/setMemory>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            if (!data.itemId?.startsWith('memory_')) {
+                return { type: "MEMORY_ERROR", error: "itemId must start with 'memory_'", ...meta };
+            }
+            await setMemoryValue(data.itemId, data.value, data.expirationInMinutes);
+            return { type: "MEMORY_UPDATED", itemId: data.itemId, ...meta };
+        } catch (e) {
+            return { type: "MEMORY_ERROR", error: e.message, ...meta };
+        }
+    }],
+    // Delete item
+    [/<deleteItem>([\s\S]*?)<\/deleteItem>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            await deleteItem(data.itemId);
+            return { type: "ITEM_DELETED", itemId: data.itemId, ...meta };
+        } catch (e) {
+            return { type: "DELETE_ERROR", error: e.message, ...meta };
+        }
+    }],
+    // Hibernate agent
+    [/<hibernateAgent>([\s\S]*?)<\/hibernateAgent>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            let sleepUntil;
+            if (data.hours) {
+                sleepUntil = new Date(Date.now() + data.hours * 60 * 60 * 1000);
+            } else if (data.days) {
+                sleepUntil = new Date(Date.now() + data.days * 24 * 60 * 60 * 1000);
+            } else if (data.until) {
+                sleepUntil = new Date(data.until);
+            } else {
+                throw new Error('Specify hours, days, or until');
+            }
+            await setAgentSetting('agent_sleepUntil', sleepUntil.toISOString());
+            return { type: "AGENT_HIBERNATING", sleepUntil: sleepUntil.toISOString(), ...meta };
+        } catch (e) {
+            return { type: "HIBERNATE_ERROR", error: e.message, ...meta };
+        }
+    }],
+    // Agent settings
+    [/<setAgentSettings>([\s\S]*?)<\/setAgentSettings>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            if (data.pulseInterval !== undefined) {
+                const interval = Math.max(1, Math.min(60, parseInt(data.pulseInterval)));
+                await setAgentSetting('agent_pulseInterval', interval);
+            }
+            if (data.wakeUp === true) {
+                await setAgentSetting('agent_sleepUntil', null);
+            }
+            return { type: "SETTINGS_UPDATED", settings: data, ...meta };
+        } catch (e) {
+            return { type: "SETTINGS_ERROR", error: e.message, ...meta };
+        }
+    }],
+    // Send to Telegram
+    [/<sendToTelegramChannel>([\s\S]*?)<\/sendToTelegramChannel>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const channelId = await getTelegramChannelId();
+            if (!channelId) {
+                throw new Error('Telegram channel ID not configured');
+            }
+            const response = await axios.post(
+                `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage`,
+                {
+                    chat_id: channelId,
+                    text: data.message,
+                    parse_mode: 'Markdown',
+                    disable_notification: data.silent || false
+                }
+            );
+            if (!response.data.ok) {
+                throw new Error(response.data.description);
+            }
+            return { type: "TELEGRAM_SENT", messageId: response.data.result.message_id, ...meta };
+        } catch (e) {
+            return { type: "TELEGRAM_ERROR", error: e.message, ...meta };
+        }
+    }],
+    // Send photo to Telegram
+    [/<sendPhotoToTelegramChannel>([\s\S]*?)<\/sendPhotoToTelegramChannel>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const channelId = await getTelegramChannelId();
+            if (!channelId) {
+                throw new Error('Telegram channel ID not configured');
+            }
+            const response = await axios.post(
+                `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendPhoto`,
+                {
+                    chat_id: channelId,
+                    photo: data.photoUrl,
+                    caption: data.caption || '',
+                    parse_mode: 'Markdown'
+                }
+            );
+            if (!response.data.ok) {
+                throw new Error(response.data.description);
+            }
+            return { type: "TELEGRAM_PHOTO_SENT", messageId: response.data.result.message_id, ...meta };
+        } catch (e) {
+            return { type: "TELEGRAM_ERROR", error: e.message, ...meta };
+        }
+    }]
+];

package/templates/.claude/skills/openkbs/examples/monitoring-bot/src/Events/handler.js ADDED Viewed

@@ -0,0 +1,32 @@
+import actions from './actions.js';
+export const handler = async (event) => {
+    const { text } = event.payload;
+    const results = [];
+    // Match all commands in parallel
+    const matchPromises = actions.map(async ([regex, handler]) => {
+        const matches = [...text.matchAll(new RegExp(regex.source, regex.flags + 'g'))];
+        return Promise.all(matches.map(match => handler(match)));
+    });
+    const allResults = await Promise.all(matchPromises);
+    for (const resultGroup of allResults) {
+        for (const result of resultGroup) {
+            if (result) results.push(result);
+        }
+    }
+    if (results.length === 0) {
+        return { type: 'NO_COMMANDS' };
+    }
+    // If any result requests chat model, return it
+    const needsChat = results.find(r => r._meta_actions?.includes('REQUEST_CHAT_MODEL'));
+    if (needsChat) {
+        return results.length === 1 ? results[0] : { type: 'BATCH_RESULTS', results, ...needsChat };
+    }
+    return results.length === 1 ? results[0] : { type: 'BATCH_RESULTS', results };
+};

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

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