openbot 0.4.0 → 0.4.2

package/src/plugins/bash/index.ts

@@ -0,0 +1,232 @@
+import { MelonyPlugin } from 'melony';
+import { z } from 'zod';
+import { spawn, ChildProcess } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import type { Plugin } from '../../services/plugins/types.js';
+import { OpenBotEvent, OpenBotState } from '../../app/types.js';
+import { resolvePath } from '../../app/config.js';
+
+const bashToolDefinitions = {
+  bash: {
+    description:
+      'Execute a bash command in a stateful session. The working directory and environment variables persist between calls. Use this for all system tasks, file operations, and running development servers.',
+    inputSchema: z.object({
+      command: z.string().describe('The bash command to execute.'),
+      restart: z
+        .boolean()
+        .optional()
+        .describe('Restart the bash session before running the command.'),
+    }),
+  },
+  bash_stop: {
+    description: 'Stop the bash session for the current or specified channel.',
+    inputSchema: z.object({
+      channelId: z.string().optional().describe('The channel ID to stop the session for.'),
+    }),
+  },
+  bash_list_sessions: {
+    description: 'List all active bash sessions.',
+    inputSchema: z.object({}),
+  },
+};
+
+interface BashSession {
+  process: ChildProcess;
+  cwd: string;
+  lastActivity: number;
+}
+
+const sessions = new Map<string, BashSession>();
+
+const getSession = (channelId: string, initialCwd: string): BashSession => {
+  let session = sessions.get(channelId);
+  if (!session) {
+    const childProcess = spawn('bash', ['--login'], {
+      cwd: initialCwd,
+      env: { ...process.env, PS1: '' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    session = {
+      process: childProcess,
+      cwd: initialCwd,
+      lastActivity: Date.now(),
+    };
+    sessions.set(channelId, session);
+
+    // Basic error handling for the process
+    childProcess.on('error', (err: Error) => {
+      console.error(`[bash] Session error for channel ${channelId}:`, err);
+      sessions.delete(channelId);
+    });
+
+    childProcess.on('exit', () => {
+      sessions.delete(channelId);
+    });
+  }
+  return session;
+};
+
+const bashPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
+  builder.on('action:bash', async function* (event, context) {
+    const { command, restart } = event.data;
+    const channelId = context.state.channelId;
+    const initialCwd = resolvePath(context.state.channelDetails?.cwd || process.cwd());
+
+    if (restart) {
+      const oldSession = sessions.get(channelId);
+      if (oldSession) {
+        oldSession.process.kill();
+        sessions.delete(channelId);
+      }
+    }
+
+    const session = getSession(channelId, initialCwd);
+    session.lastActivity = Date.now();
+
+    try {
+      const result = await new Promise<{
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        timedOut: boolean;
+      }>((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const sentinel = `__OPENBOT_BASH_DONE_${Math.random().toString(36).substring(7)}__`;
+
+        const timeoutMs = 60000; // 1 minute timeout for tool calls
+        const timer = setTimeout(() => {
+          timedOut = true;
+          // We don't kill the session on timeout, just return what we have
+          resolve({ exitCode: null, stdout, stderr, timedOut });
+        }, timeoutMs);
+
+        const onStdout = (data: Buffer) => {
+          const str = data.toString();
+          if (str.includes(sentinel)) {
+            const parts = str.split(sentinel);
+            stdout += parts[0];
+            const exitCodeMatch = parts[1].match(/EXIT:(\d+)/);
+            const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 0;
+
+            cleanup();
+            resolve({ exitCode, stdout, stderr, timedOut: false });
+          } else {
+            stdout += str;
+          }
+        };
+
+        const onStderr = (data: Buffer) => {
+          stderr += data.toString();
+        };
+
+        const cleanup = () => {
+          clearTimeout(timer);
+          session.process.stdout?.removeListener('data', onStdout);
+          session.process.stderr?.removeListener('data', onStderr);
+        };
+
+        session.process.stdout?.on('data', onStdout);
+        session.process.stderr?.on('data', onStderr);
+
+        // Execute command and then echo the sentinel with exit code
+        session.process.stdin?.write(`${command}\necho "${sentinel}EXIT:$?"\n`);
+      });
+
+      yield {
+        type: 'action:bash:result',
+        data: {
+          success: result.exitCode === 0 && !result.timedOut,
+          exitCode: result.exitCode,
+          stdout: result.stdout.trim(),
+          stderr: result.stderr.trim(),
+          timedOut: result.timedOut,
+          output: result.stderr.trim() ? result.stderr.trim() : result.stdout.trim(),
+        },
+        meta: event.meta,
+      } as OpenBotEvent;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown bash error';
+      yield {
+        type: 'action:bash:result',
+        data: {
+          success: false,
+          exitCode: -1,
+          stdout: '',
+          stderr: message,
+          timedOut: false,
+          error: message,
+          output: message,
+        },
+        meta: event.meta,
+      } as OpenBotEvent;
+    }
+  });
+
+  // Add a tool to stop/kill the session
+  builder.on('action:bash_stop', async function* (event, context) {
+    const channelId = event.data?.channelId || context.state.channelId;
+    const session = sessions.get(channelId);
+    if (session) {
+      session.process.kill();
+      sessions.delete(channelId);
+    }
+    yield {
+      type: 'action:bash_stop:result',
+      data: { success: true, output: `Bash session for channel ${channelId} stopped.` },
+      meta: event.meta,
+    } as OpenBotEvent;
+  });
+
+  // Add a tool to list all active sessions
+  builder.on('action:bash_list_sessions', async function* (event, context) {
+    const activeSessions = Array.from(sessions.entries()).map(([channelId, session]) => ({
+      channelId,
+      cwd: session.cwd,
+      lastActivity: session.lastActivity,
+    }));
+
+    yield {
+      type: 'client:ui:widget',
+      data: {
+        widgetId: randomUUID(),
+        kind: 'list',
+        title: 'Active Bash Sessions',
+        description: `Found ${activeSessions.length} active bash session${activeSessions.length === 1 ? '' : 's'}.`,
+        items: activeSessions.map((s) => ({
+          id: s.channelId,
+          label: s.channelId,
+          description: `CWD: ${s.cwd}`,
+          status: 'done',
+          metadata: {
+            cwd: s.cwd,
+            lastActivity: s.lastActivity,
+          },
+        })),
+      },
+      meta: event.meta,
+    } as OpenBotEvent;
+
+    yield {
+      type: 'action:bash_list_sessions:result',
+      data: {
+        success: true,
+        sessions: activeSessions,
+        output: JSON.stringify(activeSessions),
+      },
+      meta: event.meta,
+    } as OpenBotEvent;
+  });
+};
+
+export const bashPlugin: Plugin = {
+  id: 'bash',
+  name: 'Bash',
+  description: 'Stateful bash session for the channel.',
+  toolDefinitions: bashToolDefinitions,
+  factory: () => bashPluginRuntime(),
+};
+
+export default bashPlugin;

package/src/plugins/delegation/index.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 import { generateId } from 'melony';
 import type { Plugin } from '../../services/plugins/types.js';
-import { runAgent } from '../../harness/index.js';
 import {
   OpenBotEvent,
   DelegateTaskEvent,
@@ -30,7 +29,7 @@ export const delegationPlugin: Plugin = {
   name: 'Delegation',
   description: 'Allows agents to call upon other agents to solve sub-tasks.',
   toolDefinitions: delegationToolDefinitions,
-  factory: () => (builder) => {
+  factory: (pluginContext) => (builder) => {
 
     // Handle the tool execution
     builder.on('action:delegate_task', async function* (event, context) {
@@ -54,6 +53,9 @@ export const delegationPlugin: Plugin = {
 
       if (!toolCallId) return;
 
+      // Break circular dependency by dynamic import
+      const { runAgent } = await import('../../harness/index.js');
+
       const runId = `dg_${generateId()}`;
       let lastAgentOutput = '';
 
@@ -82,6 +84,7 @@ export const delegationPlugin: Plugin = {
         } as OpenBotEvent,
         channelId: context.state.channelId,
         threadId: context.state.threadId,
+        publicBaseUrl: pluginContext.publicBaseUrl,
         onEvent: async (outEvent) => {
           // Enrich events with parent metadata so the UI can track the hierarchy
           const enrichedEvent = {

package/src/plugins/openbot/context.ts

@@ -1,7 +1,9 @@
 import { OpenBotState } from '../../app/types.js';
 import { Storage } from '../../services/plugins/domain.js';
+import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
 
 export const DEFAULT_CONTEXT_BUDGET = 8000;
+export const MAX_CONTEXT_FILES = 50;
 
 /**
  * Returns the known context window budget (in tokens) for a given model string.
@@ -42,35 +44,82 @@ export async function buildContext(state: OpenBotState, storage?: Storage): Prom
 
   const sections: string[] = [];
 
-  // 1. Environment
+  // Fetch agents once if storage is available
+  const allAgents = storage?.getAgents ? await storage.getAgents().catch(() => []) : [];
+
+  // 1. User
+  if (state.currentUser?.userName) {
+    sections.push(`## HUMAN\n- Name: ${state.currentUser.userName}`);
+  }
+
+  // 2. Environment
   let env = '## ENVIRONMENT\n';
   if (isDm) {
     env += '- Mode: Direct Message (Solo)\n';
   } else {
     const channelName = channelDetails?.name || channelId;
     env += `- Mode: Channel (#${channelName})\n`;
+    if (channelDetails?.cwd) {
+      env += `- Workspace: ${channelDetails.cwd}\n`;
+    }
     if (threadId) {
       env += `- Thread: ${threadDetails?.name || threadId}\n`;
     }
     const peerIds = participants.filter((id: string) => id !== agentId);
-    if (peerIds.length > 0) {
-      env += `- Participants: ${peerIds.join(', ')}\n`;
-    }
+    const participantLabels = peerIds.map((id) => {
+      const agent = allAgents.find((a) => a.id === id);
+      return agent ? `${agent.name} (${id})` : id;
+    });
+    env += `- Participants: ${participantLabels.length > 0 ? participantLabels.join(', ') : 'None'}\n`;
   }
   sections.push(env);
 
-  // 2. Channel Spec
+  // 2.5 Installed Agents
+  if (allAgents.length > 0) {
+    const formatted = allAgents
+      .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)
+      .join('\n');
+    sections.push(`## INSTALLED AGENTS\n${formatted}`);
+  }
+
+  // 3. Channel Spec
   const spec = channelDetails?.spec?.trim();
   if (spec) {
     sections.push(`## CHANNEL SPECIFICATION\n${spec}`);
   }
 
-  // 3. Agent Instructions
-  if (agentDetails?.instructions) {
-    sections.push(`## AGENT: ${agentDetails?.name}\n${agentDetails.instructions}`);
+  // 4. Files
+  if (storage?.listFiles && channelId && channelDetails?.cwd) {
+    try {
+      const files = await storage.listFiles({ channelId });
+      if (files.length > 0) {
+        const limited = files.slice(0, MAX_CONTEXT_FILES);
+        const formatted = limited
+          .map((f) => `- ${f.name}${f.isDirectory ? '/' : ''}`)
+          .join('\n');
+        let fileSection = `## FILES\n${formatted}`;
+        if (files.length > MAX_CONTEXT_FILES) {
+          fileSection += `\n- ... and ${files.length - MAX_CONTEXT_FILES} more files`;
+        }
+        sections.push(fileSection);
+      } else {
+        sections.push('## FILES\n- (No files in workspace)');
+      }
+    } catch (error) {
+      console.warn('[context] Failed to fetch files:', error);
+    }
+  }
+
+  // 5. Agent Instructions
+  const rawInstructions = agentDetails?.instructions?.trim();
+  if (
+    rawInstructions &&
+    rawInstructions !== OPENBOT_SYSTEM_PROMPT.trim()
+  ) {
+    sections.push(`## Instructions\n${rawInstructions}`);
   }
 
-  // 4. Memories
+  // 6. Memories
   if (storage?.listMemories) {
     try {
       const scopes = ['global', `agent:${agentId}`];

package/src/plugins/openbot/history.ts

@@ -1,6 +1,57 @@
 import { OpenBotEvent } from '../../app/types.js';
 import { ToolResultPart, type ModelMessage } from 'ai';
 
+/**
+ * Ensures every tool-call has a matching tool-result before calling the LLM.
+ * Orphaned calls (interrupted run, missing :result event, etc.) get an empty
+ * result so the conversation can resume instead of failing validation.
+ */
+function fillMissingToolResults(messages: ModelMessage[]): ModelMessage[] {
+  const filled: ModelMessage[] = [];
+  const pending = new Map<string, string>();
+
+  const flushPending = () => {
+    if (pending.size === 0) return;
+    filled.push({
+      role: 'tool',
+      content: [...pending.entries()].map(([toolCallId, toolName]) => ({
+        type: 'tool-result' as const,
+        toolCallId,
+        toolName,
+        output: { type: 'text' as const, value: '' },
+      })),
+    });
+    pending.clear();
+  };
+
+  for (const message of messages) {
+    if (message.role === 'tool' && Array.isArray(message.content)) {
+      filled.push(message);
+      for (const part of message.content) {
+        if ((part as ToolResultPart).type === 'tool-result') {
+          pending.delete((part as ToolResultPart).toolCallId);
+        }
+      }
+      continue;
+    }
+
+    flushPending();
+    filled.push(message);
+
+    if (message.role === 'assistant' && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if ((part as { type?: string; toolCallId?: string; toolName?: string }).type === 'tool-call') {
+          const toolCall = part as { toolCallId: string; toolName: string };
+          pending.set(toolCall.toolCallId, toolCall.toolName);
+        }
+      }
+    }
+  }
+
+  flushPending();
+  return filled;
+}
+
 /**
  * Converts a raw event log into a valid chain of ModelMessages for the AI SDK.
  * 
@@ -103,5 +154,5 @@ export function eventsToModelMessages(events: OpenBotEvent[]): ModelMessage[] {
     }
   }
 
-  return messages;
+  return fillMissingToolResults(messages);
 }

package/src/plugins/openbot/index.ts

@@ -1,5 +1,11 @@
 import type { Plugin } from '../../services/plugins/types.js';
 import { openbotRuntime } from './runtime.js';
+import { bashPlugin } from '../bash/index.js';
+import { memoryPlugin } from '../memory/index.js';
+import { approvalPlugin } from '../approval/index.js';
+import { storagePlugin } from '../storage/index.js';
+import { delegationPlugin } from '../delegation/index.js';
+import { uiPlugin } from '../ui/index.js';
 
 /**
  * `openbot` — the standard, opinionated OpenBot agent runtime.
@@ -7,12 +13,15 @@ import { openbotRuntime } from './runtime.js';
  * This is the canonical execution loop for OpenBot agents. It handles
  * `agent:invoke`, manages short-term memory, assembles context, and
  * orchestrates tool calls.
+ * 
+ * It comes with a "batteries-included" set of inbuilt tools: bash, memory,
+ * storage, delegation, and approval.
  */
 export const openbotPlugin: Plugin = {
   id: 'openbot',
   name: 'OpenBot Agent',
   description:
-    'The standard, opinionated OpenBot agent runtime. Handles the core execution loop and tool orchestration.',
+    'The standard OpenBot agent runtime with inbuilt tools (bash, memory, storage, delegation, and approval).',
   configSchema: {
     type: 'object',
     properties: {
@@ -22,15 +31,48 @@ export const openbotPlugin: Plugin = {
           'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
         default: 'openai/gpt-4o-mini',
       },
+      approval: {
+        type: 'object',
+        description: 'Configuration for the inbuilt approval plugin.',
+        properties: {
+          actions: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'List of actions that require manual approval.',
+          },
+        },
+      },
     },
   },
-  factory: ({ config, storage, tools }) => {
+  toolDefinitions: {
+    ...bashPlugin.toolDefinitions,
+    ...memoryPlugin.toolDefinitions,
+    ...storagePlugin.toolDefinitions,
+    ...delegationPlugin.toolDefinitions,
+    ...uiPlugin.toolDefinitions,
+  },
+  factory: (context) => (builder) => {
+    const { config, storage, tools, abortSignal } = context;
+
+    // Register inbuilt plugins
+    bashPlugin.factory(context)(builder);
+    memoryPlugin.factory(context)(builder);
+    storagePlugin.factory(context)(builder);
+    delegationPlugin.factory(context)(builder);
+    uiPlugin.factory(context)(builder);
+
+    // Approval plugin configuration
+    const approvalConfig = (config?.approval as any) || {
+      actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+    };
+    approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
 
     return openbotRuntime({
       model: config?.model as string,
       storage,
       toolDefinitions: tools,
-    });
+      abortSignal,
+    })(builder);
   },
 };