openbot 0.4.7 → 0.5.4

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, getCloudIntegrationsConfig } 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,14 @@ export async function startServer(options: ServerOptions = {}) {
   const config = loadConfig();
   processService.syncWorkspaceVariablesToProcessEnv();
 
-  const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-  const openBotDir = resolvePath(baseDir);
+  if (isCloudMode()) {
+    const integrations = getCloudIntegrationsConfig();
+    console.log(
+      `[server] Cloud mode enabled${integrations ? '' : ' (integrations proxy env not set)'}`,
+    );
+  }
+
+  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 +254,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 +288,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 +707,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'));
 }

package/src/app/types.ts

@@ -9,6 +9,7 @@ import {
 } from '../services/plugins/domain.js';
 import type { PluginRef } from '../services/plugins/types.js';
 import type { MemoryRecord } from '../plugins/memory/service.js';
+import type { TodoList } from '../plugins/todo/service.js';
 
 export interface OpenBotState {
   agentId: string;
@@ -657,11 +658,21 @@ export type UIWidgetField = {
   defaultValue?: unknown;
 };
 
+export type UIWidgetListItemStatusVariant =
+  | 'default'
+  | 'success'
+  | 'warning'
+  | 'danger'
+  | 'info';
+
 export type UIWidgetListItem = {
   id: string;
   label: string;
   description?: string;
-  status?: 'pending' | 'in_progress' | 'done' | 'error' | 'cancelled';
+  /** Optional status label shown on the item (e.g. "Pending", "Shipped") */
+  status?: string;
+  /** Optional semantic hint for status coloring in the client */
+  statusVariant?: UIWidgetListItemStatusVariant;
   metadata?: Record<string, unknown>;
 };
 
@@ -737,11 +748,12 @@ export type UIWidgetResponseEvent = BaseEvent & {
   };
 };
 
-export type BashEvent = BaseEvent & {
-  type: 'action:bash';
+export type ShellExecEvent = BaseEvent & {
+  type: 'action:shell_exec';
   data: {
+    id: string;
+    exec_dir: string;
     command: string;
-    restart?: boolean;
   };
   meta?: {
     toolCallId?: string;
@@ -751,47 +763,116 @@ export type BashEvent = BaseEvent & {
   };
 };
 
-export type BashResultEvent = BaseEvent & {
-  type: 'action:bash:result';
+export type ShellExecResultEvent = BaseEvent & {
+  type: 'action:shell_exec:result';
   data: {
     success: boolean;
     approved?: boolean;
-    exitCode: number | null;
-    stdout: string;
-    stderr: string;
-    timedOut: boolean;
+    exitCode?: number;
     error?: string;
+    output?: string;
   };
 };
 
-export type BashStopEvent = BaseEvent & {
-  type: 'action:bash_stop';
+export type ShellViewEvent = BaseEvent & {
+  type: 'action:shell_view';
   data: {
-    channelId?: string;
+    id: string;
   };
 };
 
-export type BashStopResultEvent = BaseEvent & {
-  type: 'action:bash_stop:result';
+export type ShellViewResultEvent = BaseEvent & {
+  type: 'action:shell_view:result';
   data: {
     success: boolean;
+    output?: string;
   };
 };
 
-export type BashListSessionsEvent = BaseEvent & {
-  type: 'action:bash_list_sessions';
-  data: {};
+export type ShellWaitEvent = BaseEvent & {
+  type: 'action:shell_wait';
+  data: {
+    id: string;
+    seconds: number;
+  };
 };
 
-export type BashListSessionsResultEvent = BaseEvent & {
-  type: 'action:bash_list_sessions:result';
+export type ShellWaitResultEvent = BaseEvent & {
+  type: 'action:shell_wait:result';
   data: {
     success: boolean;
-    sessions: Array<{
-      channelId: string;
-      cwd: string;
-      lastActivity: number;
-    }>;
+    waitedSeconds?: number;
+    output?: string;
+  };
+};
+
+export type ShellWriteToProcessEvent = BaseEvent & {
+  type: 'action:shell_write_to_process';
+  data: {
+    id: string;
+    input: string;
+    press_enter: boolean;
+  };
+};
+
+export type ShellWriteToProcessResultEvent = BaseEvent & {
+  type: 'action:shell_write_to_process:result';
+  data: {
+    success: boolean;
+    output?: string;
+  };
+};
+
+export type ShellKillProcessEvent = BaseEvent & {
+  type: 'action:shell_kill_process';
+  data: {
+    id: string;
+  };
+};
+
+export type ShellKillProcessResultEvent = BaseEvent & {
+  type: 'action:shell_kill_process:result';
+  data: {
+    success: boolean;
+    output?: string;
+  };
+};
+
+export type ExposePortEvent = BaseEvent & {
+  type: 'action:expose_port';
+  data: {
+    port: number;
+  };
+  meta?: {
+    toolCallId?: string;
+    approvalId?: string;
+    approvalStatus?: 'approved' | 'denied';
+    [key: string]: unknown;
+  };
+};
+
+export type ExposePortResultEvent = BaseEvent & {
+  type: 'action:expose_port:result';
+  data: {
+    success: boolean;
+    previewUrl?: string;
+    port?: number;
+    temporary?: boolean;
+    error?: string;
+    output?: string;
+  };
+};
+
+export type UnexposePortEvent = BaseEvent & {
+  type: 'action:unexpose_port';
+  data?: Record<string, never>;
+};
+
+export type UnexposePortResultEvent = BaseEvent & {
+  type: 'action:unexpose_port:result';
+  data: {
+    success: boolean;
+    output?: string;
   };
 };
 
@@ -968,6 +1049,44 @@ export type ForgetResultEvent = BaseEvent & {
   };
 };
 
+export type TodoWriteEvent = BaseEvent & {
+  type: 'action:todo_write';
+  data: {
+    items: Array<{
+      id: string;
+      content: string;
+      status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    }>;
+  };
+};
+
+export type TodoWriteResultEvent = BaseEvent & {
+  type: 'action:todo_write:result';
+  data: {
+    success: boolean;
+    list?: TodoList;
+    /** Text fed back to the model via history (`data.output`). */
+    output: string;
+    error?: string;
+  };
+};
+
+export type TodoReadEvent = BaseEvent & {
+  type: 'action:todo_read';
+  data: Record<string, never>;
+};
+
+export type TodoReadResultEvent = BaseEvent & {
+  type: 'action:todo_read:result';
+  data: {
+    success: boolean;
+    list?: TodoList;
+    /** Text fed back to the model via history (`data.output`). */
+    output: string;
+    error?: string;
+  };
+};
+
 export type DelegateTaskEvent = BaseEvent & {
   type: 'action:delegate_task';
   data: {
@@ -1101,12 +1220,20 @@ export type OpenBotEvent =
   | DeleteChannelToolResultEvent
   | UIWidgetEvent
   | UIWidgetResponseEvent
-  | BashEvent
-  | BashResultEvent
-  | BashStopEvent
-  | BashStopResultEvent
-  | BashListSessionsEvent
-  | BashListSessionsResultEvent
+  | ShellExecEvent
+  | ShellExecResultEvent
+  | ShellViewEvent
+  | ShellViewResultEvent
+  | ShellWaitEvent
+  | ShellWaitResultEvent
+  | ShellWriteToProcessEvent
+  | ShellWriteToProcessResultEvent
+  | ShellKillProcessEvent
+  | ShellKillProcessResultEvent
+  | ExposePortEvent
+  | ExposePortResultEvent
+  | UnexposePortEvent
+  | UnexposePortResultEvent
   | InstallPluginEvent
   | InstallPluginResultEvent
   | UninstallPluginEvent
@@ -1123,6 +1250,10 @@ export type OpenBotEvent =
   | RecallResultEvent
   | ForgetEvent
   | ForgetResultEvent
+  | TodoWriteEvent
+  | TodoWriteResultEvent
+  | TodoReadEvent
+  | TodoReadResultEvent
   | DelegateTaskEvent
   | DelegateTaskResultEvent
   | RenderWidgetEvent

package/src/plugins/approval/index.ts

@@ -19,7 +19,7 @@ export const approvalPlugin: Plugin = {
   description: 'Gate protected tool calls behind a UI confirmation widget.',
   factory: ({ config, storage }) => (builder) => {
     // Actions that require approval. Defaults to bash.
-    const actionsToApprove = (config.actions as string[]) || ['action:bash'];
+    const actionsToApprove = (config.actions as string[]) || ['action:shell_exec'];
 
     for (const action of actionsToApprove) {
       builder.intercept(action as OpenBotEvent['type'], (event, context) => {