openbot 0.4.7 → 0.5.4

package/src/plugins/preview/index.ts

@@ -0,0 +1,323 @@
+import { MelonyPlugin } from 'melony';
+import { z } from 'zod';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import type { Plugin } from '../../services/plugins/types.js';
+import type { Storage } from '../../services/plugins/domain.js';
+import { OpenBotEvent, OpenBotState } from '../../app/types.js';
+
+const TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+const TUNNEL_READY_TIMEOUT_MS = 60_000;
+const MAX_LOG_CHARS = 8_000;
+
+const previewToolDefinitions = {
+  expose_port: {
+    description:
+      'Expose a local dev server port via a temporary public Cloudflare quick tunnel. Returns a previewUrl stored on the channel. Dev servers must listen on 0.0.0.0 or 127.0.0.1. Call after shell_exec when the server is ready.',
+    inputSchema: z.object({
+      port: z
+        .number()
+        .int()
+        .min(1024)
+        .max(65535)
+        .describe('Local port of the running dev server (e.g. 5173).'),
+    }),
+  },
+  unexpose_port: {
+    description:
+      'Stop the active Cloudflare preview tunnel for this channel and clear previewUrl from channel state.',
+    inputSchema: z.object({}),
+  },
+};
+
+interface PreviewTunnel {
+  id: string;
+  channelId: string;
+  port: number;
+  url: string;
+  process: ChildProcess;
+  startedAt: number;
+  logs: string;
+}
+
+const tunnels = new Map<string, PreviewTunnel>();
+const tunnelByChannel = new Map<string, string>();
+
+const blockedPorts = (): Set<number> => {
+  const openbotPort = Number(process.env.PORT ?? 4132);
+  return new Set([22, 80, 443, openbotPort]);
+};
+
+const appendLog = (tunnel: PreviewTunnel, chunk: string) => {
+  tunnel.logs += chunk;
+  if (tunnel.logs.length > MAX_LOG_CHARS) {
+    tunnel.logs = tunnel.logs.slice(-MAX_LOG_CHARS);
+  }
+};
+
+const killTunnelProcess = (tunnel: PreviewTunnel) => {
+  const { process: child } = tunnel;
+  if (!child.pid) {
+    try {
+      child.kill();
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+
+  try {
+    child.kill('SIGTERM');
+  } catch {
+    try {
+      child.kill();
+    } catch {
+      /* ignore */
+    }
+  }
+};
+
+const removeTunnel = (tunnelId: string) => {
+  const tunnel = tunnels.get(tunnelId);
+  if (!tunnel) return;
+  killTunnelProcess(tunnel);
+  tunnels.delete(tunnelId);
+  if (tunnelByChannel.get(tunnel.channelId) === tunnelId) {
+    tunnelByChannel.delete(tunnel.channelId);
+  }
+};
+
+export const stopPreviewForChannel = (channelId: string) => {
+  const tunnelId = tunnelByChannel.get(channelId);
+  if (tunnelId) {
+    removeTunnel(tunnelId);
+  }
+};
+
+const waitForTunnelUrl = (child: ChildProcess, timeoutMs: number): Promise<string> =>
+  new Promise((resolve, reject) => {
+    let buffer = '';
+    let settled = false;
+
+    const cleanup = () => {
+      clearTimeout(timer);
+      child.stdout?.off('data', onData);
+      child.stderr?.off('data', onData);
+      child.off('exit', onExit);
+      child.off('error', onError);
+    };
+
+    const tryParse = () => {
+      const match = buffer.match(TUNNEL_URL_PATTERN);
+      if (match) {
+        settled = true;
+        cleanup();
+        resolve(match[0]);
+      }
+    };
+
+    const onData = (chunk: Buffer) => {
+      buffer += chunk.toString();
+      if (buffer.length > 16_000) {
+        buffer = buffer.slice(-16_000);
+      }
+      tryParse();
+    };
+
+    const onExit = (code: number | null) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error(`cloudflared exited before providing a tunnel URL (code ${code ?? 'unknown'})`));
+    };
+
+    const onError = (err: Error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error('Timed out waiting for Cloudflare tunnel URL'));
+    }, timeoutMs);
+
+    child.stdout?.on('data', onData);
+    child.stderr?.on('data', onData);
+    child.on('exit', onExit);
+    child.on('error', onError);
+    tryParse();
+  });
+
+const startCloudflaredTunnel = async (channelId: string, port: number): Promise<PreviewTunnel> => {
+  const child = spawn(
+    'cloudflared',
+    ['tunnel', '--url', `http://127.0.0.1:${port}`, '--no-autoupdate'],
+    {
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const tunnel: PreviewTunnel = {
+    id: randomUUID(),
+    channelId,
+    port,
+    url: '',
+    process: child,
+    startedAt: Date.now(),
+    logs: '',
+  };
+
+  child.stdout?.on('data', (data: Buffer) => appendLog(tunnel, data.toString()));
+  child.stderr?.on('data', (data: Buffer) => appendLog(tunnel, data.toString()));
+
+  child.on('exit', () => {
+    tunnels.delete(tunnel.id);
+    if (tunnelByChannel.get(channelId) === tunnel.id) {
+      tunnelByChannel.delete(channelId);
+    }
+  });
+
+  const url = await waitForTunnelUrl(child, TUNNEL_READY_TIMEOUT_MS);
+  tunnel.url = url;
+  tunnels.set(tunnel.id, tunnel);
+  tunnelByChannel.set(channelId, tunnel.id);
+  return tunnel;
+};
+
+const clearPreviewChannelState = async (storage: Storage, channelId: string) => {
+  await storage.patchChannelState({
+    channelId,
+    state: {
+      previewUrl: null,
+      previewPort: null,
+      previewExposedAt: null,
+    },
+  });
+};
+
+const previewPluginRuntime =
+  (storage: Storage): MelonyPlugin<OpenBotState, OpenBotEvent> =>
+  (builder) => {
+    builder.on('action:expose_port', async function* (event, context) {
+      const channelId = context.state.channelId;
+      const port = event.data?.port;
+
+      if (!Number.isInteger(port)) {
+        yield {
+          type: 'action:expose_port:result',
+          data: {
+            success: false,
+            output: 'port must be an integer between 1024 and 65535.',
+          },
+          meta: event.meta,
+        } as OpenBotEvent;
+        return;
+      }
+
+      if (blockedPorts().has(port)) {
+        yield {
+          type: 'action:expose_port:result',
+          data: {
+            success: false,
+            output: `Port ${port} is reserved and cannot be exposed.`,
+          },
+          meta: event.meta,
+        } as OpenBotEvent;
+        return;
+      }
+
+      const existingTunnelId = tunnelByChannel.get(channelId);
+      if (existingTunnelId) {
+        removeTunnel(existingTunnelId);
+      }
+
+      try {
+        const tunnel = await startCloudflaredTunnel(channelId, port);
+
+        await storage.patchChannelState({
+          channelId,
+          state: {
+            previewUrl: tunnel.url,
+            previewPort: port,
+            previewExposedAt: tunnel.startedAt,
+          },
+        });
+
+        if (context.state.channelDetails) {
+          context.state.channelDetails = await storage.getChannelDetails({ channelId });
+        }
+
+        yield {
+          type: 'action:expose_port:result',
+          data: {
+            success: true,
+            previewUrl: tunnel.url,
+            port,
+            temporary: true,
+            output: `Preview available at ${tunnel.url} (temporary Cloudflare quick tunnel).`,
+          },
+          meta: event.meta,
+        } as OpenBotEvent;
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : 'Failed to start Cloudflare tunnel';
+        const needsCloudflared =
+          message.includes('ENOENT') || message.toLowerCase().includes('cloudflared');
+        const hint = needsCloudflared
+          ? ' Install cloudflared and ensure it is on PATH (https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/downloads/).'
+          : '';
+
+        yield {
+          type: 'action:expose_port:result',
+          data: {
+            success: false,
+            error: message,
+            output: `${message}${hint}`,
+          },
+          meta: event.meta,
+        } as OpenBotEvent;
+      }
+    });
+
+    builder.on('action:unexpose_port', async function* (event, context) {
+      const channelId = context.state.channelId;
+
+      stopPreviewForChannel(channelId);
+      await clearPreviewChannelState(storage, channelId);
+
+      if (context.state.channelDetails) {
+        context.state.channelDetails = await storage.getChannelDetails({ channelId });
+      }
+
+      yield {
+        type: 'action:unexpose_port:result',
+        data: {
+          success: true,
+          output: 'Preview tunnel stopped and previewUrl cleared from channel state.',
+        },
+        meta: event.meta,
+      } as OpenBotEvent;
+    });
+
+    builder.on('action:delete_channel', async function* (event) {
+      const channelId = (event.data as { channelId?: string })?.channelId;
+      if (channelId) {
+        stopPreviewForChannel(channelId);
+      }
+    });
+  };
+
+export const previewPlugin: Plugin = {
+  id: 'preview',
+  name: 'Preview',
+  description: 'Temporary public preview URLs via Cloudflare quick tunnels.',
+  toolDefinitions: previewToolDefinitions,
+  factory: ({ storage }) => previewPluginRuntime(storage),
+};
+
+export default previewPlugin;

package/src/plugins/storage/index.ts

@@ -38,9 +38,7 @@ const storageToolDefinitions = {
         state: z
           .record(z.string(), z.unknown())
           .optional()
-          .describe(
-            'JSON state object for the channel. Use for structured metadata.',
-          ),
+          .describe('JSON state object for the channel.'),
         spec: z
           .string()
           .optional()
@@ -58,13 +56,12 @@ const storageToolDefinitions = {
       ),
   },
   patch_thread_details: {
-    description: 'Patch current thread details (state).',
+    description:
+      'Patch current thread details (state). Use for thread metadata such as `name` or `isSmartNamed`. For multi-step task tracking, use `todo_write` instead.',
     inputSchema: z.object({
       state: z
         .record(z.string(), z.unknown())
-        .describe(
-          'JSON state object for the thread. Use for structured progress or metadata.',
-        ),
+        .describe('JSON state object for the thread. Merges with existing state.'),
     }),
   },
   create_variable: {
@@ -333,7 +330,7 @@ export const storagePlugin: Plugin = {
             display: "collapsed",
           },
           meta: resultMeta,
-        }
+        };
 
         yield {
           type: 'action:patch_channel_details:result',

package/src/plugins/storage/service.ts

@@ -1,11 +1,15 @@
 import { ORCHESTRATOR_AGENT_ID, STATE_AGENT_ID } from '../../app/agent-ids.js';
+import {
+  assertCloudSystemAgentPluginsMutable,
+  CLOUD_SYSTEM_MODEL,
+  isCloudMode,
+} from '../../app/cloud-mode.js';
 import {
   DEFAULT_PLUGINS_DIR,
   DEFAULT_AGENTS_DIR,
-  DEFAULT_BASE_DIR,
   DEFAULT_CHANNELS_DIR,
+  getBaseDir,
   getDefaultChannelCwd,
-  loadConfig,
   resolvePath,
   StoredVariable,
   VARIABLES_FILE,
@@ -29,6 +33,10 @@ import {
 import type { PluginRef } from '../../services/plugins/types.js';
 import { openbotPlugin } from '../openbot/index.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
+import {
+  enrichOpenbotPluginDescriptor,
+  listRegistryModelOptions,
+} from '../../services/plugins/model-registry.js';
 import { OpenBotEvent, OpenBotState } from '../../app/types.js';
 import { processService } from '../../services/process.js';
 import { memoryService } from '../memory/service.js';
@@ -38,10 +46,7 @@ import {
   statChannelFile,
 } from './files.js';
 
-const resolveBaseDir = () => {
-  const config = loadConfig();
-  return resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-};
+const resolveBaseDir = () => getBaseDir();
 
 const ENTITY_SVG_CANDIDATE_NAMES = ['avatar.svg', 'icon.svg', 'image.svg', 'logo.svg'] as const;
 
@@ -121,12 +126,44 @@ const SYSTEM_DEFAULT_PLUGINS: PluginRef[] = [
     config: {
       model: 'openai/gpt-5.4-mini',
       approval: {
-        actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+        actions: ['action:shell_exec', 'action:create_channel', 'action:delete_channel'],
+      },
+    },
+  },
+];
+
+const CLOUD_SYSTEM_DEFAULT_PLUGINS: PluginRef[] = [
+  {
+    id: 'openbot',
+    config: {
+      model: CLOUD_SYSTEM_MODEL,
+      approval: {
+        actions: ['action:shell_exec', 'action:create_channel', 'action:delete_channel'],
       },
     },
   },
 ];
 
+function mergeCloudSystemPluginRefs(
+  defaults: PluginRef[],
+  diskRefs: PluginRef[],
+): PluginRef[] {
+  const defaultOpenbot = defaults.find((ref) => ref.id === 'openbot');
+  const diskOpenbot = diskRefs.find((ref) => ref.id === 'openbot');
+
+  if (!defaultOpenbot) return defaults;
+
+  return [
+    {
+      ...defaultOpenbot,
+      config: {
+        ...defaultOpenbot.config,
+        ...diskOpenbot?.config,
+      },
+    },
+  ];
+}
+
 /** No `openbot` / `bash` — storage-side effects and infra plugins only. */
 const STATE_DEFAULT_PLUGINS: PluginRef[] = [
   { id: 'storage' },
@@ -137,6 +174,7 @@ const STATE_AGENT_INSTRUCTIONS =
   'Built-in infra agent for deterministic state reads. No conversational model is attached; handle storage, approvals, memory, and plugin marketplace events.';
 
 function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails {
+  const defaultPlugins = isCloudMode() ? CLOUD_SYSTEM_DEFAULT_PLUGINS : SYSTEM_DEFAULT_PLUGINS;
   const defaults: AgentDetails = {
     id: SYSTEM_AGENT_ID,
     name: 'OpenBot',
@@ -144,22 +182,41 @@ function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails
     description:
       'First-party orchestration agent for OpenBot.',
     instructions: '',
-    plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
-    pluginRefs: SYSTEM_DEFAULT_PLUGINS,
+    plugins: defaultPlugins.map((ref) => ref.id),
+    pluginRefs: defaultPlugins,
     createdAt: new Date(),
     updatedAt: new Date(),
   };
 
   if (!overrides) return defaults;
 
-  const refs = overrides.pluginRefs && overrides.pluginRefs.length > 0
-    ? overrides.pluginRefs
-    : defaults.pluginRefs;
-
   const diskInstructions = overrides.instructions?.trim();
   const instructions =
     diskInstructions && diskInstructions.length > 0 ? diskInstructions : defaults.instructions;
 
+  if (isCloudMode()) {
+    const diskRefs =
+      overrides.pluginRefs && overrides.pluginRefs.length > 0 ? overrides.pluginRefs : undefined;
+    const refs = diskRefs
+      ? mergeCloudSystemPluginRefs(defaults.pluginRefs, diskRefs)
+      : defaults.pluginRefs;
+
+    return {
+      ...defaults,
+      ...overrides,
+      id: SYSTEM_AGENT_ID,
+      instructions,
+      image: overrides.image || defaults.image,
+      plugins: refs.map((ref) => ref.id),
+      pluginRefs: refs,
+      updatedAt: new Date(),
+    };
+  }
+
+  const refs = overrides.pluginRefs && overrides.pluginRefs.length > 0
+    ? overrides.pluginRefs
+    : defaults.pluginRefs;
+
   return {
     ...defaults,
     ...overrides,
@@ -992,12 +1049,17 @@ export const storageService = {
     return Array.from(deduped.values()).filter((agent) => !agent.hidden);
   },
   getPlugins: async (): Promise<PluginDescriptor[]> => {
-    const [builtIn, fromDisk] = await Promise.all([
+    const [builtIn, fromDisk, modelOptions] = await Promise.all([
       listBuiltInPluginDescriptors(),
       listPluginsFromDisk(),
+      listRegistryModelOptions(),
     ]);
 
-    const merged = [...builtIn, ...fromDisk];
+    const enrichedBuiltIn = builtIn.map((plugin) =>
+      enrichOpenbotPluginDescriptor(plugin, modelOptions),
+    );
+
+    const merged = [...enrichedBuiltIn, ...fromDisk];
     const deduped = new Map<string, PluginDescriptor>();
     for (const plugin of merged) {
       if (!deduped.has(plugin.id)) {
@@ -1081,6 +1143,7 @@ export const storageService = {
     plugins: PluginRef[];
   }): Promise<void> => {
     assertAgentIdFormat(agentId);
+    assertCloudSystemAgentPluginsMutable(agentId, plugins);
     const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
     const agentMdPath = path.join(agentDir, 'AGENT.md');
 
@@ -1133,6 +1196,7 @@ export const storageService = {
     plugins?: PluginRef[];
   }): Promise<void> => {
     assertAgentIdFormat(agentId);
+    assertCloudSystemAgentPluginsMutable(agentId, plugins);
     const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
     const agentMdPath = path.join(agentDir, 'AGENT.md');
 

package/src/plugins/todo/index.ts

@@ -0,0 +1,166 @@
+import z from 'zod';
+import type { Plugin } from '../../services/plugins/types.js';
+import type { OpenBotEvent, UIWidgetListItem } from '../../app/types.js';
+import { todoService, type TodoItem, type TodoList, type TodoStatus } from './service.js';
+
+/**
+ * `todo` — thread-scoped task checklist for multi-step agent work.
+ *
+ * Persisted at `~/.openbot/channels/<channelId>/threads/<threadId>/todos.json`.
+ * The agent replaces the full list via `todo_write`; the runtime injects the
+ * current list into context each turn.
+ */
+
+/** Map todo statuses onto UI list-item status label + variant. */
+function toWidgetItemStatus(
+  status: TodoStatus,
+): Pick<UIWidgetListItem, 'status' | 'statusVariant'> {
+  switch (status) {
+    case 'pending':
+      return { status: 'Pending', statusVariant: 'default' };
+    case 'in_progress':
+      return { status: 'In progress', statusVariant: 'info' };
+    case 'completed':
+      return { status: 'Done', statusVariant: 'success' };
+    case 'cancelled':
+      return { status: 'Cancelled', statusVariant: 'danger' };
+  }
+}
+
+function formatTodoOutput(list: TodoList): string {
+  if (list.items.length === 0) return 'Todo list is empty.';
+  const lines = list.items.map((t) => `- [${t.status}] (${t.id}) ${t.content}`);
+  return `Todos (${list.items.length}):\n${lines.join('\n')}`;
+}
+
+function todoListWidget(args: {
+  runId: string;
+  list: TodoList;
+}): OpenBotEvent {
+  const items: UIWidgetListItem[] = args.list.items.map((t: TodoItem) => ({
+    id: t.id,
+    label: t.content,
+    ...toWidgetItemStatus(t.status),
+  }));
+
+  return {
+    type: 'client:ui:widget',
+    data: {
+      // One widget per agent run — repeated todo_write calls update in place.
+      widgetId: `todos:${args.runId}`,
+      kind: 'list',
+      title: 'Todos',
+      description:
+        args.list.items.length === 0
+          ? 'No todos'
+          : `${args.list.items.filter((t) => t.status === 'completed').length}/${args.list.items.length} completed`,
+      items,
+      display: 'expanded',
+      state: 'open',
+    },
+    meta: {},
+  } as OpenBotEvent;
+}
+
+const todoItemSchema = z.object({
+  id: z.string().min(1).describe('Stable todo id (e.g. "1", "setup-repo").'),
+  content: z.string().min(1).describe('Short imperative description of the step.'),
+  status: z
+    .enum(['pending', 'in_progress', 'completed', 'cancelled'])
+    .describe('Todo status. At most one item may be in_progress.'),
+});
+
+const todoToolDefinitions = {
+  todo_write: {
+    description:
+      'Replace the current thread todo list with the provided items. Use for multi-step tasks: write the plan first, keep exactly one item in_progress while working, mark items completed immediately after finishing, and when done leave all items as completed (do not clear the list). Pass the full intended list each call (not a partial patch).',
+    inputSchema: z.object({
+      items: z
+        .array(todoItemSchema)
+        .max(20)
+        .describe('Full todo list for this thread (max 20). Replaces any previous list.'),
+    }),
+  },
+  todo_read: {
+    description:
+      'Read the current thread todo list. Usually unnecessary — the list is already injected into context each turn. Use only if you need an explicit refresh after an external change.',
+    inputSchema: z.object({}),
+  },
+};
+
+export const todoPlugin: Plugin = {
+  id: 'todo',
+  name: 'Todo',
+  description:
+    'Thread-scoped todo checklist for multi-step task tracking (todo_write / todo_read).',
+  toolDefinitions: todoToolDefinitions,
+  factory: () => (builder) => {
+    builder.on('action:todo_write', async function* (event, context) {
+      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+      try {
+        const channelId = context.state.channelId;
+        const threadId = context.state.threadId;
+        if (!channelId || !threadId) {
+          throw new Error('Missing channelId or threadId for todo_write');
+        }
+        const items = (event.data as { items: TodoItem[] }).items;
+        const list = await todoService.writeTodos({ channelId, threadId, items });
+        const runId = context.state.runId;
+        if (!runId) {
+          throw new Error('Missing runId for todo_write widget');
+        }
+
+        const widget = todoListWidget({ runId, list });
+        widget.meta = { ...resultMeta, threadId, runId };
+        yield widget;
+
+        yield {
+          type: 'action:todo_write:result',
+          data: { success: true, list, output: formatTodoOutput(list) },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        yield {
+          type: 'action:todo_write:result',
+          data: {
+            success: false,
+            error: message,
+            output: message,
+          },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      }
+    });
+
+    builder.on('action:todo_read', async function* (event, context) {
+      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+      try {
+        const channelId = context.state.channelId;
+        const threadId = context.state.threadId;
+        if (!channelId || !threadId) {
+          throw new Error('Missing channelId or threadId for todo_read');
+        }
+        const list = await todoService.getTodos({ channelId, threadId });
+        yield {
+          type: 'action:todo_read:result',
+          data: { success: true, list, output: formatTodoOutput(list) },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        yield {
+          type: 'action:todo_read:result',
+          data: {
+            success: false,
+            error: message,
+            output: message,
+          },
+          meta: resultMeta,
+        } as OpenBotEvent;
+      }
+    });
+  },
+};
+
+export default todoPlugin;