openbot 0.5.4 → 0.5.6

package/src/plugins/preview/index.ts

@@ -1,323 +0,0 @@
-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/todo/index.ts

@@ -1,166 +0,0 @@
-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;

package/src/plugins/todo/service.ts

@@ -1,123 +0,0 @@
-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;
-  },
-};