openbot 0.4.0 → 0.4.3

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();

package/src/services/plugins/domain.ts

@@ -45,13 +45,15 @@ export type ConfigSchema = {
   type: 'object';
   properties: {
     [key: string]: {
-      type: 'string' | 'number' | 'boolean' | 'integer';
+      type: 'string' | 'number' | 'boolean' | 'integer' | 'object' | 'array';
       description?: string;
       default?: unknown;
       enum?: unknown[];
       minimum?: number;
       maximum?: number;
       format?: 'password' | 'url' | 'email';
+      properties?: ConfigSchema['properties'];
+      items?: ConfigSchema['properties'][string];
     };
   };
   required?: string[];
@@ -76,6 +78,7 @@ export type Thread = {
   channelId: string;
   createdAt: Date;
   updatedAt: Date;
+  hasUnseenMessages?: boolean;
 };
 
 export type ThreadDetails = {
@@ -104,6 +107,8 @@ export interface Storage {
     initialState?: Record<string, unknown>;
     cwd?: string;
   }) => Promise<void>;
+  /** Removes the channel directory and cleans up `_meta/last-read.json`. */
+  deleteChannel: (args: { channelId: string }) => Promise<void>;
   createThread: (args: {
     channelId: string;
     threadId: string;
@@ -112,6 +117,7 @@ export interface Storage {
   }) => Promise<void>;
   getThreads: (args: { channelId: string }) => Promise<Thread[]>;
   getThreadDetails: (args: { channelId: string; threadId: string }) => Promise<ThreadDetails>;
+  setLastRead: (args: { channelId: string; threadId?: string; lastReadEventId: string }) => Promise<void>;
   /** User-facing agent list; excludes agents with `hidden: true` (e.g. built-in `state`). */
   getAgents: () => Promise<Agent[]>;
   getPlugins: () => Promise<PluginDescriptor[]>;
@@ -142,6 +148,11 @@ export interface Storage {
   /** For `system` / `state`, removes only `AGENT.md` (reverts to code defaults). */
   deleteAgent: (args: { agentId: string }) => Promise<void>;
   getEvents: (args: { channelId: string; threadId?: string }) => Promise<OpenBotEvent[]>;
+  storeEvent: (args: {
+    channelId: string;
+    threadId?: string;
+    event: OpenBotEvent;
+  }) => Promise<void>;
   getChannelDetails: (args: { channelId: string }) => Promise<ChannelDetails>;
   patchChannelState: (args: { channelId: string; state: unknown }) => Promise<void>;
   patchThreadState: (args: {
@@ -158,6 +169,28 @@ export interface Storage {
     path?: string;
   }) => Promise<Array<{ name: string; isDirectory: boolean }>>;
   readFile: (args: { channelId: string; path: string }) => Promise<string>;
+  readChannelFile: (args: {
+    channelId: string;
+    path: string;
+    encoding?: 'utf8' | 'base64';
+  }) => Promise<{ content: string; mimeType: string; size: number }>;
+  writeChannelFile: (args: {
+    channelId: string;
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    overwrite?: boolean;
+  }) => Promise<{ path: string; size: number; mimeType: string }>;
+  uploadChannelFile: (args: {
+    channelId: string;
+    path: string;
+    body: Buffer;
+    overwrite?: boolean;
+  }) => Promise<{ path: string; size: number; mimeType: string }>;
+  getChannelFileStat: (args: {
+    channelId: string;
+    path: string;
+  }) => Promise<{ abs: string; size: number; mimeType: string }>;
   /** Persist a memory record into the global memory log. */
   appendMemory: (args: {
     scope: string;

package/src/services/plugins/registry.ts

@@ -3,11 +3,12 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import type { Plugin } from './types.js';
 import { openbotPlugin } from '../../plugins/openbot/index.js';
-import { shellPlugin } from '../../plugins/shell/index.js';
+import { bashPlugin } from '../../plugins/bash/index.js';
 import { storagePlugin } from '../../plugins/storage/index.js';
 import { approvalPlugin } from '../../plugins/approval/index.js';
 import { memoryPlugin } from '../../plugins/memory/index.js';
 import { delegationPlugin } from '../../plugins/delegation/index.js';
+import { uiPlugin } from '../../plugins/ui/index.js';
 import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
 import {
@@ -20,11 +21,12 @@ let pluginsDir: string | null = null;
 
 const BUILT_IN: Record<string, Plugin> = {
   [openbotPlugin.id]: openbotPlugin,
-  [shellPlugin.id]: shellPlugin,
+  [bashPlugin.id]: bashPlugin,
   [storagePlugin.id]: storagePlugin,
   [approvalPlugin.id]: approvalPlugin,
   [memoryPlugin.id]: memoryPlugin,
   [delegationPlugin.id]: delegationPlugin,
+  [uiPlugin.id]: uiPlugin,
   [pluginManagerPlugin.id]: pluginManagerPlugin,
 };
 
@@ -77,7 +79,7 @@ export function initPlugins(dir?: string) {
 
 /**
  * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "openbot", "shell"), or
+ *   - a built-in id (e.g. "openbot", "bash"), or
  *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
  *     in which case the folder layout is `plugins/<id>/dist/index.js`.
  */

package/src/services/plugins/service.ts

@@ -26,7 +26,7 @@ export interface InstalledPlugin {
   version: string;
 }
 
-/** One marketplace entry; matches `action:marketplace:list:result` agent shape. */
+/** One marketplace entry; matches `action:marketplace:list:result` shape. */
 export type MarketplaceAgentListing = {
   id: string;
   name: string;
@@ -36,7 +36,32 @@ export type MarketplaceAgentListing = {
   plugins: PluginRef[];
 };
 
+export type StarterPrompt = {
+  label: string;
+  prompt: string;
+};
+
+/** One channel entry from the marketplace. */
+export type MarketplaceChannelListing = {
+  id: string;
+  name: string;
+  description: string;
+  image?: string;
+  spec?: string;
+  initialState?: Record<string, unknown>;
+  /** List of agent IDs that should be participants in the channel. */
+  participants: string[];
+  /** Starter prompts for the channel. */
+  starterPrompts?: StarterPrompt[];
+};
+
+export interface MarketplaceRegistry {
+  agents: MarketplaceAgentListing[];
+  channels: MarketplaceChannelListing[];
+}
+
 const DEFAULT_MARKETPLACE_AGENTS: MarketplaceAgentListing[] = [];
+const DEFAULT_MARKETPLACE_CHANNELS: MarketplaceChannelListing[] = [];
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -44,51 +69,108 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 /**
  * Parses JSON from a remote registry file. Supports either
- * `{ "agents": [ ... ] }` or a top-level array.
+ * `{ "agents": [ ... ], "channels": [ ... ] }` or a top-level array (legacy agents-only).
  */
-export function parseMarketplaceRegistryJson(data: unknown): MarketplaceAgentListing[] {
-  const rawAgents: unknown =
-    Array.isArray(data) ? data : isRecord(data) && Array.isArray(data.agents) ? data.agents : null;
-  if (!Array.isArray(rawAgents)) {
-    throw new Error('Registry JSON must be an array or an object with an "agents" array');
-  }
-  return rawAgents.map((item, i) => {
-    if (!isRecord(item)) {
-      throw new Error(`agents[${i}]: expected object`);
-    }
-    const id = item.id;
-    const name = item.name;
-    const description = item.description;
-    const instructions = item.instructions;
-    const pluginsRaw = item.plugins;
-    if (typeof id !== 'string' || !id) throw new Error(`agents[${i}].id must be a non-empty string`);
-    if (typeof name !== 'string') throw new Error(`agents[${i}].name must be a string`);
-    if (typeof description !== 'string') throw new Error(`agents[${i}].description must be a string`);
-    if (typeof instructions !== 'string') {
-      throw new Error(`agents[${i}].instructions must be a string`);
-    }
-    if (!Array.isArray(pluginsRaw)) throw new Error(`agents[${i}].plugins must be an array`);
-    const plugins: PluginRef[] = pluginsRaw.map((p, j) => {
-      if (!isRecord(p) || typeof p.id !== 'string' || !p.id) {
-        throw new Error(`agents[${i}].plugins[${j}]: expected { "id": string, "config"?: object }`);
+export function parseMarketplaceRegistryJson(data: unknown): MarketplaceRegistry {
+  const isLegacyArray = Array.isArray(data);
+  const rawAgents: unknown = isLegacyArray
+    ? data
+    : isRecord(data) && Array.isArray(data.agents)
+      ? data.agents
+      : [];
+  const rawChannels: unknown =
+    !isLegacyArray && isRecord(data) && Array.isArray(data.channels)
+      ? data.channels
+      : isRecord(data) && Array.isArray((data as any).templates)
+        ? (data as any).templates
+        : [];
+
+  const agents: MarketplaceAgentListing[] = (Array.isArray(rawAgents) ? rawAgents : []).map(
+    (item, i) => {
+      if (!isRecord(item)) {
+        throw new Error(`agents[${i}]: expected object`);
       }
-      const ref: PluginRef = { id: p.id };
-      if (p.config !== undefined) {
-        if (!isRecord(p.config)) throw new Error(`agents[${i}].plugins[${j}].config must be an object`);
-        ref.config = p.config;
+      const id = item.id;
+      const name = item.name;
+      const description = item.description;
+      const instructions = item.instructions;
+      const pluginsRaw = item.plugins;
+      if (typeof id !== 'string' || !id)
+        throw new Error(`agents[${i}].id must be a non-empty string`);
+      if (typeof name !== 'string') throw new Error(`agents[${i}].name must be a string`);
+      if (typeof description !== 'string')
+        throw new Error(`agents[${i}].description must be a string`);
+      if (typeof instructions !== 'string') {
+        throw new Error(`agents[${i}].instructions must be a string`);
       }
-      return ref;
-    });
-    const listing: MarketplaceAgentListing = { id, name, description, instructions, plugins };
-    if (item.image !== undefined) {
-      if (typeof item.image !== 'string') throw new Error(`agents[${i}].image must be a string`);
-      listing.image = item.image;
-    }
-    return listing;
-  });
+      if (!Array.isArray(pluginsRaw)) throw new Error(`agents[${i}].plugins must be an array`);
+      const plugins: PluginRef[] = pluginsRaw.map((p, j) => {
+        if (!isRecord(p) || typeof p.id !== 'string' || !p.id) {
+          throw new Error(`agents[${i}].plugins[${j}]: expected { "id": string, "config"?: object }`);
+        }
+        const ref: PluginRef = { id: p.id };
+        if (p.config !== undefined) {
+          if (!isRecord(p.config))
+            throw new Error(`agents[${i}].plugins[${j}].config must be an object`);
+          ref.config = p.config;
+        }
+        return ref;
+      });
+      const listing: MarketplaceAgentListing = { id, name, description, instructions, plugins };
+      if (item.image !== undefined) {
+        if (typeof item.image !== 'string') throw new Error(`agents[${i}].image must be a string`);
+        listing.image = item.image;
+      }
+      return listing;
+    },
+  );
+
+  const channels: MarketplaceChannelListing[] = (Array.isArray(rawChannels) ? rawChannels : []).map(
+    (item, i) => {
+      if (!isRecord(item)) {
+        throw new Error(`channels[${i}]: expected object`);
+      }
+      const id = item.id;
+      const name = item.name;
+      const description = item.description;
+      const participants = item.participants;
+
+      if (typeof id !== 'string' || !id)
+        throw new Error(`channels[${i}].id must be a non-empty string`);
+      if (typeof name !== 'string') throw new Error(`channels[${i}].name must be a string`);
+      if (typeof description !== 'string')
+        throw new Error(`channels[${i}].description must be a string`);
+      if (!Array.isArray(participants))
+        throw new Error(`channels[${i}].participants must be an array`);
+
+      const listing: MarketplaceChannelListing = {
+        id,
+        name,
+        description,
+        participants: participants.filter((p): p is string => typeof p === 'string'),
+      };
+
+      if (typeof item.image === 'string') listing.image = item.image;
+      if (typeof item.spec === 'string') listing.spec = item.spec;
+      if (isRecord(item.initialState)) listing.initialState = item.initialState;
+
+      if (Array.isArray(item.starterPrompts)) {
+        listing.starterPrompts = item.starterPrompts.map((p: any, j: number) => {
+          if (!isRecord(p) || typeof p.label !== 'string' || typeof p.prompt !== 'string') {
+            throw new Error(`channels[${i}].starterPrompts[${j}] must have label and prompt`);
+          }
+          return { label: p.label, prompt: p.prompt };
+        });
+      }
+
+      return listing;
+    },
+  );
+
+  return { agents, channels };
 }
 
-async function fetchMarketplaceAgentsFromUrl(url: string): Promise<MarketplaceAgentListing[]> {
+async function fetchMarketplaceRegistryFromUrl(url: string): Promise<MarketplaceRegistry> {
   const res = await fetch(url, {
     headers: { Accept: 'application/json' },
     signal: AbortSignal.timeout(15_000),
@@ -101,22 +183,31 @@ async function fetchMarketplaceAgentsFromUrl(url: string): Promise<MarketplaceAg
 }
 
 /**
- * Resolves marketplace agent listings from configured registry URL, or falls back to an empty list.
+ * Resolves marketplace registry (agents and channels) from configured registry URL.
  */
-export async function resolveMarketplaceAgentList(): Promise<MarketplaceAgentListing[]> {
+export async function resolveMarketplaceRegistry(): Promise<MarketplaceRegistry> {
   const { marketplaceRegistryUrl } = loadConfig();
   const registryUrl = marketplaceRegistryUrl?.trim() || DEFAULT_MARKETPLACE_REGISTRY_URL;
   try {
-    return await fetchMarketplaceAgentsFromUrl(registryUrl);
+    return await fetchMarketplaceRegistryFromUrl(registryUrl);
   } catch (err) {
     console.warn(
       `[plugins] marketplace registry fetch failed (${registryUrl}), using built-in list:`,
       err instanceof Error ? err.message : err,
     );
-    return DEFAULT_MARKETPLACE_AGENTS;
+    return { agents: DEFAULT_MARKETPLACE_AGENTS, channels: DEFAULT_MARKETPLACE_CHANNELS };
   }
 }
 
+/**
+ * Resolves marketplace agent listings from configured registry URL.
+ * @deprecated Use resolveMarketplaceRegistry instead.
+ */
+export async function resolveMarketplaceAgentList(): Promise<MarketplaceAgentListing[]> {
+  const registry = await resolveMarketplaceRegistry();
+  return registry.agents;
+}
+
 const getPluginsDir = (): string => {
   const config = loadConfig();
   const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);

package/src/services/plugins/types.ts

@@ -5,7 +5,7 @@ import { AgentDetails, ConfigSchema, Storage } from './domain.js';
 /**
  * Reference to a plugin from an agent's AGENT.md frontmatter.
  *
- * The `id` is either a built-in plugin id (e.g. `openbot`, `shell`) or an npm
+ * The `id` is either a built-in plugin id (e.g. `openbot`, `bash`) or an npm
  * package name (e.g. `openbot-plugin-codex`, `@scope/openbot-plugin-foo`).
  * Each entry may carry plugin-specific `config`.
  */
@@ -33,6 +33,10 @@ export interface PluginContext {
   config: Record<string, unknown>;
   storage: Storage;
   tools: Record<string, ToolDefinition>;
+  /** Resolved public base URL for the server (e.g. https://my-host.example or http://localhost:4132). */
+  publicBaseUrl: string;
+  /** Signal that fires when this run is stopped; runtimes should pass it to long-running calls. */
+  abortSignal?: AbortSignal;
 }
 
 /**

package/src/plugins/shell/index.ts

@@ -1,123 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import { z } from 'zod';
-import { spawn } from 'node:child_process';
-import type { Plugin } from '../../services/plugins/types.js';
-import { OpenBotEvent, OpenBotState } from '../../app/types.js';
-
-const shellToolDefinitions = {
-  shell_exec: {
-    description:
-      'Execute a shell command in the terminal. Use this for file operations, running scripts, or system tasks.',
-    inputSchema: z.object({
-      command: z.string().describe('The shell command to execute.'),
-      cwd: z
-        .string()
-        .optional()
-        .describe(
-          'Working directory. Defaults to the channel cwd or workspace root. Leave empty unless the user requests a specific directory.',
-        ),
-      shell: z.enum(['bash', 'sh', 'zsh']).optional().describe('Shell to use. Defaults to bash.'),
-      timeoutMs: z
-        .number()
-        .optional()
-        .default(30000)
-        .describe('Maximum execution time in milliseconds. Defaults to 30000 (30s).'),
-    }),
-  },
-};
-
-const shellPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:shell_exec', async function* (event, context) {
-    const { command, cwd, shell = 'bash', timeoutMs = 30000 } = event.data;
-
-    const actualTimeout = Math.max(1000, Math.min(timeoutMs, 60000));
-    const actualCwd = cwd || context.state.channelDetails?.cwd || process.cwd();
-
-    try {
-      const result = await new Promise<{
-        exitCode: number | null;
-        stdout: string;
-        stderr: string;
-        timedOut: boolean;
-      }>((resolve) => {
-        const child = spawn(command, {
-          shell,
-          cwd: actualCwd,
-          env: { ...process.env },
-        });
-
-        let stdout = '';
-        let stderr = '';
-        let timedOut = false;
-
-        const timer = setTimeout(() => {
-          timedOut = true;
-          child.kill();
-        }, actualTimeout);
-
-        child.stdout.on('data', (data) => {
-          stdout += data.toString();
-          if (stdout.length > 100000) {
-            stdout = stdout.substring(0, 100000) + '\n... [output truncated]';
-            child.kill();
-          }
-        });
-
-        child.stderr.on('data', (data) => {
-          stderr += data.toString();
-          if (stderr.length > 100000) {
-            stderr = stderr.substring(0, 100000) + '\n... [output truncated]';
-          }
-        });
-
-        child.on('close', (code) => {
-          clearTimeout(timer);
-          resolve({ exitCode: code, stdout, stderr, timedOut });
-        });
-
-        child.on('error', (err) => {
-          clearTimeout(timer);
-          resolve({ exitCode: -1, stdout, stderr: stderr + err.message, timedOut: false });
-        });
-      });
-
-      const success = result.exitCode === 0 && !result.timedOut;
-
-      yield {
-        type: 'action:shell_exec:result',
-        data: {
-          success,
-          exitCode: result.exitCode,
-          stdout: result.stdout,
-          stderr: result.stderr,
-          timedOut: result.timedOut,
-        },
-        meta: event.meta,
-      } as OpenBotEvent;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown shell error';
-      yield {
-        type: 'action:shell_exec:result',
-        data: {
-          success: false,
-          exitCode: -1,
-          stdout: '',
-          stderr: message,
-          timedOut: false,
-          error: message,
-        },
-        meta: event.meta,
-      } as OpenBotEvent;
-    }
-  });
-};
-
-export const shellPlugin: Plugin = {
-  id: 'shell',
-  name: 'Shell',
-  description: 'Execute shell commands in the channel workspace.',
-  toolDefinitions: shellToolDefinitions,
-  factory: () => shellPluginRuntime(),
-};
-
-export default shellPlugin;