openbot 0.4.7 → 0.5.4

package/dist/plugins/mcp/index.js

@@ -1,108 +0,0 @@
-import z from 'zod';
-import { mcpService } from '../../harness/mcp.js';
-function stringifyResult(value) {
-    if (typeof value === 'string')
-        return value;
-    try {
-        return JSON.stringify(value, null, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
-const mcpToolDefinitions = {
-    mcp_list_tools: {
-        description: 'List available tools from a configured MCP server. Use this first before calling tools on an unknown server.',
-        inputSchema: z.object({
-            serverId: z.string().describe('Configured MCP server id (e.g. github, notion, linear).'),
-        }),
-    },
-    mcp_call: {
-        description: 'Call a tool on a configured MCP server. Provide tool arguments as a JSON object. Use mcp_list_tools first when uncertain.',
-        inputSchema: z.object({
-            serverId: z.string().describe('Configured MCP server id.'),
-            toolName: z.string().describe('Exact MCP tool name from mcp_list_tools.'),
-            args: z
-                .record(z.string(), z.unknown())
-                .default({})
-                .describe('Tool arguments as a JSON object.'),
-        }),
-    },
-};
-const mcpPluginRuntime = () => (builder) => {
-    builder.on('action:mcp_list_tools', async function* (event, context) {
-        const serverId = event.data?.serverId;
-        try {
-            const tools = await mcpService.listTools(serverId);
-            const toolNames = tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ''}`);
-            yield {
-                type: 'action:mcp_list_tools:result',
-                data: { success: true, serverId, tools },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: {
-                    content: toolNames.length > 0
-                        ? `MCP tools available on \`${serverId}\`:\n${toolNames.join('\n')}`
-                        : `MCP server \`${serverId}\` has no tools.`,
-                },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown MCP error';
-            yield {
-                type: 'action:mcp_list_tools:result',
-                data: { success: false, serverId, tools: [], error: message },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: { content: `Failed to list MCP tools for \`${serverId}\`: ${message}` },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-        }
-    });
-    builder.on('action:mcp_call', async function* (event, context) {
-        const data = event.data;
-        const serverId = data?.serverId;
-        const toolName = data?.toolName;
-        const args = (data?.args || {});
-        try {
-            const result = await mcpService.callTool(serverId, toolName, args);
-            const rendered = stringifyResult(result);
-            yield {
-                type: 'action:mcp_call:result',
-                data: { success: true, serverId, toolName, result },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: { content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}` },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown MCP error';
-            yield {
-                type: 'action:mcp_call:result',
-                data: { success: false, serverId, toolName, error: message },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: { content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}` },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-        }
-    });
-};
-export const mcpPlugin = {
-    id: 'mcp',
-    name: 'MCP',
-    description: 'Connect to Model Context Protocol servers and call their tools.',
-    toolDefinitions: mcpToolDefinitions,
-    factory: () => mcpPluginRuntime(),
-};
-export default mcpPlugin;

package/dist/plugins/mcp.js

@@ -1,140 +0,0 @@
-import z from 'zod';
-import { mcpService } from '../harness/mcp.js';
-function stringifyResult(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    try {
-        return JSON.stringify(value, null, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
-export const mcpToolDefinitions = {
-    mcp_list_tools: {
-        description: 'List available tools from a configured MCP server. Use this first before calling tools on an unknown server.',
-        inputSchema: z.object({
-            serverId: z.string().describe('Configured MCP server id (for example: github, notion, linear).'),
-        }),
-    },
-    mcp_call: {
-        description: 'Call a tool on a configured MCP server. Provide tool arguments as a JSON object. Use mcp_list_tools first when uncertain.',
-        inputSchema: z.object({
-            serverId: z.string().describe('Configured MCP server id.'),
-            toolName: z.string().describe('Exact MCP tool name from mcp_list_tools.'),
-            args: z.record(z.string(), z.unknown()).default({}).describe('Tool arguments as a JSON object.'),
-        }),
-    },
-};
-export const mcpPlugin = () => (builder) => {
-    builder.on('action:mcp_list_tools', async function* (event, context) {
-        const serverId = event.data?.serverId;
-        try {
-            const tools = await mcpService.listTools(serverId);
-            const toolNames = tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ''}`);
-            yield {
-                type: 'action:mcp_list_tools:result',
-                data: {
-                    success: true,
-                    serverId,
-                    tools,
-                },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: {
-                    content: toolNames.length > 0
-                        ? `MCP tools available on \`${serverId}\`:\n${toolNames.join('\n')}`
-                        : `MCP server \`${serverId}\` has no tools.`,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown MCP error';
-            yield {
-                type: 'action:mcp_list_tools:result',
-                data: {
-                    success: false,
-                    serverId,
-                    tools: [],
-                    error: message,
-                },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: {
-                    content: `Failed to list MCP tools for \`${serverId}\`: ${message}`,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-        }
-    });
-    builder.on('action:mcp_call', async function* (event, context) {
-        const serverId = event.data?.serverId;
-        const toolName = event.data?.toolName;
-        const args = (event.data?.args || {});
-        try {
-            const result = await mcpService.callTool(serverId, toolName, args);
-            const rendered = stringifyResult(result);
-            yield {
-                type: 'action:mcp_call:result',
-                data: {
-                    success: true,
-                    serverId,
-                    toolName,
-                    result,
-                },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: {
-                    content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}`,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown MCP error';
-            yield {
-                type: 'action:mcp_call:result',
-                data: {
-                    success: false,
-                    serverId,
-                    toolName,
-                    error: message,
-                },
-                meta: event.meta,
-            };
-            yield {
-                type: 'agent:output',
-                data: {
-                    content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}`,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-        }
-    });
-};
-export const plugin = {
-    name: 'mcp',
-    description: 'Basic MCP integration for configured servers',
-    factory: mcpPlugin,
-    toolDefinitions: mcpToolDefinitions,
-};

package/dist/plugins/shell/index.js

@@ -1,100 +0,0 @@
-import { z } from 'zod';
-import { spawn } from 'node:child_process';
-import { resolvePath } from '../../app/config.js';
-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('Working directory. Defaults to the channel cwd or workspace root. Leave empty unless the user requests a specific directory.'),
-            shell: z.enum(['bash', 'sh', 'zsh']).optional().describe('Shell to use. Defaults to bash.'),
-            timeoutMs: z
-                .number()
-                .optional()
-                .default(30000)
-                .describe('Maximum execution time in milliseconds. Defaults to 30000 (30s).'),
-        }),
-    },
-};
-const shellPluginRuntime = () => (builder) => {
-    builder.on('action:shell_exec', async function* (event, context) {
-        const { command, cwd, shell = 'bash', timeoutMs = 30000 } = event.data;
-        const actualTimeout = Math.max(1000, Math.min(timeoutMs, 60000));
-        const actualCwd = resolvePath(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();
-                    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,
-            };
-        }
-        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,
-            };
-        }
-    });
-};
-export const shellPlugin = {
-    id: 'shell',
-    name: 'Shell',
-    description: 'Execute shell commands in the channel workspace.',
-    toolDefinitions: shellToolDefinitions,
-    factory: () => shellPluginRuntime(),
-};
-export default shellPlugin;

package/dist/plugins/shell.js

@@ -1,123 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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 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).',
-        inputSchema: z.object({
-            state: z
-                .record(z.string(), z.unknown())
-                .describe('JSON state object for the thread. Use for structured progress or metadata.'),
-        }),
-    },
-    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;