openbot 0.2.12 → 0.2.14

package/dist/plugins/storage.js

@@ -0,0 +1,502 @@
+import { storageService } from '../services/storage.js';
+import z from 'zod';
+export const storageToolDefinitions = {
+    create_channel: {
+        description: 'Create a new channel. Use this when you think the user intent is completelly different from the current channel and should be split into multiple channels. Before creating, always notify with details and ask for confirmation. If user asks basic questions, no need to create a channel.',
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .describe('Unique channel ID. Example: product-launch, backend-platform, or channel_roadmap.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Optional initial markdown content for the channel spec.'),
+            initialState: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('Optional initial state object for the channel.'),
+            cwd: z
+                .string()
+                .optional()
+                .describe('Optional initial current working directory for the channel.'),
+        }),
+    },
+    patch_channel_details: {
+        description: 'Patch current channel details (state and/or spec).',
+        inputSchema: z
+            .object({
+            state: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('JSON state object for the channel. Use this for structured data like `todos` or metadata.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Markdown content for the channel specification (SPEC.md). Use this for goals and rules.'),
+            cwd: z.string().optional().describe('Current working directory for the channel.'),
+        })
+            .refine((value) => value.state !== undefined || value.spec !== undefined || value.cwd !== undefined, {
+            message: 'Provide at least one of state, spec, or cwd.',
+        }),
+    },
+    patch_thread_details: {
+        description: 'Patch current thread details (state and/or spec).',
+        inputSchema: z
+            .object({
+            state: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('JSON state object for the thread. Use this for structured data like `todos` or progress tracking.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Markdown content for the thread specification (SPEC.md). Use this for detailed plans and goals.'),
+        })
+            .refine((value) => value.state !== undefined || value.spec !== undefined, {
+            message: 'Provide at least one of state or spec.',
+        }),
+    },
+};
+export const storagePlugin = (options) => (builder) => {
+    const { storage } = options;
+    builder.on('action:create_thread', async function* (event, context) {
+        // We take threadId from meta so the next agent:invoke event will reply in the same thread.
+        const threadId = event.meta?.threadId;
+        const channelId = context.state.channelId;
+        const { threadTitle, spec, initialState } = event.data;
+        if (!threadId) {
+            console.warn('[storage] Cannot create thread: meta.threadId is missing');
+            return;
+        }
+        // Override threadId in state to keep subsequent replies in the same thread.
+        context.state.threadId = threadId;
+        if (channelId) {
+            try {
+                await storage.createThread({
+                    channelId,
+                    threadId,
+                    threadTitle,
+                    spec,
+                    initialState: initialState || {},
+                });
+                context.state.threadDetails = await storage.getThreadDetails({
+                    channelId,
+                    threadId,
+                });
+            }
+            catch (error) {
+                console.warn(`[storage] Failed to initialize thread for channel ${channelId} thread ${threadId}`, error);
+            }
+        }
+        yield {
+            type: 'action:create_thread:result',
+            data: {
+                success: true,
+                threadId,
+                threadTitle,
+            },
+            meta: {
+                threadId,
+            },
+        };
+    });
+    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 : '';
+        if (!rawChannelId) {
+            yield {
+                type: 'action:create_channel:result',
+                data: {
+                    success: false,
+                    channelId: '',
+                    channelUrl: '',
+                },
+            };
+            return;
+        }
+        const channelUrl = `/channels/${rawChannelId}`;
+        try {
+            await storage.createChannel({
+                channelId: rawChannelId,
+                spec: channelSpec,
+                initialState: initialState,
+                cwd,
+            });
+            yield {
+                type: 'action:create_channel:result',
+                data: {
+                    success: true,
+                    channelId: rawChannelId,
+                    channelUrl,
+                },
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Created channel \`${rawChannelId}\`.`,
+                },
+                meta: {
+                    ...(event.meta || {}),
+                    agentId: context.state.agentId,
+                },
+            };
+        }
+        catch {
+            yield {
+                type: 'action:create_channel:result',
+                data: {
+                    success: false,
+                    channelId: rawChannelId,
+                    channelUrl,
+                },
+            };
+        }
+    });
+    builder.on('action:storage:get-channels', async function* () {
+        const channels = await storage.getChannels();
+        yield {
+            type: 'action:storage:get-channels-result',
+            data: { channels },
+        };
+    });
+    builder.on('action:storage:get-threads', async function* (event) {
+        const threads = await storage.getThreads({ channelId: event.data.channelId });
+        yield {
+            type: 'action:storage:get-threads-result',
+            data: { threads },
+        };
+    });
+    builder.on('action:storage:get-channel-details', async function* (_, state) {
+        const channelDetails = await storage.getChannelDetails({ channelId: state.state.channelId });
+        yield {
+            type: 'action:storage:get-channel-details-result',
+            data: { channelDetails },
+        };
+    });
+    builder.on('action:storage:get-agents', async function* () {
+        const agents = await storage.getAgents();
+        yield {
+            type: 'action:storage:get-agents-result',
+            data: { agents },
+        };
+    });
+    builder.on('action:storage:get-plugins', async function* () {
+        const plugins = await storage.getPlugins();
+        yield {
+            type: 'action:storage:get-plugins-result',
+            data: { plugins },
+        };
+    });
+    builder.on('action:storage:get-agent-details', async function* (event, state) {
+        const agentDetails = await storage.getAgentDetails({ agentId: event.data.agentId });
+        yield {
+            type: 'action:storage:get-agent-details-result',
+            data: { agentDetails },
+        };
+    });
+    builder.on('action:storage:get-events', async function* (_, state) {
+        const events = await storage.getEvents(state.state);
+        // Simple: fetching main channel events marks it as read
+        if (!state.state.threadId && events.length > 0) {
+            const lastId = events[events.length - 1]?.id;
+            if (lastId) {
+                // We call storageService directly as it's an internal helper now
+                await storageService.setLastReadForChannel({
+                    channelId: state.state.channelId,
+                    lastReadEventId: lastId,
+                });
+            }
+        }
+        yield {
+            type: 'action:storage:get-events-result',
+            data: { events },
+        };
+    });
+    builder.on('action:storage:get-variables', async function* () {
+        const variables = await storage.getVariables();
+        const maskedVariables = {};
+        for (const [key, val] of Object.entries(variables)) {
+            if (typeof val === 'object' && val !== null && val.secret) {
+                maskedVariables[key] = '********';
+            }
+            else {
+                maskedVariables[key] = typeof val === 'string' ? val : val.value;
+            }
+        }
+        yield {
+            type: 'action:storage:get-variables-result',
+            data: { variables: maskedVariables },
+        };
+    });
+    builder.on('action:storage:patch-channel-state', async function* (event, state) {
+        try {
+            await storage.patchChannelState({
+                channelId: state.state.channelId,
+                state: event.data.state,
+            });
+            yield {
+                type: 'action:storage:patch-channel-state-result',
+                data: { success: true },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:storage:patch-channel-state-result',
+                data: { success: false },
+            };
+        }
+    });
+    builder.on('action:storage:patch-thread-state', async function* (event, state) {
+        try {
+            if (!state.state.threadId) {
+                throw new Error('Missing threadId in state for patch-thread-state');
+            }
+            await storage.patchThreadState({
+                channelId: state.state.channelId,
+                threadId: state.state.threadId,
+                state: event.data.state,
+            });
+            yield {
+                type: 'action:storage:patch-thread-state-result',
+                data: { success: true },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:storage:patch-thread-state-result',
+                data: { success: false },
+            };
+        }
+    });
+    builder.on('action:patch_channel_details', async function* (event, context) {
+        const updatedFields = [];
+        try {
+            if (event.data.state !== undefined) {
+                await storage.patchChannelState({
+                    channelId: context.state.channelId,
+                    state: event.data.state,
+                });
+                updatedFields.push('state');
+            }
+            if (typeof event.data.spec === 'string') {
+                await storage.patchChannelSpec({
+                    channelId: context.state.channelId,
+                    spec: event.data.spec,
+                });
+                updatedFields.push('spec');
+            }
+            if (typeof event.data.cwd === 'string') {
+                await storage.patchChannelState({
+                    channelId: context.state.channelId,
+                    state: { cwd: event.data.cwd },
+                });
+                updatedFields.push('cwd');
+            }
+            context.state.channelDetails = await storage.getChannelDetails({
+                channelId: context.state.channelId,
+            });
+            yield {
+                type: 'action:patch_channel_details:result',
+                data: {
+                    success: true,
+                    updatedFields,
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:patch_channel_details:result',
+                data: {
+                    success: false,
+                    updatedFields,
+                },
+            };
+        }
+    });
+    // Backward-compatible event used by external frontends.
+    builder.on('action:update_channel', async function* (event, context) {
+        const data = (event.data || {});
+        const targetChannelId = (data.channelId || context.state.channelId || '').trim();
+        if (!targetChannelId) {
+            yield {
+                type: 'action:update_channel:result',
+                data: {
+                    success: false,
+                    channelId: '',
+                    updatedFields: [],
+                },
+            };
+            return;
+        }
+        const patch = {};
+        const updatedFields = [];
+        if (typeof data.name === 'string' && data.name.trim()) {
+            patch.name = data.name.trim();
+            updatedFields.push('name');
+        }
+        if (typeof data.cwd === 'string' && data.cwd.trim()) {
+            patch.cwd = data.cwd.trim();
+            updatedFields.push('cwd');
+        }
+        try {
+            if (updatedFields.length > 0) {
+                await storage.patchChannelState({
+                    channelId: targetChannelId,
+                    state: patch,
+                });
+            }
+            if (targetChannelId === context.state.channelId) {
+                context.state.channelDetails = await storage.getChannelDetails({
+                    channelId: context.state.channelId,
+                });
+            }
+            yield {
+                type: 'action:update_channel:result',
+                data: {
+                    success: true,
+                    channelId: targetChannelId,
+                    updatedFields,
+                },
+            };
+        }
+        catch {
+            yield {
+                type: 'action:update_channel:result',
+                data: {
+                    success: false,
+                    channelId: targetChannelId,
+                    updatedFields,
+                },
+            };
+        }
+    });
+    builder.on('action:patch_thread_details', async function* (event, context) {
+        const updatedFields = [];
+        try {
+            if (!context.state.threadId) {
+                throw new Error('Missing threadId in state for patch_thread_details');
+            }
+            if (event.data.state !== undefined) {
+                await storage.patchThreadState({
+                    channelId: context.state.channelId,
+                    threadId: context.state.threadId,
+                    state: event.data.state,
+                });
+                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,
+            });
+            yield {
+                type: 'action:patch_thread_details:result',
+                data: {
+                    success: true,
+                    updatedFields,
+                },
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Thread details updated: ${updatedFields.join(', ')}`,
+                },
+                meta: {
+                    agentId: context.state.agentId,
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:patch_thread_details:result',
+                data: {
+                    success: false,
+                    updatedFields,
+                },
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Failed to update thread details: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+                meta: {
+                    agentId: context.state.agentId,
+                },
+            };
+        }
+    });
+    builder.on('action:storage:list-files', async function* (event, context) {
+        const channelId = context.state.channelId;
+        const subPath = event.data?.path || '';
+        try {
+            const files = await storage.listFiles({ channelId, path: subPath });
+            yield {
+                type: 'action:storage:list-files:result',
+                data: {
+                    success: true,
+                    files,
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:storage:list-files:result',
+                data: {
+                    success: false,
+                    files: [],
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+            };
+        }
+    });
+    builder.on('action:storage:read-file', async function* (event, context) {
+        const channelId = context.state.channelId;
+        const filePath = event.data?.path;
+        if (!filePath) {
+            yield {
+                type: 'action:storage:read-file:result',
+                data: {
+                    success: false,
+                    path: '',
+                    error: 'Path is required',
+                },
+            };
+            return;
+        }
+        try {
+            const content = await storage.readFile({ channelId, path: filePath });
+            yield {
+                type: 'action:storage:read-file:result',
+                data: {
+                    success: true,
+                    content,
+                    path: filePath,
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:storage:read-file:result',
+                data: {
+                    success: false,
+                    path: filePath,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+            };
+        }
+    });
+};
+export const plugin = {
+    name: 'storage',
+    description: 'Built-in storage plugin',
+    factory: storagePlugin,
+    toolDefinitions: storageToolDefinitions,
+};

package/dist/plugins/ui.js

@@ -0,0 +1,47 @@
+import z from 'zod';
+/**
+ * UI Plugin for Melony.
+ * Provides tools for agents to trigger interactive UI widgets.
+ */
+export const uiPlugin = () => (builder) => {
+    builder.on('action:render_ui_widget', async function* (event, context) {
+        const { kind, title, props } = event.data;
+        const finalProps = { ...props };
+        // Auto-inject todos if it's a todo_list and they aren't provided
+        if (kind === 'todo_list' && !finalProps.todos) {
+            finalProps.todos = context.state.threadDetails?.state?.todos || [];
+        }
+        yield {
+            type: 'client:ui:widget',
+            data: {
+                widgetId: `${kind}_${Date.now()}`,
+                kind,
+                title: title || (kind === 'approval' ? 'Approval Required' : kind === 'todo_list' ? 'Task List' : 'Details Required'),
+                props: finalProps,
+            },
+            meta: event.meta,
+        };
+    });
+};
+export const uiToolDefinitions = {
+    render_ui_widget: {
+        description: 'Render an interactive UI widget (approval, todo_list, or form) in the conversation.',
+        inputSchema: z.object({
+            kind: z.enum(['approval', 'todo_list', 'form']).describe('The type of widget to render.'),
+            title: z.string().optional().describe('Optional title for the widget.'),
+            props: z.record(z.string(), z.unknown()).describe('Properties for the widget. \n' +
+                '- For "approval": { message: string, actionId: string }\n' +
+                '- For "todo_list": { title?: string } (Note: current thread todos are auto-injected if not provided)\n' +
+                '- For "form": { schema: Array<{ id, label, type, options?, required? }>, submitLabel?: string }'),
+        }),
+    },
+};
+export const plugin = {
+    name: 'ui',
+    description: 'UI Widgets plugin',
+    version: '1.0.0',
+    author: 'OpenBot',
+    license: 'MIT',
+    factory: uiPlugin,
+    toolDefinitions: uiToolDefinitions,
+};

package/dist/registry/plugins.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { aiSdkPlugin } from '../plugins/ai-sdk.js';
+import { storagePlugin } from '../plugins/storage.js';
+import { storageService } from '../services/storage.js';
+import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
+import { delegationPlugin } from '../plugins/delegation.js';
+import { mcpPlugin } from '../plugins/mcp.js';
+import { uiPlugin } from '../plugins/ui.js';
+let pluginsDir = null;
+const loadedPlugins = new Set();
+/**
+ * Initializes the plugins directory.
+ */
+export function initPlugins(dir) {
+    if (dir) {
+        pluginsDir = dir;
+    }
+    else {
+        const config = loadConfig();
+        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
+        pluginsDir = path.join(resolvePath(baseDir), 'plugins');
+    }
+}
+/**
+ * Resolves a plugin from its name and config.
+ */
+export async function resolvePlugin(pluginName, config = {}) {
+    // 1. Built-in plugins
+    switch (pluginName) {
+        case 'storage':
+            return storagePlugin({ storage: storageService, ...config });
+        case 'ai-sdk':
+            return aiSdkPlugin({
+                storage: storageService,
+                ...config,
+            });
+        case 'delegation':
+            return delegationPlugin();
+        case 'mcp':
+            return mcpPlugin();
+        case 'ui':
+            return uiPlugin();
+    }
+    // 2. Search for external plugins in the initialized plugins directory
+    if (!pluginsDir) {
+        initPlugins();
+    }
+    if (pluginsDir) {
+        const pluginDir = path.resolve(pluginsDir, pluginName);
+        const distPath = path.join(pluginDir, 'dist', 'index.js');
+        if (fs.existsSync(distPath)) {
+            try {
+                // Dynamic import needs file:// URL for absolute paths
+                const module = await import(pathToFileURL(distPath).href);
+                const factory = module.plugin.factory;
+                if (typeof factory === 'function') {
+                    if (!loadedPlugins.has(pluginName)) {
+                        console.log(`[plugins] Loaded community plugin "${pluginName}" from ${distPath}`);
+                        loadedPlugins.add(pluginName);
+                    }
+                    return factory(config);
+                }
+            }
+            catch (e) {
+                console.warn(`[plugins] Failed to load plugin "${pluginName}" from ${distPath}:`, e);
+            }
+        }
+    }
+    console.warn(`[plugins] Plugin "${pluginName}" not found in registry or external directory.`);
+    return null;
+}