@meetopenbot/openbot 0.2.7 → 1.0.0

package/dist/tools/thread-title.js

@@ -0,0 +1,57 @@
+import z from "zod";
+function formatTitleOutput(title) {
+    return `Job title set to ${title}.`;
+}
+export const toolDefinitions = {
+    set_thread_title: {
+        description: "Set this job's title. Use a concise, human-readable name (e.g. \"Project Brainstorming\", not \"project-brainstorm\"). Call once when the thread is unnamed; call again only if the topic clearly changes.",
+        inputSchema: z.object({
+            title: z
+                .string()
+                .min(1)
+                .describe("Concise thread title shown in the job list."),
+        }),
+    },
+};
+export const tools = {
+    set_thread_title: {
+        ...toolDefinitions.set_thread_title,
+        execute: async (rawArgs, ctx) => {
+            try {
+                const channelId = ctx.channelId ?? ctx.state.channelId ?? "";
+                const threadId = ctx.threadId ?? ctx.state.threadId;
+                if (!channelId || !threadId) {
+                    throw new Error("Missing channelId or threadId for set_thread_title");
+                }
+                const data = (rawArgs ?? {});
+                const title = typeof data.title === "string" ? data.title.trim() : "";
+                if (!title) {
+                    throw new Error("title is required");
+                }
+                await ctx.storage.patchThreadState({
+                    channelId,
+                    threadId,
+                    state: {
+                        name: title,
+                        isSmartNamed: true,
+                    },
+                });
+                ctx.state.threadDetails = await ctx.storage.getThreadDetails({
+                    channelId,
+                    threadId,
+                });
+                const output = formatTitleOutput(title);
+                return {
+                    success: true,
+                    title,
+                    output,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                return { success: false, error: message, output: message };
+            }
+        },
+    },
+};
+export const threadTitleTools = tools;

package/dist/tools/todo.js

@@ -46,7 +46,7 @@ function todoListWidget(args) {
             display: 'collapsed',
             state: 'open',
         },
-        meta: {},
+        meta: args.meta,
     };
 }
 const todoItemSchema = z.object({
@@ -56,7 +56,7 @@ const todoItemSchema = z.object({
         .enum(['pending', 'in_progress', 'completed', 'cancelled'])
         .describe('Todo status. At most one item may be in_progress.'),
 });
-const todoToolDefinitions = {
+export const toolDefinitions = {
     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({
@@ -71,76 +71,57 @@ const todoToolDefinitions = {
         inputSchema: z.object({}),
     },
 };
-export const todoPlugin = {
-    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 };
+export const tools = {
+    todo_write: {
+        ...toolDefinitions.todo_write,
+        execute: async (rawArgs, ctx) => {
             try {
-                const channelId = context.state.channelId;
-                const threadId = context.state.threadId;
+                const channelId = ctx.channelId ?? ctx.state.channelId ?? '';
+                const threadId = ctx.threadId ?? ctx.state.threadId;
                 if (!channelId || !threadId) {
                     throw new Error('Missing channelId or threadId for todo_write');
                 }
-                const items = event.data.items;
+                const items = (rawArgs ?? {}).items;
                 const list = await todoService.writeTodos({ channelId, threadId, items });
-                const runId = context.state.runId;
+                const runId = ctx.runId ?? ctx.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,
-                };
+                await ctx.emit(todoListWidget({
+                    runId,
+                    list,
+                    meta: {
+                        agentId: ctx.agentId,
+                        threadId,
+                        runId,
+                        toolCallId: ctx.toolCallId,
+                    },
+                }));
+                return { success: true, list, output: formatTodoOutput(list) };
             }
             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,
-                };
+                return { success: false, error: message, output: message };
             }
-        });
-        builder.on('action:todo_read', async function* (event, context) {
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        },
+    },
+    todo_read: {
+        ...toolDefinitions.todo_read,
+        execute: async (_rawArgs, ctx) => {
             try {
-                const channelId = context.state.channelId;
-                const threadId = context.state.threadId;
+                const channelId = ctx.channelId ?? ctx.state.channelId ?? '';
+                const threadId = ctx.threadId ?? ctx.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,
-                };
+                return { success: true, list, output: formatTodoOutput(list) };
             }
             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,
-                };
+                return { success: false, error: message, output: message };
             }
-        });
+        },
     },
 };
-export default todoPlugin;
+export const todoTools = tools;

package/dist/types.js

@@ -1,12 +1,4 @@
 export { definePlugin } from "@meetopenbot/plugin-sdk";
-export function asActionBuilder(builder) {
-    return {
-        on(action, handler) {
-            builder.on(`action:${action}`, handler);
-        },
-    };
-}
-/** Type-safe plugin definition for the extended OpenBot host context. */
 export function defineOpenbotPlugin(definition) {
     return definition;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "0.2.7",
+  "version": "1.0.0",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,7 +24,7 @@
     "@ai-sdk/openai": "^4.0.46",
     "ai": "^7.0.77",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^0.5.1"
+    "@meetopenbot/plugin-sdk": "^1.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",

package/dist/tools/bash.js

@@ -1,432 +0,0 @@
-import { z } from 'zod';
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-import { asActionBuilder } from '../types.js';
-const DEFAULT_TIMEOUT_MS = 120000;
-const FOREGROUND_DEV_TIMEOUT_MS = 5000;
-const TIMEOUT_EXIT_CODE = 124;
-const MAX_LOG_CHARS = 32000;
-const DEFAULT_SESSION_ID = 'default';
-const DEV_SERVER_READY_PATTERNS = [
-    /\bready in \d+/i,
-    /\blocal\s+https?:\/\//i,
-    /\blistening on\b/i,
-    /\bstarted server on\b/i,
-    /\bwatching for file changes\b/i,
-];
-const isBackgroundedCommand = (command) => {
-    const trimmed = command.trim();
-    return /\s&\s*$/.test(trimmed) || /\bnohup\b/.test(trimmed) || /\bdisown\b/.test(trimmed);
-};
-const looksLikeForegroundDevServer = (command) => {
-    const trimmed = command.trim();
-    if (isBackgroundedCommand(trimmed))
-        return false;
-    return (/\b(pnpm|npm|yarn|bun)\s+(run\s+)?dev\b/.test(trimmed) ||
-        /\b(astro|vite|next|nuxt|remix)\s+dev\b/.test(trimmed) ||
-        /\bpnpm\s+start\b/.test(trimmed) ||
-        /\bnpm\s+run\s+start\b/.test(trimmed));
-};
-const resolveExecTimeoutMs = (command) => looksLikeForegroundDevServer(command) ? FOREGROUND_DEV_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
-const isDevServerReady = (output) => DEV_SERVER_READY_PATTERNS.some((pattern) => pattern.test(output));
-const formatTimeoutOutput = (partialOutput, timeoutMs, ready) => {
-    const seconds = Math.round(timeoutMs / 1000);
-    const statusLine = ready
-        ? `[shell_exec timed out after ${seconds}s — process is still running and appears ready. Use shell_view to confirm the URL/port. Do not start a duplicate server.]`
-        : `[shell_exec timed out after ${seconds}s — process may still be starting. Poll with shell_wait then shell_view until ready. Do not start a duplicate server.]`;
-    const body = partialOutput.trim();
-    return body ? `${body}\n\n${statusLine}` : statusLine;
-};
-const shellToolDefinitions = {
-    shell_exec: {
-        description: 'Execute a command in a stateful shell session. Blocks until the command exits. Foreground dev servers (e.g. `pnpm dev` without `&`) return after ~15s with output so far — poll with shell_wait/shell_view until ready. Prefer `pnpm dev &` to return immediately.',
-        inputSchema: z.object({
-            id: z
-                .string()
-                .describe('Shell session identifier (e.g. "default", "server"). Reuse ids to keep state.'),
-            exec_dir: z
-                .string()
-                .describe('Working directory for this command (absolute path).'),
-            command: z.string().describe('Shell command to execute.'),
-        }),
-    },
-    shell_view: {
-        description: 'View recent output from a shell session. Use to poll dev-server logs after shell_exec times out or after backgrounding with `&`.',
-        inputSchema: z.object({
-            id: z.string().describe('Shell session identifier.'),
-        }),
-    },
-    shell_wait: {
-        description: 'Wait N seconds, then return recent shell output. Use with shell_view to poll dev-server startup after shell_exec times out (e.g. shell_wait 3s, then shell_view, repeat until ready).',
-        inputSchema: z.object({
-            id: z.string().describe('Shell session identifier.'),
-            seconds: z.number().int().min(1).max(300).describe('Seconds to wait.'),
-        }),
-    },
-    shell_write_to_process: {
-        description: 'Write input to a running process in a shell session. Use to answer interactive prompts.',
-        inputSchema: z.object({
-            id: z.string().describe('Shell session identifier.'),
-            input: z.string().describe('Input to send to the process.'),
-            press_enter: z
-                .boolean()
-                .describe('Whether to press Enter after the input.'),
-        }),
-    },
-    shell_kill_process: {
-        description: 'Send interrupt to the active process in a shell session (e.g. stop a dev server).',
-        inputSchema: z.object({
-            id: z.string().describe('Shell session identifier.'),
-        }),
-    },
-};
-const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-let resolvePathFn = (p) => p;
-const isUsableExecDir = (value) => path.isAbsolute(value) || value.startsWith('~/');
-const resolveCwd = (context, execDir) => {
-    const channelCwd = typeof context.state.channelDetails?.cwd === 'string'
-        ? context.state.channelDetails.cwd.trim()
-        : '';
-    const requested = typeof execDir === 'string' ? execDir.trim() : '';
-    const raw = (requested && isUsableExecDir(requested) ? requested : '') ||
-        channelCwd ||
-        requested ||
-        process.cwd();
-    return resolvePathFn(raw);
-};
-const sessionKey = (channelId, id) => `${channelId}:${id}`;
-class ShellSession {
-    constructor(channelId, id, cwd) {
-        this.channelId = channelId;
-        this.id = id;
-        this.cwd = cwd;
-        this.output = '';
-        this.process = null;
-        this.execQueue = Promise.resolve();
-        this.spawn();
-    }
-    spawn() {
-        this.process = spawn('bash', [], {
-            cwd: this.cwd,
-            env: process.env,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        this.process.stdout?.on('data', (chunk) => this.append(chunk.toString()));
-        this.process.stderr?.on('data', (chunk) => this.append(chunk.toString()));
-        this.process.on('exit', () => {
-            this.process = null;
-            this.rejectPending(new Error('Shell session exited unexpectedly'));
-        });
-        this.process.on('error', (error) => {
-            this.rejectPending(error);
-        });
-    }
-    rejectPending(error) {
-        if (!this.pending)
-            return;
-        clearTimeout(this.pending.timer);
-        this.pending.reject(error);
-        this.pending = undefined;
-    }
-    append(chunk) {
-        this.output += chunk;
-        if (this.output.length > MAX_LOG_CHARS) {
-            this.output = this.output.slice(-MAX_LOG_CHARS);
-        }
-        if (!this.pending)
-            return;
-        const tail = this.output.slice(this.pending.startLen);
-        const markerIndex = tail.indexOf(this.pending.marker);
-        if (markerIndex === -1)
-            return;
-        const afterMarker = tail.slice(markerIndex + this.pending.marker.length);
-        const match = afterMarker.match(/^:(\d+)/);
-        const exitCode = match ? Number.parseInt(match[1], 10) : 0;
-        const output = tail.slice(0, markerIndex).trimEnd();
-        clearTimeout(this.pending.timer);
-        this.pending.resolve({ exitCode, output });
-        this.pending = undefined;
-    }
-    ensureProcess() {
-        if (!this.process?.stdin) {
-            this.spawn();
-        }
-        if (!this.process?.stdin) {
-            throw new Error('Failed to start shell session');
-        }
-        return this.process;
-    }
-    enqueue(fn) {
-        const next = this.execQueue.then(fn, fn);
-        this.execQueue = next.catch(() => undefined);
-        return next;
-    }
-    view() {
-        return this.output.slice(-8000);
-    }
-    async exec(command, execDir) {
-        return this.enqueue(() => this.execInternal(command, execDir));
-    }
-    execInternal(command, execDir) {
-        const process = this.ensureProcess();
-        const marker = `__OPENBOT_${randomUUID().replace(/-/g, '')}__`;
-        const script = `cd ${shellQuote(execDir)} && ${command}; printf '\\n${marker}:%s\\n' "$?"`;
-        const timeoutMs = resolveExecTimeoutMs(command);
-        return new Promise((resolve, reject) => {
-            if (this.pending) {
-                reject(new Error('Shell session is busy'));
-                return;
-            }
-            const startLen = this.output.length;
-            const timer = setTimeout(() => {
-                if (!this.pending)
-                    return;
-                const { startLen: pendingStartLen, timeoutMs: pendingTimeoutMs, resolve: pendingResolve } = this.pending;
-                clearTimeout(this.pending.timer);
-                this.pending = undefined;
-                const partial = this.output.slice(pendingStartLen).trimEnd();
-                const ready = isDevServerReady(partial);
-                pendingResolve({
-                    exitCode: TIMEOUT_EXIT_CODE,
-                    output: formatTimeoutOutput(partial, pendingTimeoutMs, ready),
-                    timedOut: true,
-                    stillRunning: true,
-                });
-            }, timeoutMs);
-            this.pending = { marker, startLen, timeoutMs, resolve, reject, timer };
-            try {
-                process.stdin.write(`${script}\n`);
-            }
-            catch (error) {
-                clearTimeout(timer);
-                this.pending = undefined;
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-    }
-    async wait(seconds) {
-        await new Promise((resolve) => setTimeout(resolve, seconds * 1000));
-        return this.view();
-    }
-    write(input, pressEnter) {
-        const process = this.ensureProcess();
-        process.stdin.write(pressEnter ? `${input}\n` : input);
-    }
-    kill() {
-        const process = this.ensureProcess();
-        process.stdin.write('\x03');
-    }
-    destroy() {
-        this.rejectPending(new Error('Shell session closed'));
-        if (!this.process)
-            return;
-        try {
-            this.process.kill('SIGTERM');
-        }
-        catch {
-            // ignore
-        }
-        this.process = null;
-    }
-}
-const sessions = new Map();
-const getSession = (channelId, id, defaultCwd) => {
-    const key = sessionKey(channelId, id);
-    const existing = sessions.get(key);
-    if (existing)
-        return existing;
-    const session = new ShellSession(channelId, id, defaultCwd);
-    sessions.set(key, session);
-    return session;
-};
-const destroySessionsForChannel = (channelId) => {
-    for (const [key, session] of sessions.entries()) {
-        if (!key.startsWith(`${channelId}:`))
-            continue;
-        session.destroy();
-        sessions.delete(key);
-    }
-};
-const formatResult = (output, extra) => ({
-    success: true,
-    output: output.trim() || '(no output)',
-    ...extra,
-});
-const resolveShellWidgetId = (event) => {
-    const toolCallId = event.meta?.toolCallId;
-    return typeof toolCallId === 'string' ? toolCallId : randomUUID();
-};
-const formatShellWidgetBody = (input, output) => {
-    const inputText = JSON.stringify(input, null, 2);
-    const outputText = output.trim() || '(no output)';
-    return `Input:\n${inputText}\n\nOutput:\n${outputText}`;
-};
-function* emitShellWidgetPending(event, context, tool, input, widgetId) {
-    const threadId = event.meta?.threadId || context.state.threadId;
-    yield {
-        type: 'client:ui:widget',
-        data: {
-            widgetId,
-            kind: 'message',
-            title: tool,
-            body: formatShellWidgetBody(input, '(running...)'),
-            display: 'collapsed',
-            metadata: {
-                type: 'shell:tool',
-                tool,
-                input,
-                status: 'running',
-            },
-        },
-        meta: { agentId: context.state.agentId, threadId },
-    };
-}
-function* emitShellToolResult(event, context, tool, input, result, widgetId) {
-    const threadId = event.meta?.threadId || context.state.threadId;
-    const output = String(result.output ?? '');
-    yield {
-        type: 'client:ui:widget',
-        data: {
-            widgetId,
-            kind: 'message',
-            title: tool,
-            body: formatShellWidgetBody(input, output),
-            state: result.success ? 'submitted' : 'error',
-            display: 'collapsed',
-            metadata: {
-                type: 'shell:tool',
-                tool,
-                input,
-                output,
-                success: result.success,
-                status: result.success ? 'done' : 'error',
-            },
-        },
-        meta: { agentId: context.state.agentId, threadId },
-    };
-    const { output: _output, ...resultData } = result;
-    yield {
-        type: `action:${tool}:result`,
-        data: { ...resultData, output },
-        meta: event.meta,
-    };
-}
-async function* runShellTool(event, context, tool, input, execute) {
-    const widgetId = resolveShellWidgetId(event);
-    yield* emitShellWidgetPending(event, context, tool, input, widgetId);
-    try {
-        const result = await execute();
-        yield* emitShellToolResult(event, context, tool, input, result, widgetId);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown shell error';
-        yield* emitShellToolResult(event, context, tool, input, { success: false, output: message, error: message }, widgetId);
-    }
-}
-const shellPluginRuntime = () => (builder) => {
-    const actions = asActionBuilder(builder);
-    actions.on('shell_exec', async function* (event, context) {
-        const { id, exec_dir, command } = event.data;
-        const sessionId = (id || DEFAULT_SESSION_ID).trim() || DEFAULT_SESSION_ID;
-        const channelId = context.state.channelId;
-        const input = {
-            id: sessionId,
-            exec_dir: exec_dir ?? resolveCwd(context),
-            command: command ?? '',
-        };
-        if (!command?.trim()) {
-            yield* runShellTool(event, context, 'shell_exec', input, async () => ({
-                success: false,
-                output: 'command is required',
-            }));
-            return;
-        }
-        yield* runShellTool(event, context, 'shell_exec', input, async () => {
-            const execDir = resolveCwd(context, exec_dir);
-            const session = getSession(channelId, sessionId, execDir);
-            const result = await session.exec(command, execDir);
-            const success = result.timedOut ? isDevServerReady(result.output) : result.exitCode === 0;
-            return {
-                success,
-                exitCode: result.exitCode,
-                output: result.output.trim() || '(no output)',
-                ...(result.timedOut && { timedOut: true, stillRunning: result.stillRunning }),
-            };
-        });
-    });
-    actions.on('shell_view', async function* (event, context) {
-        const sessionId = (event.data?.id || DEFAULT_SESSION_ID).trim();
-        const channelId = context.state.channelId;
-        const defaultCwd = resolveCwd(context);
-        const input = { id: sessionId };
-        yield* runShellTool(event, context, 'shell_view', input, async () => {
-            const session = getSession(channelId, sessionId, defaultCwd);
-            return formatResult(session.view());
-        });
-    });
-    actions.on('shell_wait', async function* (event, context) {
-        const { id, seconds } = event.data;
-        const sessionId = (id || DEFAULT_SESSION_ID).trim();
-        const channelId = context.state.channelId;
-        const defaultCwd = resolveCwd(context);
-        const waitedSeconds = seconds ?? 5;
-        const input = { id: sessionId, seconds: waitedSeconds };
-        yield* runShellTool(event, context, 'shell_wait', input, async () => {
-            const session = getSession(channelId, sessionId, defaultCwd);
-            const output = await session.wait(waitedSeconds);
-            return formatResult(output, { waitedSeconds });
-        });
-    });
-    actions.on('shell_write_to_process', async function* (event, context) {
-        const { id, input: textInput, press_enter } = event.data;
-        const sessionId = (id || DEFAULT_SESSION_ID).trim();
-        const channelId = context.state.channelId;
-        const defaultCwd = resolveCwd(context);
-        const toolInput = {
-            id: sessionId,
-            input: textInput ?? '',
-            press_enter: press_enter ?? true,
-        };
-        if (!textInput?.trim()) {
-            yield* runShellTool(event, context, 'shell_write_to_process', toolInput, async () => ({
-                success: false,
-                output: 'input is required',
-            }));
-            return;
-        }
-        yield* runShellTool(event, context, 'shell_write_to_process', toolInput, async () => {
-            const session = getSession(channelId, sessionId, defaultCwd);
-            session.write(textInput, toolInput.press_enter);
-            return { success: true, output: 'Input sent to shell session.' };
-        });
-    });
-    actions.on('shell_kill_process', async function* (event, context) {
-        const sessionId = (event.data?.id || DEFAULT_SESSION_ID).trim();
-        const channelId = context.state.channelId;
-        const defaultCwd = resolveCwd(context);
-        const input = { id: sessionId };
-        yield* runShellTool(event, context, 'shell_kill_process', input, async () => {
-            const session = getSession(channelId, sessionId, defaultCwd);
-            session.kill();
-            return { success: true, output: 'Interrupt sent to shell session.' };
-        });
-    });
-    actions.on('delete_channel', async function* (event) {
-        const channelId = event.data?.channelId;
-        if (channelId) {
-            destroySessionsForChannel(channelId);
-        }
-    });
-};
-export const bashPlugin = {
-    id: 'bash',
-    name: 'Shell',
-    description: 'Stateful shell sessions for the channel workspace (Manus-style).',
-    toolDefinitions: shellToolDefinitions,
-    factory: ({ host }) => {
-        resolvePathFn = host.resolvePath;
-        return shellPluginRuntime();
-    },
-};
-export default bashPlugin;