openbot 0.4.0 → 0.4.2

package/src/app/server.ts

@@ -13,7 +13,14 @@ import { ActiveRunsSnapshotEvent, OpenBotEvent, OpenBotState } from './types.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> };
 
@@ -53,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);
@@ -71,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,
@@ -86,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`);
@@ -130,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 });
@@ -161,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();
 
@@ -192,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({
@@ -210,6 +323,92 @@ export async function startServer(options: ServerOptions = {}) {
       return;
     }
 
+    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;
@@ -229,6 +428,8 @@ 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);
       }
 
       sendToClientKey(targetClientKey, chunk);
@@ -251,6 +452,7 @@ export async function startServer(options: ServerOptions = {}) {
         event,
         channelId,
         threadId,
+        publicBaseUrl: resolvePublicBaseUrl(),
         onEvent,
       });
       res.sendStatus(200);
@@ -277,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) => {
@@ -293,6 +524,7 @@ export async function startServer(options: ServerOptions = {}) {
         channelId,
         threadId,
         persistEvents: false,
+        publicBaseUrl: resolvePublicBaseUrl(),
         onEvent,
       });
       res.json({ events });