openbot 0.3.6 → 0.4.2

package/src/plugins/mcp/index.ts

@@ -1,128 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-import { OpenBotEvent, OpenBotState } from '../../app/types.js';
-import { mcpService } from '../../harness/mcp.js';
-
-function stringifyResult(value: unknown): string {
-  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 = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:mcp_list_tools', async function* (event, context) {
-    const serverId = (event.data as { serverId?: string })?.serverId as string;
-
-    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,
-      } as OpenBotEvent;
-
-      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 },
-      } as OpenBotEvent;
-    } 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,
-      } as OpenBotEvent;
-      yield {
-        type: 'agent:output',
-        data: { content: `Failed to list MCP tools for \`${serverId}\`: ${message}` },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    }
-  });
-
-  builder.on('action:mcp_call', async function* (event, context) {
-    const data = event.data as {
-      serverId?: string;
-      toolName?: string;
-      args?: Record<string, unknown>;
-    };
-    const serverId = data?.serverId as string;
-    const toolName = data?.toolName as string;
-    const args = (data?.args || {}) as Record<string, unknown>;
-
-    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,
-      } as OpenBotEvent;
-
-      yield {
-        type: 'agent:output',
-        data: { content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}` },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    } 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,
-      } as OpenBotEvent;
-      yield {
-        type: 'agent:output',
-        data: { content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}` },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    }
-  });
-};
-
-export const mcpPlugin: Plugin = {
-  id: 'mcp',
-  name: 'MCP',
-  description: 'Connect to Model Context Protocol servers and call their tools.',
-  toolDefinitions: mcpToolDefinitions,
-  factory: () => mcpPluginRuntime(),
-};
-
-export default mcpPlugin;

package/src/plugins/shell/index.ts

@@ -1,123 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import { z } from 'zod';
-import { spawn } from 'node:child_process';
-import type { Plugin } from '../../bus/plugin.js';
-import { OpenBotEvent, OpenBotState } from '../../app/types.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 = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (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 = cwd || context.state.channelDetails?.cwd || process.cwd();
-
-    try {
-      const result = await new Promise<{
-        exitCode: number | null;
-        stdout: string;
-        stderr: string;
-        timedOut: boolean;
-      }>((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,
-      } as OpenBotEvent;
-    } 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,
-      } as OpenBotEvent;
-    }
-  });
-};
-
-export const shellPlugin: Plugin = {
-  id: 'shell',
-  name: 'Shell',
-  description: 'Execute shell commands in the channel workspace.',
-  toolDefinitions: shellToolDefinitions,
-  factory: () => shellPluginRuntime(),
-};
-
-export default shellPlugin;

package/src/plugins/storage-tools/index.ts

@@ -1,90 +0,0 @@
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-
-/**
- * `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).',
-    inputSchema: z.object({
-      state: z
-        .record(z.string(), z.unknown())
-        .describe(
-          'JSON state object for the thread. Use for structured data like `todos` or progress.',
-        ),
-    }),
-  },
-  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: Plugin = {
-  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/src/plugins/todo/index.ts

@@ -1,64 +0,0 @@
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-
-/**
- * `todo` — shared, per-thread task list for autonomous multi-agent flows.
- *
- * Todos live in `threadDetails.state.todos` and are owned by the system
- * (handlers in `bus/services.ts`). Any agent in the thread can read the
- * list via context, and propose mutations through these tools. Each item
- * may carry an `assignee` agent id; combine with `handoff` to drive an
- * autonomous, multi-step plan across agents.
- *
- * Keep the surface minimal: two tools (replace-all, patch-one) cover plan
- * authoring, status transitions, and reassignment.
- */
-const todoStatus = z.enum(['pending', 'in_progress', 'done', 'cancelled']);
-
-const todoToolDefinitions = {
-  todo_write: {
-    description:
-      'Author or rewrite the shared todo plan for the current thread. Pass the full ordered list — missing items are removed. Use at the start of multi-step work, or whenever the plan changes shape. For status flips, prefer `todo_update`.',
-    inputSchema: z.object({
-      todos: z
-        .array(
-          z.object({
-            id: z
-              .string()
-              .optional()
-              .describe('Stable id. Reuse existing ids to preserve history; omit to create.'),
-            content: z.string().min(1).describe('What needs to be done. One concrete step.'),
-            status: todoStatus.optional().describe('Defaults to `pending`.'),
-            assignee: z
-              .string()
-              .optional()
-              .describe('Agent id responsible for this step. Pair with `handoff` to delegate.'),
-          }),
-        )
-        .describe('The complete, ordered plan.'),
-    }),
-  },
-  todo_update: {
-    description:
-      'Patch a single todo by id. Use to mark progress (`in_progress`, `done`, `cancelled`), rephrase, or reassign without rewriting the whole list.',
-    inputSchema: z.object({
-      id: z.string().describe('Todo id from `todo_write` or the rendered list.'),
-      status: todoStatus.optional(),
-      content: z.string().min(1).optional(),
-      assignee: z.string().optional().describe('Use empty string to clear.'),
-    }),
-  },
-};
-
-export const todoPlugin: Plugin = {
-  id: 'todo',
-  name: 'Todo',
-  description:
-    'Shared per-thread task list for coordinating multi-step, multi-agent work.',
-  toolDefinitions: todoToolDefinitions,
-  factory: () => () => {
-    // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
-  },
-};
-
-export default todoPlugin;

package/src/services/plugins.ts

@@ -1,133 +0,0 @@
-import fs from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import {
-  DEFAULT_PLUGINS_DIR,
-  DEFAULT_BASE_DIR,
-  loadConfig,
-  resolvePath,
-} from '../app/config.js';
-import { invalidatePlugin } from '../registry/plugins.js';
-
-const execAsync = promisify(exec);
-
-export interface InstallOptions {
-  packageName: string;
-  version?: string;
-}
-
-export interface InstalledPlugin {
-  /** npm package name; doubles as the plugin id used everywhere else. */
-  name: string;
-  version: string;
-}
-
-const getPluginsDir = (): string => {
-  const config = loadConfig();
-  const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-  return path.join(baseDir, DEFAULT_PLUGINS_DIR);
-};
-
-/**
- * Lifecycle for community-built plugins distributed via npm.
- * Each plugin is installed to `<plugins>/<npm-name>/` and is identified
- * everywhere (AGENT.md `plugins[].id`, registry, runtime resolution) by its
- * npm name. Scoped packages (`@scope/foo`) live under `<plugins>/@scope/foo/`.
- */
-export const pluginService = {
-  isInstalled: async (packageName: string): Promise<boolean> => {
-    const finalPath = path.join(getPluginsDir(), packageName);
-    return existsSync(path.join(finalPath, 'dist', 'index.js'));
-  },
-
-  install: async ({ packageName, version }: InstallOptions): Promise<InstalledPlugin> => {
-    const pluginsDir = getPluginsDir();
-    await fs.mkdir(pluginsDir, { recursive: true });
-
-    const finalPath = path.join(pluginsDir, packageName);
-
-    if (existsSync(path.join(finalPath, 'package.json'))) {
-      try {
-        const pkgJson = JSON.parse(
-          await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'),
-        );
-        if (!version || pkgJson.version === version) {
-          console.log(
-            `[plugins] ${packageName}${version ? `@${version}` : ''} is already installed.`,
-          );
-          return { name: pkgJson.name, version: pkgJson.version };
-        }
-      } catch {
-        // corrupted; reinstall below
-      }
-    }
-
-    const target = version ? `${packageName}@${version}` : packageName;
-    console.log(`[plugins] Installing ${target} to ${pluginsDir}...`);
-
-    const tempDir = path.join(pluginsDir, '.tmp_' + Date.now());
-    try {
-      await fs.mkdir(tempDir, { recursive: true });
-      await execAsync(`npm install ${target} --no-save --prefix "${tempDir}"`);
-
-      const installedPath = path.join(tempDir, 'node_modules', packageName);
-      if (!existsSync(installedPath)) {
-        throw new Error(`npm did not produce ${installedPath}`);
-      }
-
-      await fs.mkdir(path.dirname(finalPath), { recursive: true });
-      await fs.rm(finalPath, { recursive: true, force: true });
-      await fs.rename(installedPath, finalPath);
-
-      console.log(`[plugins] Running npm install in ${finalPath}...`);
-      try {
-        await execAsync(`npm install`, { cwd: finalPath });
-        console.log(`[plugins] npm install completed in ${finalPath}`);
-      } catch (e) {
-        console.warn(`[plugins] Failed to run npm install in ${finalPath}:`, e);
-      }
-
-      const pkgJson = JSON.parse(
-        await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'),
-      );
-
-      invalidatePlugin(packageName);
-      return { name: pkgJson.name, version: pkgJson.version };
-    } catch (error) {
-      console.error(`[plugins] Failed to install ${packageName}:`, error);
-      throw new Error(
-        `Failed to install plugin ${packageName}: ${(error as Error).message}`,
-      );
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
-    }
-  },
-
-  uninstall: async (packageName: string): Promise<void> => {
-    const pluginsDir = getPluginsDir();
-    const pluginPath = path.join(pluginsDir, packageName);
-
-    try {
-      await fs.rm(pluginPath, { recursive: true, force: true });
-      invalidatePlugin(packageName);
-      console.log(`[plugins] Uninstalled plugin ${packageName}`);
-
-      if (packageName.startsWith('@')) {
-        const scopeDir = path.dirname(pluginPath);
-        try {
-          const remaining = await fs.readdir(scopeDir);
-          if (remaining.length === 0) await fs.rmdir(scopeDir);
-        } catch {
-          // ignore
-        }
-      }
-    } catch (error) {
-      console.error(`[plugins] Failed to uninstall ${packageName}:`, error);
-      throw new Error(
-        `Failed to uninstall plugin ${packageName}: ${(error as Error).message}`,
-      );
-    }
-  },
-};