openbot 0.3.0 → 0.3.2

package/dist/app/cli.js

@@ -16,7 +16,7 @@ function checkNodeVersion() {
     }
 }
 checkNodeVersion();
-program.name('openbot').description('OpenBot CLI').version('0.2.14');
+program.name('openbot').description('OpenBot CLI').version('0.3.1');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/app/server.js

@@ -236,9 +236,6 @@ export async function startServer(options = {}) {
     });
     app.listen(PORT, () => {
         console.log(`\x1b[32mOpenBot server listening at http://localhost:${PORT}\x1b[0m`);
-        console.log(`  - Health endpoint: GET /health`);
-        console.log(`  - Events endpoint: GET /api/events (SSE)`);
-        console.log(`  - Publish endpoint: POST /api/publish`);
-        console.log(`  - State endpoint: GET /api/state`);
+        console.log(`🌐 Visit \x1b[96m\x1b[1mhttps://openbot.one\x1b[0m to connect to this runtime and manage everything from there. ✨`);
     });
 }

package/dist/bus/services.js

@@ -1,6 +1,49 @@
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
 import { storageService } from '../services/storage.js';
 import { pluginService } from '../services/plugins.js';
+const readTodos = (state) => {
+    const raw = state.threadDetails?.state?.todos;
+    return Array.isArray(raw) ? raw : [];
+};
+let todoCounter = 0;
+const newTodoId = (now, idx) => `todo_${now.toString(36)}_${(todoCounter++).toString(36)}_${idx}`;
+async function persistTodos(storage, state, todos) {
+    if (!state.threadId)
+        throw new Error('No active thread');
+    await storage.patchThreadState({
+        channelId: state.channelId,
+        threadId: state.threadId,
+        state: { todos },
+    });
+    state.threadDetails = await storage.getThreadDetails({
+        channelId: state.channelId,
+        threadId: state.threadId,
+    });
+}
+/**
+ * Resolve a scope alias to a concrete scope string. Aliases let tools accept
+ * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
+ * them using `context.state`.
+ */
+function resolveMemoryScope(alias, state) {
+    switch (alias) {
+        case 'agent':
+            return `agent:${state.agentId}`;
+        case 'channel':
+            return `channel:${state.channelId}`;
+        case 'global':
+        case undefined:
+            return 'global';
+        default:
+            return 'global';
+    }
+}
+function resolveMemoryScopeFilter(alias, state) {
+    if (alias === 'all' || alias === undefined) {
+        return ['global', `agent:${state.agentId}`, `channel:${state.channelId}`];
+    }
+    return [resolveMemoryScope(alias, state)];
+}
 const DEFAULT_MARKETPLACE_AGENTS = [
     {
         id: 'researcher',
@@ -90,7 +133,7 @@ export const busServicesPlugin = (options) => (builder) => {
     builder.on('action:create_thread', async function* (event, context) {
         const threadId = event.meta?.threadId;
         const channelId = context.state.channelId;
-        const { threadTitle, spec, initialState } = event.data;
+        const { threadTitle, initialState } = event.data;
         if (!threadId) {
             console.warn('[bus] Cannot create thread: meta.threadId is missing');
             return;
@@ -102,7 +145,6 @@ export const busServicesPlugin = (options) => (builder) => {
                     channelId,
                     threadId,
                     threadTitle,
-                    spec,
                     initialState: initialState || {},
                 });
                 context.state.threadDetails = await storage.getThreadDetails({
@@ -117,17 +159,19 @@ export const busServicesPlugin = (options) => (builder) => {
         yield {
             type: 'action:create_thread:result',
             data: { success: true, threadId, threadTitle },
-            meta: { threadId },
+            meta: { ...(event.meta || {}), threadId, agentId: context.state.agentId },
         };
     });
     builder.on('action:create_channel', async function* (event, context) {
         const { channelId, spec, initialState, cwd } = event.data;
         const rawChannelId = (channelId || '').trim();
         const channelSpec = typeof spec === 'string' ? spec : '';
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         if (!rawChannelId) {
             yield {
                 type: 'action:create_channel:result',
                 data: { success: false, channelId: '', channelUrl: '' },
+                meta: resultMeta,
             };
             return;
         }
@@ -142,30 +186,31 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:create_channel:result',
                 data: { success: true, channelId: rawChannelId, channelUrl },
+                meta: resultMeta,
             };
             yield {
                 type: 'agent:output',
                 data: { content: `Created channel \`${rawChannelId}\`.` },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:create_channel:result',
                 data: { success: false, channelId: rawChannelId, channelUrl },
+                meta: resultMeta,
             };
         }
     });
     builder.on('action:update_channel', async function* (event, context) {
         const data = (event.data || {});
         const targetChannelId = (data.channelId || context.state.channelId || '').trim();
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         if (!targetChannelId) {
             yield {
                 type: 'action:update_channel:result',
                 data: { success: false, channelId: '', updatedFields: [] },
+                meta: resultMeta,
             };
             return;
         }
@@ -191,17 +236,20 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:update_channel:result',
                 data: { success: true, channelId: targetChannelId, updatedFields },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:update_channel:result',
                 data: { success: false, channelId: targetChannelId, updatedFields },
+                meta: resultMeta,
             };
         }
     });
     builder.on('action:patch_channel_details', async function* (event, context) {
         const updatedFields = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
             if (event.data.state !== undefined) {
                 await storage.patchChannelState({
@@ -230,17 +278,20 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:patch_channel_details:result',
                 data: { success: true, updatedFields },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:patch_channel_details:result',
                 data: { success: false, updatedFields },
+                meta: resultMeta,
             };
         }
     });
     builder.on('action:patch_thread_details', async function* (event, context) {
         const updatedFields = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
             if (!context.state.threadId) {
                 throw new Error('Missing threadId in state for patch_thread_details');
@@ -253,14 +304,6 @@ export const busServicesPlugin = (options) => (builder) => {
                 });
                 updatedFields.push('state');
             }
-            if (typeof event.data.spec === 'string') {
-                await storage.patchThreadSpec({
-                    channelId: context.state.channelId,
-                    threadId: context.state.threadId,
-                    spec: event.data.spec,
-                });
-                updatedFields.push('spec');
-            }
             context.state.threadDetails = await storage.getThreadDetails({
                 channelId: context.state.channelId,
                 threadId: context.state.threadId,
@@ -268,12 +311,100 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:patch_thread_details:result',
                 data: { success: true, updatedFields },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:patch_thread_details:result',
                 data: { success: false, updatedFields },
+                meta: resultMeta,
+            };
+        }
+    });
+    builder.on('action:todo_write', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+            if (!context.state.threadId) {
+                throw new Error('todo_write requires an active thread');
+            }
+            const existing = readTodos(context.state);
+            const byId = new Map(existing.map((t) => [t.id, t]));
+            const now = Date.now();
+            const author = context.state.agentId || 'system';
+            const inputs = event.data.todos || [];
+            const next = inputs.map((raw, idx) => {
+                const prior = raw.id ? byId.get(raw.id) : undefined;
+                return {
+                    id: prior?.id || raw.id || newTodoId(now, idx),
+                    content: raw.content,
+                    status: raw.status || prior?.status || 'pending',
+                    assignee: raw.assignee ?? prior?.assignee,
+                    createdBy: prior?.createdBy || author,
+                    createdAt: prior?.createdAt || now,
+                    updatedAt: now,
+                    ...(prior?.result !== undefined ? { result: prior.result } : {}),
+                };
+            });
+            await persistTodos(storage, context.state, next);
+            yield {
+                type: 'action:todo_write:result',
+                data: { success: true, todos: next },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:todo_write:result',
+                data: {
+                    success: false,
+                    todos: readTodos(context.state),
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
+            };
+        }
+    });
+    builder.on('action:todo_update', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        const patch = event.data;
+        try {
+            if (!context.state.threadId) {
+                throw new Error('todo_update requires an active thread');
+            }
+            const existing = readTodos(context.state);
+            const idx = existing.findIndex((t) => t.id === patch.id);
+            if (idx === -1) {
+                throw new Error(`Todo "${patch.id}" not found`);
+            }
+            const now = Date.now();
+            const updated = {
+                ...existing[idx],
+                ...(patch.content !== undefined ? { content: patch.content } : {}),
+                ...(patch.status !== undefined ? { status: patch.status } : {}),
+                ...(patch.assignee !== undefined
+                    ? { assignee: patch.assignee === '' ? undefined : patch.assignee }
+                    : {}),
+                updatedAt: now,
+            };
+            const next = [...existing];
+            next[idx] = updated;
+            await persistTodos(storage, context.state, next);
+            yield {
+                type: 'action:todo_update:result',
+                data: { success: true, todo: updated, todos: next },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:todo_update:result',
+                data: {
+                    success: false,
+                    todos: readTodos(context.state),
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
             };
         }
     });
@@ -549,6 +680,82 @@ export const busServicesPlugin = (options) => (builder) => {
             data: { success: true, agents },
         };
     });
+    builder.on('action:remember', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+            const { content, scope, tags } = event.data;
+            const record = await storage.appendMemory({
+                scope: resolveMemoryScope(scope, context.state),
+                content,
+                tags,
+            });
+            yield {
+                type: 'action:remember:result',
+                data: { success: true, record },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:remember:result',
+                data: {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
+            };
+        }
+    });
+    builder.on('action:recall', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+            const { query, tag, scope, limit } = event.data;
+            const records = await storage.listMemories({
+                scopes: resolveMemoryScopeFilter(scope, context.state),
+                query,
+                tag,
+                limit,
+            });
+            yield {
+                type: 'action:recall:result',
+                data: { success: true, records },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:recall:result',
+                data: {
+                    success: false,
+                    records: [],
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
+            };
+        }
+    });
+    builder.on('action:forget', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+            const deleted = await storage.deleteMemory({ id: event.data.id });
+            yield {
+                type: 'action:forget:result',
+                data: { success: true, deleted },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:forget:result',
+                data: {
+                    success: false,
+                    deleted: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
+            };
+        }
+    });
     builder.on('action:agent:install', async function* (event) {
         try {
             const { agentId, name, description, instructions, plugins } = event.data;