openbot 0.4.7 → 0.5.4

package/dist/plugins/preview/index.js

@@ -0,0 +1,267 @@
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+const TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+const TUNNEL_READY_TIMEOUT_MS = 60000;
+const MAX_LOG_CHARS = 8000;
+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({}),
+    },
+};
+const tunnels = new Map();
+const tunnelByChannel = new Map();
+const blockedPorts = () => {
+    const openbotPort = Number(process.env.PORT ?? 4132);
+    return new Set([22, 80, 443, openbotPort]);
+};
+const appendLog = (tunnel, chunk) => {
+    tunnel.logs += chunk;
+    if (tunnel.logs.length > MAX_LOG_CHARS) {
+        tunnel.logs = tunnel.logs.slice(-MAX_LOG_CHARS);
+    }
+};
+const killTunnelProcess = (tunnel) => {
+    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) => {
+    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) => {
+    const tunnelId = tunnelByChannel.get(channelId);
+    if (tunnelId) {
+        removeTunnel(tunnelId);
+    }
+};
+const waitForTunnelUrl = (child, timeoutMs) => 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 += chunk.toString();
+        if (buffer.length > 16000) {
+            buffer = buffer.slice(-16000);
+        }
+        tryParse();
+    };
+    const onExit = (code) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        reject(new Error(`cloudflared exited before providing a tunnel URL (code ${code ?? 'unknown'})`));
+    };
+    const onError = (err) => {
+        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, port) => {
+    const child = spawn('cloudflared', ['tunnel', '--url', `http://127.0.0.1:${port}`, '--no-autoupdate'], {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const tunnel = {
+        id: randomUUID(),
+        channelId,
+        port,
+        url: '',
+        process: child,
+        startedAt: Date.now(),
+        logs: '',
+    };
+    child.stdout?.on('data', (data) => appendLog(tunnel, data.toString()));
+    child.stderr?.on('data', (data) => 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, channelId) => {
+    await storage.patchChannelState({
+        channelId,
+        state: {
+            previewUrl: null,
+            previewPort: null,
+            previewExposedAt: null,
+        },
+    });
+};
+const previewPluginRuntime = (storage) => (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,
+            };
+            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,
+            };
+            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,
+            };
+        }
+        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,
+            };
+        }
+    });
+    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,
+        };
+    });
+    builder.on('action:delete_channel', async function* (event) {
+        const channelId = event.data?.channelId;
+        if (channelId) {
+            stopPreviewForChannel(channelId);
+        }
+    });
+};
+export const previewPlugin = {
+    id: 'preview',
+    name: 'Preview',
+    description: 'Temporary public preview URLs via Cloudflare quick tunnels.',
+    toolDefinitions: previewToolDefinitions,
+    factory: ({ storage }) => previewPluginRuntime(storage),
+};
+export default previewPlugin;

package/dist/plugins/storage/index.js

@@ -32,7 +32,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()
@@ -44,11 +44,11 @@ const storageToolDefinitions = {
             value.cwd !== undefined, { message: 'Provide at least one of state, spec, or cwd.' }),
     },
     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: {

package/dist/plugins/storage/service.js

@@ -1,5 +1,6 @@
 import { ORCHESTRATOR_AGENT_ID, STATE_AGENT_ID } from '../../app/agent-ids.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, getDefaultChannelCwd, loadConfig, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
+import { assertCloudSystemAgentPluginsMutable, CLOUD_SYSTEM_MODEL, isCloudMode, } from '../../app/cloud-mode.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_CHANNELS_DIR, getBaseDir, getDefaultChannelCwd, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
 import fs from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
@@ -8,13 +9,11 @@ import crypto from 'node:crypto';
 import matter from 'gray-matter';
 import { openbotPlugin } from '../openbot/index.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
+import { enrichOpenbotPluginDescriptor, listRegistryModelOptions, } from '../../services/plugins/model-registry.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();
-    return resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-};
+const resolveBaseDir = () => getBaseDir();
 const ENTITY_SVG_CANDIDATE_NAMES = ['avatar.svg', 'icon.svg', 'image.svg', 'logo.svg'];
 const toSvgDataUrl = (svg) => `data:image/svg+xml;base64,${Buffer.from(svg, 'utf-8').toString('base64')}`;
 let bundledSystemAgentImage;
@@ -85,11 +84,37 @@ const SYSTEM_DEFAULT_PLUGINS = [
         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 = [
+    {
+        id: 'openbot',
+        config: {
+            model: CLOUD_SYSTEM_MODEL,
+            approval: {
+                actions: ['action:shell_exec', 'action:create_channel', 'action:delete_channel'],
             },
         },
     },
 ];
+function mergeCloudSystemPluginRefs(defaults, diskRefs) {
+    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 = [
     { id: 'storage' },
@@ -97,24 +122,41 @@ const STATE_DEFAULT_PLUGINS = [
 ];
 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) {
+    const defaultPlugins = isCloudMode() ? CLOUD_SYSTEM_DEFAULT_PLUGINS : SYSTEM_DEFAULT_PLUGINS;
     const defaults = {
         id: SYSTEM_AGENT_ID,
         name: 'OpenBot',
         image: getBundledSystemAgentImage(),
         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 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;
-    const diskInstructions = overrides.instructions?.trim();
-    const instructions = diskInstructions && diskInstructions.length > 0 ? diskInstructions : defaults.instructions;
     return {
         ...defaults,
         ...overrides,
@@ -775,11 +817,13 @@ export const storageService = {
         return Array.from(deduped.values()).filter((agent) => !agent.hidden);
     },
     getPlugins: async () => {
-        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();
         for (const plugin of merged) {
             if (!deduped.has(plugin.id)) {
@@ -839,6 +883,7 @@ export const storageService = {
     },
     createAgent: async ({ agentId, name, description = '', image, hidden, instructions, plugins, }) => {
         assertAgentIdFormat(agentId);
+        assertCloudSystemAgentPluginsMutable(agentId, plugins);
         const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
         const agentMdPath = path.join(agentDir, 'AGENT.md');
         try {
@@ -874,6 +919,7 @@ export const storageService = {
     },
     updateAgent: async ({ agentId, name, description, image, hidden, instructions, plugins, }) => {
         assertAgentIdFormat(agentId);
+        assertCloudSystemAgentPluginsMutable(agentId, plugins);
         const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
         const agentMdPath = path.join(agentDir, 'AGENT.md');
         let raw;

package/dist/plugins/todo/index.js

@@ -1,53 +1,146 @@
 import z from 'zod';
-const todoStatus = z.enum(['pending', 'in_progress', 'done', 'cancelled']);
+import { todoService } 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) {
+    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) {
+    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) {
+    const items = args.list.items.map((t) => ({
+        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: {},
+    };
+}
+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: 'Manage the shared todo list (create, update, append, remove).',
+        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({
-            todos: z
-                .array(z.object({
-                id: z
-                    .string()
-                    .optional()
-                    .describe('Stable id. Reuse existing ids to update; omit to create.'),
-                content: z.string().min(1).optional().describe('What needs to be done.'),
-                status: todoStatus.optional().describe('Defaults to `pending`.'),
-                assignee: z
-                    .string()
-                    .optional()
-                    .describe('Suggested agent id for this step (plain id, no @ prefix).'),
-                deleted: z.boolean().optional().describe('If true, remove this item.'),
-            }))
-                .describe('List of todo items to write or patch.'),
-            merge: z
-                .boolean()
-                .optional()
-                .describe('If true (default), patches existing items by id and appends new ones. If false, replaces the entire list.'),
+            items: z
+                .array(todoItemSchema)
+                .max(20)
+                .describe('Full todo list for this thread (max 20). Replaces any previous list.'),
         }),
     },
-    delegate_to_agent: {
-        description: 'Run a worker agent on a self-contained task and return their output. ' +
-            'Call when a todo step should be executed by a participant; review the result and update todos before delegating again or replying to the user.',
-        inputSchema: z.object({
-            agentId: z
-                .string()
-                .min(1)
-                .describe('Worker agent id from channel participants (plain id, no @ prefix).'),
-            task: z
-                .string()
-                .min(1)
-                .describe('Complete instruction for the worker — they do not see the full todo plan.'),
-            todoId: z.string().optional().describe('Optional todo id this step relates to.'),
-        }),
+    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 = {
     id: 'todo',
     name: 'Todo',
-    description: 'Shared todo list and worker delegation for multi-step orchestration.',
+    description: 'Thread-scoped todo checklist for multi-step task tracking (todo_write / todo_read).',
     toolDefinitions: todoToolDefinitions,
-    factory: () => () => {
-        // Handlers live in bus/services.ts.
+    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.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,
+                };
+            }
+            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,
+                };
+            }
+        });
+        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,
+                };
+            }
+            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,
+                };
+            }
+        });
     },
 };
 export default todoPlugin;