openbot 0.4.6 → 0.5.4

package/dist/plugins/bash/index.js

@@ -2,194 +2,416 @@ import { z } from 'zod';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { resolvePath } from '../../app/config.js';
-const bashToolDefinitions = {
-    bash: {
-        description: 'Execute a bash command in a stateful session. The working directory and environment variables persist between calls. Use this for all system tasks, file operations, and running development servers.',
+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({
-            command: z.string().describe('The bash command to execute.'),
-            restart: z
-                .boolean()
-                .optional()
-                .describe('Restart the bash session before running the command.'),
+            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.'),
         }),
     },
-    bash_stop: {
-        description: 'Stop the bash session for the current or specified channel.',
+    shell_write_to_process: {
+        description: 'Write input to a running process in a shell session. Use to answer interactive prompts.',
         inputSchema: z.object({
-            channelId: z.string().optional().describe('The channel ID to stop the session for.'),
+            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.'),
         }),
     },
-    bash_list_sessions: {
-        description: 'List all active bash sessions.',
-        inputSchema: z.object({}),
+    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 sessions = new Map();
-const getSession = (channelId, initialCwd) => {
-    let session = sessions.get(channelId);
-    if (!session) {
-        const childProcess = spawn('bash', ['--login'], {
-            cwd: initialCwd,
-            env: { ...process.env, PS1: '' },
+const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+const resolveCwd = (context, execDir) => {
+    const raw = (typeof execDir === 'string' && execDir.trim()) ||
+        context.state.channelDetails?.cwd ||
+        process.cwd();
+    return resolvePath(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'],
         });
-        session = {
-            process: childProcess,
-            cwd: initialCwd,
-            lastActivity: Date.now(),
-        };
-        sessions.set(channelId, session);
-        // Basic error handling for the process
-        childProcess.on('error', (err) => {
-            console.error(`[bash] Session error for channel ${channelId}:`, err);
-            sessions.delete(channelId);
+        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);
         });
-        childProcess.on('exit', () => {
-            sessions.delete(channelId);
+    }
+    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 bashPluginRuntime = () => (builder) => {
-    builder.on('action:bash', async function* (event, context) {
-        const { command, restart } = event.data;
+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) => event.meta?.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) => {
+    builder.on('action: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 initialCwd = resolvePath(context.state.channelDetails?.cwd || process.cwd());
-        if (restart) {
-            const oldSession = sessions.get(channelId);
-            if (oldSession) {
-                oldSession.process.kill();
-                sessions.delete(channelId);
-            }
-        }
-        const session = getSession(channelId, initialCwd);
-        session.lastActivity = Date.now();
-        try {
-            const result = await new Promise((resolve) => {
-                let stdout = '';
-                let stderr = '';
-                let timedOut = false;
-                const sentinel = `__OPENBOT_BASH_DONE_${Math.random().toString(36).substring(7)}__`;
-                const timeoutMs = 60000; // 1 minute timeout for tool calls
-                const timer = setTimeout(() => {
-                    timedOut = true;
-                    // We don't kill the session on timeout, just return what we have
-                    resolve({ exitCode: null, stdout, stderr, timedOut });
-                }, timeoutMs);
-                const onStdout = (data) => {
-                    const str = data.toString();
-                    if (str.includes(sentinel)) {
-                        const parts = str.split(sentinel);
-                        stdout += parts[0];
-                        const exitCodeMatch = parts[1].match(/EXIT:(\d+)/);
-                        const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 0;
-                        cleanup();
-                        resolve({ exitCode, stdout, stderr, timedOut: false });
-                    }
-                    else {
-                        stdout += str;
-                    }
-                };
-                const onStderr = (data) => {
-                    stderr += data.toString();
-                };
-                const cleanup = () => {
-                    clearTimeout(timer);
-                    session.process.stdout?.removeListener('data', onStdout);
-                    session.process.stderr?.removeListener('data', onStderr);
-                };
-                session.process.stdout?.on('data', onStdout);
-                session.process.stderr?.on('data', onStderr);
-                // Execute command and then echo the sentinel with exit code
-                session.process.stdin?.write(`${command}\necho "${sentinel}EXIT:$?"\n`);
-            });
-            yield {
-                type: 'action:bash:result',
-                data: {
-                    success: result.exitCode === 0 && !result.timedOut,
-                    exitCode: result.exitCode,
-                    stdout: result.stdout.trim(),
-                    stderr: result.stderr.trim(),
-                    timedOut: result.timedOut,
-                    output: result.stderr.trim() ? result.stderr.trim() : result.stdout.trim(),
-                },
-                meta: event.meta,
-            };
+        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;
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown bash error';
-            yield {
-                type: 'action:bash:result',
-                data: {
-                    success: false,
-                    exitCode: -1,
-                    stdout: '',
-                    stderr: message,
-                    timedOut: false,
-                    error: message,
-                    output: message,
-                },
-                meta: event.meta,
+        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 }),
             };
-        }
+        });
     });
-    // Add a tool to stop/kill the session
-    builder.on('action:bash_stop', async function* (event, context) {
-        const channelId = event.data?.channelId || context.state.channelId;
-        const session = sessions.get(channelId);
-        if (session) {
-            session.process.kill();
-            sessions.delete(channelId);
-        }
-        yield {
-            type: 'action:bash_stop:result',
-            data: { success: true, output: `Bash session for channel ${channelId} stopped.` },
-            meta: event.meta,
-        };
+    builder.on('action: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());
+        });
     });
-    // Add a tool to list all active sessions
-    builder.on('action:bash_list_sessions', async function* (event, context) {
-        const activeSessions = Array.from(sessions.entries()).map(([channelId, session]) => ({
-            channelId,
-            cwd: session.cwd,
-            lastActivity: session.lastActivity,
-        }));
-        yield {
-            type: 'client:ui:widget',
-            data: {
-                widgetId: randomUUID(),
-                kind: 'list',
-                title: 'Active Bash Sessions',
-                description: `Found ${activeSessions.length} active bash session${activeSessions.length === 1 ? '' : 's'}.`,
-                items: activeSessions.map((s) => ({
-                    id: s.channelId,
-                    label: s.channelId,
-                    description: `CWD: ${s.cwd}`,
-                    status: 'done',
-                    metadata: {
-                        cwd: s.cwd,
-                        lastActivity: s.lastActivity,
-                    },
-                })),
-            },
-            meta: event.meta,
-        };
-        yield {
-            type: 'action:bash_list_sessions:result',
-            data: {
-                success: true,
-                sessions: activeSessions,
-                output: JSON.stringify(activeSessions),
-            },
-            meta: event.meta,
+    builder.on('action: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 });
+        });
+    });
+    builder.on('action: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.' };
+        });
+    });
+    builder.on('action: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.' };
+        });
+    });
+    builder.on('action:delete_channel', async function* (event) {
+        const channelId = event.data?.channelId;
+        if (channelId) {
+            destroySessionsForChannel(channelId);
+        }
     });
 };
 export const bashPlugin = {
     id: 'bash',
-    name: 'Bash',
-    description: 'Stateful bash session for the channel.',
-    toolDefinitions: bashToolDefinitions,
-    factory: () => bashPluginRuntime(),
+    name: 'Shell',
+    description: 'Stateful shell sessions for the channel workspace (Manus-style).',
+    toolDefinitions: shellToolDefinitions,
+    factory: () => shellPluginRuntime(),
 };
 export default bashPlugin;

package/dist/plugins/memory/service.js

@@ -1,13 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+import { getBaseDir } from '../../app/config.js';
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
-const getMemoryDir = () => {
-    const config = loadConfig();
-    return path.join(resolvePath(config.baseDir || DEFAULT_BASE_DIR), 'memory');
-};
+const getMemoryDir = () => path.join(getBaseDir(), 'memory');
 const getLogPath = () => path.join(getMemoryDir(), 'log.jsonl');
 const ensureDir = async () => {
     await fs.mkdir(getMemoryDir(), { recursive: true });

package/dist/plugins/openbot/context.js

@@ -1,4 +1,5 @@
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+import { todoService } from '../todo/service.js';
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
 /**
@@ -43,7 +44,22 @@ export async function buildContext(state, storage) {
         env += `- Thread: ${threadDetails?.name || threadId}\n`;
     }
     sections.push(env);
-    // 2.5 Installed Agents
+    // 2.5 Thread todos
+    if (channelId && threadId) {
+        try {
+            const list = await todoService.getTodos({ channelId, threadId });
+            if (list.items.length > 0) {
+                const formatted = list.items
+                    .map((t) => `- [${t.status}] (${t.id}) ${t.content}`)
+                    .join('\n');
+                sections.push(`## TODOS\n${formatted}`);
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch todos:', error);
+        }
+    }
+    // 2.6 Installed Agents
     if (allAgents.length > 0) {
         const formatted = allAgents
             .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)