openbot 0.2.14 → 0.3.1

package/dist/plugins/shell.js

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+export const shellToolDefinitions = {
+    shell_exec: {
+        description: 'Execute a shell command in the terminal. Use this for file operations, running scripts, or system tasks.',
+        inputSchema: z.object({
+            command: z.string().describe('The shell command to execute.'),
+            cwd: z.string().optional().describe('The working directory for the command. Defaults to the channel cwd or workspace root. Leave it empty unless user asks for a specific directory.'),
+            shell: z.enum(['bash', 'sh', 'zsh']).optional().describe('The shell to use. Defaults to bash.'),
+            timeoutMs: z.number().optional().default(30000).describe('Maximum execution time in milliseconds. Defaults to 30000 (30s).'),
+        }),
+    },
+};
+export const shellPlugin = () => (builder) => {
+    builder.on('action:shell_exec', async function* (event, context) {
+        const { command, cwd, shell = 'bash', timeoutMs = 30000 } = event.data;
+        // Clamp timeout between 1s and 60s
+        const actualTimeout = Math.max(1000, Math.min(timeoutMs, 60000));
+        // Default CWD to channel CWD if not provided
+        const actualCwd = cwd || context.state.channelDetails?.cwd || process.cwd();
+        try {
+            const result = await new Promise((resolve) => {
+                const child = spawn(command, {
+                    shell,
+                    cwd: actualCwd,
+                    env: { ...process.env },
+                });
+                let stdout = '';
+                let stderr = '';
+                let timedOut = false;
+                const timer = setTimeout(() => {
+                    timedOut = true;
+                    child.kill();
+                }, actualTimeout);
+                child.stdout.on('data', (data) => {
+                    stdout += data.toString();
+                    // Cap output at 100KB
+                    if (stdout.length > 100000) {
+                        stdout = stdout.substring(0, 100000) + '\n... [output truncated]';
+                        child.kill();
+                    }
+                });
+                child.stderr.on('data', (data) => {
+                    stderr += data.toString();
+                    if (stderr.length > 100000) {
+                        stderr = stderr.substring(0, 100000) + '\n... [output truncated]';
+                    }
+                });
+                child.on('close', (code) => {
+                    clearTimeout(timer);
+                    resolve({ exitCode: code, stdout, stderr, timedOut });
+                });
+                child.on('error', (err) => {
+                    clearTimeout(timer);
+                    resolve({ exitCode: -1, stdout, stderr: stderr + err.message, timedOut: false });
+                });
+            });
+            const success = result.exitCode === 0 && !result.timedOut;
+            yield {
+                type: 'action:shell_exec:result',
+                data: {
+                    success,
+                    exitCode: result.exitCode,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    timedOut: result.timedOut,
+                },
+                meta: event.meta,
+            };
+            // const output = [
+            //   `Command: \`${command}\``,
+            //   result.exitCode !== null ? `Exit code: ${result.exitCode}` : 'Exit code: unknown',
+            //   result.timedOut ? '⚠️ Command timed out.' : '',
+            //   result.stdout ? `\n**STDOUT**:\n${result.stdout}` : '',
+            //   result.stderr ? `\n**STDERR**:\n${result.stderr}` : '',
+            // ].filter(Boolean).join('\n');
+            // yield {
+            //   type: 'agent:output',
+            //   data: {
+            //     content: output,
+            //   },
+            //   meta: {
+            //     ...(event.meta || {}),
+            //     agentId: context.state.agentId,
+            //   },
+            // } as any;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown shell error';
+            yield {
+                type: 'action:shell_exec:result',
+                data: {
+                    success: false,
+                    exitCode: -1,
+                    stdout: '',
+                    stderr: message,
+                    timedOut: false,
+                    error: message,
+                },
+                meta: event.meta,
+            };
+            // yield {
+            //   type: 'agent:output',
+            //   data: {
+            //     content: `Failed to execute shell command: ${message}`,
+            //   },
+            //   meta: {
+            //     ...(event.meta || {}),
+            //     agentId: context.state.agentId,
+            //   },
+            // } as any;
+        }
+    });
+};
+export const plugin = {
+    name: 'shell',
+    description: 'Execute shell commands in the terminal',
+    version: '1.0.0',
+    author: 'OpenBot',
+    license: 'MIT',
+    factory: shellPlugin,
+    toolDefinitions: shellToolDefinitions,
+};

package/dist/plugins/storage-tools/index.js

@@ -0,0 +1,85 @@
+import z from 'zod';
+/**
+ * `storage-tools` — exposes channel/thread/variable mutation tools to runtime
+ * plugins. The actual handlers live in `bus/services.ts` because storage is
+ * platform infrastructure, not agent behaviour.
+ */
+const storageToolDefinitions = {
+    create_channel: {
+        description: 'Create a new channel. Use when the user intent is clearly different from the current channel and should be split. Always confirm before creating. Skip for simple Q&A.',
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .describe('Unique channel ID (e.g. product-launch, backend-platform, 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, spec, cwd).',
+        inputSchema: z
+            .object({
+            state: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('JSON state object for the channel. Use for structured data like `todos` or metadata.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Markdown content for the channel specification (SPEC.md). Use 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 for structured data like `todos` or progress.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Markdown content for the thread specification (SPEC.md). Use for 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 storageToolsPlugin = {
+    id: 'storage-tools',
+    name: 'Storage Tools',
+    description: 'Tools for creating channels, patching state, and managing workspace variables.',
+    toolDefinitions: storageToolDefinitions,
+    factory: () => () => {
+        // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+    },
+};
+export default storageToolsPlugin;

package/dist/plugins/storage.js

@@ -1,4 +1,5 @@
 import { storageService } from '../services/storage.js';
+import { pluginService } from '../services/plugins.js';
 import z from 'zod';
 export const storageToolDefinitions = {
     create_channel: {
@@ -56,6 +57,20 @@ export const storageToolDefinitions = {
             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;
@@ -174,6 +189,16 @@ export const storagePlugin = (options) => (builder) => {
             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 {
@@ -189,11 +214,94 @@ export const storagePlugin = (options) => (builder) => {
         };
     });
     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 },
-        };
+        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);
@@ -229,6 +337,44 @@ export const storagePlugin = (options) => (builder) => {
             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({
@@ -493,6 +639,95 @@ export const storagePlugin = (options) => (builder) => {
             };
         }
     });
+    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',

package/dist/plugins/ui/index.js

@@ -0,0 +1,184 @@
+import z from 'zod';
+const actionSchema = z.object({
+    id: z.string().describe('Stable action ID returned by client:ui:widget:response.'),
+    label: z.string().describe('Human-readable button label.'),
+    value: z.unknown().optional().describe('Optional machine-readable value for this action.'),
+    variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+    disabled: z.boolean().optional(),
+});
+const optionSchema = z.object({
+    label: z.string(),
+    value: z.string(),
+});
+const fieldSchema = z.object({
+    id: z.string().describe('Stable field ID used as the submitted value key.'),
+    label: z.string(),
+    type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
+    description: z.string().optional(),
+    placeholder: z.string().optional(),
+    required: z.boolean().optional(),
+    options: z.array(optionSchema).optional(),
+    defaultValue: z.unknown().optional(),
+});
+const listItemSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const widgetBaseSchema = {
+    widgetId: z.string().optional().describe('Stable widget ID. Defaults from toolCallId.'),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    body: z.string().optional(),
+    state: z.enum(['open', 'submitted', 'cancelled', 'error']).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+};
+const renderWidgetSchema = z.union([
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('message'),
+        actions: z.array(actionSchema).optional(),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('choice'),
+        actions: z.array(actionSchema).min(1),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('form'),
+        fields: z.array(fieldSchema).optional(),
+        submitLabel: z.string().optional(),
+        actions: z.array(actionSchema).optional(),
+        props: z.record(z.string(), z.unknown()).optional(),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('list'),
+        items: z.array(listItemSchema).optional(),
+        actions: z.array(actionSchema).optional(),
+    }),
+    z.object({
+        kind: z.enum(['approval', 'todo_list']).describe('Legacy preset. Prefer choice or list.'),
+        widgetId: z.string().optional(),
+        title: z.string().optional(),
+        props: z.record(z.string(), z.unknown()).optional(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+    }),
+]);
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const readString = (value) => typeof value === 'string' && value.trim() ? value : undefined;
+const asFields = (value) => Array.isArray(value) ? value : undefined;
+const asListItems = (value) => Array.isArray(value) ? value : undefined;
+const todoToListItem = (todo, index) => {
+    if (!isRecord(todo)) {
+        return { id: `todo_${index + 1}`, label: String(todo) };
+    }
+    return {
+        id: readString(todo.id) || `todo_${index + 1}`,
+        label: readString(todo.label) ||
+            readString(todo.task) ||
+            readString(todo.title) ||
+            `Todo ${index + 1}`,
+        description: readString(todo.description),
+        status: readString(todo.status),
+        metadata: todo,
+    };
+};
+const createWidgetId = (data, toolCallId) => {
+    if ('widgetId' in data && data.widgetId)
+        return data.widgetId;
+    if (toolCallId)
+        return `widget_${toolCallId}`;
+    return `widget_${Date.now()}`;
+};
+const normalizeWidget = (data, state, toolCallId) => {
+    const widgetId = createWidgetId(data, toolCallId);
+    if (data.kind === 'approval') {
+        const props = data.props || {};
+        return {
+            widgetId,
+            kind: 'choice',
+            title: data.title || 'Approval Required',
+            body: readString(props.message) ||
+                readString(props.summary) ||
+                'Please approve or deny this action.',
+            metadata: {
+                ...(data.metadata || {}),
+                legacyKind: 'approval',
+                actionId: props.actionId,
+            },
+            actions: [
+                { id: 'approve', label: 'Approve', value: props.actionId || 'approve', variant: 'primary' },
+                { id: 'deny', label: 'Deny', value: props.actionId || 'deny', variant: 'danger' },
+            ],
+        };
+    }
+    if (data.kind === 'todo_list') {
+        const props = data.props || {};
+        const stateTodos = isRecord(state.threadDetails?.state)
+            ? state.threadDetails.state.todos
+            : undefined;
+        const todos = asListItems(props.todos) || asListItems(stateTodos) || [];
+        return {
+            widgetId,
+            kind: 'list',
+            title: data.title || readString(props.title) || 'Task List',
+            description: readString(props.description),
+            metadata: { ...(data.metadata || {}), legacyKind: 'todo_list' },
+            items: todos.map(todoToListItem),
+        };
+    }
+    if (data.kind === 'form') {
+        const propsSource = data.props;
+        const props = isRecord(propsSource) ? propsSource : {};
+        return {
+            widgetId,
+            kind: 'form',
+            title: data.title || 'Details Required',
+            description: data.description,
+            body: data.body,
+            state: data.state,
+            metadata: data.metadata,
+            fields: data.fields || asFields(props.schema) || [],
+            submitLabel: data.submitLabel || readString(props.submitLabel),
+            actions: data.actions,
+        };
+    }
+    if (data.kind === 'list') {
+        return { ...data, widgetId, title: data.title || 'Task List', items: data.items || [] };
+    }
+    if (data.kind === 'choice') {
+        return { ...data, widgetId, title: data.title || 'Choose an Option' };
+    }
+    if (data.kind === 'message') {
+        return { ...data, widgetId, title: data.title || 'Message' };
+    }
+    throw new Error(`Unsupported UI widget kind: ${data.kind || 'unknown'}`);
+};
+const uiToolDefinitions = {
+    render_ui_widget: {
+        description: 'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy presets approval and todo_list are accepted.',
+        inputSchema: renderWidgetSchema,
+    },
+};
+const uiPluginRuntime = () => (builder) => {
+    builder.on('action:render_ui_widget', async function* (event, context) {
+        const widget = normalizeWidget(event.data, context.state, event.meta?.toolCallId);
+        yield {
+            type: 'client:ui:widget',
+            data: widget,
+            meta: event.meta,
+        };
+    });
+};
+export const uiPlugin = {
+    id: 'ui',
+    name: 'UI Widgets',
+    description: 'Render server-driven UI widgets (messages, choices, forms, lists) in the conversation.',
+    toolDefinitions: uiToolDefinitions,
+    factory: () => uiPluginRuntime(),
+};
+export default uiPlugin;