openbot 0.4.7 → 0.5.5

package/docs/plugins.md

@@ -39,6 +39,14 @@ same agent into a single map and passes it to every plugin via `context.tools`.
 Runtime plugins read it; tool plugins ignore it. First plugin wins on tool
 name collisions.
 
+### Tool results
+
+When a tool handler finishes, yield `action:<tool>:result` with
+`data.output: string`. The OpenBot runtime feeds that string back into the
+model as the tool result (`history.ts`). Structured fields (e.g. `list`,
+`success`) are fine alongside it, but without `output` the model only sees
+`"No output"`.
+
 ## Built-in plugins
 
 | Id              | Role       | Notes                                                     |
@@ -49,6 +57,7 @@ name collisions.
 | `bash`          | Tool       | `bash` (inbuilt in `openbot`)                             |
 | `storage`       | Tool       | `create_channel`, `patch_*`, ... (inbuilt in `openbot`)   |
 | `memory`        | Tool       | `remember`, `recall`, `forget` (inbuilt in `openbot`)     |
+| `todo`          | Tool       | `todo_write`, `todo_read` (inbuilt in `openbot`)          |
 | `plugin-manager`| Infra      | Marketplace list, npm plugin install/uninstall, agent install |
 
 ## Batteries-included: `openbot` runtime
@@ -58,6 +67,7 @@ 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.
+- **Todo**: Thread-scoped multi-step task checklist.
 - **Storage**: Channel and thread management.
 - **Delegation**: Calling upon other specialized agents.
 - **Approval**: Gating protected actions behind UI confirmation.
@@ -71,7 +81,7 @@ plugins:
     config:
       model: openai/gpt-4o-mini
       approval:
-        actions: [action:bash, action:create_channel]
+        actions: [action:shell_exec, action:create_channel]
 ```
 
 A community plugin is just an npm package whose default export matches the
@@ -90,11 +100,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:bash`.
+The `approval` plugin gates protected tool calls behind a UI confirmation widget. By default, it gates `action:shell_exec`.
 
 ```yaml
 plugins:
   - id: approval
     config:
-      actions: [action:bash]
+      actions: [action:shell_exec]
 ```

package/docs/templates/AGENT.example.md

@@ -8,27 +8,21 @@ name: Example Agent
 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 `bash`,
-# `delegation`, and `storage-tools` contribute tools to whichever runtime
-# plugin can consume them.
+# At least one plugin must handle `agent:invoke`. Use the monolithic runtime:
+# `@meetopenbot/openbot` (batteries-included: shell, memory, todo, storage tools,
+# delegation, approval, preview).
 #
-# Built-in plugin ids: openbot, claude-code, gemini-cli, bash, delegation,
-# storage-tools, approval.
+# Core built-in plugin ids: storage, plugin-manager.
 #
 # Community plugins are referenced by their npm package name (e.g.
-# `openbot-plugin-search` or `@scope/openbot-plugin-foo`) and are auto-installed
+# `openbot-plugin-search` or `@meetopenbot/openbot`) and are auto-installed
 # on first use into ~/.openbot/plugins/<id>/.
 plugins:
-  - id: openbot
+  - id: '@meetopenbot/openbot'
     config:
       model: openai/gpt-4o-mini
-  - id: bash
-  - id: delegation
-  - id: storage
-  - id: approval
-    config:
-      actions: [action:bash]
+      approval:
+        actions: [action:shell_exec]
 ---
 
 <!--

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.4.7",
+  "version": "0.5.5",
   "private": false,
   "type": "module",
   "engines": {
@@ -9,7 +9,9 @@
   "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"
+    "start": "node dist/app/cli.js start",
+    "format": "prettier --write .",
+    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.5"
   },
   "bin": {
     "openbot": "./dist/app/cli.js"
@@ -34,6 +36,7 @@
     "@types/express": "^4.17.21",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.10.1",
+    "prettier": "^3.4.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/src/app/bootstrap.ts

@@ -0,0 +1,43 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  CONFIG_FILE,
+  DEFAULT_AGENTS_DIR,
+  DEFAULT_CHANNELS_DIR,
+  DEFAULT_PLUGINS_DIR,
+  getBaseDir,
+  getChannelsWorkspaceRoot,
+  getConfigDir,
+  type OpenBotconfig,
+} from './config.js';
+
+/** Ensure data directories and a minimal config exist (first boot on a Fly volume). */
+export async function bootstrap(): Promise<void> {
+  const baseDir = getBaseDir();
+  const configDir = getConfigDir();
+
+  await fs.mkdir(path.join(baseDir, DEFAULT_AGENTS_DIR), { recursive: true });
+  await fs.mkdir(path.join(baseDir, DEFAULT_PLUGINS_DIR), { recursive: true });
+  await fs.mkdir(path.join(baseDir, DEFAULT_CHANNELS_DIR), { recursive: true });
+  await fs.mkdir(getChannelsWorkspaceRoot(), { recursive: true });
+  await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
+
+  const configPath = path.join(configDir, CONFIG_FILE);
+  try {
+    await fs.access(configPath);
+  } catch {
+    const initial: OpenBotconfig = { baseDir };
+
+    const publicUrl = process.env.OPENBOT_PUBLIC_URL?.trim();
+    if (publicUrl) {
+      initial.publicUrl = publicUrl.replace(/\/$/, '');
+    }
+
+    const workspaceDir = process.env.OPENBOT_CHANNELS_WORKSPACE_DIR?.trim();
+    if (workspaceDir) {
+      initial.channelsWorkspaceDir = getChannelsWorkspaceRoot();
+    }
+
+    await fs.writeFile(configPath, JSON.stringify(initial, null, 2), { mode: 0o600 });
+  }
+}

package/src/app/cli.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { bootstrap } from './bootstrap.js';
+import { ensureDefaultStack } from './ensure-default-stack.js';
 import { startServer } from './server.js';
 
 const program = new Command();
@@ -25,13 +27,15 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.4.7');
+program.name('openbot').description('OpenBot CLI').version('0.5.5');
 
 program
   .command('start')
   .description('Start the OpenBot harness')
   .option('-p, --port <number>', 'Port to listen on')
   .action(async (options) => {
+    await bootstrap();
+    await ensureDefaultStack();
     await startServer(options);
   });
 

package/src/app/cloud-mode.ts

@@ -0,0 +1,26 @@
+import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
+
+/** Platform-managed OpenBot (Fly). Self-hosted when unset. */
+export const isCloudMode = (): boolean => process.env.OPENBOT_CLOUD_MODE === '1';
+
+/** How the cloud system agent authenticates to LLM providers. */
+export type OpenbotAuthMode = 'credits' | 'byok';
+
+/** Default cloud openbot plugin auth mode. */
+export const DEFAULT_CLOUD_OPENBOT_AUTH_MODE: OpenbotAuthMode = 'credits';
+
+export function isCloudSystemAgent(agentId: string): boolean {
+  return isCloudMode() && agentId === ORCHESTRATOR_AGENT_ID;
+}
+
+export function parseOpenbotAuthMode(value: unknown): OpenbotAuthMode {
+  return value === 'byok' ? 'byok' : 'credits';
+}
+
+export function assertCloudSystemAgentPluginsMutable(
+  agentId: string,
+  plugins: unknown,
+): void {
+  void agentId;
+  void plugins;
+}

package/src/app/config.ts

@@ -8,6 +8,8 @@ export interface OpenBotconfig {
   model?: string;
   image?: string;
   baseDir?: string;
+  /** Parent directory for per-channel working directories (user-facing workspace). */
+  channelsWorkspaceDir?: string;
   port?: number;
   /**
    * Overrides the default public marketplace registry URL. If omitted or blank,
@@ -41,52 +43,102 @@ export function resolvePath(p: string) {
   return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
 
+function readConfigFile(configDir: string): OpenBotconfig {
+  const configPath = path.join(configDir, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8')) as OpenBotconfig;
+    } catch (error) {
+      console.error(`Warning: Failed to parse config at ${configPath}`, error);
+    }
+  }
+  return {};
+}
+
+/** Directory that holds `config.json` (env `OPENBOT_BASE_DIR` or `~/.openbot`). */
+export function getConfigDir(): string {
+  const envBase = process.env.OPENBOT_BASE_DIR?.trim();
+  if (envBase) {
+    return resolvePath(envBase);
+  }
+  return path.join(os.homedir(), '.openbot');
+}
+
+/** Resolved OpenBot data root (agents, channels, plugins, variables). */
+export function getBaseDir(): string {
+  const envBase = process.env.OPENBOT_BASE_DIR?.trim();
+  if (envBase) {
+    return resolvePath(envBase);
+  }
+  const fileConfig = readConfigFile(getConfigDir());
+  return resolvePath(fileConfig.baseDir || DEFAULT_BASE_DIR);
+}
+
+/** Resolved parent directory for per-channel workspace folders. */
+export function getChannelsWorkspaceRoot(): string {
+  const env = process.env.OPENBOT_CHANNELS_WORKSPACE_DIR?.trim();
+  if (env) {
+    return resolvePath(env);
+  }
+  const fileConfig = readConfigFile(getConfigDir());
+  if (fileConfig.channelsWorkspaceDir) {
+    return resolvePath(fileConfig.channelsWorkspaceDir);
+  }
+  return resolvePath(DEFAULT_CHANNELS_WORKSPACE_DIR);
+}
+
 /** 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}`);
+  return path.join(getChannelsWorkspaceRoot(), id);
 }
 
 export function loadConfig(): OpenBotconfig {
-  const configPath = path.join(os.homedir(), '.openbot', CONFIG_FILE);
-  if (fs.existsSync(configPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    } catch (error) {
-      console.error(`Warning: Failed to parse config at ${configPath}`, error);
-    }
+  const fileConfig = readConfigFile(getConfigDir());
+  const merged: OpenBotconfig = { ...fileConfig };
+
+  merged.baseDir = getBaseDir();
+
+  const envPublicUrl = process.env.OPENBOT_PUBLIC_URL?.trim();
+  if (envPublicUrl) {
+    merged.publicUrl = envPublicUrl.replace(/\/$/, '');
+  } else if (merged.publicUrl) {
+    merged.publicUrl = merged.publicUrl.replace(/\/$/, '');
   }
-  return {};
+
+  merged.channelsWorkspaceDir = getChannelsWorkspaceRoot();
+
+  const envPort = process.env.PORT?.trim();
+  if (envPort && !Number.isNaN(Number(envPort))) {
+    merged.port = Number(envPort);
+  }
+
+  return merged;
 }
 
 export function saveConfig(config: Partial<OpenBotconfig>) {
-  const configDir = resolvePath(DEFAULT_BASE_DIR);
+  const configDir = getConfigDir();
   const configPath = path.join(configDir, CONFIG_FILE);
 
   if (!fs.existsSync(configDir)) {
     fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
   }
 
-  const currentConfig = loadConfig();
+  const currentConfig = readConfigFile(configDir);
   const newConfig = { ...currentConfig, ...config };
 
   fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2), { mode: 0o600 });
 }
 
 export function isConfigured(): boolean {
-  const configPath = path.join(resolvePath(DEFAULT_BASE_DIR), CONFIG_FILE);
-  return fs.existsSync(configPath);
+  return fs.existsSync(path.join(getConfigDir(), CONFIG_FILE));
 }
 
 export function loadVariables(): { version: number; variables: StoredVariable[] } {
-  const config = loadConfig();
-  const variablesPath = path.join(
-    resolvePath(config.baseDir || DEFAULT_BASE_DIR),
-    VARIABLES_FILE,
-  );
+  const variablesPath = path.join(getBaseDir(), VARIABLES_FILE);
   if (fs.existsSync(variablesPath)) {
     return JSON.parse(fs.readFileSync(variablesPath, 'utf-8')) as {
       version: number;
@@ -94,4 +146,4 @@ export function loadVariables(): { version: number; variables: StoredVariable[]
     };
   }
   return { version: 1, variables: [] };
-}
+}

package/src/app/ensure-default-stack.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
+import { DEFAULT_SYSTEM_AGENT_MODEL, OPENBOT_PLUGIN_ID } from './openbot-plugin.js';
+import { DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode } from './cloud-mode.js';
+import { DEFAULT_AGENTS_DIR, getBaseDir } from './config.js';
+import { pluginService } from '../services/plugins/service.js';
+
+function systemAgentMdPath(): string {
+  return path.join(getBaseDir(), DEFAULT_AGENTS_DIR, ORCHESTRATOR_AGENT_ID, 'AGENT.md');
+}
+
+function defaultSystemPluginConfig(): Record<string, unknown> {
+  const config: Record<string, unknown> = {
+    model: DEFAULT_SYSTEM_AGENT_MODEL,
+  };
+  if (isCloudMode()) {
+    config.authMode = DEFAULT_CLOUD_OPENBOT_AUTH_MODE;
+  }
+  return config;
+}
+
+async function ensureOpenbotPluginInstalled(): Promise<void> {
+  if (await pluginService.isInstalled(OPENBOT_PLUGIN_ID)) {
+    return;
+  }
+
+  console.log(`[bootstrap] Installing ${OPENBOT_PLUGIN_ID} from npm`);
+  await pluginService.install({ packageName: OPENBOT_PLUGIN_ID });
+}
+
+async function ensureSystemAgentMaterialized(): Promise<void> {
+  const agentMdPath = systemAgentMdPath();
+  if (existsSync(agentMdPath)) {
+    return;
+  }
+
+  const agentDir = path.dirname(agentMdPath);
+  await fs.mkdir(agentDir, { recursive: true });
+
+  const frontmatter = {
+    name: 'OpenBot',
+    description: 'First-party orchestration agent for OpenBot.',
+    plugins: [
+      {
+        id: OPENBOT_PLUGIN_ID,
+        config: defaultSystemPluginConfig(),
+      },
+    ],
+  };
+
+  const content = matter.stringify('', frontmatter);
+  await fs.writeFile(agentMdPath, content, 'utf-8');
+  console.log(`[bootstrap] Materialized system agent at ${agentMdPath}`);
+}
+
+/** Install the default agent plugin from npm and materialize the system agent on first boot. */
+export async function ensureDefaultStack(): Promise<void> {
+  await ensureOpenbotPluginInstalled();
+  await ensureSystemAgentMaterialized();
+}

package/src/app/openbot-plugin.ts

@@ -0,0 +1,5 @@
+/** npm package id for the monolithic OpenBot agent runtime plugin. */
+export const OPENBOT_PLUGIN_ID = '@meetopenbot/openbot';
+
+/** Default model for the materialized system agent. */
+export const DEFAULT_SYSTEM_AGENT_MODEL = 'openai/gpt-5.4-mini';

package/src/app/server.ts

@@ -8,7 +8,8 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 import { generateId } from 'melony';
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
+import { getBaseDir, loadConfig } from '../app/config.js';
+import { isCloudMode } from './cloud-mode.js';
 import { ActiveRunsSnapshotEvent, OpenBotEvent, OpenBotState } from './types.js';
 import { processService } from '../services/process.js';
 import { runAgent, STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
@@ -46,8 +47,11 @@ export async function startServer(options: ServerOptions = {}) {
   const config = loadConfig();
   processService.syncWorkspaceVariablesToProcessEnv();
 
-  const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-  const openBotDir = resolvePath(baseDir);
+  if (isCloudMode()) {
+    console.log('[server] Cloud mode enabled');
+  }
+
+  const openBotDir = getBaseDir();
   const PORT = Number(options.port ?? config.port ?? process.env.PORT ?? 4132);
   const app = express();
   const clients: Map<string, express.Response[]> = new Map();
@@ -247,6 +251,23 @@ export async function startServer(options: ServerOptions = {}) {
 
   app.use(cors());
 
+  const gatewayToken = process.env.OPENBOT_GATEWAY_TOKEN?.trim();
+  if (gatewayToken) {
+    app.use((req, res, next) => {
+      if (req.path === '/api/health' || req.method === 'OPTIONS') {
+        next();
+        return;
+      }
+
+      const got = req.get('x-openbot-gateway-token');
+      if (got !== gatewayToken) {
+        res.status(401).json({ error: 'unauthorized' });
+        return;
+      }
+      next();
+    });
+  }
+
   const resolvePublicBaseUrl = () => getPublicBaseUrl(PORT, config.publicUrl);
 
   app.use((req, res, next) => {
@@ -264,7 +285,7 @@ export async function startServer(options: ServerOptions = {}) {
   });
 
   app.get('/api/health', (req, res) => {
-    res.json({ status: 'ok', version: pkg.version });
+    res.json({ status: 'ok', version: pkg.version, apiVersion: 1 });
   });
 
   app.get('/api/events', (req, res) => {
@@ -683,10 +704,25 @@ export async function startServer(options: ServerOptions = {}) {
     }
   });
 
-  app.listen(PORT, () => {
-    console.log(`\x1b[32mOpenBot server listening at http://localhost:${PORT}\x1b[0m`);
+  const HOST = process.env.HOST || '0.0.0.0';
+  const server = app.listen(PORT, HOST, () => {
+    console.log(`\x1b[32mOpenBot server listening at http://${HOST}:${PORT}\x1b[0m`);
     console.log(
       `🌐 Visit \x1b[96m\x1b[1mhttps://openbot.one\x1b[0m to connect to this runtime and manage everything from there. ✨`,
     );
   });
+
+  const shutdown = (signal: string) => {
+    console.log(`\n[server] Received ${signal}, shutting down...`);
+    server.close(() => {
+      process.exit(0);
+    });
+    setTimeout(() => {
+      console.error('[server] Forced shutdown after timeout');
+      process.exit(1);
+    }, 10_000).unref();
+  };
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
 }