openbot 0.4.7 → 0.5.4

package/dist/plugins/storage.js

@@ -1,737 +0,0 @@
-import { storageService } from '../services/storage.js';
-import { pluginService } from '../services/plugins.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.',
-        }),
-    },
-    create_variable: {
-        description: 'Create or update a variable in the workspace storage.',
-        inputSchema: z.object({
-            key: z.string().describe('The key of the variable.'),
-            value: z.string().describe('The value of the variable.'),
-            secret: z.boolean().optional().describe('Whether the variable is a secret.'),
-        }),
-    },
-    delete_variable: {
-        description: 'Delete a variable from the workspace storage.',
-        inputSchema: z.object({
-            key: z.string().describe('The key of the variable to delete.'),
-        }),
-    },
-};
-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-thread-details', async function* (_, state) {
-        const threadId = state.state.threadId;
-        const threadDetails = threadId
-            ? await storage.getThreadDetails({ channelId: state.state.channelId, threadId })
-            : null;
-        yield {
-            type: 'action:storage:get-thread-details-result',
-            data: { threadDetails },
-        };
-    });
-    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) {
-        try {
-            const agentDetails = await storage.getAgentDetails({ agentId: event.data.agentId });
-            yield {
-                type: 'action:storage:get-agent-details-result',
-                data: { agentDetails },
-            };
-        }
-        catch (error) {
-            console.error(`[storage] Failed to get agent details for ${event.data.agentId}`, error);
-            yield {
-                type: 'action:storage:get-agent-details-result',
-                data: {
-                    agentDetails: null,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-    builder.on('action:storage:create-agent', async function* (event) {
-        try {
-            const { agentId, name, description, instructions, plugins, runtime } = event.data;
-            await storage.createAgent({
-                agentId,
-                name,
-                description,
-                instructions,
-                plugins,
-                runtime,
-            });
-            yield {
-                type: 'action:storage:create-agent-result',
-                data: { success: true },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:storage:create-agent-result',
-                data: {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-    builder.on('action:storage:update-agent', async function* (event) {
-        try {
-            const { agentId, name, description, instructions, plugins, runtime } = event.data;
-            await storage.updateAgent({
-                agentId,
-                name,
-                description,
-                instructions,
-                plugins,
-                runtime,
-            });
-            yield {
-                type: 'action:storage:update-agent-result',
-                data: { success: true },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:storage:update-agent-result',
-                data: {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-    builder.on('action:storage:delete-agent', async function* (event) {
-        try {
-            const { agentId } = event.data;
-            await storage.deleteAgent({ agentId });
-            yield {
-                type: 'action:storage:delete-agent-result',
-                data: { success: true },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:storage:delete-agent-result',
-                data: {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-    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:create-variable', async function* (event) {
-        try {
-            const { key, value, secret } = event.data;
-            await storage.createVariable({ key, value, secret });
-            yield {
-                type: 'action:storage:create-variable-result',
-                data: { success: true },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:storage:create-variable-result',
-                data: {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-    builder.on('action:storage:delete-variable', async function* (event) {
-        try {
-            const { key } = event.data;
-            await storage.deleteVariable({ key });
-            yield {
-                type: 'action:storage:delete-variable-result',
-                data: { success: true },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:storage:delete-variable-result',
-                data: {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-    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',
-                },
-            };
-        }
-    });
-    builder.on('action:plugin:install', async function* (event) {
-        try {
-            const { name, version } = event.data;
-            const result = await pluginService.installPlugin({ packageName: name, version });
-            yield {
-                type: 'action:plugin:install:result',
-                data: { success: true, plugin: result },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:plugin:install:result',
-                data: { success: false, error: error.message },
-            };
-        }
-    });
-    builder.on('action:plugin:uninstall', async function* (event) {
-        try {
-            const { id } = event.data;
-            await pluginService.uninstallPlugin(id);
-            yield {
-                type: 'action:plugin:uninstall:result',
-                data: { success: true },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:plugin:uninstall:result',
-                data: { success: false, error: error.message },
-            };
-        }
-    });
-    builder.on('action:marketplace:list', async function* () {
-        // Mock marketplace agents for MVP
-        const agents = [
-            {
-                id: 'researcher',
-                name: 'Researcher',
-                description: 'Specialized in web research and information synthesis.',
-                // image: 'https://registry.openbot.local/agents/researcher/icon.svg',
-                instructions: 'You are a research assistant. Use available tools to find information.',
-                runtime: { name: 'ai-sdk', config: { model: 'openai/gpt-4o' } },
-            },
-            {
-                id: 'coder',
-                name: 'Coder',
-                description: 'Expert in multiple programming languages and software architecture.',
-                // image: 'https://registry.openbot.local/agents/coder/icon.svg',
-                instructions: 'You are an expert software engineer. Help the user with coding tasks.',
-                runtime: { name: 'ai-sdk', config: { model: 'openai/gpt-4o' } },
-            },
-        ];
-        yield {
-            type: 'action:marketplace:list:result',
-            data: { success: true, agents },
-        };
-    });
-    builder.on('action:agent:install', async function* (event) {
-        try {
-            const { agentId, name, description, instructions, runtime, plugins } = event.data;
-            await storage.createAgent({
-                agentId,
-                name,
-                description,
-                instructions,
-                runtime,
-                plugins,
-            });
-            yield {
-                type: 'action:agent:install:result',
-                data: { success: true, agentId },
-            };
-            yield {
-                type: 'agent:output',
-                data: { content: `Successfully installed agent **${name}** (${agentId}) from marketplace.` },
-                meta: { agentId: 'system' },
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:agent:install:result',
-                data: {
-                    success: false,
-                    agentId: event.data.agentId,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-            };
-        }
-    });
-};
-export const plugin = {
-    name: 'storage',
-    description: 'Built-in storage plugin',
-    factory: storagePlugin,
-    toolDefinitions: storageToolDefinitions,
-};