openbot 0.4.7 → 0.5.4

package/src/plugins/todo/service.ts

@@ -0,0 +1,123 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_CHANNELS_DIR, getBaseDir, resolvePath } from '../../app/config.js';
+
+export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
+
+export type TodoItem = {
+  id: string;
+  content: string;
+  status: TodoStatus;
+};
+
+export type TodoList = {
+  items: TodoItem[];
+  updatedAt: string;
+};
+
+export const MAX_TODO_ITEMS = 20;
+
+const TODO_STATUSES: ReadonlySet<string> = new Set([
+  'pending',
+  'in_progress',
+  'completed',
+  'cancelled',
+]);
+
+const getThreadDir = (channelId: string, threadId: string): string => {
+  const base = resolvePath(path.join(getBaseDir(), DEFAULT_CHANNELS_DIR, channelId));
+  return path.join(base, 'threads', threadId);
+};
+
+const getTodosPath = (channelId: string, threadId: string): string =>
+  path.join(getThreadDir(channelId, threadId), 'todos.json');
+
+const emptyList = (): TodoList => ({
+  items: [],
+  updatedAt: new Date().toISOString(),
+});
+
+/**
+ * Validate and normalize a todo list write. Throws on invalid input.
+ * Enforces: non-empty content, known statuses, unique ids, max size,
+ * and at most one `in_progress` item.
+ */
+export function validateTodoItems(items: TodoItem[]): TodoItem[] {
+  if (!Array.isArray(items)) {
+    throw new Error('todos must be an array');
+  }
+  if (items.length > MAX_TODO_ITEMS) {
+    throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
+  }
+
+  const seen = new Set<string>();
+  let inProgressCount = 0;
+  const normalized: TodoItem[] = [];
+
+  for (const raw of items) {
+    if (!raw || typeof raw !== 'object') {
+      throw new Error('Each todo must be an object');
+    }
+    const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+    const content = typeof raw.content === 'string' ? raw.content.trim() : '';
+    const status = raw.status;
+
+    if (!id) throw new Error('Each todo requires a non-empty id');
+    if (!content) throw new Error(`Todo "${id}" requires non-empty content`);
+    if (!TODO_STATUSES.has(status)) {
+      throw new Error(
+        `Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`,
+      );
+    }
+    if (seen.has(id)) throw new Error(`Duplicate todo id "${id}"`);
+    seen.add(id);
+
+    if (status === 'in_progress') inProgressCount += 1;
+
+    normalized.push({ id, content, status: status as TodoStatus });
+  }
+
+  if (inProgressCount > 1) {
+    throw new Error('At most one todo may be in_progress');
+  }
+
+  return normalized;
+}
+
+export const todoService = {
+  getTodos: async (args: { channelId: string; threadId: string }): Promise<TodoList> => {
+    const filePath = getTodosPath(args.channelId, args.threadId);
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const parsed = JSON.parse(raw) as Partial<TodoList>;
+      const items = Array.isArray(parsed.items) ? (parsed.items as TodoItem[]) : [];
+      return {
+        items,
+        updatedAt:
+          typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+      };
+    } catch (e: unknown) {
+      if ((e as { code?: string })?.code === 'ENOENT') return emptyList();
+      throw e;
+    }
+  },
+
+  writeTodos: async (args: {
+    channelId: string;
+    threadId: string;
+    items: TodoItem[];
+  }): Promise<TodoList> => {
+    const items = validateTodoItems(args.items);
+    const list: TodoList = {
+      items,
+      updatedAt: new Date().toISOString(),
+    };
+    const threadDir = getThreadDir(args.channelId, args.threadId);
+    await fs.mkdir(threadDir, { recursive: true });
+    const filePath = getTodosPath(args.channelId, args.threadId);
+    const tmp = `${filePath}.tmp`;
+    await fs.writeFile(tmp, `${JSON.stringify(list, null, 2)}\n`, 'utf-8');
+    await fs.rename(tmp, filePath);
+    return list;
+  },
+};

package/src/plugins/ui/index.ts

@@ -40,7 +40,14 @@ export const uiPlugin: Plugin = {
           id: z.string(),
           label: z.string(),
           description: z.string().optional(),
-          status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+          status: z
+            .string()
+            .optional()
+            .describe('Status label shown on the item (e.g. "Pending", "Shipped").'),
+          statusVariant: z
+            .enum(['default', 'success', 'warning', 'danger', 'info'])
+            .optional()
+            .describe('Semantic hint for status badge coloring in the client.'),
           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").')

package/src/services/plugins/domain.ts

@@ -49,6 +49,8 @@ export type ConfigSchema = {
       description?: string;
       default?: unknown;
       enum?: unknown[];
+      /** Labeled select options (preferred over bare `enum` when present). */
+      options?: Array<{ label: string; value: string; description?: string }>;
       minimum?: number;
       maximum?: number;
       format?: 'password' | 'url' | 'email';

package/src/services/plugins/model-registry.ts

@@ -0,0 +1,146 @@
+import {
+  DEFAULT_MARKETPLACE_REGISTRY_URL,
+  loadConfig,
+} from '../../app/config.js';
+import { isCloudMode } from '../../app/cloud-mode.js';
+import type { ConfigSchema, PluginDescriptor } from './domain.js';
+
+export type RegistryProviderCatalog = Record<
+  string,
+  {
+    label: string;
+    models: Array<{ id: string; label: string; description: string }>;
+  }
+>;
+
+export type ModelRegistry = {
+  providers?: RegistryProviderCatalog;
+};
+
+export type RegistryModelOption = {
+  value: string;
+  label: string;
+  description?: string;
+  provider: string;
+};
+
+let cachedRegistry: ModelRegistry | null = null;
+let cacheUrl: string | null = null;
+
+function getRegistryUrl(): string {
+  const { marketplaceRegistryUrl } = loadConfig();
+  return marketplaceRegistryUrl?.trim() || DEFAULT_MARKETPLACE_REGISTRY_URL;
+}
+
+export async function resolveModelRegistry(): Promise<ModelRegistry> {
+  const url = getRegistryUrl();
+  if (cachedRegistry && cacheUrl === url) return cachedRegistry;
+
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: 'application/json' },
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok) {
+      throw new Error(`Registry HTTP ${res.status} ${res.statusText}`);
+    }
+    cachedRegistry = (await res.json()) as ModelRegistry;
+    cacheUrl = url;
+    return cachedRegistry;
+  } catch (err) {
+    console.warn(
+      '[model-registry] fetch failed:',
+      err instanceof Error ? err.message : err,
+    );
+    return { providers: {} };
+  }
+}
+
+export function listModelOptionsFromRegistry(registry: ModelRegistry): RegistryModelOption[] {
+  const providers = registry.providers ?? {};
+  const out: RegistryModelOption[] = [];
+
+  for (const [providerId, provider] of Object.entries(providers)) {
+    for (const model of provider.models ?? []) {
+      out.push({
+        value: `${providerId}/${model.id}`,
+        label: `${provider.label} — ${model.label}`,
+        description: model.description,
+        provider: providerId,
+      });
+    }
+  }
+
+  return out;
+}
+
+export async function listRegistryModelOptions(): Promise<RegistryModelOption[]> {
+  const registry = await resolveModelRegistry();
+  return listModelOptionsFromRegistry(registry);
+}
+
+export function listApiKeyProvidersFromRegistry(
+  registry: ModelRegistry,
+): Array<{ id: string; label: string }> {
+  const providers = registry.providers ?? {};
+  return Object.entries(providers).map(([id, provider]) => ({
+    id,
+    label: provider.label,
+  }));
+}
+
+function pickDefaultModelValue(options: RegistryModelOption[]): string | undefined {
+  if (options.length === 0) return undefined;
+  const values = options.map((option) => option.value);
+  const preferred = isCloudMode()
+    ? values.find((value) => value.startsWith('openbot/'))
+    : values.find((value) => value.startsWith('openai/'));
+  return preferred ?? values[0];
+}
+
+export function enrichOpenbotPluginDescriptor(
+  descriptor: PluginDescriptor,
+  modelOptions: RegistryModelOption[],
+): PluginDescriptor {
+  if (descriptor.id !== 'openbot' || !descriptor.configSchema) return descriptor;
+
+  const modelProperty = descriptor.configSchema.properties.model;
+  if (!modelProperty) return descriptor;
+
+  const values = modelOptions.map((option) => option.value);
+  const staticDefault =
+    typeof modelProperty.default === 'string' ? modelProperty.default : undefined;
+  const defaultModel =
+    staticDefault && values.includes(staticDefault)
+      ? staticDefault
+      : pickDefaultModelValue(modelOptions) ?? staticDefault;
+
+  const nextModelProperty: ConfigSchema['properties'][string] = {
+    ...modelProperty,
+    description: 'Model from the hosted marketplace registry.',
+  };
+
+  if (values.length > 0) {
+    nextModelProperty.enum = values;
+    nextModelProperty.options = modelOptions.map((option) => ({
+      label: option.label,
+      value: option.value,
+      description: option.description,
+    }));
+  }
+
+  if (defaultModel) {
+    nextModelProperty.default = defaultModel;
+  }
+
+  return {
+    ...descriptor,
+    configSchema: {
+      ...descriptor.configSchema,
+      properties: {
+        ...descriptor.configSchema.properties,
+        model: nextModelProperty,
+      },
+    },
+  };
+}

package/src/services/plugins/registry.ts

@@ -7,10 +7,12 @@ 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 { todoPlugin } from '../../plugins/todo/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 { previewPlugin } from '../../plugins/preview/index.js';
+import { DEFAULT_PLUGINS_DIR, getBaseDir } from '../../app/config.js';
 import {
   invalidatePlugin as clearResolvedPluginEntry,
   loadedCommunityPlugins,
@@ -25,9 +27,11 @@ const BUILT_IN: Record<string, Plugin> = {
   [storagePlugin.id]: storagePlugin,
   [approvalPlugin.id]: approvalPlugin,
   [memoryPlugin.id]: memoryPlugin,
+  [todoPlugin.id]: todoPlugin,
   [delegationPlugin.id]: delegationPlugin,
   [uiPlugin.id]: uiPlugin,
   [pluginManagerPlugin.id]: pluginManagerPlugin,
+  [previewPlugin.id]: previewPlugin,
 };
 
 /**
@@ -71,9 +75,7 @@ export function initPlugins(dir?: string) {
   if (dir) {
     pluginsDir = dir;
   } else {
-    const config = loadConfig();
-    const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-    pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_DIR);
+    pluginsDir = path.join(getBaseDir(), DEFAULT_PLUGINS_DIR);
   }
 }
 

package/src/services/plugins/service.ts

@@ -5,8 +5,8 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import {
   DEFAULT_PLUGINS_DIR,
-  DEFAULT_BASE_DIR,
   DEFAULT_MARKETPLACE_REGISTRY_URL,
+  getBaseDir,
   loadConfig,
   resolvePath,
 } from '../../app/config.js';
@@ -202,11 +202,7 @@ export async function resolveMarketplaceAgentList(): Promise<MarketplaceAgentLis
   return registry.agents;
 }
 
-const getPluginsDir = (): string => {
-  const config = loadConfig();
-  const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-  return path.join(baseDir, DEFAULT_PLUGINS_DIR);
-};
+const getPluginsDir = (): string => path.join(getBaseDir(), DEFAULT_PLUGINS_DIR);
 
 /**
  * Lifecycle for community-built plugins distributed via npm.

package/dist/agents/openbot/index.js

@@ -1,76 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { openBotRuntime } from './runtime.js';
-import { shellPlugin, shellToolDefinitions } from './tools/shell.js';
-import { mcpPlugin, mcpToolDefinitions } from './tools/mcp.js';
-import { uiPlugin, uiToolDefinitions } from './tools/ui.js';
-import { delegationPlugin, delegationToolDefinitions } from './tools/delegation.js';
-import { storageToolDefinitions } from './tools/storage.js';
-import { approvalPlugin } from './middleware/approval.js';
-import { DEFAULT_OPENBOT_APPROVAL_RULES, OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
-const OPENBOT_ICON_DATA_URL = (() => {
-    try {
-        const svg = readFileSync(new URL('../../assets/icon.svg', import.meta.url), 'utf-8').trim();
-        if (!svg.startsWith('<svg'))
-            return undefined;
-        return `data:image/svg+xml;base64,${Buffer.from(svg, 'utf-8').toString('base64')}`;
-    }
-    catch {
-        return undefined;
-    }
-})();
-const composeMelonyPlugin = (...plugins) => {
-    return (builder) => {
-        for (const plugin of plugins) {
-            plugin(builder);
-        }
-    };
-};
-/**
- * OpenBot — the first-party orchestrator agent package.
- *
- * Treats the bus as a peer environment: registers a runtime that owns
- * `agent:invoke`, exposes a curated tool set (delegation, storage, MCP, shell,
- * UI widgets), and wires approval middleware for protected actions.
- *
- * Other agents (Codex, Claude Code, Gemini, custom Coder/Researcher) are
- * separate AgentPackages with their own runtime + tool composition.
- */
-export const openBotAgentPackage = {
-    id: 'openbot',
-    name: 'OpenBot',
-    description: 'First-party orchestration agent for OpenBot. Coordinates other agents via handoff and delegation.',
-    image: OPENBOT_ICON_DATA_URL,
-    defaultInstructions: OPENBOT_SYSTEM_PROMPT,
-    configSchema: {
-        type: 'object',
-        properties: {
-            model: {
-                type: 'string',
-                description: 'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
-                default: 'openai/gpt-4o-mini',
-            },
-        },
-    },
-    factory: ({ agentDetails, config, storage }) => {
-        const model = typeof config.model === 'string' && config.model
-            ? config.model
-            : 'openai/gpt-4o-mini';
-        const toolDefinitions = {
-            ...delegationToolDefinitions,
-            ...storageToolDefinitions,
-            ...mcpToolDefinitions,
-            ...shellToolDefinitions,
-            // Re-enable when the dashboard renders widgets:
-            // ...uiToolDefinitions,
-        };
-        const systemPrompt = agentDetails.instructions || OPENBOT_SYSTEM_PROMPT;
-        return composeMelonyPlugin(openBotRuntime({
-            model,
-            system: systemPrompt,
-            storage,
-            toolDefinitions,
-        }), approvalPlugin({ rules: DEFAULT_OPENBOT_APPROVAL_RULES }), delegationPlugin(), shellPlugin(), mcpPlugin(), uiPlugin());
-    },
-};
-// Suppress unused warning while UI widget tools are not wired into the LLM tool list.
-void uiToolDefinitions;

package/dist/agents/openbot/middleware/approval.js

@@ -1,132 +0,0 @@
-import { storageService } from '../../../services/storage.js';
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
-    ? value
-    : {};
-const getApprovalsFromState = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
-    const stateRecord = asRecord(source);
-    return asRecord(stateRecord.approvals);
-};
-const persistApprovals = async (state, approvals) => {
-    if (state.threadId) {
-        await storageService.patchThreadState({
-            channelId: state.channelId,
-            threadId: state.threadId,
-            state: { approvals },
-        });
-        return;
-    }
-    await storageService.patchChannelState({
-        channelId: state.channelId,
-        state: { approvals },
-    });
-};
-export const approvalPlugin = (options = {}) => (builder) => {
-    const rules = options.rules || [];
-    for (const rule of rules) {
-        builder.on(rule.action, async function* (event, context) {
-            const meta = asRecord(event.meta);
-            if (meta.approvalStatus === 'approved')
-                return;
-            const eventData = asRecord(event.data);
-            const eventMeta = meta;
-            const approvalId = `approval_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-            const widgetId = `widget_${approvalId}`;
-            const executeEvent = rule.executeEvent || rule.action;
-            const denyEvent = rule.denyEvent || `${rule.action}:result`;
-            const denyData = rule.denyData || {};
-            const hiddenKeys = new Set(rule.hiddenKeys || []);
-            const detailKeys = rule.detailKeys || Object.keys(eventData);
-            const details = detailKeys
-                .filter((key) => !hiddenKeys.has(key))
-                .map((key) => `- ${key}: ${String(eventData[key] ?? '')}`)
-                .join('\n');
-            const pendingApprovals = getApprovalsFromState(context.state);
-            pendingApprovals[approvalId] = {
-                id: approvalId,
-                action: rule.action,
-                executeEvent,
-                denyEvent,
-                denyData,
-                payload: eventData,
-                meta: eventMeta,
-                message: rule.message || `Approval required for ${rule.action}.`,
-                createdAt: new Date().toISOString(),
-                status: 'pending',
-            };
-            await persistApprovals(context.state, pendingApprovals);
-            yield {
-                type: 'client:ui:widget',
-                data: {
-                    kind: 'choice',
-                    widgetId,
-                    title: 'Approval Required',
-                    body: `${rule.message || 'A protected action requires approval.'}${details ? `\n\n${details}` : ''}`,
-                    metadata: { type: 'approval:request', approvalId, action: rule.action },
-                    actions: [
-                        { id: 'approve', label: 'Approve', variant: 'primary' },
-                        { id: 'deny', label: 'Deny', variant: 'danger' },
-                    ],
-                },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-            yield {
-                type: 'agent:output',
-                data: { content: `Waiting for approval before running \`${rule.action}\`.` },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-            context.suspend();
-        });
-    }
-    builder.on('client:ui:widget:response', async function* (event, context) {
-        const metadata = asRecord(event.data?.metadata);
-        if (metadata.type !== 'approval:request')
-            return;
-        const approvalId = String(metadata.approvalId || '');
-        if (!approvalId)
-            return;
-        const approvals = getApprovalsFromState(context.state);
-        const approval = approvals[approvalId];
-        if (!approval || approval.status !== 'pending') {
-            yield {
-                type: 'agent:output',
-                data: { content: 'Approval request not found or already resolved.' },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-            return;
-        }
-        const approved = event.data.actionId === 'approve';
-        approvals[approvalId] = {
-            ...approval,
-            status: approved ? 'approved' : 'denied',
-        };
-        await persistApprovals(context.state, approvals);
-        if (approved) {
-            yield {
-                type: approval.executeEvent,
-                data: approval.payload,
-                meta: {
-                    ...(approval.meta || {}),
-                    approvalId,
-                    approvalStatus: 'approved',
-                },
-            };
-            return;
-        }
-        yield {
-            type: approval.denyEvent,
-            data: {
-                success: false,
-                approved: false,
-                error: 'Action denied by user approval.',
-                ...approval.denyData,
-            },
-            meta: { ...(approval.meta || {}), approvalId },
-        };
-        yield {
-            type: 'agent:output',
-            data: { content: 'Action denied by user approval.' },
-            meta: { ...(event.meta || {}), agentId: context.state.agentId },
-        };
-    });
-};