openbot 0.4.0 → 0.4.3

package/dist/plugins/ui/index.js

@@ -1,154 +1,113 @@
-import z from 'zod';
-const actionSchema = z.object({
-    id: z.string().describe('Stable action ID returned by client:ui:widget:response.'),
-    label: z.string().describe('Human-readable button label.'),
-    value: z.unknown().optional().describe('Optional machine-readable value for this action.'),
-    variant: z.enum(['primary', 'secondary', 'danger']).optional(),
-    disabled: z.boolean().optional(),
-});
-const optionSchema = z.object({
-    label: z.string(),
-    value: z.string(),
-});
-const fieldSchema = z.object({
-    id: z.string().describe('Stable field ID used as the submitted value key.'),
-    label: z.string(),
-    type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
-    description: z.string().optional(),
-    placeholder: z.string().optional(),
-    required: z.boolean().optional(),
-    options: z.array(optionSchema).optional(),
-    defaultValue: z.unknown().optional(),
-});
-const listItemSchema = z.object({
-    id: z.string(),
-    label: z.string(),
-    description: z.string().optional(),
-    status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-});
-const widgetBaseSchema = {
-    widgetId: z.string().optional().describe('Stable widget ID. Defaults from toolCallId.'),
-    title: z.string().optional(),
-    description: z.string().optional(),
-    body: z.string().optional(),
-    state: z.enum(['open', 'submitted', 'cancelled', 'error']).optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-};
-const renderWidgetSchema = z.union([
-    z.object({
-        ...widgetBaseSchema,
-        kind: z.literal('message'),
-        actions: z.array(actionSchema).optional(),
-    }),
-    z.object({
-        ...widgetBaseSchema,
-        kind: z.literal('choice'),
-        actions: z.array(actionSchema).min(1),
-    }),
-    z.object({
-        ...widgetBaseSchema,
-        kind: z.literal('form'),
-        fields: z.array(fieldSchema).optional(),
-        submitLabel: z.string().optional(),
-        actions: z.array(actionSchema).optional(),
-        props: z.record(z.string(), z.unknown()).optional(),
-    }),
-    z.object({
-        ...widgetBaseSchema,
-        kind: z.literal('list'),
-        items: z.array(listItemSchema).optional(),
-        actions: z.array(actionSchema).optional(),
-    }),
-    z.object({
-        kind: z.literal('approval').describe('Legacy preset. Prefer choice or list.'),
-        widgetId: z.string().optional(),
-        title: z.string().optional(),
-        props: z.record(z.string(), z.unknown()).optional(),
-        metadata: z.record(z.string(), z.unknown()).optional(),
-    }),
-]);
-const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
-const readString = (value) => typeof value === 'string' && value.trim() ? value : undefined;
-const asFields = (value) => Array.isArray(value) ? value : undefined;
-const asListItems = (value) => Array.isArray(value) ? value : undefined;
-const createWidgetId = (data, toolCallId) => {
-    if ('widgetId' in data && data.widgetId)
-        return data.widgetId;
-    if (toolCallId)
-        return `widget_${toolCallId}`;
-    return `widget_${Date.now()}`;
-};
-const normalizeWidget = (data, state, toolCallId) => {
-    const widgetId = createWidgetId(data, toolCallId);
-    if (data.kind === 'approval') {
-        const props = data.props || {};
-        return {
-            widgetId,
-            kind: 'choice',
-            title: data.title || 'Approval Required',
-            body: readString(props.message) ||
-                readString(props.summary) ||
-                'Please approve or deny this action.',
-            metadata: {
-                ...(data.metadata || {}),
-                legacyKind: 'approval',
-                actionId: props.actionId,
-            },
-            actions: [
-                { id: 'approve', label: 'Approve', value: props.actionId || 'approve', variant: 'primary' },
-                { id: 'deny', label: 'Deny', value: props.actionId || 'deny', variant: 'danger' },
-            ],
-        };
-    }
-    if (data.kind === 'form') {
-        const propsSource = data.props;
-        const props = isRecord(propsSource) ? propsSource : {};
-        return {
-            widgetId,
-            kind: 'form',
-            title: data.title || 'Details Required',
-            description: data.description,
-            body: data.body,
-            state: data.state,
-            metadata: data.metadata,
-            fields: data.fields || asFields(props.schema) || [],
-            submitLabel: data.submitLabel || readString(props.submitLabel),
-            actions: data.actions,
-        };
-    }
-    if (data.kind === 'list') {
-        return { ...data, widgetId, title: data.title || 'Task List', items: data.items || [] };
-    }
-    if (data.kind === 'choice') {
-        return { ...data, widgetId, title: data.title || 'Choose an Option' };
-    }
-    if (data.kind === 'message') {
-        return { ...data, widgetId, title: data.title || 'Message' };
-    }
-    throw new Error(`Unsupported UI widget kind: ${data.kind || 'unknown'}`);
-};
-const uiToolDefinitions = {
-    render_ui_widget: {
-        description: 'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy preset approval is accepted.',
-        inputSchema: renderWidgetSchema,
-    },
-};
-const uiPluginRuntime = () => (builder) => {
-    builder.on('action:render_ui_widget', async function* (event, context) {
-        const widget = normalizeWidget(event.data, context.state, event.meta?.toolCallId);
-        yield {
-            type: 'client:ui:widget',
-            data: widget,
-            meta: event.meta,
-        };
-    });
-};
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+/**
+ * `ui` — provides a tool for the agent to render interactive UI widgets.
+ *
+ * The model can choose which widget to render (form, choice, list, message)
+ * depending on the situation.
+ */
 export const uiPlugin = {
     id: 'ui',
-    name: 'UI Widgets',
-    description: 'Render server-driven UI widgets (messages, choices, forms, lists) in the conversation.',
-    toolDefinitions: uiToolDefinitions,
-    factory: () => uiPluginRuntime(),
+    name: 'UI',
+    description: 'Render interactive UI widgets to interact with the user.',
+    toolDefinitions: {
+        render_widget: {
+            description: 'Render a UI widget to the user. Use "form" for data collection, "choice" for simple selection, "list" for displaying items, and "message" for simple notifications with actions. When using form widge to unquire user, do not provide complex forms with many fields, always try to make it simple to keep the experience smooth and straightforward.',
+            inputSchema: z.object({
+                kind: z.enum(['message', 'choice', 'form', 'list']).describe('The type of widget to render.'),
+                title: z.string().describe('The title of the widget.'),
+                description: z.string().optional().describe('A description or body text.'),
+                fields: z.array(z.object({
+                    id: z.string().describe('Unique ID for the field.'),
+                    label: z.string().describe('Label shown to the user.'),
+                    type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
+                    description: z.string().optional(),
+                    placeholder: z.string().optional(),
+                    required: z.boolean().optional(),
+                    options: z.array(z.object({ label: z.string(), value: z.string() })).optional(),
+                    defaultValue: z.any().optional()
+                })).optional().describe('Required for kind="form". List of form fields.'),
+                actions: z.array(z.object({
+                    id: z.string(),
+                    label: z.string(),
+                    variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+                })).optional().describe('Buttons or actions available on the widget.'),
+                items: z.array(z.object({
+                    id: z.string(),
+                    label: z.string(),
+                    description: z.string().optional(),
+                    status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+                    metadata: z.record(z.string(), z.any()).optional()
+                })).optional().describe('Required for kind="list". List of items to display.'),
+                submitLabel: z.string().optional().describe('Label for the primary action button (e.g. "Submit", "Save").')
+            })
+        }
+    },
+    factory: () => (builder) => {
+        // Handle the tool call from the agent
+        builder.on('action:render_widget', async function* (event, context) {
+            const widgetEvent = event;
+            const toolCallId = widgetEvent.meta?.toolCallId;
+            const threadId = widgetEvent.meta?.threadId || context.state.threadId;
+            if (!toolCallId)
+                return;
+            const widgetId = randomUUID();
+            // Emit the UI widget event to the client
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    ...widgetEvent.data,
+                    widgetId,
+                    metadata: {
+                        type: 'ui:request',
+                        originalEvent: widgetEvent
+                    }
+                },
+                meta: { agentId: context.state.agentId, threadId }
+            };
+        });
+        // Handle the user's response from the UI widget
+        builder.on('client:ui:widget:response', async function* (event, context) {
+            const responseEvent = event;
+            const { widgetId, actionId, values, metadata } = responseEvent.data;
+            if (metadata?.type !== 'ui:request')
+                return;
+            const originalEvent = metadata.originalEvent;
+            const toolCallId = originalEvent?.meta?.toolCallId;
+            const threadId = originalEvent?.meta?.threadId || context.state.threadId;
+            if (!toolCallId)
+                return;
+            // Yield a "submitted" widget update to the UI to collapse/disable it
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId,
+                    title: originalEvent.data.title,
+                    kind: originalEvent.data.kind,
+                    state: 'submitted',
+                    body: "Thank you for your response. We will process it and get back to you soon.",
+                    display: 'collapsed',
+                    disabled: true,
+                    actions: [], // Clear actions to disable buttons in UI
+                },
+                meta: { agentId: context.state.agentId, threadId },
+            };
+            // Emit the tool result event so the agent runtime can resume
+            yield {
+                type: 'action:render_widget:result',
+                data: {
+                    success: true,
+                    actionId,
+                    values,
+                    output: JSON.stringify(values)
+                },
+                meta: {
+                    agentId: context.state.agentId,
+                    threadId,
+                    toolCallId
+                }
+            };
+        });
+    },
 };
 export default uiPlugin;

package/dist/services/abort.js

@@ -0,0 +1,43 @@
+/**
+ * Tracks in-flight agent runs so they can be cancelled.
+ *
+ * Runs are grouped by `channelId:threadId`. Delegated sub-agents run in the
+ * same channel/thread as their parent, so aborting that key stops the whole
+ * chain (parent + any delegated runs) in one shot.
+ */
+export const abortKey = (channelId, threadId) => `${channelId}:${threadId || ''}`;
+class AbortRegistry {
+    constructor() {
+        this.entries = new Map();
+    }
+    /** Register interest in a run. Returns a shared signal for the key. */
+    acquire(key) {
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = { controller: new AbortController(), refs: 0 };
+            this.entries.set(key, entry);
+        }
+        entry.refs += 1;
+        return entry.controller.signal;
+    }
+    /** Release interest. Removes the entry once no runs reference it. */
+    release(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return;
+        entry.refs -= 1;
+        if (entry.refs <= 0) {
+            this.entries.delete(key);
+        }
+    }
+    /** Abort all runs for the key. Returns true if something was active. */
+    abort(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        entry.controller.abort();
+        this.entries.delete(key);
+        return true;
+    }
+}
+export const abortRegistry = new AbortRegistry();

package/dist/services/plugins/registry.js

@@ -2,22 +2,24 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { openbotPlugin } from '../../plugins/openbot/index.js';
-import { shellPlugin } from '../../plugins/shell/index.js';
+import { bashPlugin } from '../../plugins/bash/index.js';
 import { storagePlugin } from '../../plugins/storage/index.js';
 import { approvalPlugin } from '../../plugins/approval/index.js';
 import { memoryPlugin } from '../../plugins/memory/index.js';
 import { delegationPlugin } from '../../plugins/delegation/index.js';
+import { uiPlugin } from '../../plugins/ui/index.js';
 import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
 import { invalidatePlugin as clearResolvedPluginEntry, loadedCommunityPlugins, resolvedPluginCache, } from './plugin-cache.js';
 let pluginsDir = null;
 const BUILT_IN = {
     [openbotPlugin.id]: openbotPlugin,
-    [shellPlugin.id]: shellPlugin,
+    [bashPlugin.id]: bashPlugin,
     [storagePlugin.id]: storagePlugin,
     [approvalPlugin.id]: approvalPlugin,
     [memoryPlugin.id]: memoryPlugin,
     [delegationPlugin.id]: delegationPlugin,
+    [uiPlugin.id]: uiPlugin,
     [pluginManagerPlugin.id]: pluginManagerPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
@@ -56,7 +58,7 @@ export function initPlugins(dir) {
 }
 /**
  * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "openbot", "shell"), or
+ *   - a built-in id (e.g. "openbot", "bash"), or
  *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
  *     in which case the folder layout is `plugins/<id>/dist/index.js`.
  */

package/dist/services/plugins/service.js

@@ -7,19 +7,27 @@ import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, DEFAULT_MARKETPLACE_REGISTRY_URL
 import { invalidatePlugin } from './plugin-cache.js';
 const execAsync = promisify(exec);
 const DEFAULT_MARKETPLACE_AGENTS = [];
+const DEFAULT_MARKETPLACE_CHANNELS = [];
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /**
  * Parses JSON from a remote registry file. Supports either
- * `{ "agents": [ ... ] }` or a top-level array.
+ * `{ "agents": [ ... ], "channels": [ ... ] }` or a top-level array (legacy agents-only).
  */
 export function parseMarketplaceRegistryJson(data) {
-    const rawAgents = Array.isArray(data) ? data : isRecord(data) && Array.isArray(data.agents) ? data.agents : null;
-    if (!Array.isArray(rawAgents)) {
-        throw new Error('Registry JSON must be an array or an object with an "agents" array');
-    }
-    return rawAgents.map((item, i) => {
+    const isLegacyArray = Array.isArray(data);
+    const rawAgents = isLegacyArray
+        ? data
+        : isRecord(data) && Array.isArray(data.agents)
+            ? data.agents
+            : [];
+    const rawChannels = !isLegacyArray && isRecord(data) && Array.isArray(data.channels)
+        ? data.channels
+        : isRecord(data) && Array.isArray(data.templates)
+            ? data.templates
+            : [];
+    const agents = (Array.isArray(rawAgents) ? rawAgents : []).map((item, i) => {
         if (!isRecord(item)) {
             throw new Error(`agents[${i}]: expected object`);
         }
@@ -59,8 +67,47 @@ export function parseMarketplaceRegistryJson(data) {
         }
         return listing;
     });
+    const channels = (Array.isArray(rawChannels) ? rawChannels : []).map((item, i) => {
+        if (!isRecord(item)) {
+            throw new Error(`channels[${i}]: expected object`);
+        }
+        const id = item.id;
+        const name = item.name;
+        const description = item.description;
+        const participants = item.participants;
+        if (typeof id !== 'string' || !id)
+            throw new Error(`channels[${i}].id must be a non-empty string`);
+        if (typeof name !== 'string')
+            throw new Error(`channels[${i}].name must be a string`);
+        if (typeof description !== 'string')
+            throw new Error(`channels[${i}].description must be a string`);
+        if (!Array.isArray(participants))
+            throw new Error(`channels[${i}].participants must be an array`);
+        const listing = {
+            id,
+            name,
+            description,
+            participants: participants.filter((p) => typeof p === 'string'),
+        };
+        if (typeof item.image === 'string')
+            listing.image = item.image;
+        if (typeof item.spec === 'string')
+            listing.spec = item.spec;
+        if (isRecord(item.initialState))
+            listing.initialState = item.initialState;
+        if (Array.isArray(item.starterPrompts)) {
+            listing.starterPrompts = item.starterPrompts.map((p, j) => {
+                if (!isRecord(p) || typeof p.label !== 'string' || typeof p.prompt !== 'string') {
+                    throw new Error(`channels[${i}].starterPrompts[${j}] must have label and prompt`);
+                }
+                return { label: p.label, prompt: p.prompt };
+            });
+        }
+        return listing;
+    });
+    return { agents, channels };
 }
-async function fetchMarketplaceAgentsFromUrl(url) {
+async function fetchMarketplaceRegistryFromUrl(url) {
     const res = await fetch(url, {
         headers: { Accept: 'application/json' },
         signal: AbortSignal.timeout(15000),
@@ -72,19 +119,27 @@ async function fetchMarketplaceAgentsFromUrl(url) {
     return parseMarketplaceRegistryJson(json);
 }
 /**
- * Resolves marketplace agent listings from configured registry URL, or falls back to an empty list.
+ * Resolves marketplace registry (agents and channels) from configured registry URL.
  */
-export async function resolveMarketplaceAgentList() {
+export async function resolveMarketplaceRegistry() {
     const { marketplaceRegistryUrl } = loadConfig();
     const registryUrl = marketplaceRegistryUrl?.trim() || DEFAULT_MARKETPLACE_REGISTRY_URL;
     try {
-        return await fetchMarketplaceAgentsFromUrl(registryUrl);
+        return await fetchMarketplaceRegistryFromUrl(registryUrl);
     }
     catch (err) {
         console.warn(`[plugins] marketplace registry fetch failed (${registryUrl}), using built-in list:`, err instanceof Error ? err.message : err);
-        return DEFAULT_MARKETPLACE_AGENTS;
+        return { agents: DEFAULT_MARKETPLACE_AGENTS, channels: DEFAULT_MARKETPLACE_CHANNELS };
     }
 }
+/**
+ * Resolves marketplace agent listings from configured registry URL.
+ * @deprecated Use resolveMarketplaceRegistry instead.
+ */
+export async function resolveMarketplaceAgentList() {
+    const registry = await resolveMarketplaceRegistry();
+    return registry.agents;
+}
 const getPluginsDir = () => {
     const config = loadConfig();
     const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);

package/docs/agents.md

@@ -17,8 +17,6 @@ plugins:
   - id: openbot
     config:
       model: anthropic/claude-3-5-sonnet-20240620
-  - id: shell
-  - id: delegation
 ---
 
 You are a web research specialist. Use the available tools to gather and
@@ -37,20 +35,19 @@ the bus). Built-in **`state`** is hidden by default.
 A runtime plugin is one that handles `agent:invoke` (the LLM loop). Without
 one, the agent will not respond to user input. Built-in runtime plugins:
 
-- `openbot` — the standard, opinionated OpenBot agent runtime. Consumes tools
-  from other plugins listed alongside it.
+- `openbot` — the standard, opinionated OpenBot agent runtime. It is
+  **batteries-included** and provides inbuilt tools (bash, memory, storage,
+  delegation, and approval).
 - `claude-code` — runs Claude inside the Claude Agent SDK with its own tools.
 - `gemini-cli` — spawns Google's `gemini` CLI in headless mode.
 
 `claude-code` and `gemini-cli` own their own tool loops, so attaching tool
-plugins like `shell` to them has no effect. Pair tool plugins with
-`openbot`.
+plugins like `bash` to them has no effect.
 
 ## Built-in agents
 
 OpenBot ships a built-in **`system`** agent (the orchestrator) with the `openbot`
-runtime plus the standard tool plugins (storage, shell, delegation,
-approval, memory, etc.). A built-in **`state`** agent backs deterministic
+runtime. A built-in **`state`** agent backs deterministic
 `/api/state` handling and infra events.
 
 You can optionally persist overrides for either id at `~/.openbot/agents/system/AGENT.md` or `~/.openbot/agents/state/AGENT.md`. When present, settings are merged on top of the code defaults (`getAgentDetails`). The **`state`** agent is not listed by **`action:storage:get-agents`** (`hidden: true`); **`system`** is listed. Use **`action:storage:create-agent`** to create an overlay once, **`action:storage:update-agent`** for partial updates (creating the file if missing for `system` / `state`), and **`action:storage:delete-agent`** to remove only that `AGENT.md` and revert to defaults (other files under the folder are left untouched).

package/docs/architecture.md

@@ -18,7 +18,7 @@ A dynamic registry that manages all available agents. Agents can be:
 - **TS Packages**: Advanced agents with custom logic in `~/.openbot/agents/*/index.ts`.
 
 ### 3. Plugin registry
-The "capability layer" that provides tools and logic shared across the platform. Plugins (like `shell` or `file-system`) define the actions agents can perform.
+The "capability layer" that provides tools and logic shared across the platform. Plugins (like `bash` or `file-system`) define the actions agents can perform.
 
 ### 4. Orchestration layer (Melony)
 The underlying event bus that handles all communication. It ensures that agents can collaborate asynchronously, share context, and emit real-time updates to the UI.

package/docs/plugins.md

@@ -43,15 +43,36 @@ name collisions.
 
 | Id              | Role       | Notes                                                     |
 | --------------- | ---------- | --------------------------------------------------------- |
-| `openbot`       | Runtime    | The standard, opinionated OpenBot agent runtime.          |
+| `openbot`       | Runtime    | Standard batteries-included OpenBot agent runtime.        |
 | `claude-code`   | Runtime    | Claude Agent SDK; owns its own tool loop                  |
 | `gemini-cli`    | Runtime    | Google `gemini` CLI in headless mode                      |
-| `shell`         | Tool       | `shell_exec`                                              |
-| `storage`       | Tool       | `create_channel`, `patch_*`, `create_variable`, ...       |
-| `memory`        | Tool       | `remember`, `recall`, `forget`                            |
+| `bash`          | Tool       | `bash` (inbuilt in `openbot`)                             |
+| `storage`       | Tool       | `create_channel`, `patch_*`, ... (inbuilt in `openbot`)   |
+| `memory`        | Tool       | `remember`, `recall`, `forget` (inbuilt in `openbot`)     |
 | `plugin-manager`| Infra      | Marketplace list, npm plugin install/uninstall, agent install |
 
-## Community plugins
+## Batteries-included: `openbot` runtime
+
+The `openbot` plugin is the standard runtime for OpenBot agents. It is designed
+to be isolated and self-contained, providing a core ecosystem of inbuilt tools:
+
+- **Bash**: Stateful system tasks and file operations.
+- **Memory**: Long-term durable fact storage.
+- **Storage**: Channel and thread management.
+- **Delegation**: Calling upon other specialized agents.
+- **Approval**: Gating protected actions behind UI confirmation.
+
+When you use the `openbot` runtime, these tools are automatically available.
+You can configure the inbuilt `approval` plugin via the `openbot` plugin config:
+
+```yaml
+plugins:
+  - id: openbot
+    config:
+      model: openai/gpt-4o-mini
+      approval:
+        actions: [action:bash, action:create_channel]
+```
 
 A community plugin is just an npm package whose default export matches the
 `Plugin` interface. Reference it by its npm package name in AGENT.md:
@@ -69,11 +90,11 @@ On first use OpenBot installs the package into
 
 ## Approval plugin
 
-The `approval` plugin gates protected tool calls behind a UI confirmation widget. By default, it gates `action:shell_exec`.
+The `approval` plugin gates protected tool calls behind a UI confirmation widget. By default, it gates `action:bash`.
 
 ```yaml
 plugins:
   - id: approval
     config:
-      actions: [action:shell_exec]
+      actions: [action:bash]
 ```

package/docs/templates/AGENT.example.md

@@ -9,11 +9,11 @@ description: One-line description shown in agent pickers and lists.
 
 # Plugins compose the agent. Order matters for tool collisions (first wins).
 # At least one plugin must handle `agent:invoke` (a "runtime" plugin like
-# `openbot`, `claude-code`, or `gemini-cli`). Tool plugins like `shell`,
+# `openbot`, `claude-code`, or `gemini-cli`). Tool plugins like `bash`,
 # `delegation`, and `storage-tools` contribute tools to whichever runtime
 # plugin can consume them.
 #
-# Built-in plugin ids: openbot, claude-code, gemini-cli, shell, delegation,
+# Built-in plugin ids: openbot, claude-code, gemini-cli, bash, delegation,
 # storage-tools, approval.
 #
 # Community plugins are referenced by their npm package name (e.g.
@@ -23,12 +23,12 @@ plugins:
   - id: openbot
     config:
       model: openai/gpt-4o-mini
-  - id: shell
+  - id: bash
   - id: delegation
   - id: storage
   - id: approval
     config:
-      actions: [action:shell_exec]
+      actions: [action:bash]
 ---
 
 <!--

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "openbot",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "private": false,
   "type": "module",
   "engines": {
     "node": ">=20.12.0"
   },
+  "scripts": {
+    "dev": "tsx watch src/app/cli.ts start",
+    "build": "tsc && mkdir -p dist/assets && cp src/assets/icon.svg dist/assets/icon.svg",
+    "start": "node dist/app/cli.js start"
+  },
   "bin": {
     "openbot": "./dist/app/cli.js"
   },
@@ -30,10 +35,5 @@
     "@types/node": "^20.10.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
-  },
-  "scripts": {
-    "dev": "tsx watch src/app/cli.ts start",
-    "build": "tsc && mkdir -p dist/assets && cp src/assets/icon.svg dist/assets/icon.svg",
-    "start": "node dist/app/cli.js start"
   }
-}
+}

package/src/app/cli.ts

@@ -25,7 +25,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.4.0');
+program.name('openbot').description('OpenBot CLI').version('0.4.3');
 
 program
   .command('start')

package/src/app/config.ts

@@ -14,6 +14,8 @@ export interface OpenBotconfig {
    * {@link DEFAULT_MARKETPLACE_REGISTRY_URL} is used.
    */
   marketplaceRegistryUrl?: string;
+  /** Public base URL for workspace file links (e.g. https://my-host.example). Falls back to OPENBOT_PUBLIC_URL env or http://localhost:{port}. */
+  publicUrl?: string;
 }
 
 export interface StoredVariable {
@@ -23,6 +25,8 @@ export interface StoredVariable {
 }
 
 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';
@@ -37,6 +41,15 @@ export function resolvePath(p: string) {
   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: string): string {
+  const id = channelId.trim();
+  if (!id) {
+    throw new Error('channelId is required');
+  }
+  return resolvePath(`${DEFAULT_CHANNELS_WORKSPACE_DIR}/${id}`);
+}
+
 export function loadConfig(): OpenBotconfig {
   const configPath = path.join(os.homedir(), '.openbot', CONFIG_FILE);
   if (fs.existsSync(configPath)) {