openbot 0.4.0 → 0.4.2

package/dist/app/cli.js

@@ -16,7 +16,7 @@ function checkNodeVersion() {
     }
 }
 checkNodeVersion();
-program.name('openbot').description('OpenBot CLI').version('0.4.0');
+program.name('openbot').description('OpenBot CLI').version('0.4.2');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/app/config.js

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 export const DEFAULT_BASE_DIR = '~/.openbot';
+/** Default parent directory for per-channel working directories (user-facing workspace). */
+export const DEFAULT_CHANNELS_WORKSPACE_DIR = '~/openbot';
 export const DEFAULT_PLUGINS_DIR = 'plugins';
 export const DEFAULT_AGENTS_DIR = 'agents';
 export const DEFAULT_CHANNELS_DIR = 'channels';
@@ -12,6 +14,14 @@ export const DEFAULT_MARKETPLACE_REGISTRY_URL = 'https://raw.githubusercontent.c
 export function resolvePath(p) {
     return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
+/** Default absolute cwd for a channel when none is provided at creation time. */
+export function getDefaultChannelCwd(channelId) {
+    const id = channelId.trim();
+    if (!id) {
+        throw new Error('channelId is required');
+    }
+    return resolvePath(`${DEFAULT_CHANNELS_WORKSPACE_DIR}/${id}`);
+}
 export function loadConfig() {
     const configPath = path.join(os.homedir(), '.openbot', CONFIG_FILE);
     if (fs.existsSync(configPath)) {

package/dist/app/server.js

@@ -12,7 +12,10 @@ import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 import { processService } from '../services/process.js';
 import { runAgent, STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
 import { initPlugins } from '../services/plugins/registry.js';
+import { storageService } from '../plugins/storage/service.js';
+import { buildWorkspaceFileUrl, getPublicBaseUrl, openChannelFileStream, } from '../plugins/storage/files.js';
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
+import { abortRegistry, abortKey } from '../services/abort.js';
 export async function startServer(options = {}) {
     const publishEventSchema = z
         .object({
@@ -36,6 +39,9 @@ export async function startServer(options = {}) {
     await fs.mkdir(agentsDir, { recursive: true });
     await fs.mkdir(pluginsDir, { recursive: true });
     initPlugins(pluginsDir);
+    // Pre-warm caches for agents and plugins to speed up first UI load
+    storageService.getAgents().catch((err) => console.warn('[server] Failed to pre-warm agents cache', err));
+    storageService.getPlugins().catch((err) => console.warn('[server] Failed to pre-warm plugins cache', err));
     const getContext = (req) => {
         const channelId = req.get('x-openbot-channel-id') || req.query.channelId || (req.body && req.body.channelId);
         const threadId = req.get('x-openbot-thread-id') || req.query.threadId || (req.body && req.body.threadId);
@@ -48,7 +54,7 @@ export async function startServer(options = {}) {
             req.query.responseType ||
             (req.body && req.body.responseType);
         return {
-            channelId: (channelId || (threadId ? 'general' : 'general')), // Default to general if none
+            channelId: (channelId || (threadId ? 'uncategorized' : 'uncategorized')), // Default to uncategorized if none
             threadId: threadId,
             agentId: agentId,
             runId: runId,
@@ -59,8 +65,15 @@ export async function startServer(options = {}) {
     const getRunKey = (runId, agentId, channelId, threadId) => `${runId}:${agentId}:${channelId}:${threadId || ''}`;
     const sendToClientKey = (clientKey, chunk) => {
         const threadClients = clients.get(clientKey);
-        if (!threadClients)
+        if (!threadClients || threadClients.length === 0)
             return;
+        // Auto-detect "read" state: if someone is listening, they just "read" this event.
+        if (chunk.id && clientKey !== GLOBAL_CHANNEL_ID) {
+            const parts = clientKey.split(':');
+            const channelId = parts[0];
+            const threadId = parts[1]; // undefined if no ":"
+            storageService.setLastRead({ channelId, threadId, lastReadEventId: chunk.id }).catch(() => { });
+        }
         threadClients.forEach((client) => {
             if (!client.writableEnded) {
                 client.write(`data: ${JSON.stringify(chunk)}\n\n`);
@@ -103,8 +116,31 @@ export async function startServer(options = {}) {
             data: { channels },
         };
     };
+    // Drop every tracked run for a channel/thread. A stop aborts the whole
+    // chain (parent + delegated sub-agents), but the sub-agents' `agent:run:end`
+    // events can be swallowed when the parent run loop breaks on abort, leaving
+    // orphaned entries that keep a channel falsely "active". Purging by
+    // channel/thread guarantees the snapshot self-heals after a stop.
+    const purgeActiveRunsForThread = (channelId, threadId) => {
+        const target = threadId || undefined;
+        for (const [key, run] of activeRuns) {
+            if (run.channelId === channelId && (run.threadId || undefined) === target) {
+                activeRuns.delete(key);
+            }
+        }
+    };
     app.use(cors());
-    app.use(express.json({ limit: '20mb' }));
+    const resolvePublicBaseUrl = () => getPublicBaseUrl(PORT, config.publicUrl);
+    app.use((req, res, next) => {
+        const isWorkspaceUpload = req.method === 'POST' &&
+            req.path === '/api/publish' &&
+            req.get('x-openbot-event-type') === 'action:storage:upload-file';
+        if (isWorkspaceUpload) {
+            express.raw({ type: () => true, limit: '100mb' })(req, res, next);
+            return;
+        }
+        express.json({ limit: '20mb' })(req, res, next);
+    });
     app.get('/api/health', (req, res) => {
         res.json({ status: 'ok', version: pkg.version });
     });
@@ -128,6 +164,18 @@ export async function startServer(options = {}) {
             clients.set(clientKey, []);
         }
         clients.get(clientKey).push(res);
+        // Auto-detect "read" state on connection: mark the latest event as seen.
+        if (channelId !== GLOBAL_CHANNEL_ID) {
+            storageService
+                .getEvents({ channelId, threadId })
+                .then((events) => {
+                const latestId = events[events.length - 1]?.id;
+                if (latestId) {
+                    return storageService.setLastRead({ channelId, threadId, lastReadEventId: latestId });
+                }
+            })
+                .catch(() => { });
+        }
         if (channelId === GLOBAL_CHANNEL_ID) {
             const snapshot = buildActiveRunsSnapshot();
             ensureEventId(snapshot);
@@ -155,6 +203,53 @@ export async function startServer(options = {}) {
         });
     });
     app.post('/api/publish', async (req, res) => {
+        if (req.get('x-openbot-event-type') === 'action:storage:upload-file') {
+            const channelId = req.get('x-openbot-channel-id') ||
+                (typeof req.query.channelId === 'string' ? req.query.channelId : undefined);
+            const filePath = req.get('x-openbot-file-path');
+            const overwrite = req.get('x-openbot-file-overwrite') === 'true';
+            if (!channelId?.trim()) {
+                res.status(400).json({ error: 'channelId is required' });
+                return;
+            }
+            if (!filePath?.trim()) {
+                res.status(400).json({ error: 'x-openbot-file-path header is required' });
+                return;
+            }
+            const body = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
+            if (body.length === 0) {
+                res.status(400).json({ error: 'Request body is empty' });
+                return;
+            }
+            try {
+                const result = await storageService.uploadChannelFile({
+                    channelId: channelId.trim(),
+                    path: filePath.trim(),
+                    body,
+                    overwrite,
+                });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId: channelId.trim(),
+                    filePath: result.path,
+                });
+                res.json({
+                    type: 'action:storage:upload-file:result',
+                    data: { success: true, ...result, url },
+                });
+            }
+            catch (error) {
+                res.status(400).json({
+                    type: 'action:storage:upload-file:result',
+                    data: {
+                        success: false,
+                        path: filePath,
+                        error: error instanceof Error ? error.message : 'Upload failed',
+                    },
+                });
+            }
+            return;
+        }
         const parseResult = publishEventSchema.safeParse(req.body);
         if (!parseResult.success) {
             res.status(400).json({
@@ -169,6 +264,76 @@ export async function startServer(options = {}) {
             res.status(400).json({ error: 'channelId is required' });
             return;
         }
+        if (event.type === 'action:storage:write-file') {
+            const data = (event.data ?? {});
+            if (!data.path?.trim()) {
+                res.status(400).json({
+                    type: 'action:storage:write-file:result',
+                    data: { success: false, path: '', error: 'path is required' },
+                });
+                return;
+            }
+            if (typeof data.content !== 'string') {
+                res.status(400).json({
+                    type: 'action:storage:write-file:result',
+                    data: { success: false, path: data.path, error: 'content is required' },
+                });
+                return;
+            }
+            try {
+                const result = await storageService.writeChannelFile({
+                    channelId,
+                    path: data.path.trim(),
+                    content: data.content,
+                    encoding: data.encoding ?? 'utf8',
+                    overwrite: data.overwrite ?? false,
+                });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId,
+                    filePath: result.path,
+                });
+                res.json({
+                    type: 'action:storage:write-file:result',
+                    data: { success: true, ...result, url },
+                });
+            }
+            catch (error) {
+                res.status(400).json({
+                    type: 'action:storage:write-file:result',
+                    data: {
+                        success: false,
+                        path: data.path,
+                        error: error instanceof Error ? error.message : 'Write failed',
+                    },
+                });
+            }
+            return;
+        }
+        // Stop request: cancel the in-flight run (and any delegated sub-agents in the
+        // same thread) instead of spinning up a new agent turn.
+        if (event.type === 'action:agent_run_stop') {
+            const data = (event.data ?? {});
+            const targetChannelId = data.channelId || channelId;
+            const targetThreadId = data.threadId || threadId;
+            const stopped = abortRegistry.abort(abortKey(targetChannelId, targetThreadId));
+            purgeActiveRunsForThread(targetChannelId, targetThreadId);
+            const stoppedEvent = {
+                type: 'agent:run:stopped',
+                data: {
+                    runId: data.runId || runId,
+                    agentId: data.agentId || agentId || ORCHESTRATOR_AGENT_ID,
+                    channelId: targetChannelId,
+                    threadId: targetThreadId,
+                    reason: data.reason,
+                },
+            };
+            ensureEventId(stoppedEvent);
+            sendToClientKey(getClientKey(targetChannelId, targetThreadId), stoppedEvent);
+            sendToClientKey(GLOBAL_CHANNEL_ID, stoppedEvent);
+            res.json({ success: stopped });
+            return;
+        }
         const onEvent = async (chunk, state) => {
             const targetChannelId = state?.channelId || channelId;
             const targetThreadId = state?.threadId || threadId;
@@ -184,6 +349,9 @@ export async function startServer(options = {}) {
             else if (chunk.type === 'agent:run:end') {
                 activeRuns.delete(getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId));
             }
+            else if (chunk.type === 'agent:run:stopped') {
+                purgeActiveRunsForThread(chunk.data.channelId, chunk.data.threadId);
+            }
             sendToClientKey(targetClientKey, chunk);
             if (chunk.type === 'agent:run:start' ||
                 chunk.type === 'agent:run:end' ||
@@ -199,6 +367,7 @@ export async function startServer(options = {}) {
                 event,
                 channelId,
                 threadId,
+                publicBaseUrl: resolvePublicBaseUrl(),
                 onEvent,
             });
             res.sendStatus(200);
@@ -225,6 +394,33 @@ export async function startServer(options = {}) {
             return;
         }
         const { channelId, threadId, agentId, runId } = getContext(req);
+        if (event.type === 'action:storage:serve-file') {
+            const filePath = event.data?.path;
+            if (!channelId?.trim()) {
+                res.status(400).json({ error: 'channelId is required' });
+                return;
+            }
+            if (!filePath?.trim()) {
+                res.status(400).json({ error: 'path is required' });
+                return;
+            }
+            try {
+                const { abs, size, mimeType } = await storageService.getChannelFileStat({
+                    channelId,
+                    path: filePath.trim(),
+                });
+                res.setHeader('Content-Type', mimeType);
+                res.setHeader('Content-Length', String(size));
+                res.setHeader('Cache-Control', 'private, max-age=3600');
+                openChannelFileStream(abs).pipe(res);
+            }
+            catch (error) {
+                res.status(404).json({
+                    error: error instanceof Error ? error.message : 'File not found',
+                });
+            }
+            return;
+        }
         const events = [];
         const onEvent = async (chunk) => {
             events.push(chunk);
@@ -238,6 +434,7 @@ export async function startServer(options = {}) {
                 channelId,
                 threadId,
                 persistEvents: false,
+                publicBaseUrl: resolvePublicBaseUrl(),
                 onEvent,
             });
             res.json({ events });

package/dist/harness/index.js

@@ -3,6 +3,9 @@ import { ensureEventId } from '../app/utils.js';
 import { storageService } from '../plugins/storage/service.js';
 import { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../app/agent-ids.js';
 import { resolvePlugin } from '../services/plugins/registry.js';
+import { abortRegistry, abortKey } from '../services/abort.js';
+import { loadConfig } from '../app/config.js';
+import { getPublicBaseUrl } from '../plugins/storage/files.js';
 export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
 async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId, }) {
     ensureEventId(chunk);
@@ -30,6 +33,12 @@ async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onE
 export async function runAgent(options) {
     const { runId, agentId, event, channelId, threadId, onEvent } = options;
     const persistEvents = options.persistEvents !== false;
+    let publicBaseUrl = options.publicBaseUrl;
+    if (!publicBaseUrl) {
+        const config = loadConfig();
+        const port = Number(config.port ?? process.env.PORT ?? 4132);
+        publicBaseUrl = getPublicBaseUrl(port, config.publicUrl);
+    }
     const parentAgentId = event.meta?.parentAgentId;
     const parentToolCallId = event.meta?.parentToolCallId;
     const agentDetails = await storageService.getAgentDetails({ agentId });
@@ -40,6 +49,10 @@ export async function runAgent(options) {
         threadId,
         event,
     });
+    // Shared per-thread abort signal so a stop request cancels this run and any
+    // delegated sub-agent runs (which execute in the same channel/thread).
+    const runKey = abortKey(channelId, threadId);
+    const abortSignal = abortRegistry.acquire(runKey);
     await emitEvent({
         type: 'agent:run:start',
         data: { runId, agentId, channelId, threadId },
@@ -64,11 +77,15 @@ export async function runAgent(options) {
                 config: ref.config ?? {},
                 storage: storageService,
                 tools,
+                publicBaseUrl,
+                abortSignal,
             }));
         }
         const runtime = builder.build();
         const generator = runtime.run(event, { runId, state });
         for await (const outputEvent of generator) {
+            if (abortSignal.aborted)
+                break;
             await emitEvent(outputEvent, state, {
                 persistEvents,
                 channelId,
@@ -83,6 +100,7 @@ export async function runAgent(options) {
         console.error(`[harness] Error running agent ${agentId}:`, error);
     }
     finally {
+        abortRegistry.release(runKey);
         await emitEvent({
             type: 'agent:run:end',
             data: { runId, agentId, channelId, threadId },

package/dist/plugins/approval/index.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 /**
  * `approval` — gates protected tool calls behind a UI confirmation widget.
  *
- * This is a simplified version that intercepts specified actions (default: shell_exec)
+ * This is a simplified version that intercepts specified actions (default: bash)
  * and requires user approval before they are allowed to proceed.
  */
 // In-memory tracking for pending approval IDs with TTL (shared across plugin instances)
@@ -12,21 +12,19 @@ export const approvalPlugin = {
     id: 'approval',
     name: 'Approval',
     description: 'Gate protected tool calls behind a UI confirmation widget.',
-    factory: ({ config }) => (builder) => {
-        // Actions that require approval. Defaults to shell_exec.
-        const actionsToApprove = config.actions || ['action:shell_exec'];
+    factory: ({ config, storage }) => (builder) => {
+        // Actions that require approval. Defaults to bash.
+        const actionsToApprove = config.actions || ['action:bash'];
         for (const action of actionsToApprove) {
             builder.intercept(action, (event, context) => {
                 // If already approved in this flow, let it pass to the actual handler
                 if (event.meta?.approvalStatus === 'approved')
                     return event;
                 // Otherwise, intercept and ask for approval via a UI widget
-                const displayData = action === 'action:shell_exec'
-                    ? `\`\`\`bash\n${event.data.command}\n\`\`\``
-                    : `\`\`\`json\n${JSON.stringify(event.data, null, 2)}\n\`\`\``;
+                const displayData = JSON.stringify(event?.data) || '';
                 const widgetId = randomUUID();
                 pendingApprovals.set(widgetId, Date.now());
-                context.suspend({
+                return {
                     type: 'client:ui:widget',
                     data: {
                         widgetId,
@@ -43,7 +41,7 @@ export const approvalPlugin = {
                         ],
                     },
                     meta: { agentId: context.state.agentId, threadId: context.state.threadId },
-                });
+                };
             });
         }
         // Handle the user's response from the UI widget
@@ -67,6 +65,7 @@ export const approvalPlugin = {
             pendingApprovals.delete(widgetId);
             const originalEvent = metadata.originalEvent;
             const approved = actionId === 'approve';
+            const displayData = JSON.stringify(event?.data) || '';
             // Yield a "responded" widget update to the UI
             yield {
                 type: 'client:ui:widget',
@@ -74,7 +73,7 @@ export const approvalPlugin = {
                     widgetId,
                     kind: 'message',
                     title: `Action ${approved ? 'Approved' : 'Denied'}`,
-                    body: `The request for \`${originalEvent.type}\` was ${approved ? 'approved' : 'denied'}.`,
+                    body: displayData,
                     state: approved ? 'submitted' : 'cancelled',
                     display: 'collapsed',
                     disabled: true,
@@ -93,16 +92,32 @@ export const approvalPlugin = {
                 };
             }
             else {
-                // Emit a failure result event for the denied action
-                // yield {
-                //   type: `${originalEvent.type}:result` as OpenBotEvent['type'],
-                //   data: {
-                //     success: false,
-                //     error: 'Action denied by user.',
-                //     stderr: 'Action denied by user.',
-                //   },
-                //   meta: originalEvent.meta,
-                // } as OpenBotEvent;
+                // Manually store the original event with denied status so it's recorded in history
+                // but NOT re-emitted to the pipeline (to avoid actual execution).
+                if (storage) {
+                    await storage.storeEvent({
+                        channelId: context.state.channelId,
+                        threadId: context.state.threadId,
+                        event: {
+                            ...originalEvent,
+                            meta: {
+                                ...(originalEvent.meta || {}),
+                                approvalStatus: 'denied',
+                            },
+                        },
+                    });
+                }
+                // Emit a failure result event for the denied action to clear the pending tool batch
+                yield {
+                    type: `${originalEvent.type}:result`,
+                    data: {
+                        success: false,
+                        error: 'Action denied by user.',
+                        stderr: 'Action denied by user.',
+                        output: 'Action denied by user.',
+                    },
+                    meta: originalEvent.meta,
+                };
                 yield {
                     type: 'agent:output',
                     data: { content: `Action \`${originalEvent.type}\` was denied.` },

package/dist/plugins/bash/index.js

@@ -0,0 +1,195 @@
+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.',
+        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.'),
+        }),
+    },
+    bash_stop: {
+        description: 'Stop the bash session for the current or specified channel.',
+        inputSchema: z.object({
+            channelId: z.string().optional().describe('The channel ID to stop the session for.'),
+        }),
+    },
+    bash_list_sessions: {
+        description: 'List all active bash sessions.',
+        inputSchema: z.object({}),
+    },
+};
+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: '' },
+            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);
+        });
+        childProcess.on('exit', () => {
+            sessions.delete(channelId);
+        });
+    }
+    return session;
+};
+const bashPluginRuntime = () => (builder) => {
+    builder.on('action:bash', async function* (event, context) {
+        const { command, restart } = event.data;
+        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,
+            };
+        }
+        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,
+            };
+        }
+    });
+    // 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,
+        };
+    });
+    // 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,
+        };
+    });
+};
+export const bashPlugin = {
+    id: 'bash',
+    name: 'Bash',
+    description: 'Stateful bash session for the channel.',
+    toolDefinitions: bashToolDefinitions,
+    factory: () => bashPluginRuntime(),
+};
+export default bashPlugin;