openbot 0.3.6 → 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,51 +1,151 @@
-import { MelonyPlugin } from 'melony';
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-import { OpenBotEvent, OpenBotState } from '../../app/types.js';
-
-const handoffToolDefinitions = {
-  handoff: {
-    description:
-      'Transfer control to another agent. The target agent continues the task in this thread.',
+import { z } from 'zod';
+import { generateId } from 'melony';
+import type { Plugin } from '../../services/plugins/types.js';
+import {
+  OpenBotEvent,
+  DelegateTaskEvent,
+} from '../../app/types.js';
+
+/**
+ * `delegation` — allows agents to delegate tasks to other agents.
+ * 
+ * Only the 'system' agent is allowed to delegate by default.
+ * It uses runAgent to execute the delegated agent in its own isolated runtime,
+ * bridging events back to the caller's stream.
+ */
+
+const delegationToolDefinitions = {
+  delegate_task: {
+    description: 'Delegate a specific task or question to another specialized agent.',
     inputSchema: z.object({
-      agentId: z.string().describe('The ID of the target agent.'),
-      content: z.string().describe('The message or task to hand off.'),
+      agentId: z.string().describe('The ID of the agent to delegate to (e.g., "researcher", "coder").'),
+      prompt: z.string().describe('The instructions or question for the delegated agent.'),
     }),
   },
 };
 
-const handoffPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:handoff', async function* (event, context) {
-    const { agentId, content } = event.data;
+export const delegationPlugin: Plugin = {
+  id: 'delegation',
+  name: 'Delegation',
+  description: 'Allows agents to call upon other agents to solve sub-tasks.',
+  toolDefinitions: delegationToolDefinitions,
+  factory: (pluginContext) => (builder) => {
 
-    yield {
-      type: 'agent:output',
-      data: { content: `Handing off to **${agentId}**: ${content}` },
-      meta: { ...(event.meta || {}), agentId: context.state.agentId },
-    };
+    // Handle the tool execution
+    builder.on('action:delegate_task', async function* (event, context) {
+      const delegateEvent = event as DelegateTaskEvent;
 
-    yield {
-      type: 'handoff:request',
-      data: { agentId, content },
-      meta: { ...(event.meta || {}), agentId: context.state.agentId },
-    };
+      // POLICY: Only the 'system' agent can delegate
+      if (context.state.agentId !== 'system') {
+        yield {
+          type: 'action:delegate_task:result',
+          data: {
+            success: false,
+            error: 'Only the system agent can delegate.'
+          },
+          meta: delegateEvent.meta,
+        } as OpenBotEvent;
+        return;
+      }
 
-    if (event.meta?.toolCallId) {
-      yield {
-        type: 'action:handoff:result',
-        data: { success: true, agentId, accepted: true },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      };
-    }
-  });
-};
+      const { agentId, prompt } = delegateEvent.data;
+      const toolCallId = delegateEvent.meta?.toolCallId;
 
-export const delegationPlugin: Plugin = {
-  id: 'delegation',
-  name: 'Handoff',
-  description: 'Hand off tasks to other agents on the bus.',
-  toolDefinitions: handoffToolDefinitions,
-  factory: () => handoffPluginRuntime(),
+      if (!toolCallId) return;
+
+      // Break circular dependency by dynamic import
+      const { runAgent } = await import('../../harness/index.js');
+
+      const runId = `dg_${generateId()}`;
+      let lastAgentOutput = '';
+
+      // Queue to bridge the async onEvent callback to this generator
+      const eventQueue: OpenBotEvent[] = [];
+      let resolveNext: (() => void) | null = null;
+      let isFinished = false;
+
+      // Start the delegated agent in its own runtime.
+      // We don't await this immediately so we can yield events as they arrive.
+      const runPromise = runAgent({
+        runId,
+        agentId,
+        event: {
+          type: 'agent:invoke',
+          data: {
+            role: 'user',
+            content: prompt,
+            agentId: agentId,
+          },
+          meta: {
+            threadId: context.state.threadId,
+            parentAgentId: context.state.agentId,
+            parentToolCallId: toolCallId,
+          },
+        } 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 = {
+            ...outEvent,
+            meta: {
+              ...outEvent.meta,
+              parentAgentId: context.state.agentId,
+              parentToolCallId: toolCallId,
+            }
+          };
+
+          eventQueue.push(enrichedEvent);
+
+          if (outEvent.type === 'agent:output') {
+            lastAgentOutput = outEvent.data.content;
+          }
+
+          // Wake up the generator loop if it's waiting
+          if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+          }
+        }
+      }).catch(error => {
+        console.error(`[delegation] Error in delegated run ${runId}:`, error);
+      }).finally(() => {
+        isFinished = true;
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+      });
+
+      // Yield events from the delegated agent as they arrive
+      while (!isFinished || eventQueue.length > 0) {
+        if (eventQueue.length === 0) {
+          await new Promise<void>(r => { resolveNext = r; });
+        }
+        while (eventQueue.length > 0) {
+          yield eventQueue.shift()!;
+        }
+      }
+
+      // Ensure the run is fully complete (though isFinished already implies this)
+      await runPromise;
+
+      // Yield the result back to our own LLM runtime.
+      yield {
+        type: 'action:delegate_task:result',
+        data: {
+          success: true,
+          output: lastAgentOutput,
+        },
+        meta: {
+          ...delegateEvent.meta,
+          agentId: context.state.agentId,
+          toolCallId: toolCallId,
+        },
+      } as OpenBotEvent;
+    });
+  },
 };
 
 export default delegationPlugin;

package/src/plugins/memory/index.ts

@@ -1,19 +1,42 @@
 import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
+import type { Plugin } from '../../services/plugins/types.js';
+import { OpenBotEvent, MemoryScopeAlias } from '../../app/types.js';
 
 /**
- * `memory` — exposes the global memory store as agent tools.
- *
- * The actual handlers live in `bus/services.ts` because memory is platform
- * infrastructure (shared across every agent on the bus); this plugin only
- * contributes the tool definitions so a runtime plugin (e.g. `ai-sdk`) can
- * surface them to the LLM.
- *
- * Scopes
- * ------
- * - `global`  (default) — visible to every agent and channel.
- * - `agent`   — visible only to the agent that wrote it.
- * - `channel` — visible only inside the active channel.
+ * Resolve a scope alias to a concrete scope string. Aliases let tools accept
+ * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
+ * them using `context.state`.
+ */
+function resolveMemoryScope(
+  alias: MemoryScopeAlias | undefined,
+  state: any,
+): string {
+  switch (alias) {
+    case 'agent':
+      return `agent:${state.agentId}`;
+    case 'channel':
+      return `channel:${state.channelId}`;
+    case 'global':
+    case undefined:
+      return 'global';
+    default:
+      return 'global';
+  }
+}
+
+function resolveMemoryScopeFilter(
+  alias: MemoryScopeAlias | 'all' | undefined,
+  state: any,
+): string[] | undefined {
+  if (alias === 'all' || alias === undefined) {
+    return ['global', `agent:${state.agentId}`, `channel:${state.channelId}`];
+  }
+  return [resolveMemoryScope(alias, state)];
+}
+
+/**
+ * `memory` — exposes the global memory store as agent tools and provides
+ * platform-level memory handlers.
  */
 const memoryToolDefinitions = {
   remember: {
@@ -77,8 +100,82 @@ export const memoryPlugin: Plugin = {
   description:
     'Global long-term memory: remember/recall/forget facts across runs and agents.',
   toolDefinitions: memoryToolDefinitions,
-  factory: () => () => {
-    // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+  factory: ({ storage }) => (builder) => {
+    builder.on('action:remember', async function* (event, context) {
+      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+      try {
+        const { content, scope, tags } = event.data;
+        const record = await storage.appendMemory({
+          scope: resolveMemoryScope(scope, context.state),
+          content,
+          tags,
+        });
+        yield {
+          type: 'action:remember:result',
+          data: { success: true, record },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      } catch (error) {
+        yield {
+          type: 'action:remember:result',
+          data: {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      }
+    });
+
+    builder.on('action:recall', async function* (event, context) {
+      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+      try {
+        const { query, tag, scope, limit } = event.data;
+        const records = await storage.listMemories({
+          scopes: resolveMemoryScopeFilter(scope, context.state),
+          query,
+          tag,
+          limit,
+        });
+        yield {
+          type: 'action:recall:result',
+          data: { success: true, records },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      } catch (error) {
+        yield {
+          type: 'action:recall:result',
+          data: {
+            success: false,
+            records: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+          },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      }
+    });
+
+    builder.on('action:forget', async function* (event, context) {
+      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+      try {
+        const deleted = await storage.deleteMemory({ id: event.data.id });
+        yield {
+          type: 'action:forget:result',
+          data: { success: true, deleted },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      } catch (error) {
+        yield {
+          type: 'action:forget:result',
+          data: {
+            success: false,
+            deleted: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      }
+    });
   },
 };
 

package/src/{services/memory.ts → plugins/memory/service.ts}

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
+import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
 
 /**
  * Global memory service.