openbot 0.3.6 → 0.4.2

package/src/app/config.ts

@@ -9,20 +9,13 @@ export interface OpenBotconfig {
   image?: string;
   baseDir?: string;
   port?: number;
-  mcpServers?: MCPServerConfig[];
   /**
    * Overrides the default public marketplace registry URL. If omitted or blank,
    * {@link DEFAULT_MARKETPLACE_REGISTRY_URL} is used.
    */
   marketplaceRegistryUrl?: string;
-}
-
-export interface MCPServerConfig {
-  id: string;
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-  cwd?: string;
+  /** Public base URL for workspace file links (e.g. https://my-host.example). Falls back to OPENBOT_PUBLIC_URL env or http://localhost:{port}. */
+  publicUrl?: string;
 }
 
 export interface StoredVariable {
@@ -32,6 +25,8 @@ export interface StoredVariable {
 }
 
 export const DEFAULT_BASE_DIR = '~/.openbot';
+/** Default parent directory for per-channel working directories (user-facing workspace). */
+export const DEFAULT_CHANNELS_WORKSPACE_DIR = '~/openbot';
 export const DEFAULT_PLUGINS_DIR = 'plugins';
 export const DEFAULT_AGENTS_DIR = 'agents';
 export const DEFAULT_CHANNELS_DIR = 'channels';
@@ -46,6 +41,15 @@ export function resolvePath(p: string) {
   return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
 
+/** Default absolute cwd for a channel when none is provided at creation time. */
+export function getDefaultChannelCwd(channelId: string): string {
+  const id = channelId.trim();
+  if (!id) {
+    throw new Error('channelId is required');
+  }
+  return resolvePath(`${DEFAULT_CHANNELS_WORKSPACE_DIR}/${id}`);
+}
+
 export function loadConfig(): OpenBotconfig {
   const configPath = path.join(os.homedir(), '.openbot', CONFIG_FILE);
   if (fs.existsSync(configPath)) {
@@ -90,25 +94,4 @@ export function loadVariables(): { version: number; variables: StoredVariable[]
     };
   }
   return { version: 1, variables: [] };
-}
-
-export const DEFAULT_AGENT_MD = `---
-description: A specialized AI agent
----
-
-# Agent Profile
-
-You are a specialized AI agent within the OpenBot system.
-Your role is defined by your configuration and the tools you have access to.
-
-## Persona
-- Helpful and precise
-- Focused on my specific domain
-- Professional in all interactions
-`;
-
-export const DEFAULT_USER_MD = `# About Me
-
-<!-- OpenBot reads this file to understand who you are and how you like to work. -->
-<!-- Edit it here or just chat — agents can update it with the "remember" tool. -->
-`;
+}

package/src/app/server.ts

@@ -10,11 +10,17 @@ const pkg = require('../../package.json');
 import { generateId } from 'melony';
 import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 import { ActiveRunsSnapshotEvent, OpenBotEvent, OpenBotState } from './types.js';
-import { processService } from '../harness/process.js';
-import { storageService } from '../services/storage.js';
-import { dispatch } from '../harness/dispatcher.js';
-import { initPlugins } from '../registry/plugins.js';
+import { processService } from '../services/process.js';
+import { runAgent, STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
+import { initPlugins } from '../services/plugins/registry.js';
+import { storageService } from '../plugins/storage/service.js';
+import {
+  buildWorkspaceFileUrl,
+  getPublicBaseUrl,
+  openChannelFileStream,
+} from '../plugins/storage/files.js';
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
+import { abortRegistry, abortKey } from '../services/abort.js';
 
 type Bucket = { channelId: string; threadId?: string; activeCount: number; agentIds: Set<string> };
 
@@ -54,6 +60,10 @@ export async function startServer(options: ServerOptions = {}) {
 
   initPlugins(pluginsDir);
 
+  // Pre-warm caches for agents and plugins to speed up first UI load
+  storageService.getAgents().catch((err) => console.warn('[server] Failed to pre-warm agents cache', err));
+  storageService.getPlugins().catch((err) => console.warn('[server] Failed to pre-warm plugins cache', err));
+
   const getContext = (req: express.Request) => {
     const channelId =
       req.get('x-openbot-channel-id') || req.query.channelId || (req.body && req.body.channelId);
@@ -72,7 +82,7 @@ export async function startServer(options: ServerOptions = {}) {
       (req.body && req.body.responseType);
 
     return {
-      channelId: (channelId || (threadId ? 'general' : 'general')) as string, // Default to general if none
+      channelId: (channelId || (threadId ? 'uncategorized' : 'uncategorized')) as string, // Default to uncategorized if none
       threadId: threadId as string | undefined,
       agentId: agentId as string | undefined,
       runId: runId as string,
@@ -87,7 +97,16 @@ export async function startServer(options: ServerOptions = {}) {
 
   const sendToClientKey = (clientKey: string, chunk: OpenBotEvent) => {
     const threadClients = clients.get(clientKey);
-    if (!threadClients) return;
+    if (!threadClients || threadClients.length === 0) return;
+
+    // Auto-detect "read" state: if someone is listening, they just "read" this event.
+    if (chunk.id && clientKey !== GLOBAL_CHANNEL_ID) {
+      const parts = clientKey.split(':');
+      const channelId = parts[0];
+      const threadId = parts[1]; // undefined if no ":"
+      storageService.setLastRead({ channelId, threadId, lastReadEventId: chunk.id }).catch(() => {});
+    }
+
     threadClients.forEach((client) => {
       if (!client.writableEnded) {
         client.write(`data: ${JSON.stringify(chunk)}\n\n`);
@@ -131,8 +150,37 @@ export async function startServer(options: ServerOptions = {}) {
     };
   };
 
+  // Drop every tracked run for a channel/thread. A stop aborts the whole
+  // chain (parent + delegated sub-agents), but the sub-agents' `agent:run:end`
+  // events can be swallowed when the parent run loop breaks on abort, leaving
+  // orphaned entries that keep a channel falsely "active". Purging by
+  // channel/thread guarantees the snapshot self-heals after a stop.
+  const purgeActiveRunsForThread = (channelId: string, threadId?: string): void => {
+    const target = threadId || undefined;
+    for (const [key, run] of activeRuns) {
+      if (run.channelId === channelId && (run.threadId || undefined) === target) {
+        activeRuns.delete(key);
+      }
+    }
+  };
+
   app.use(cors());
-  app.use(express.json({ limit: '20mb' }));
+
+  const resolvePublicBaseUrl = () => getPublicBaseUrl(PORT, config.publicUrl);
+
+  app.use((req, res, next) => {
+    const isWorkspaceUpload =
+      req.method === 'POST' &&
+      req.path === '/api/publish' &&
+      req.get('x-openbot-event-type') === 'action:storage:upload-file';
+
+    if (isWorkspaceUpload) {
+      express.raw({ type: () => true, limit: '100mb' })(req, res, next);
+      return;
+    }
+
+    express.json({ limit: '20mb' })(req, res, next);
+  });
 
   app.get('/api/health', (req, res) => {
     res.json({ status: 'ok', version: pkg.version });
@@ -162,6 +210,19 @@ export async function startServer(options: ServerOptions = {}) {
     }
     clients.get(clientKey)!.push(res);
 
+    // Auto-detect "read" state on connection: mark the latest event as seen.
+    if (channelId !== GLOBAL_CHANNEL_ID) {
+      storageService
+        .getEvents({ channelId, threadId })
+        .then((events) => {
+          const latestId = events[events.length - 1]?.id;
+          if (latestId) {
+            return storageService.setLastRead({ channelId, threadId, lastReadEventId: latestId });
+          }
+        })
+        .catch(() => {});
+    }
+
     if (channelId === GLOBAL_CHANNEL_ID) {
       const snapshot = buildActiveRunsSnapshot();
 
@@ -193,6 +254,57 @@ export async function startServer(options: ServerOptions = {}) {
   });
 
   app.post('/api/publish', async (req, res) => {
+    if (req.get('x-openbot-event-type') === 'action:storage:upload-file') {
+      const channelId =
+        req.get('x-openbot-channel-id') ||
+        (typeof req.query.channelId === 'string' ? req.query.channelId : undefined);
+      const filePath = req.get('x-openbot-file-path');
+      const overwrite = req.get('x-openbot-file-overwrite') === 'true';
+
+      if (!channelId?.trim()) {
+        res.status(400).json({ error: 'channelId is required' });
+        return;
+      }
+      if (!filePath?.trim()) {
+        res.status(400).json({ error: 'x-openbot-file-path header is required' });
+        return;
+      }
+
+      const body = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
+      if (body.length === 0) {
+        res.status(400).json({ error: 'Request body is empty' });
+        return;
+      }
+
+      try {
+        const result = await storageService.uploadChannelFile({
+          channelId: channelId.trim(),
+          path: filePath.trim(),
+          body,
+          overwrite,
+        });
+        const url = buildWorkspaceFileUrl({
+          baseUrl: resolvePublicBaseUrl(),
+          channelId: channelId.trim(),
+          filePath: result.path,
+        });
+        res.json({
+          type: 'action:storage:upload-file:result',
+          data: { success: true, ...result, url },
+        });
+      } catch (error) {
+        res.status(400).json({
+          type: 'action:storage:upload-file:result',
+          data: {
+            success: false,
+            path: filePath,
+            error: error instanceof Error ? error.message : 'Upload failed',
+          },
+        });
+      }
+      return;
+    }
+
     const parseResult = publishEventSchema.safeParse(req.body);
     if (!parseResult.success) {
       res.status(400).json({
@@ -211,9 +323,93 @@ export async function startServer(options: ServerOptions = {}) {
       return;
     }
 
-    const onEvent = async (chunk: OpenBotEvent, state?: OpenBotState) => {
-      ensureEventId(chunk);
+    if (event.type === 'action:storage:write-file') {
+      const data = (event.data ?? {}) as {
+        path?: string;
+        content?: string;
+        encoding?: 'utf8' | 'base64';
+        overwrite?: boolean;
+      };
+
+      if (!data.path?.trim()) {
+        res.status(400).json({
+          type: 'action:storage:write-file:result',
+          data: { success: false, path: '', error: 'path is required' },
+        });
+        return;
+      }
+      if (typeof data.content !== 'string') {
+        res.status(400).json({
+          type: 'action:storage:write-file:result',
+          data: { success: false, path: data.path, error: 'content is required' },
+        });
+        return;
+      }
+
+      try {
+        const result = await storageService.writeChannelFile({
+          channelId,
+          path: data.path.trim(),
+          content: data.content,
+          encoding: data.encoding ?? 'utf8',
+          overwrite: data.overwrite ?? false,
+        });
+        const url = buildWorkspaceFileUrl({
+          baseUrl: resolvePublicBaseUrl(),
+          channelId,
+          filePath: result.path,
+        });
+        res.json({
+          type: 'action:storage:write-file:result',
+          data: { success: true, ...result, url },
+        });
+      } catch (error) {
+        res.status(400).json({
+          type: 'action:storage:write-file:result',
+          data: {
+            success: false,
+            path: data.path,
+            error: error instanceof Error ? error.message : 'Write failed',
+          },
+        });
+      }
+      return;
+    }
+
+    // Stop request: cancel the in-flight run (and any delegated sub-agents in the
+    // same thread) instead of spinning up a new agent turn.
+    if (event.type === 'action:agent_run_stop') {
+      const data = (event.data ?? {}) as {
+        runId?: string;
+        agentId?: string;
+        channelId?: string;
+        threadId?: string;
+        reason?: string;
+      };
+      const targetChannelId = data.channelId || channelId;
+      const targetThreadId = data.threadId || threadId;
+      const stopped = abortRegistry.abort(abortKey(targetChannelId, targetThreadId));
+      purgeActiveRunsForThread(targetChannelId, targetThreadId);
+
+      const stoppedEvent: OpenBotEvent = {
+        type: 'agent:run:stopped',
+        data: {
+          runId: data.runId || runId,
+          agentId: data.agentId || agentId || ORCHESTRATOR_AGENT_ID,
+          channelId: targetChannelId,
+          threadId: targetThreadId,
+          reason: data.reason,
+        },
+      } as OpenBotEvent;
+      ensureEventId(stoppedEvent);
+      sendToClientKey(getClientKey(targetChannelId, targetThreadId), stoppedEvent);
+      sendToClientKey(GLOBAL_CHANNEL_ID, stoppedEvent);
+
+      res.json({ success: stopped });
+      return;
+    }
 
+    const onEvent = async (chunk: OpenBotEvent, state?: OpenBotState) => {
       const targetChannelId = state?.channelId || channelId;
       const targetThreadId = state?.threadId || threadId;
       const targetClientKey = getClientKey(targetChannelId, targetThreadId);
@@ -232,14 +428,10 @@ export async function startServer(options: ServerOptions = {}) {
         activeRuns.delete(
           getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId),
         );
+      } else if (chunk.type === 'agent:run:stopped') {
+        purgeActiveRunsForThread(chunk.data.channelId, chunk.data.threadId);
       }
 
-      await storageService.storeEvent({
-        channelId: targetChannelId,
-        threadId: targetThreadId,
-        event: chunk,
-      });
-
       sendToClientKey(targetClientKey, chunk);
 
       if (
@@ -254,12 +446,13 @@ export async function startServer(options: ServerOptions = {}) {
     try {
       ensureEventId(event);
 
-      await dispatch({
+      await runAgent({
         runId,
-        agentId: agentId || 'system',
+        agentId: agentId || ORCHESTRATOR_AGENT_ID,
         event,
         channelId,
         threadId,
+        publicBaseUrl: resolvePublicBaseUrl(),
         onEvent,
       });
       res.sendStatus(200);
@@ -286,6 +479,35 @@ export async function startServer(options: ServerOptions = {}) {
     }
 
     const { channelId, threadId, agentId, runId } = getContext(req);
+
+    if (event.type === 'action:storage:serve-file') {
+      const filePath = (event.data as { path?: string })?.path;
+      if (!channelId?.trim()) {
+        res.status(400).json({ error: 'channelId is required' });
+        return;
+      }
+      if (!filePath?.trim()) {
+        res.status(400).json({ error: 'path is required' });
+        return;
+      }
+
+      try {
+        const { abs, size, mimeType } = await storageService.getChannelFileStat({
+          channelId,
+          path: filePath.trim(),
+        });
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Content-Length', String(size));
+        res.setHeader('Cache-Control', 'private, max-age=3600');
+        openChannelFileStream(abs).pipe(res);
+      } catch (error) {
+        res.status(404).json({
+          error: error instanceof Error ? error.message : 'File not found',
+        });
+      }
+      return;
+    }
+
     const events: OpenBotEvent[] = [];
 
     const onEvent = async (chunk: OpenBotEvent) => {
@@ -295,12 +517,14 @@ export async function startServer(options: ServerOptions = {}) {
     try {
       ensureEventId(event);
 
-      await dispatch({
+      await runAgent({
         runId,
-        agentId: agentId || 'system',
+        agentId: agentId || STATE_AGENT_ID,
         event,
         channelId,
         threadId,
+        persistEvents: false,
+        publicBaseUrl: resolvePublicBaseUrl(),
         onEvent,
       });
       res.json({ events });