bus-agent 2.3.0

package/lib/mcp.js

@@ -0,0 +1,730 @@
+/**
+ * MCP Protocol Handler — JSON-RPC 2.0 over stdio
+ *
+ * MCP CoCo v2.1: Agent Profiles, Discovery, Profiles, Scheduler base
+ */
+const readline = require('readline');
+const path = require('path');
+const { HermesBridge } = require('./hermes');
+const { AgentBus } = require('./bus');
+const { Scheduler } = require('./scheduler');
+const { Orchestrator } = require('./orchestrator');
+
+class MCPServer {
+  constructor() {
+    this.bridge = new HermesBridge();
+    this.bus = new AgentBus();
+    this.agentName = 'coco';
+
+    // Auto-register CoCo on bus with full profile
+    this.bus.registerAgent('coco', 'MCP CoCo — Universal Agent Communication Hub', {
+      version: '2.1.0',
+      capabilities: [
+        'agent-registry', 'agent-discovery', 'agent-profiles',
+        'direct-messaging', 'broadcast', 'channels',
+        'system-events', 'webhook-gateway',
+      ],
+      tags: ['bus', 'hub', 'orchestrator', 'bridge'],
+      tools: [],
+    });
+
+    this.tools = [
+      // ── Hermes Bridge Tools (legacy) ──
+      {
+        name: 'ask_hermes',
+        description: 'Send a prompt to Hermes Agent and get its response. Supports multi-turn via session_key.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            prompt: { type: 'string', description: 'The prompt/message to send' },
+            session_key: { type: 'string', description: 'Previous session key to continue (optional)' },
+          },
+          required: ['prompt'],
+        },
+      },
+      {
+        name: 'hermes_send',
+        description: 'Send a message through Hermes to a chat platform (Telegram, Discord, etc.)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            target: { type: 'string', description: 'Target platform:chat_id (e.g. telegram:6616375428)' },
+            message: { type: 'string', description: 'Message text to send' },
+          },
+          required: ['target', 'message'],
+        },
+      },
+      {
+        name: 'hermes_channels',
+        description: 'List available Hermes messaging channels/platforms',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            platform: { type: 'string', description: 'Optional platform filter (telegram, discord, etc.)' },
+          },
+        },
+      },
+      {
+        name: 'coco_health',
+        description: 'Check MCP CoCo bridge and Hermes Agent health status',
+        inputSchema: { type: 'object', properties: {} },
+      },
+
+      // ── Agent Profiles & Registry ──
+      {
+        name: 'agent_register',
+        description: 'Register your agent on the bus with a rich profile. Announce join to all agents.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Your agent name (e.g. openclaw, hermes, claude)' },
+            description: { type: 'string', description: 'Short description of your agent' },
+            capabilities: {
+              type: 'array', items: { type: 'string' },
+              description: 'What your agent can do (e.g. ["code-review", "web-search", "chat"])',
+            },
+            model: {
+              type: 'object',
+              properties: {
+                provider: { type: 'string', description: 'e.g. opencode, anthropic, openai' },
+                name: { type: 'string', description: 'e.g. deepseek-v4, claude-opus-4' },
+                context_window: { type: 'number' },
+              },
+              description: 'AI model info',
+            },
+            tags: { type: 'array', items: { type: 'string' }, description: 'Tags like ["code", "ai", "bot"]' },
+            version: { type: 'string', description: 'Agent version string' },
+            endpoints: {
+              type: 'object',
+              properties: {
+                mcp: { type: 'string' }, http: { type: 'string' }, websocket: { type: 'string' },
+              },
+              description: 'Connection endpoints',
+            },
+            tools: { type: 'array', items: { type: 'string' }, description: 'Tool names this agent exposes' },
+            status: { type: 'string', enum: ['idle', 'busy', 'offline'], description: 'Initial status' },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'agent_update_profile',
+        description: 'Update your agent profile fields (description, capabilities, status, etc.)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Your agent name' },
+            description: { type: 'string' },
+            capabilities: { type: 'array', items: { type: 'string' } },
+            model: { type: 'object', properties: { provider: { type: 'string' }, name: { type: 'string' }, context_window: { type: 'number' } } },
+            tags: { type: 'array', items: { type: 'string' } },
+            status: { type: 'string', enum: ['idle', 'busy', 'offline'] },
+            version: { type: 'string' },
+            endpoints: { type: 'object' },
+            tools: { type: 'array', items: { type: 'string' } },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'agent_get_profile',
+        description: 'Get detailed profile for a specific agent',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Agent name' },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'agent_list',
+        description: 'List agents with optional filters (online, capability, model, tag, status, search)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            online_only: { type: 'boolean', description: 'Only show agents seen in last 5 min' },
+            capability: { type: 'string', description: 'Filter by capability (e.g. "code-review")' },
+            model: { type: 'string', description: 'Filter by model name/provider' },
+            tag: { type: 'string', description: 'Filter by exact tag match' },
+            status: { type: 'string', enum: ['idle', 'busy', 'offline'], description: 'Filter by status' },
+            search: { type: 'string', description: 'Search name/description/capabilities' },
+          },
+        },
+      },
+      {
+        name: 'agent_search',
+        description: 'Search for agents by name, capability, or description. Returns matching profiles.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'Search query' },
+            max_results: { type: 'number', description: 'Max results (default 20)' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'agent_heartbeat',
+        description: 'Ping the bus to mark your agent as online',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Your agent name' },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'agent_set_status',
+        description: 'Set your agent status: idle, busy, or offline',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Your agent name' },
+            status: { type: 'string', enum: ['idle', 'busy', 'offline'], description: 'New status' },
+          },
+          required: ['name', 'status'],
+        },
+      },
+
+      // ── Direct Messages ──
+      {
+        name: 'message_send',
+        description: 'Send a direct message to another agent on the bus',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            from: { type: 'string', description: 'Your agent name' },
+            to: { type: 'string', description: 'Target agent name' },
+            message: { type: 'string', description: 'Message content' },
+            metadata: { type: 'object', description: 'Optional metadata (type, priority, etc.)' },
+          },
+          required: ['from', 'to', 'message'],
+        },
+      },
+      {
+        name: 'message_broadcast',
+        description: 'Send a message to ALL agents on the bus',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            from: { type: 'string', description: 'Your agent name' },
+            message: { type: 'string', description: 'Message content' },
+          },
+          required: ['from', 'message'],
+        },
+      },
+      {
+        name: 'message_fetch',
+        description: 'Fetch messages from your inbox. Supports filtering by sender and pagination.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_name: { type: 'string', description: 'Your agent name' },
+            limit: { type: 'number', description: 'Max messages to fetch (default 50)' },
+            after_id: { type: 'string', description: 'Fetch messages after this ID (for pagination)' },
+            from: { type: 'string', description: 'Filter messages from a specific sender' },
+          },
+          required: ['agent_name'],
+        },
+      },
+      {
+        name: 'message_wait',
+        description: 'Long-poll: wait for a new message (up to 30s), then return',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_name: { type: 'string', description: 'Your agent name' },
+            timeout_ms: { type: 'number', description: 'Wait timeout in ms (default 30000, max 60000)' },
+          },
+          required: ['agent_name'],
+        },
+      },
+      {
+        name: 'message_delete',
+        description: 'Delete messages from your inbox by message ID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_name: { type: 'string', description: 'Your agent name' },
+            message_ids: { type: 'array', items: { type: 'string' }, description: 'Message IDs to delete' },
+          },
+          required: ['agent_name', 'message_ids'],
+        },
+      },
+
+      // ── Channels ──
+      {
+        name: 'channel_create',
+        description: 'Create a shared channel for multi-agent conversations',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string', description: 'Channel name (e.g. dev-chat, general)' },
+            topic: { type: 'string', description: 'Channel topic/description' },
+            created_by: { type: 'string', description: 'Your agent name' },
+          },
+          required: ['channel_id'],
+        },
+      },
+      {
+        name: 'channel_join',
+        description: 'Join an existing channel to receive its messages',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string', description: 'Channel name' },
+            agent_name: { type: 'string', description: 'Your agent name' },
+          },
+          required: ['channel_id', 'agent_name'],
+        },
+      },
+      {
+        name: 'channel_leave',
+        description: 'Leave a channel',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string', description: 'Channel name' },
+            agent_name: { type: 'string', description: 'Your agent name' },
+          },
+          required: ['channel_id', 'agent_name'],
+        },
+      },
+      {
+        name: 'channel_send',
+        description: 'Send a message to a channel (delivered to all members)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string', description: 'Channel name' },
+            from: { type: 'string', description: 'Your agent name' },
+            message: { type: 'string', description: 'Message content' },
+          },
+          required: ['channel_id', 'from', 'message'],
+        },
+      },
+      {
+        name: 'channel_history',
+        description: 'Read recent messages from a channel',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string', description: 'Channel name' },
+            limit: { type: 'number', description: 'Max messages (default 50)' },
+          },
+          required: ['channel_id'],
+        },
+      },
+
+      // ── System Events ──
+      {
+        name: 'system_get_events',
+        description: 'Get recent system events (agent join/leave, profile changes, etc.)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            since: { type: 'string', description: 'ISO timestamp: only events after this time' },
+            category: { type: 'string', description: 'Filter by category (e.g. "system")' },
+            type: { type: 'string', description: 'Filter by event type (e.g. "agent_joined", "agent_offline")' },
+            limit: { type: 'number', description: 'Max events (default 100)' },
+          },
+        },
+      },
+      {
+        name: 'system_wait_for_event',
+        description: 'Long-poll: wait for a system event (agent join/leave, etc.)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            category: { type: 'string', description: 'Event category (e.g. "system")' },
+            type: { type: 'string', description: 'Event type (e.g. "agent_joined")' },
+            timeout_ms: { type: 'number', description: 'Wait timeout in ms (default 30000)' },
+          },
+        },
+      },
+
+      // ── Memory Layer ──
+      {
+        name: 'memory_store',
+        description: 'Store a memory for an agent. Memories persist in .bus/memory/ with keyword search index.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent: { type: 'string' },
+            content: { type: 'string' },
+            key: { type: 'string' },
+            namespace: { type: 'string' },
+            metadata: { type: 'object' },
+          },
+          required: ['agent', 'content'],
+        },
+      },
+      {
+        name: 'memory_search',
+        description: 'Search memories by content using TF-IDF keyword scoring + recency boost.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent: { type: 'string' },
+            query: { type: 'string' },
+            limit: { type: 'number' },
+            namespace: { type: 'string' },
+            threshold: { type: 'number' },
+          },
+          required: ['agent', 'query'],
+        },
+      },
+      {
+        name: 'memory_recall',
+        description: 'Recall a specific memory by ID or key.',
+        inputSchema: { type: 'object', properties: { agent: { type: 'string' }, id: { type: 'string' } }, required: ['agent', 'id'] },
+      },
+      {
+        name: 'memory_list',
+        description: 'List recent memories for an agent.',
+        inputSchema: { type: 'object', properties: { agent: { type: 'string' }, namespace: { type: 'string' }, limit: { type: 'number' }, offset: { type: 'number' } }, required: ['agent'] },
+      },
+      {
+        name: 'memory_forget',
+        description: 'Delete a specific memory by ID.',
+        inputSchema: { type: 'object', properties: { agent: { type: 'string' }, id: { type: 'string' } }, required: ['agent', 'id'] },
+      },
+      {
+        name: 'memory_stats',
+        description: 'Get memory usage statistics for an agent.',
+        inputSchema: { type: 'object', properties: { agent: { type: 'string' } }, required: ['agent'] },
+      },
+      {
+        name: 'memory_archive',
+        description: 'Archive old messages from agent inbox into memory, optionally deleting originals.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent: { type: 'string' },
+            max_age_days: { type: 'number' },
+            delete_after: { type: 'boolean' },
+          },
+          required: ['agent'],
+        },
+      },
+      {
+        name: 'memory_configure',
+        description: 'Configure embedding provider for semantic search (Ollama, OpenAI, Custom). Default: keyword-only.',
+        inputSchema: { type: 'object', properties: { provider: { type: 'string', enum: ['keyword', 'ollama', 'openai', 'custom'] }, api_key: { type: 'string' }, endpoint: { type: 'string' }, model: { type: 'string' } } },
+      },
+      {
+        name: 'memory_clear',
+        description: 'Clear all memories for an agent, optionally filtered by namespace.',
+        inputSchema: { type: 'object', properties: { agent: { type: 'string' }, namespace: { type: 'string' } }, required: ['agent'] },
+      },
+      {
+        name: 'memory_rebuild',
+        description: 'Rebuild all vector embeddings for an agent (requires embedding provider configured).',
+        inputSchema: { type: 'object', properties: { agent: { type: 'string' } }, required: ['agent'] },
+      },
+    ];
+
+    // Init memory store
+    const { MemoryStore } = require('./memory');
+    this.memory = new MemoryStore(path.join(__dirname, '..', '.bus'));
+
+    // Init scheduler & orchestrator
+    this.scheduler = new Scheduler(this.bus);
+    this.orchestrator = new Orchestrator(this.bus);
+
+    // Spread scheduler + orchestrator tools into this.tools
+    this.tools.push(...this.scheduler.getScheduleTools());
+    this.tools.push(...this.orchestrator.getTools());
+
+    // Start scheduler
+    this.scheduler.start();
+
+    // Update CoCo's tool list in profile
+    this.bus.updateProfile('coco', { tools: this.tools.map(t => t.name) });
+  }
+
+  async handleRequest(msg) {
+    const method = msg.method;
+    const id = msg.id;
+    const params = msg.params || {};
+
+    switch (method) {
+      case 'initialize':
+        return this._respond(id, {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'mcp-coco', version: '2.1.0' },
+        });
+
+      case 'notifications/initialized':
+        return null;
+
+      case 'tools/list':
+        return this._respond(id, { tools: this.tools });
+
+      case 'tools/call':
+        return await this._handleToolCall(id, params.name || '', params.arguments || {});
+
+      case 'shutdown':
+        return this._respond(id, null);
+
+      case 'ping':
+        return this._respond(id, { status: 'ok', agent: this.agentName });
+
+      default:
+        return this._error(id, -32601, `Method not found: ${method}`);
+    }
+  }
+
+  async _handleToolCall(id, tool, args) {
+    try {
+      let result;
+
+      switch (tool) {
+        // ── Hermes ──
+        case 'ask_hermes':
+          result = await this.bridge.askHermes(args.prompt || '', args.session_key || '');
+          break;
+        case 'hermes_send':
+          result = await this.bridge.sendMessage(args.target, args.message);
+          break;
+        case 'hermes_channels':
+          result = await this.bridge.listChannels(args.platform);
+          break;
+        case 'coco_health':
+          result = await this.bridge.healthCheck();
+          break;
+
+        // ── Agent Profiles & Registry ──
+        case 'agent_register': {
+          const metadata = {
+            capabilities: args.capabilities || [],
+            model: args.model || null,
+            tags: args.tags || [],
+            version: args.version || '1.0.0',
+            endpoints: args.endpoints || {},
+            tools: args.tools || [],
+            status: args.status || 'idle',
+            metadata: {},
+          };
+          if (args.description) metadata.description = args.description;
+          result = this.bus.registerAgent(args.name, args.description || 'MCP agent on CoCo bus', metadata);
+          break;
+        }
+        case 'agent_update_profile':
+          result = this.bus.updateProfile(args.name, args);
+          break;
+        case 'agent_get_profile':
+          result = { agent: this.bus.getProfile(args.name) };
+          break;
+        case 'agent_list':
+          result = { agents: this.bus.listAgents({
+            online_only: args.online_only,
+            capability: args.capability,
+            model: args.model,
+            tag: args.tag,
+            status: args.status,
+            search: args.search,
+          })};
+          break;
+        case 'agent_search': {
+          const agents = this.bus.listAgents({ search: args.query });
+          result = { query: args.query, count: agents.length, agents: agents.slice(0, args.max_results || 20) };
+          break;
+        }
+        case 'agent_heartbeat':
+          result = this.bus.heartbeat(args.name);
+          break;
+        case 'agent_set_status':
+          result = this.bus.setStatus(args.name, args.status);
+          break;
+
+        // ── Messages ──
+        case 'message_send':
+          result = this.bus.sendMessage(args.from, args.to, args.message, args.metadata);
+          // Trigger auto-reply rules after sending
+          if (result && result.sent) {
+            try {
+              this.orchestrator._checkRules({
+                id: result.message_id,
+                from: args.from,
+                to: args.to,
+                message: args.message,
+                metadata: args.metadata || {},
+                timestamp: new Date().toISOString(),
+              }, {
+                sendMessage: (from, to, msg) => this.bus.sendMessage(from, to, msg, { auto_reply: true }),
+                broadcastMessage: (from, msg) => this.bus.broadcastMessage(from, msg),
+              });
+            } catch (e) {
+              console.warn('[Auto-Reply] Error checking rules:', e.message);
+            }
+          }
+          break;
+        case 'message_broadcast':
+          result = this.bus.broadcastMessage(args.from, args.message);
+          break;
+        case 'message_fetch':
+          result = { messages: this.bus.fetchMessages(args.agent_name, args.limit, {
+            after_id: args.after_id,
+            from: args.from,
+          })};
+          break;
+        case 'message_wait':
+          this.bus.registerAgent(args.agent_name, `agent on bus`);
+          result = await this.bus.waitForMessages(args.agent_name, Math.min(args.timeout_ms || 30000, 60000));
+          break;
+        case 'message_delete':
+          result = this.bus.deleteMessages(args.agent_name, args.message_ids);
+          break;
+
+        // ── Channels ──
+        case 'channel_create':
+          result = this.bus.createChannel(args.channel_id, args.topic, args.created_by);
+          break;
+        case 'channel_join':
+          result = this.bus.joinChannel(args.channel_id, args.agent_name);
+          break;
+        case 'channel_leave':
+          result = this.bus.leaveChannel(args.channel_id, args.agent_name);
+          break;
+        case 'channel_send':
+          result = this.bus.channelSend(args.channel_id, args.from, args.message);
+          break;
+        case 'channel_history':
+          result = { messages: this.bus.channelHistory(args.channel_id, args.limit) };
+          break;
+
+        // ── System Events ──
+        case 'system_get_events':
+          result = { events: this.bus.getEvents({
+            since: args.since, category: args.category, type: args.type, limit: args.limit,
+          })};
+          break;
+        case 'system_wait_for_event':
+          result = await this.bus.waitForEvents(args.category, args.type, Math.min(args.timeout_ms || 30000, 60000));
+          break;
+
+        // ── Memory Layer ──
+        case 'memory_store':
+          result = { id: await this.memory.store(args.agent, {
+            content: args.content, key: args.key, namespace: args.namespace, metadata: args.metadata,
+          })};
+          break;
+        case 'memory_search':
+          result = { results: await this.memory.search(args.agent, args.query, {
+            limit: args.limit, namespace: args.namespace, threshold: args.threshold,
+          })};
+          break;
+        case 'memory_recall':
+          result = { memory: this.memory.recall(args.agent, args.id) };
+          break;
+        case 'memory_list':
+          result = { memories: this.memory.list(args.agent, { namespace: args.namespace, limit: args.limit, offset: args.offset }) };
+          break;
+        case 'memory_forget':
+          result = { deleted: this.memory.forget(args.agent, args.id) };
+          break;
+        case 'memory_stats':
+          result = this.memory.stats(args.agent);
+          break;
+        case 'memory_archive':
+          result = await this.memory.archive(args.agent, { maxAgeDays: args.max_age_days, deleteAfter: args.delete_after });
+          break;
+        case 'memory_configure':
+          result = this.memory.configure({ provider: args.provider, api_key: args.api_key, endpoint: args.endpoint, model: args.model });
+          break;
+        case 'memory_rebuild':
+          result = await this.memory.rebuildVectors(args.agent);
+          break;
+        case 'memory_clear':
+          result = { deleted: this.memory.clear(args.agent, args.namespace) };
+          break;
+
+        // ── Scheduler Tools ──
+        case 'scheduler_add':
+          result = this.scheduler.addJob(args);
+          break;
+        case 'scheduler_remove':
+          result = this.scheduler.removeJob(args.job_id);
+          break;
+        case 'scheduler_list':
+          result = { jobs: this.scheduler.listJobs() };
+          break;
+
+        // ── Auto-Reply Tools ──
+        case 'auto_reply_add':
+          result = this.orchestrator.addRule(args);
+          break;
+        case 'auto_reply_remove':
+          result = this.orchestrator.removeRule(args.rule_id);
+          break;
+        case 'auto_reply_list':
+          result = { rules: this.orchestrator.listRules() };
+          break;
+
+        // ── Workflow Tools ──
+        case 'workflow_create':
+          result = this.orchestrator.createWorkflow(args);
+          break;
+        case 'workflow_run':
+          result = await this.orchestrator.runWorkflow(args.workflow_id, args.input, args.timeout_ms);
+          break;
+        case 'workflow_remove':
+          result = this.orchestrator.removeWorkflow(args.workflow_id);
+          break;
+        case 'workflow_list':
+          result = { workflows: this.orchestrator.listWorkflows() };
+          break;
+
+        default:
+          return this._error(id, -32601, `Tool not found: ${tool}`);
+      }
+
+      return this._respond(id, {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        isError: false,
+      });
+    } catch (err) {
+      return this._respond(id, {
+        content: [{ type: 'text', text: `Error: ${err.message}` }],
+        isError: true,
+      });
+    }
+  }
+
+  _respond(id, result) {
+    return { jsonrpc: '2.0', id, result };
+  }
+
+  _error(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } };
+  }
+}
+
+async function runStdio() {
+  const server = new MCPServer();
+  const rl = readline.createInterface({ input: process.stdin });
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const msg = JSON.parse(trimmed);
+      const resp = await server.handleRequest(msg);
+      if (resp) {
+        process.stdout.write(JSON.stringify(resp) + '\n');
+      }
+    } catch (err) {
+      const errorResp = {
+        jsonrpc: '2.0',
+        error: { code: -32700, message: `Parse error: ${err.message}` },
+      };
+      process.stdout.write(JSON.stringify(errorResp) + '\n');
+    }
+  }
+}
+
+module.exports = { MCPServer, runStdio };