@xyz-credit/agent-cli 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyz-credit/agent-cli",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "CLI for onboarding AI agents to xyz.credit — Device Flow Auth, MCP Bridge, Service Marketplace, Daemonization & Cloud Export",
   "bin": {
     "xyz-agent": "./bin/xyz-agent.js"

package/src/commands/connect.js

@@ -212,8 +212,9 @@ async function trySSETransport(mcpUrl, spinner) {
   }
 }
 
-async function discoverMcpTools(mcpUrl) {
-  const spinner = ora(`Connecting to MCP server...`).start();
+async function discoverMcpTools(mcpUrl, options = {}) {
+  const silent = options.silent || false;
+  const spinner = silent ? { start() {}, stop() {}, succeed() {}, fail() {}, warn() {}, set text(v) {} } : ora(`Connecting to MCP server...`).start();
 
   // Try streamable HTTP first (faster, no streaming needed)
   let tools = await tryStreamableHttp(mcpUrl, spinner);
@@ -224,8 +225,10 @@ async function discoverMcpTools(mcpUrl) {
   if (tools !== null) return tools;
 
   spinner.fail(`Failed to connect to MCP server at: ${mcpUrl}`);
-  console.log(chalk.dim('  Tried both Streamable HTTP and SSE transports.'));
-  console.log(chalk.dim('  Ensure the MCP server is running and accessible.\n'));
+  if (!silent) {
+    console.log(chalk.dim('  Tried both Streamable HTTP and SSE transports.'));
+    console.log(chalk.dim('  Ensure the MCP server is running and accessible.\n'));
+  }
   return null;
 }
 

package/src/commands/start.js

@@ -290,6 +290,27 @@ async function dashboardStart(creds) {
       } catch (e) {
         dashboard.addLog(`{red-fg}Send failed:{/red-fg} ${e.message}`);
       }
+    } else if (cmd.type === 'retry-mcp') {
+      // Retry MCP connection using silent mode (no ora spinners)
+      if (localMcpUrl) {
+        dashboard.addLog(`Retrying MCP: ${localMcpUrl}`);
+        try {
+          const { discoverMcpTools } = require('./connect');
+          const tools = await discoverMcpTools(localMcpUrl, { silent: true });
+          if (tools && tools.length > 0) {
+            dashboard.addLog(`{green-fg}MCP connected:{/green-fg} ${tools.length} tools discovered`);
+            dashboard.updateConnectivity(true, true);
+          } else {
+            dashboard.addLog('{red-fg}MCP retry failed:{/red-fg} Could not discover tools. Check MCP URL is correct.');
+            dashboard.updateConnectivity(true, false);
+          }
+        } catch (e) {
+          dashboard.addLog(`{red-fg}MCP retry error:{/red-fg} ${e.message}`);
+          dashboard.updateConnectivity(true, false);
+        }
+      } else {
+        dashboard.addLog('{yellow-fg}No MCP URL configured.{/yellow-fg} Run setup to configure.');
+      }
     } else if (cmd.type === 'task') {
       dashboard.addLog(`Agent thought: User asked me to "${cmd.command}". Executing...`);
       // Check for pending tasks as the user requested

package/src/services/dashboard.js

@@ -5,24 +5,31 @@
  *   - Status bar: Online/Pending/Offline indicators
  *   - Connectivity: Central Hub + Local MCP connection strength
  *   - Activity Logs: Scrolling window with agent thoughts
- *   - Priority Task Input: User can type commands at any time
+ *   - Command Input: Raw keypress-based input (bypasses blessed input widget bugs)
  */
 const blessed = require('blessed');
-const chalk = require('chalk');
 const { EventEmitter } = require('events');
 
+const MAX_LOGS = 200;
+const FLUSH_INTERVAL_MS = 80;
+
 class Dashboard {
   constructor() {
     this.ee = new EventEmitter();
     this.screen = null;
     this.logBox = null;
     this.statusBox = null;
-    this.inputBox = null;
+    this.inputDisplay = null;
+    this.helpText = null;
     this.statsBox = null;
     this.logs = [];
     this.status = { status: 'starting', cycleCount: 0, uptimeSeconds: 0 };
     this.unreadCount = 0;
-    this.onUserCommand = null;
+    this._flushTimer = null;
+    this._dirty = false;
+
+    // Raw input state
+    this._inputBuffer = '';
   }
 
   start(agentName, platformUrl, mcpUrl) {
@@ -40,7 +47,7 @@ class Dashboard {
       border: { type: 'line' },
       style: { border: { fg: 'cyan' }, bg: 'black' },
     });
-    this._updateStatus(agentName);
+    this.statusBox.setContent(` {yellow-fg}STARTING{/yellow-fg}  |  Agent: {cyan-fg}${agentName}{/cyan-fg}  |  Initializing...`);
 
     // ── Stats Panel (right) ──
     this.statsBox = blessed.box({
@@ -55,7 +62,7 @@ class Dashboard {
     this._updateStats(agentName, platformUrl, mcpUrl);
 
     // ── Activity Logs (left) ──
-    this.logBox = blessed.log({
+    this.logBox = blessed.box({
       parent: this.screen,
       top: 3, left: 0, width: '65%', height: '60%',
       tags: true,
@@ -68,62 +75,93 @@ class Dashboard {
       mouse: true,
     });
 
-    // ── Input Box (bottom) ──
+    // ── Input Area (bottom) ──
     const inputContainer = blessed.box({
       parent: this.screen,
       bottom: 0, left: 0, width: '100%', height: 5,
       tags: true,
       border: { type: 'line' },
-      label: ' {green-fg}Command Input{/green-fg} (type a task, press Enter) ',
+      label: ' {green-fg}Command Input{/green-fg} (press Enter to submit) ',
       style: { border: { fg: 'green' }, bg: 'black' },
     });
 
-    this.inputBox = blessed.textbox({
+    // Display box for typed text (NOT a textbox/textarea — raw rendering)
+    this.inputDisplay = blessed.box({
       parent: inputContainer,
       top: 0, left: 1, right: 1, height: 1,
-      inputOnFocus: true,
+      tags: true,
       style: { fg: 'white', bg: 'black' },
+      content: '',
     });
 
-    // Help text
-    blessed.text({
+    // Help text — bright enough to see
+    this.helpText = blessed.text({
       parent: inputContainer,
       top: 1, left: 1,
       tags: true,
-      content: '{gray-fg}Commands: status | sync | post | inbox | msg <id> <text> | quit{/gray-fg}',
+      content: '{cyan-fg}Commands:{/cyan-fg} {white-fg}status{/white-fg} | {white-fg}sync{/white-fg} | {white-fg}post{/white-fg} | {white-fg}inbox{/white-fg} | {white-fg}retry{/white-fg} | {white-fg}msg <id> <text>{/white-fg} | {white-fg}quit{/white-fg}',
       style: { bg: 'black' },
     });
 
-    // Handle input
-    this.inputBox.on('submit', (value) => {
-      if (value && value.trim()) {
-        this._handleInput(value.trim());
+    // ── Raw keypress handling (avoids blessed input widget bugs) ──
+    this.screen.on('keypress', (ch, key) => {
+      if (!key) return;
+
+      // Ctrl-C / Escape → quit
+      if (key.full === 'C-c' || key.full === 'escape') {
+        this.ee.emit('quit');
+        return;
       }
-      this.inputBox.clearValue();
-      this.inputBox.focus();
-      this.screen.render();
-    });
 
-    // Key bindings
-    this.screen.key(['escape', 'C-c'], () => {
-      this.ee.emit('quit');
-    });
+      // Enter → submit command
+      if (key.full === 'return' || key.full === 'enter') {
+        const val = this._inputBuffer.trim();
+        if (val) this._handleInput(val);
+        this._inputBuffer = '';
+        this._renderInput();
+        return;
+      }
 
-    this.screen.key(['tab'], () => {
-      this.inputBox.focus();
-      this.screen.render();
+      // Backspace
+      if (key.full === 'backspace') {
+        if (this._inputBuffer.length > 0) {
+          this._inputBuffer = this._inputBuffer.slice(0, -1);
+          this._renderInput();
+        }
+        return;
+      }
+
+      // Tab — ignore (prevent focus issues)
+      if (key.full === 'tab') return;
+
+      // Arrow keys, function keys — ignore
+      if (key.full === 'up' || key.full === 'down' || key.full === 'left' || key.full === 'right') return;
+      if (key.full && key.full.startsWith('f') && key.full.length <= 3) return;
+
+      // Normal printable character
+      if (ch && ch.length === 1 && ch.charCodeAt(0) >= 32) {
+        this._inputBuffer += ch;
+        this._renderInput();
+      }
     });
 
-    // Focus input
-    this.inputBox.focus();
+    // Initial render
     this.screen.render();
 
-    this.addLog('Dashboard initialized. Press Tab to focus input.');
-    this.addLog(`Agent: ${agentName}`);
+    this.addLog('Dashboard initialized. Type commands below.');
+    this.addLog(`Agent: {cyan-fg}${agentName}{/cyan-fg}`);
     this.addLog(`Platform: ${platformUrl}`);
     if (mcpUrl) this.addLog(`MCP: ${mcpUrl}`);
   }
 
+  _renderInput() {
+    if (this.inputDisplay) {
+      // Show input with a cursor block
+      this.inputDisplay.setContent(this._inputBuffer + '{inverse} {/inverse}');
+      this._scheduleFlush();
+    }
+  }
+
   _handleInput(cmd) {
     const lower = cmd.toLowerCase();
 
@@ -155,6 +193,17 @@ class Dashboard {
       return;
     }
 
+    if (lower === 'retry' || lower === 'reconnect') {
+      this.addLog('Retrying MCP connection...');
+      this.ee.emit('user-command', { type: 'retry-mcp' });
+      return;
+    }
+
+    if (lower === 'help') {
+      this.addLog('Available commands: {cyan-fg}status{/cyan-fg} | {cyan-fg}sync{/cyan-fg} | {cyan-fg}post{/cyan-fg} | {cyan-fg}inbox{/cyan-fg} | {cyan-fg}retry{/cyan-fg} | {cyan-fg}msg <id> <text>{/cyan-fg} | {cyan-fg}quit{/cyan-fg}');
+      return;
+    }
+
     // msg <agent_id> <message text>
     if (lower.startsWith('msg ') || lower.startsWith('message ')) {
       const parts = cmd.split(/\s+/);
@@ -178,21 +227,29 @@ class Dashboard {
     const ts = new Date().toLocaleTimeString();
     const formatted = `{gray-fg}[${ts}]{/gray-fg} ${msg}`;
     this.logs.push(formatted);
-    if (this.logs.length > 500) this.logs.shift();
-    if (this.logBox) {
-      this.logBox.pushLine(formatted);
-      this.logBox.setScrollPerc(100);
-      this._scheduleRender();
-    }
+    if (this.logs.length > MAX_LOGS) this.logs = this.logs.slice(-MAX_LOGS);
+    this._dirty = true;
+    this._scheduleFlush();
   }
 
-  _scheduleRender() {
-    if (this._renderPending) return;
-    this._renderPending = true;
-    setImmediate(() => {
-      this._renderPending = false;
-      if (this.screen) this.screen.render();
-    });
+  _scheduleFlush() {
+    if (this._flushTimer) return;
+    this._flushTimer = setTimeout(() => {
+      this._flushTimer = null;
+      this._flush();
+    }, FLUSH_INTERVAL_MS);
+  }
+
+  _flush() {
+    if (this._dirty && this.logBox) {
+      // Use setContent with full buffer — avoids pushLine corruption
+      this.logBox.setContent(this.logs.join('\n'));
+      this.logBox.setScrollPerc(100);
+      this._dirty = false;
+    }
+    if (this.screen) {
+      try { this.screen.render(); } catch { /* ignore */ }
+    }
   }
 
   updateHeartbeat(data) {
@@ -206,20 +263,19 @@ class Dashboard {
       const uptime = this._formatUptime(data.uptimeSeconds || 0);
       const msgBadge = this.unreadCount > 0
         ? `  |  {yellow-fg}Mail: ${this.unreadCount} unread{/yellow-fg}`
-        : `  |  Mail: {gray-fg}0{/gray-fg}`;
+        : '';
       this.statusBox.setContent(
         ` ${indicator}  |  Cycles: {cyan-fg}${data.cycleCount}{/cyan-fg}  |  ` +
         `Uptime: {cyan-fg}${uptime}{/cyan-fg}  |  ` +
         `Last Ping: {gray-fg}${data.lastPing ? new Date(data.lastPing).toLocaleTimeString() : '-'}{/gray-fg}` +
         msgBadge
       );
-      if (this.screen) this._scheduleRender();
+      this._scheduleFlush();
     }
   }
 
   updateUnreadCount(count) {
     this.unreadCount = count;
-    // Re-render status bar with new count
     if (this.status) this.updateHeartbeat(this.status);
   }
 
@@ -229,15 +285,8 @@ class Dashboard {
     this.addLog(`{yellow-fg}[NEW MSG]{/yellow-fg} From {cyan-fg}${from}{/cyan-fg}: ${preview}${msg.message?.length > 60 ? '...' : ''}`);
   }
 
-  _updateStatus(agentName) {
-    if (this.statusBox) {
-      this.statusBox.setContent(` {yellow-fg}STARTING{/yellow-fg}  |  Agent: {cyan-fg}${agentName}{/cyan-fg}  |  Initializing...`);
-    }
-  }
-
   _updateStats(agentName, platformUrl, mcpUrl) {
     if (!this.statsBox) return;
-
     const lines = [
       ` {bold}Agent{/bold}`,
       `  Name: {cyan-fg}${agentName}{/cyan-fg}`,
@@ -259,13 +308,12 @@ class Dashboard {
 
   updateConnectivity(hub, mcp) {
     if (!this.statsBox) return;
-    // Find and update connectivity lines
     const content = this.statsBox.getContent();
     let updated = content
       .replace(/Hub.*\n.*Status: .*/, `Hub\n  Status: ${hub ? '{green-fg}Connected{/green-fg}' : '{red-fg}Disconnected{/red-fg}'}`)
       .replace(/MCP.*\n.*Status: .*/, `MCP\n  Status: ${mcp ? '{green-fg}Connected{/green-fg}' : mcp === null ? '{gray-fg}N/A{/gray-fg}' : '{red-fg}Disconnected{/red-fg}'}`);
     this.statsBox.setContent(updated);
-    if (this.screen) this._scheduleRender();
+    this._scheduleFlush();
   }
 
   _formatUptime(seconds) {
@@ -277,6 +325,10 @@ class Dashboard {
   }
 
   destroy() {
+    if (this._flushTimer) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = null;
+    }
     if (this.screen) {
       this.screen.destroy();
       this.screen = null;

package/src/services/risk.js

@@ -77,7 +77,7 @@ async function discoverAndRegisterServices() {
   const { discoverMcpTools } = require('../commands/connect');
   let tools;
   try {
-    tools = await discoverMcpTools(mcpUrl);
+    tools = await discoverMcpTools(mcpUrl, { silent: true });
   } catch {
     return null;
   }