openbot 0.4.0 → 0.4.2

package/src/plugins/storage/service.ts

@@ -4,6 +4,7 @@ import {
   DEFAULT_AGENTS_DIR,
   DEFAULT_BASE_DIR,
   DEFAULT_CHANNELS_DIR,
+  getDefaultChannelCwd,
   loadConfig,
   resolvePath,
   StoredVariable,
@@ -26,11 +27,15 @@ import {
 } from '../../services/plugins/domain.js';
 import type { PluginRef } from '../../services/plugins/types.js';
 import { openbotPlugin } from '../openbot/index.js';
-import { OPENBOT_SYSTEM_PROMPT } from '../openbot/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
 import { OpenBotEvent, OpenBotState } from '../../app/types.js';
 import { processService } from '../../services/process.js';
 import { memoryService } from '../memory/service.js';
+import {
+  guessMimeType,
+  resolveChannelFile,
+  statChannelFile,
+} from './files.js';
 
 const resolveBaseDir = () => {
   const config = loadConfig();
@@ -110,15 +115,18 @@ const getConversationDir = (channelId: string, threadId?: string) => {
 const SYSTEM_AGENT_ID = ORCHESTRATOR_AGENT_ID;
 
 const SYSTEM_DEFAULT_PLUGINS: PluginRef[] = [
-  { id: 'openbot', config: { model: 'openai/gpt-5.4-mini' } },
-  { id: 'shell' },
-  { id: 'approval' },
-  { id: 'memory' },
-  { id: 'delegation' },
-  { id: 'storage' },
+  {
+    id: 'openbot',
+    config: {
+      model: 'openai/gpt-5.4-mini',
+      approval: {
+        actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+      },
+    },
+  },
 ];
 
-/** No `openbot` / `shell` — storage-side effects and infra plugins only. */
+/** No `openbot` / `bash` — storage-side effects and infra plugins only. */
 const STATE_DEFAULT_PLUGINS: PluginRef[] = [
   { id: 'storage' },
   { id: 'plugin-manager' },
@@ -134,7 +142,7 @@ function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails
     image: getBundledSystemAgentImage(),
     description:
       'First-party orchestration agent for OpenBot.',
-    instructions: OPENBOT_SYSTEM_PROMPT,
+    instructions: '',
     plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
     pluginRefs: SYSTEM_DEFAULT_PLUGINS,
     createdAt: new Date(),
@@ -232,6 +240,25 @@ const getAgentsRootDir = () => path.join(resolveBaseDir(), DEFAULT_AGENTS_DIR);
 const getLastReadFilePath = () =>
   path.join(resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR), '_meta', 'last-read.json');
 
+/** Sentinel key for channel-root events (no threadId). */
+export const ROOT_THREAD_KEY = '__root__';
+
+export type LastReadMap = Record<string, Record<string, string>>;
+
+const readLastReadMap = async (): Promise<LastReadMap> => {
+  const raw = await readJsonFile<Record<string, any>>(getLastReadFilePath(), {});
+  const map: LastReadMap = {};
+  for (const [channelId, value] of Object.entries(raw)) {
+    if (typeof value === 'string') {
+      // Migrate old format
+      map[channelId] = { [ROOT_THREAD_KEY]: value };
+    } else if (value && typeof value === 'object') {
+      map[channelId] = value as Record<string, string>;
+    }
+  }
+  return map;
+};
+
 const THREAD_TITLE_MAX_LENGTH = 80;
 
 const buildThreadTitleFromEvent = (event: OpenBotEvent): string | undefined => {
@@ -257,9 +284,12 @@ const buildThreadTitleFromEvent = (event: OpenBotEvent): string | undefined => {
 
 const readJsonFile = async <T>(filePath: string, fallback: T): Promise<T> => {
   try {
-    return JSON.parse(await fs.readFile(filePath, 'utf-8')) as T;
+    const content = (await fs.readFile(filePath, 'utf-8')).trim();
+    if (!content) return fallback;
+    return JSON.parse(content) as T;
   } catch (e: unknown) {
     if ((e as { code?: string })?.code === 'ENOENT') return fallback;
+    if (e instanceof SyntaxError) return fallback;
     throw e;
   }
 };
@@ -426,22 +456,27 @@ const serializePluginRefs = (refs: PluginRef[]): unknown[] =>
   refs.map((ref) => (ref.config ? { id: ref.id, config: ref.config } : { id: ref.id }));
 
 export const storageService = {
-  getLastReadByChannel: async (): Promise<Record<string, string>> => {
-    return readJsonFile(getLastReadFilePath(), {});
+  getLastReadMap: async (): Promise<LastReadMap> => {
+    return readLastReadMap();
   },
 
-  setLastReadForChannel: async ({
+  setLastRead: async ({
     channelId,
+    threadId,
     lastReadEventId,
   }: {
     channelId: string;
+    threadId?: string;
     lastReadEventId: string;
   }): Promise<void> => {
     const p = getLastReadFilePath();
     await fs.mkdir(path.dirname(p), { recursive: true });
-    const map = await readJsonFile<Record<string, string>>(p, {});
-    map[channelId] = lastReadEventId;
-    await fs.writeFile(p, JSON.stringify(map, null, 2), 'utf-8');
+    const map = await readLastReadMap();
+    if (!map[channelId]) map[channelId] = {};
+    map[channelId][threadId || ROOT_THREAD_KEY] = lastReadEventId;
+    const tmp = `${p}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(map, null, 2), 'utf-8');
+    await fs.rename(tmp, p);
   },
 
   getChannels: async (): Promise<Channel[]> => {
@@ -455,11 +490,12 @@ export const storageService = {
     const channelNames = (await fs.readdir(channelsDir)).filter(
       (name) => !name.startsWith('.') && name !== '_meta',
     );
-    const lastReadByChannel = await storageService.getLastReadByChannel();
+    const lastReadMap = await storageService.getLastReadMap();
 
     const channels = await Promise.all(
       channelNames.map(async (name) => {
         const channelDir = getConversationDir(name);
+        const stats = await fs.stat(channelDir);
         const statePath = path.join(channelDir, 'state.json');
         let cwd: string | undefined;
         let displayName = name;
@@ -482,24 +518,28 @@ export const storageService = {
           description: '',
           cwd,
           participants,
-          createdAt: new Date(),
-          updatedAt: new Date(),
+          createdAt: stats.birthtime,
+          updatedAt: stats.mtime,
         };
-        const rid = lastReadByChannel[name];
-        try {
-          const events = await storageService.getEvents({ channelId: name });
-          const latestId = events[events.length - 1]?.id;
-          channel.hasUnseenMessages = !!(latestId && latestId !== rid);
-        } catch {
-          channel.hasUnseenMessages = false;
-        }
 
+        const channelLastRead = lastReadMap[name] || {};
+        
         try {
+          // Check root unread
+          const rootEvents = await storageService.getEvents({ channelId: name });
+          const rootLatestId = rootEvents[rootEvents.length - 1]?.id;
+          const rootUnseen = !!(rootLatestId && rootLatestId !== channelLastRead[ROOT_THREAD_KEY]);
+
+          // Check threads unread
           const allThreads = await storageService.getThreads({ channelId: name });
           channel.recentThreads = allThreads
             .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
             .slice(0, 5);
+          
+          const threadsUnseen = allThreads.some(t => t.hasUnseenMessages);
+          channel.hasUnseenMessages = rootUnseen || threadsUnseen;
         } catch {
+          channel.hasUnseenMessages = false;
           channel.recentThreads = [];
         }
 
@@ -507,7 +547,7 @@ export const storageService = {
       }),
     );
 
-    return channels;
+    return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
   },
   createChannel: async ({
     channelId,
@@ -539,22 +579,63 @@ export const storageService = {
       }
     }
 
-    const finalState = {
+    const finalState: Record<string, unknown> = {
       ...(initialState || {}),
     };
 
-    if (cwd) {
-      (finalState as Record<string, unknown>).cwd = cwd;
-    }
+    const rawCwd =
+      (typeof cwd === 'string' && cwd.trim()) ||
+      (typeof finalState.cwd === 'string' && finalState.cwd.trim()) ||
+      getDefaultChannelCwd(normalizedChannelId);
 
+    const resolvedCwd = resolvePath(rawCwd);
+    finalState.cwd = resolvedCwd;
+    await fs.mkdir(resolvedCwd, { recursive: true });
     await fs.mkdir(channelDir, { recursive: true });
     await fs.writeFile(
       specPath,
       spec?.trim() ||
-      `# ${normalizedChannelId}\n\nDefine the goals and rules for this channel here.\n`,
+      `# ${normalizedChannelId}\n\n`,
     );
     await fs.writeFile(statePath, JSON.stringify(finalState, null, 2));
   },
+  deleteChannel: async ({ channelId }: { channelId: string }): Promise<void> => {
+    const normalizedChannelId = channelId.trim();
+    if (!normalizedChannelId) {
+      throw new Error('channelId is required');
+    }
+    if (normalizedChannelId === '_meta') {
+      throw new Error('Cannot delete reserved channel path');
+    }
+
+    const channelDir = getConversationDir(normalizedChannelId);
+    try {
+      await fs.access(channelDir);
+    } catch (error: unknown) {
+      if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+        const err = new Error(`Channel "${normalizedChannelId}" does not exist.`);
+        (err as Error & { code?: string }).code = 'CHANNEL_NOT_FOUND';
+        throw err;
+      }
+      throw error;
+    }
+
+    await fs.rm(channelDir, { recursive: true, force: true });
+
+    try {
+      const lastReadPath = getLastReadFilePath();
+      const map = await readJsonFile<Record<string, string>>(lastReadPath, {});
+      if (normalizedChannelId in map) {
+        delete map[normalizedChannelId];
+        await fs.mkdir(path.dirname(lastReadPath), { recursive: true });
+        const tmp = `${lastReadPath}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(map, null, 2), 'utf-8');
+        await fs.rename(tmp, lastReadPath);
+      }
+    } catch {
+      // ignore last-read cleanup failures
+    }
+  },
   createThread: async ({
     channelId,
     threadId,
@@ -605,6 +686,8 @@ export const storageService = {
       return [];
     }
 
+    const lastReadMap = await storageService.getLastReadMap();
+    const channelLastRead = lastReadMap[channelId] || {};
     const threadNames = (await fs.readdir(threadsDir)).filter((name) => !name.startsWith('.'));
 
     const threads = await Promise.all(
@@ -631,12 +714,22 @@ export const storageService = {
           }
         }
 
+        let hasUnseen = false;
+        try {
+          const events = await storageService.getEvents({ channelId, threadId: name });
+          const latestId = events[events.length - 1]?.id;
+          hasUnseen = !!(latestId && latestId !== channelLastRead[name]);
+        } catch {
+          // ignore
+        }
+
         return {
           id: name,
           name: threadDisplayName,
           channelId,
           createdAt: stats.birthtime,
           updatedAt: stats.mtime,
+          hasUnseenMessages: hasUnseen,
         };
       }),
     );
@@ -1357,12 +1450,9 @@ export const storageService = {
       throw new Error('Channel has no CWD configured');
     }
 
-    const resolvedBase = path.resolve(baseCwd);
-    const targetDir = path.resolve(resolvedBase, subPath);
-
-    if (!targetDir.startsWith(resolvedBase)) {
-      throw new Error('Access denied: directory escape');
-    }
+    const targetDir = subPath
+      ? resolveChannelFile(baseCwd, subPath)
+      : resolvePath(baseCwd);
 
     const entries = await fs.readdir(targetDir, { withFileTypes: true });
     return entries
@@ -1387,14 +1477,142 @@ export const storageService = {
       throw new Error('Channel has no CWD configured');
     }
 
-    const resolvedBase = path.resolve(baseCwd);
-    const targetFile = path.resolve(resolvedBase, filePath);
+    const targetFile = resolveChannelFile(baseCwd, filePath);
+    return fs.readFile(targetFile, 'utf-8');
+  },
+
+  readChannelFile: async ({
+    channelId,
+    path: filePath,
+    encoding = 'utf8',
+  }: {
+    channelId: string;
+    path: string;
+    encoding?: 'utf8' | 'base64';
+  }): Promise<{ content: string; mimeType: string; size: number }> => {
+    const details = await storageService.getChannelDetails({ channelId });
+    const baseCwd = details.cwd;
 
-    if (!targetFile.startsWith(resolvedBase)) {
-      throw new Error('Access denied: directory escape');
+    if (!baseCwd) {
+      throw new Error('Channel has no CWD configured');
     }
 
-    return fs.readFile(targetFile, 'utf-8');
+    const targetFile = resolveChannelFile(baseCwd, filePath);
+    const buf = await fs.readFile(targetFile);
+    const content =
+      encoding === 'base64' ? buf.toString('base64') : buf.toString('utf-8');
+
+    return {
+      content,
+      mimeType: guessMimeType(targetFile),
+      size: buf.length,
+    };
+  },
+
+  writeChannelFile: async ({
+    channelId,
+    path: filePath,
+    content,
+    encoding = 'utf8',
+    overwrite = false,
+  }: {
+    channelId: string;
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    overwrite?: boolean;
+  }): Promise<{ path: string; size: number; mimeType: string }> => {
+    const details = await storageService.getChannelDetails({ channelId });
+    const baseCwd = details.cwd;
+
+    if (!baseCwd) {
+      throw new Error('Channel has no CWD configured');
+    }
+
+    const abs = resolveChannelFile(baseCwd, filePath);
+    await fs.mkdir(path.dirname(abs), { recursive: true });
+
+    if (!overwrite) {
+      try {
+        await fs.access(abs);
+        throw new Error('File already exists');
+      } catch (error: unknown) {
+        const code = (error as NodeJS.ErrnoException)?.code;
+        if (code !== 'ENOENT') {
+          throw error;
+        }
+      }
+    }
+
+    const buf =
+      encoding === 'base64' ? Buffer.from(content, 'base64') : Buffer.from(content, 'utf8');
+    await fs.writeFile(abs, buf);
+
+    return {
+      path: filePath,
+      size: buf.length,
+      mimeType: guessMimeType(abs),
+    };
+  },
+
+  uploadChannelFile: async ({
+    channelId,
+    path: filePath,
+    body,
+    overwrite = false,
+  }: {
+    channelId: string;
+    path: string;
+    body: Buffer;
+    overwrite?: boolean;
+  }): Promise<{ path: string; size: number; mimeType: string }> => {
+    const details = await storageService.getChannelDetails({ channelId });
+    const baseCwd = details.cwd;
+
+    if (!baseCwd) {
+      throw new Error('Channel has no CWD configured');
+    }
+
+    const abs = resolveChannelFile(baseCwd, filePath);
+    await fs.mkdir(path.dirname(abs), { recursive: true });
+
+    if (!overwrite) {
+      try {
+        await fs.access(abs);
+        throw new Error('File already exists');
+      } catch (error: unknown) {
+        const code = (error as NodeJS.ErrnoException)?.code;
+        if (code !== 'ENOENT') {
+          throw error;
+        }
+      }
+    }
+
+    await fs.writeFile(abs, body);
+
+    return {
+      path: filePath,
+      size: body.length,
+      mimeType: guessMimeType(abs),
+    };
+  },
+
+  getChannelFileStat: async ({
+    channelId,
+    path: filePath,
+  }: {
+    channelId: string;
+    path: string;
+  }): Promise<{ abs: string; size: number; mimeType: string }> => {
+    const details = await storageService.getChannelDetails({ channelId });
+    const baseCwd = details.cwd;
+
+    if (!baseCwd) {
+      throw new Error('Channel has no CWD configured');
+    }
+
+    const { abs, size } = await statChannelFile(baseCwd, filePath);
+    return { abs, size, mimeType: guessMimeType(abs) };
   },
 
   appendMemory: memoryService.appendMemory,
@@ -1443,12 +1661,17 @@ export const storageService = {
       }
     }
 
+    const threadState = (threadDetails?.state as Record<string, unknown>) || {};
+
     return {
       runId,
       agentId,
       channelId,
       threadId,
       triggerEvent: event,
+      pendingToolCallIds: Array.isArray(threadState.pendingToolCallIds)
+        ? (threadState.pendingToolCallIds as string[])
+        : undefined,
       agentDetails: {
         id: agentDetails.id,
         name: agentDetails.name,

package/src/plugins/ui/index.ts

@@ -0,0 +1,123 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import type { Plugin } from '../../services/plugins/types.js';
+import { OpenBotEvent, RenderWidgetEvent, UIWidgetResponseEvent } from '../../app/types.js';
+
+/**
+ * `ui` — provides a tool for the agent to render interactive UI widgets.
+ * 
+ * The model can choose which widget to render (form, choice, list, message)
+ * depending on the situation.
+ */
+
+export const uiPlugin: Plugin = {
+  id: 'ui',
+  name: 'UI',
+  description: 'Render interactive UI widgets to interact with the user.',
+  toolDefinitions: {
+    render_widget: {
+      description: 'Render a UI widget to the user. Use "form" for data collection, "choice" for simple selection, "list" for displaying items, and "message" for simple notifications with actions. When using form widge to unquire user, do not provide complex forms with many fields, always try to make it simple to keep the experience smooth and straightforward.',
+      inputSchema: z.object({
+        kind: z.enum(['message', 'choice', 'form', 'list']).describe('The type of widget to render.'),
+        title: z.string().describe('The title of the widget.'),
+        description: z.string().optional().describe('A description or body text.'),
+        fields: z.array(z.object({
+          id: z.string().describe('Unique ID for the field.'),
+          label: z.string().describe('Label shown to the user.'),
+          type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
+          description: z.string().optional(),
+          placeholder: z.string().optional(),
+          required: z.boolean().optional(),
+          options: z.array(z.object({ label: z.string(), value: z.string() })).optional(),
+          defaultValue: z.any().optional()
+        })).optional().describe('Required for kind="form". List of form fields.'),
+        actions: z.array(z.object({
+          id: z.string(),
+          label: z.string(),
+          variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+        })).optional().describe('Buttons or actions available on the widget.'),
+        items: z.array(z.object({
+          id: z.string(),
+          label: z.string(),
+          description: z.string().optional(),
+          status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+          metadata: z.record(z.string(), z.any()).optional()
+        })).optional().describe('Required for kind="list". List of items to display.'),
+        submitLabel: z.string().optional().describe('Label for the primary action button (e.g. "Submit", "Save").')
+      })
+    }
+  },
+  factory: () => (builder) => {
+    // Handle the tool call from the agent
+    builder.on('action:render_widget', async function* (event, context) {
+      const widgetEvent = event as RenderWidgetEvent;
+      const toolCallId = widgetEvent.meta?.toolCallId;
+      const threadId = widgetEvent.meta?.threadId || context.state.threadId;
+
+      if (!toolCallId) return;
+
+      const widgetId = randomUUID();
+
+      // Emit the UI widget event to the client
+      yield {
+        type: 'client:ui:widget',
+        data: {
+          ...widgetEvent.data,
+          widgetId,
+          metadata: {
+            type: 'ui:request',
+            originalEvent: widgetEvent
+          }
+        },
+        meta: { agentId: context.state.agentId, threadId }
+      } as OpenBotEvent;
+    });
+
+    // Handle the user's response from the UI widget
+    builder.on('client:ui:widget:response', async function* (event, context) {
+      const responseEvent = event as UIWidgetResponseEvent;
+      const { widgetId, actionId, values, metadata } = responseEvent.data;
+      if (metadata?.type !== 'ui:request') return;
+
+      const originalEvent = metadata.originalEvent as RenderWidgetEvent;
+      const toolCallId = originalEvent?.meta?.toolCallId;
+      const threadId = originalEvent?.meta?.threadId || context.state.threadId;
+
+      if (!toolCallId) return;
+
+      // Yield a "submitted" widget update to the UI to collapse/disable it
+      yield {
+        type: 'client:ui:widget',
+        data: {
+          widgetId,
+          title: originalEvent.data.title,
+          kind: originalEvent.data.kind as any,
+          state: 'submitted',
+          body: "Thank you for your response. We will process it and get back to you soon.",
+          display: 'collapsed',
+          disabled: true,
+          actions: [], // Clear actions to disable buttons in UI
+        },
+        meta: { agentId: context.state.agentId, threadId },
+      } as OpenBotEvent;
+
+      // Emit the tool result event so the agent runtime can resume
+      yield {
+        type: 'action:render_widget:result',
+        data: {
+          success: true,
+          actionId,
+          values,
+          output: JSON.stringify(values)
+        },
+        meta: {
+          agentId: context.state.agentId,
+          threadId,
+          toolCallId
+        }
+      } as any as OpenBotEvent;
+    });
+  },
+};
+
+export default uiPlugin;

package/src/services/abort.ts

@@ -0,0 +1,46 @@
+/**
+ * Tracks in-flight agent runs so they can be cancelled.
+ *
+ * Runs are grouped by `channelId:threadId`. Delegated sub-agents run in the
+ * same channel/thread as their parent, so aborting that key stops the whole
+ * chain (parent + any delegated runs) in one shot.
+ */
+
+export const abortKey = (channelId: string, threadId?: string): string =>
+  `${channelId}:${threadId || ''}`;
+
+class AbortRegistry {
+  private entries = new Map<string, { controller: AbortController; refs: number }>();
+
+  /** Register interest in a run. Returns a shared signal for the key. */
+  acquire(key: string): AbortSignal {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = { controller: new AbortController(), refs: 0 };
+      this.entries.set(key, entry);
+    }
+    entry.refs += 1;
+    return entry.controller.signal;
+  }
+
+  /** Release interest. Removes the entry once no runs reference it. */
+  release(key: string): void {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.refs -= 1;
+    if (entry.refs <= 0) {
+      this.entries.delete(key);
+    }
+  }
+
+  /** Abort all runs for the key. Returns true if something was active. */
+  abort(key: string): boolean {
+    const entry = this.entries.get(key);
+    if (!entry) return false;
+    entry.controller.abort();
+    this.entries.delete(key);
+    return true;
+  }
+}
+
+export const abortRegistry = new AbortRegistry();