openbot 0.4.7 → 0.5.5

package/dist/workflow/service.js

@@ -1,106 +0,0 @@
-import { generateId } from 'melony';
-import { storageService } from '../services/storage.js';
-import { WORKFLOW_SCHEMA_VERSION, WORKFLOW_THREAD_STATE_KEY, } from './types.js';
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
-    ? value
-    : {};
-const isTodoStatus = (value) => value === 'pending' || value === 'done' || value === 'failed';
-const parseTodo = (value) => {
-    const record = asRecord(value);
-    if (typeof record.id !== 'string' || !record.id)
-        return null;
-    if (typeof record.text !== 'string' || !record.text)
-        return null;
-    if (!isTodoStatus(record.status))
-        return null;
-    return {
-        id: record.id,
-        text: record.text,
-        status: record.status,
-        summary: typeof record.summary === 'string' ? record.summary : undefined,
-    };
-};
-export const parseThreadWorkflow = (state) => {
-    const record = asRecord(state);
-    const raw = record[WORKFLOW_THREAD_STATE_KEY];
-    const workflow = asRecord(raw);
-    if (typeof workflow.id !== 'string' || !workflow.id)
-        return null;
-    if (!Array.isArray(workflow.todos))
-        return null;
-    const todos = workflow.todos
-        .map((todo) => parseTodo(todo))
-        .filter((todo) => todo !== null);
-    if (todos.length === 0 && !workflow.title)
-        return null;
-    return {
-        version: typeof workflow.version === 'number' ? workflow.version : WORKFLOW_SCHEMA_VERSION,
-        id: workflow.id,
-        title: typeof workflow.title === 'string' ? workflow.title : undefined,
-        todos,
-        updatedAt: typeof workflow.updatedAt === 'string' ? workflow.updatedAt : new Date().toISOString(),
-    };
-};
-export const loadThreadWorkflow = async (channelId, threadId) => {
-    const details = await storageService.getThreadDetails({ channelId, threadId });
-    return parseThreadWorkflow(details.state);
-};
-export const persistWorkflow = async (channelId, threadId, workflow) => {
-    const next = {
-        ...workflow,
-        version: WORKFLOW_SCHEMA_VERSION,
-        updatedAt: new Date().toISOString(),
-    };
-    await storageService.patchThreadState({
-        channelId,
-        threadId,
-        state: { [WORKFLOW_THREAD_STATE_KEY]: next },
-    });
-    return next;
-};
-export const setWorkflowPlan = async (options) => {
-    const { channelId, threadId, plan } = options;
-    const workflow = {
-        version: WORKFLOW_SCHEMA_VERSION,
-        id: `wf_${generateId()}`,
-        title: plan.title,
-        todos: plan.todos.map((t) => ({
-            id: t.id || `todo_${generateId()}`,
-            text: t.text,
-            status: 'pending',
-        })),
-        updatedAt: new Date().toISOString(),
-    };
-    return persistWorkflow(channelId, threadId, workflow);
-};
-export const updateWorkflowTodo = async (options) => {
-    const { channelId, threadId, update } = options;
-    const workflow = await loadThreadWorkflow(channelId, threadId);
-    if (!workflow)
-        throw new Error('No active workflow found.');
-    const todos = workflow.todos.map((todo) => {
-        if (todo.id !== update.todoId)
-            return todo;
-        return {
-            ...todo,
-            ...(update.status ? { status: update.status } : {}),
-            ...(update.summary !== undefined ? { summary: update.summary } : {}),
-        };
-    });
-    return persistWorkflow(channelId, threadId, { ...workflow, todos });
-};
-export const formatWorkflowForPrompt = (workflow) => {
-    const lines = [
-        '## Current Workflow Plan',
-        workflow.title ? `Title: ${workflow.title}` : '',
-        'This plan is for your internal coordination. Update it as you progress.',
-        '',
-    ].filter(Boolean);
-    for (const todo of workflow.todos) {
-        lines.push(`- [${todo.status}] ${todo.id}: ${todo.text}`);
-        if (todo.summary) {
-            lines.push(`  Result: ${todo.summary}`);
-        }
-    }
-    return lines.join('\n');
-};

package/dist/workflow/types.js

@@ -1,3 +0,0 @@
-export const WORKFLOW_SCHEMA_VERSION = 3;
-export const WORKFLOW_THREAD_STATE_KEY = 'workflow';
-export const OPENBOT_SYSTEM_AGENT_ID = 'system';

package/src/plugins/approval/index.ts

@@ -1,147 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import type { Plugin } from '../../services/plugins/types.js';
-import { OpenBotEvent } from '../../app/types.js';
-
-/**
- * `approval` — gates protected tool calls behind a UI confirmation widget.
- * 
- * This is a simplified version that intercepts specified actions (default: bash)
- * and requires user approval before they are allowed to proceed.
- */
-
-// In-memory tracking for pending approval IDs with TTL (shared across plugin instances)
-const pendingApprovals = new Map<string, number>();
-const TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
-
-export const approvalPlugin: Plugin = {
-  id: 'approval',
-  name: 'Approval',
-  description: 'Gate protected tool calls behind a UI confirmation widget.',
-  factory: ({ config, storage }) => (builder) => {
-    // Actions that require approval. Defaults to bash.
-    const actionsToApprove = (config.actions as string[]) || ['action:bash'];
-
-    for (const action of actionsToApprove) {
-      builder.intercept(action as OpenBotEvent['type'], (event, context) => {
-        // If already approved in this flow, let it pass to the actual handler
-        if (event.meta?.approvalStatus === 'approved') return event;
-
-        // Otherwise, intercept and ask for approval via a UI widget
-        const displayData = JSON.stringify((event as any)?.data) || '';
-
-        const widgetId = randomUUID();
-        pendingApprovals.set(widgetId, Date.now());
-
-        return {
-          type: 'client:ui:widget',
-          data: {
-            widgetId,
-            kind: 'message',
-            title: `The agent wants to perform \`${action}\``,
-            body: displayData,
-            metadata: {
-              type: 'approval:request',
-              originalEvent: event,
-            },
-            actions: [
-              { id: 'approve', label: 'Approve', variant: 'primary' },
-              { id: 'deny', label: 'Deny', variant: 'danger' },
-            ],
-          },
-          meta: { agentId: context.state.agentId, threadId: context.state.threadId },
-        } as OpenBotEvent;
-      });
-    }
-
-    // Handle the user's response from the UI widget
-    builder.on('client:ui:widget:response', async function* (event, context) {
-      const { widgetId, actionId } = event.data;
-      const metadata = event.data?.metadata;
-      if (metadata?.type !== 'approval:request') return;
-
-      // Verify the widget is still pending and hasn't expired
-      if (!widgetId || !pendingApprovals.has(widgetId)) {
-        console.warn(`[approval] Received response for unknown or already handled widget: ${widgetId}`);
-        return;
-      }
-
-      const timestamp = pendingApprovals.get(widgetId)!;
-      if (Date.now() - timestamp > TTL_MS) {
-        pendingApprovals.delete(widgetId);
-        console.warn(`[approval] Received response for expired widget: ${widgetId}`);
-        return;
-      }
-
-      // Mark as handled
-      pendingApprovals.delete(widgetId);
-
-      const originalEvent = metadata.originalEvent as OpenBotEvent;
-      const approved = actionId === 'approve';
-
-      const displayData = JSON.stringify((event as any)?.data) || '';
-
-      // Yield a "responded" widget update to the UI
-      yield {
-        type: 'client:ui:widget',
-        data: {
-          widgetId,
-          kind: 'message',
-          title: `Action ${approved ? 'Approved' : 'Denied'}`,
-          body: displayData,
-          state: approved ? 'submitted' : 'cancelled',
-          display: 'collapsed',
-          disabled: true,
-          actions: [], // Clear actions to disable buttons in UI
-        },
-        meta: { agentId: context.state.agentId, threadId: context.state.threadId },
-      } as OpenBotEvent;
-
-      if (approved) {
-        // Re-emit the original event with approved status so the actual handler can run
-        yield {
-          ...originalEvent,
-          meta: {
-            ...(originalEvent.meta || {}),
-            approvalStatus: 'approved',
-          },
-        };
-      } else {
-        // Manually store the original event with denied status so it's recorded in history
-        // but NOT re-emitted to the pipeline (to avoid actual execution).
-        if (storage) {
-          await storage.storeEvent({
-            channelId: context.state.channelId,
-            threadId: context.state.threadId,
-            event: {
-              ...originalEvent,
-              meta: {
-                ...(originalEvent.meta || {}),
-                approvalStatus: 'denied',
-              },
-            },
-          });
-        }
-
-        // Emit a failure result event for the denied action to clear the pending tool batch
-        yield {
-          type: `${originalEvent.type}:result` as OpenBotEvent['type'],
-          data: {
-            success: false,
-            error: 'Action denied by user.',
-            stderr: 'Action denied by user.',
-            output: 'Action denied by user.',
-          },
-          meta: originalEvent.meta,
-        } as OpenBotEvent;
-
-        yield {
-          type: 'agent:output',
-          data: { content: `Action \`${originalEvent.type}\` was denied.` },
-          meta: { agentId: context.state.agentId },
-        } as OpenBotEvent;
-      }
-    });
-  },
-};
-
-export default approvalPlugin;

package/src/plugins/bash/index.ts

@@ -1,232 +0,0 @@
-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,153 +0,0 @@
-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 agent to delegate to (e.g., "researcher", "coder").'),
-      prompt: z.string().describe('The instructions or question for the delegated agent.'),
-    }),
-  },
-};
-
-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) => {
-
-    // Handle the tool execution
-    builder.on('action:delegate_task', async function* (event, context) {
-      const delegateEvent = event as DelegateTaskEvent;
-
-      // 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;
-      }
-
-      const { agentId, prompt } = delegateEvent.data;
-      const toolCallId = delegateEvent.meta?.toolCallId;
-
-      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,
-        // Child events are re-yielded to the parent harness, which persists them once.
-        persistEvents: false,
-        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;