@xyz-credit/agent-cli 1.2.2 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyz-credit/agent-cli",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "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/auth.js

@@ -43,7 +43,7 @@ async function authCommand() {
     type: 'input',
     name: 'platformUrl',
     message: 'Platform URL:',
-    default: config.get('platformUrl') || 'https://agent-messaging.preview.emergentagent.com',
+    default: config.get('platformUrl') || 'https://thread-debug.preview.emergentagent.com',
     validate: (v) => v.startsWith('http') ? true : 'Must be a valid URL',
   }]);
 

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/setup.js

@@ -99,14 +99,50 @@ async function setupCommand() {
   if (isAuthenticated()) {
     const creds = getCredentials();
     console.log(chalk.yellow(`  Existing agent found: ${creds.agentName} (${creds.agentId.slice(0, 12)}...)`));
-    const { reconfigure } = await inquirer.prompt([{
-      type: 'confirm', name: 'reconfigure',
-      message: 'Reconfigure from scratch?', default: false,
+    const { action } = await inquirer.prompt([{
+      type: 'list', name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Start agent with existing configuration', value: 'start' },
+        { name: 'Reconfigure from scratch (keep agent)', value: 'reconfigure' },
+        { name: 'Remove existing agent & create new one', value: 'remove' },
+        { name: 'Exit', value: 'exit' },
+      ],
     }]);
-    if (!reconfigure) {
+
+    if (action === 'start') {
       console.log(chalk.green('  Using existing configuration.\n'));
+      console.log(chalk.dim('  Launching agent...\n'));
+      const { startCommand } = require('./start');
+      await startCommand({});
       return;
     }
+
+    if (action === 'remove') {
+      const { confirmRemove } = await inquirer.prompt([{
+        type: 'confirm', name: 'confirmRemove',
+        message: chalk.red('This will delete your local agent credentials. Are you sure?'),
+        default: false,
+      }]);
+      if (!confirmRemove) {
+        console.log(chalk.yellow('  Cancelled. Keeping existing agent.\n'));
+        return;
+      }
+      // Clear stored credentials
+      config.delete('agentId');
+      config.delete('agentName');
+      config.delete('apiKey');
+      config.delete('agentId');
+      console.log(chalk.green('  Agent credentials removed. Starting fresh setup...\n'));
+      // Fall through to full setup below
+    }
+
+    if (action === 'exit') {
+      console.log(chalk.dim('  Goodbye.\n'));
+      return;
+    }
+
+    // 'reconfigure' and 'remove' both fall through to the full setup wizard
   }
 
   // ── Step 1: Platform URL ──
@@ -114,7 +150,7 @@ async function setupCommand() {
   const { platformUrl } = await inquirer.prompt([{
     type: 'input', name: 'platformUrl',
     message: 'Platform URL:',
-    default: config.get('platformUrl') || 'https://agent-messaging.preview.emergentagent.com',
+    default: config.get('platformUrl') || 'https://thread-debug.preview.emergentagent.com',
     validate: (v) => v.startsWith('http') ? true : 'Must start with http(s)://',
   }]);
 

package/src/commands/start.js

@@ -291,16 +291,17 @@ async function dashboardStart(creds) {
         dashboard.addLog(`{red-fg}Send failed:{/red-fg} ${e.message}`);
       }
     } else if (cmd.type === 'retry-mcp') {
-      // Retry MCP connection
+      // Retry MCP connection using silent mode (no ora spinners)
       if (localMcpUrl) {
         dashboard.addLog(`Retrying MCP: ${localMcpUrl}`);
         try {
-          const discovery = await discoverAndRegisterServices();
-          if (discovery) {
-            dashboard.addLog(`{green-fg}MCP reconnected:{/green-fg} ${discovery.tools_count} tools found${discovery.registered ? ' (auto-registered)' : ''}`);
+          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');
+            dashboard.addLog('{red-fg}MCP retry failed:{/red-fg} Could not discover tools. Check MCP URL is correct.');
             dashboard.updateConnectivity(true, false);
           }
         } catch (e) {

package/src/services/dashboard.js

@@ -5,25 +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 { 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._renderTimer = null;
-    this._logQueue = [];
+    this._flushTimer = null;
+    this._dirty = false;
+
+    // Raw input state
+    this._inputBuffer = '';
   }
 
   start(agentName, platformUrl, mcpUrl) {
@@ -31,7 +37,6 @@ class Dashboard {
       smartCSR: true,
       title: `xyz-agent — ${agentName}`,
       fullUnicode: true,
-      grabKeys: false,
     });
 
     // ── Status Bar (top) ──
@@ -42,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({
@@ -70,71 +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.textarea({
+    // 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,
-      keys: true,
-      mouse: false,
-      inputOnFocus: false,
+      tags: true,
       style: { fg: 'white', bg: 'black' },
+      content: '',
     });
 
-    // Help text — use white so it's actually visible
+    // Help text — bright enough to see
     this.helpText = blessed.text({
       parent: inputContainer,
       top: 1, left: 1,
       tags: true,
-      content: '{white-fg}Commands: status | sync | post | inbox | retry | msg <id> <text> | quit{/white-fg}',
-      style: { fg: 'white', bg: 'black' },
+      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 enter key on textarea manually
-    this.inputBox.key('enter', () => {
-      const value = this.inputBox.getValue().replace(/\n/g, '').trim();
-      if (value) {
-        this._handleInput(value);
+    // ── 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._render();
-    });
 
-    // Escape/Ctrl-C to quit
-    this.inputBox.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;
+      }
 
-    // Global Ctrl-C fallback
-    this.screen.key(['C-c'], () => {
-      this.ee.emit('quit');
-    });
+      // 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;
 
-    // Tab to re-focus input
-    this.screen.key(['tab'], () => {
-      this.inputBox.focus();
-      this._render();
+      // 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 and do initial render
-    this.inputBox.focus();
+    // Initial render
     this.screen.render();
 
     this.addLog('Dashboard initialized. Type commands below.');
-    this.addLog(`Agent: ${agentName}`);
+    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();
 
@@ -172,6 +199,11 @@ class Dashboard {
       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+/);
@@ -195,32 +227,28 @@ 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();
-    this._logQueue.push(formatted);
+    if (this.logs.length > MAX_LOGS) this.logs = this.logs.slice(-MAX_LOGS);
+    this._dirty = true;
     this._scheduleFlush();
   }
 
   _scheduleFlush() {
-    if (this._renderTimer) return;
-    this._renderTimer = setTimeout(() => {
-      this._renderTimer = null;
-      this._flushLogs();
-    }, 50);
+    if (this._flushTimer) return;
+    this._flushTimer = setTimeout(() => {
+      this._flushTimer = null;
+      this._flush();
+    }, FLUSH_INTERVAL_MS);
   }
 
-  _flushLogs() {
-    if (!this.logBox || this._logQueue.length === 0) return;
-    const lines = this._logQueue.splice(0);
-    for (const line of lines) {
-      this.logBox.pushLine(line);
+  _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;
     }
-    this.logBox.setScrollPerc(100);
-    this._render();
-  }
-
-  _render() {
     if (this.screen) {
-      try { this.screen.render(); } catch { /* ignore render errors */ }
+      try { this.screen.render(); } catch { /* ignore */ }
     }
   }
 
@@ -235,14 +263,14 @@ 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
       );
-      this._render();
+      this._scheduleFlush();
     }
   }
 
@@ -257,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}`,
@@ -292,7 +313,7 @@ class Dashboard {
       .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);
-    this._render();
+    this._scheduleFlush();
   }
 
   _formatUptime(seconds) {
@@ -304,9 +325,9 @@ class Dashboard {
   }
 
   destroy() {
-    if (this._renderTimer) {
-      clearTimeout(this._renderTimer);
-      this._renderTimer = null;
+    if (this._flushTimer) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = null;
     }
     if (this.screen) {
       this.screen.destroy();

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;
   }