@xyz-credit/agent-cli 1.1.2 → 1.2.1

package/bin/xyz-agent.js

@@ -1,105 +1,178 @@
 #!/usr/bin/env node
 /**
- * xyz-agent CLI — AI Agent Onboarding for xyz.credit
- * 
- * Usage:
- *   npx @xyz-credit/agent-cli auth          # Device Flow Auth
- *   npx @xyz-credit/agent-cli config         # Interactive config editor
- *   npx @xyz-credit/agent-cli config headless on  # Enable headless mode
- *   npx @xyz-credit/agent-cli config allow interactive  # Edit allow_list
- *   npx @xyz-credit/agent-cli connect       # MCP Bridge & Auto-Discovery
- *   npx @xyz-credit/agent-cli register-service  # Register local MCP tools
- *   npx @xyz-credit/agent-cli market        # Auto-market services on forum
- *   npx @xyz-credit/agent-cli start         # Start agent (foreground)
- *   npx @xyz-credit/agent-cli start --daemon # Start agent (background via pm2)
- *   npx @xyz-credit/agent-cli generate-docker # Generate Dockerfile for cloud deploy
- *   npx @xyz-credit/agent-cli status        # Check agent status
+ * xyz-agent CLI — @xyz-credit/agent-cli
+ *
+ * Commands:
+ *   setup              Automated setup wizard (LLM, MCP, config)
+ *   auth               Authenticate with xyz.credit platform
+ *   connect            Bridge local MCP tools
+ *   register-service   Publish services to marketplace
+ *   market             Manage marketplace listings
+ *   start              Launch agent with dashboard & heartbeat
+ *   start --headless   Launch in headless mode
+ *   start --daemon     Launch as background daemon (pm2)
+ *   status             Show agent status
+ *   generate-docker    Generate Dockerfile
  */
-const { program } = require('commander');
+const { Command } = require('commander');
 const chalk = require('chalk');
+const boxen = require('boxen');
+const { config } = require('../src/config');
+
+const program = new Command();
+const pkg = require('../package.json');
 
 program
   .name('xyz-agent')
-  .description('CLI for onboarding AI agents to xyz.credit')
-  .version('1.1.2');
+  .description('xyz.credit AI Agent CLI — join the decentralized agent economy')
+  .version(pkg.version);
 
-// ── Config Command ────────────────────────────────────
+// ── Setup Wizard ──
 program
-  .command('config [subcommand] [args...]')
-  .description('Manage allow_list, headless mode, and credentials')
-  .action(async (subcommand, args) => {
-    const { configCommand } = require('../src/commands/config');
-    await configCommand(subcommand, args);
+  .command('setup')
+  .description('Automated setup wizard — configure LLM, MCP, and agent identity')
+  .action(async () => {
+    try {
+      const { setupCommand } = require('../src/commands/setup');
+      await setupCommand();
+    } catch (e) {
+      console.error(chalk.red(`  Setup error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Auth Command ──────────────────────────────────────
+// ── Auth ──
 program
   .command('auth')
-  .description('Authenticate via Device Flow (browser verification + CAPTCHA)')
+  .description('Authenticate with the xyz.credit platform')
   .action(async () => {
-    const { authCommand } = require('../src/commands/auth');
-    await authCommand();
+    try {
+      const { authCommand } = require('../src/commands/auth');
+      await authCommand();
+    } catch (e) {
+      console.error(chalk.red(`  Auth error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Connect Command ───────────────────────────────────
+// ── Connect ──
 program
   .command('connect')
-  .description('Connect to a local MCP server and introspect available tools')
-  .option('-u, --url <url>', 'Local MCP server URL')
+  .description('Bridge local MCP tools to the network')
+  .option('-u, --url <url>', 'MCP server URL (SSE endpoint)')
   .action(async (opts) => {
-    const { connectCommand } = require('../src/commands/connect');
-    await connectCommand(opts);
+    try {
+      const { connectCommand } = require('../src/commands/connect');
+      await connectCommand(opts);
+    } catch (e) {
+      console.error(chalk.red(`  Connect error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Register Service Command ──────────────────────────
+// ── Register Service ──
 program
   .command('register-service')
-  .description('Register local MCP tools as a marketplace service')
-  .option('-n, --name <name>', 'Service name')
-  .option('-f, --fee <fee>', 'Fee in USDC', '0')
-  .action(async (opts) => {
-    const { registerServiceCommand } = require('../src/commands/register_service');
-    await registerServiceCommand(opts);
+  .alias('register')
+  .description('Register your MCP tools as marketplace services')
+  .action(async () => {
+    try {
+      const { registerServiceCommand } = require('../src/commands/register_service');
+      await registerServiceCommand();
+    } catch (e) {
+      console.error(chalk.red(`  Register error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Market Command ────────────────────────────────────
+// ── Market ──
 program
   .command('market')
-  .description('Auto-advertise services on the xyz.credit forum')
-  .option('-i, --interval <minutes>', 'Post interval in minutes', '360')
-  .option('--once', 'Post a single ad and exit (no loop)')
+  .description('Browse and manage marketplace listings')
+  .option('-t, --template <type>', 'Create from template (analytics, api, content, data)')
+  .option('--dry-run', 'Preview without publishing')
   .action(async (opts) => {
-    const { marketCommand } = require('../src/commands/market');
-    await marketCommand(opts);
+    try {
+      const { marketCommand } = require('../src/commands/market');
+      await marketCommand(opts);
+    } catch (e) {
+      console.error(chalk.red(`  Market error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Start Command ─────────────────────────────────────
+// ── Start ──
 program
   .command('start')
-  .description('Start the agent (listens for incoming service requests)')
-  .option('-d, --daemon', 'Run as background daemon via pm2')
+  .description('Start agent with dashboard, heartbeat & marketplace sync')
+  .option('--headless', 'Run in headless mode (no terminal UI)')
+  .option('--daemon [subcommand]', 'Run as background daemon (pm2). Subcommands: status, logs, stop')
   .action(async (opts) => {
-    const { startCommand } = require('../src/commands/start');
-    await startCommand(opts);
+    try {
+      const { startCommand } = require('../src/commands/start');
+      await startCommand(opts);
+    } catch (e) {
+      console.error(chalk.red(`  Start error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Generate Docker Command ───────────────────────────
+// ── Generate Docker ──
 program
   .command('generate-docker')
-  .description('Generate a Dockerfile for cloud deployment')
-  .option('-o, --output <path>', 'Output directory', '.')
+  .description('Generate Dockerfile for cloud deployment')
+  .option('-p, --preset <provider>', 'Cloud preset: aws, gcp, azure, railway, fly')
   .action(async (opts) => {
-    const { generateDockerCommand } = require('../src/commands/docker');
-    await generateDockerCommand(opts);
+    try {
+      const { dockerCommand } = require('../src/commands/docker');
+      await dockerCommand(opts);
+    } catch (e) {
+      console.error(chalk.red(`  Docker error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
-// ── Status Command ────────────────────────────────────
+// ── Message ──
+program
+  .command('message [action] [args...]')
+  .alias('msg')
+  .description('Agent-to-agent direct messaging (send, inbox, outbox, read, agents)')
+  .option('-s, --subject <subject>', 'Message subject')
+  .option('-m, --message <message>', 'Message content (alternative to positional)')
+  .option('--unread', 'Show only unread messages')
+  .action(async (action, args, opts) => {
+    try {
+      const { messageCommand } = require('../src/commands/message');
+      await messageCommand(action, args, opts);
+    } catch (e) {
+      console.error(chalk.red(`  Message error: ${e.message}`));
+      process.exit(1);
+    }
+  });
+
+// ── Status ──
 program
   .command('status')
-  .description('Check agent registration and service status')
+  .description('Show agent status and connectivity')
   .action(async () => {
-    const { statusCommand } = require('../src/commands/status');
-    await statusCommand();
+    try {
+      const { statusCommand } = require('../src/commands/status');
+      await statusCommand();
+    } catch (e) {
+      console.error(chalk.red(`  Status error: ${e.message}`));
+      process.exit(1);
+    }
   });
 
+// ── Default ──
+if (process.argv.length <= 2) {
+  console.log('');
+  console.log(boxen(
+    chalk.bold.cyan('  xyz.credit Agent CLI\n\n') +
+    chalk.white(`  Get started: ${chalk.cyan('xyz-agent setup')}\n`) +
+    chalk.dim(`  View commands: ${chalk.white('xyz-agent --help')}`),
+    { padding: 1, margin: 1, borderColor: 'cyan', borderStyle: 'round' }
+  ));
+}
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyz-credit/agent-cli",
-  "version": "1.1.2",
+  "version": "1.2.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"
@@ -19,6 +19,7 @@
     "register-service": "node bin/xyz-agent.js register-service"
   },
   "dependencies": {
+    "blessed": "^0.1.81",
     "boxen": "^5.1.2",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",

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-registry-4.preview.emergentagent.com',
+    default: config.get('platformUrl') || 'https://agent-messaging.preview.emergentagent.com',
     validate: (v) => v.startsWith('http') ? true : 'Must be a valid URL',
   }]);
 

package/src/commands/connect.js

@@ -1,8 +1,12 @@
 /**
  * Connect Command — MCP Bridge & Introspection Engine
  * 
- * Connects to the user's local MCP server, discovers available tools,
+ * Connects to an MCP server (local or remote), discovers available tools,
  * and prepares them for marketplace registration.
+ *
+ * Supports:
+ *   - Streamable HTTP (POST JSON-RPC with Accept: application/json, text/event-stream)
+ *   - SSE transport (GET /sse → get messages endpoint → POST JSON-RPC)
  */
 const inquirer = require('inquirer');
 const chalk = require('chalk');
@@ -10,21 +14,160 @@ const ora = require('ora');
 const fetch = require('node-fetch');
 const { config, isAuthenticated, getCredentials } = require('../config');
 
-async function discoverMcpTools(mcpUrl) {
+function parseSSEResponse(text) {
+  for (const line of text.split('\n')) {
+    if (line.startsWith('data: ')) {
+      try { return JSON.parse(line.slice(6)); } catch { /* skip */ }
+    }
+  }
+  return null;
+}
+
+async function tryStreamableHttp(baseUrl, spinner) {
   /**
-   * Connect to a local MCP server and call tools/list to extract
-   * available functions and their JSON schemas.
-   * 
-   * For SSE-based MCP servers, we use the JSON-RPC protocol.
+   * Try streamable HTTP transport.
+   * Derives candidate URLs from the input.
    */
-  const spinner = ora(`Connecting to ${mcpUrl}...`).start();
+  const candidates = [];
+  const stripped = baseUrl.replace(/\/+$/, '');
+
+  // If URL ends with /sse, convert to streamable HTTP equivalents
+  if (stripped.endsWith('/sse')) {
+    const sseBase = stripped.replace(/\/sse$/, '');
+    // xyz.credit pattern: /api/mcp/sse → /api/mcp-http/mcp
+    const parts = sseBase.split('/');
+    const lastPart = parts[parts.length - 1];
+    const parentPath = parts.slice(0, -1).join('/');
+    candidates.push(`${parentPath}/${lastPart}-http/${lastPart}`);
+    candidates.push(`${sseBase}/mcp`);
+    candidates.push(sseBase);
+  } else {
+    candidates.push(stripped);
+    candidates.push(`${stripped}/mcp`);
+    // Also try deriving the -http pattern (e.g. /api/mcp → /api/mcp-http/mcp)
+    const parts = stripped.split('/');
+    const lastPart = parts[parts.length - 1];
+    const parentPath = parts.slice(0, -1).join('/');
+    candidates.push(`${parentPath}/${lastPart}-http/${lastPart}`);
+  }
+
+  for (const url of candidates) {
+    try {
+      spinner.text = `Trying ${url}...`;
+      const initRes = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json, text/event-stream',
+        },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'initialize',
+          params: {
+            protocolVersion: '2025-03-26',
+            capabilities: {},
+            clientInfo: { name: 'xyz-agent-cli', version: '1.1.2' }
+          }
+        }),
+        timeout: 15000,
+      });
+
+      if (!initRes.ok) continue;
+
+      const initText = await initRes.text();
+      const initData = parseSSEResponse(initText) || JSON.parse(initText);
+      if (!initData?.result) continue;
+
+      const sessionId = initRes.headers.get('mcp-session-id') || '';
+      spinner.text = 'Listing tools...';
+
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json, text/event-stream',
+      };
+      if (sessionId) headers['Mcp-Session-Id'] = sessionId;
+
+      const toolsRes = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: 2,
+          method: 'tools/list',
+          params: {}
+        }),
+        timeout: 15000,
+      });
+
+      const toolsText = await toolsRes.text();
+      const toolsData = parseSSEResponse(toolsText) || JSON.parse(toolsText);
+      const tools = toolsData?.result?.tools || [];
+
+      spinner.succeed(`Connected via Streamable HTTP! Found ${tools.length} tools`);
+      return tools;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+async function trySSETransport(mcpUrl, spinner) {
+  /**
+   * Try SSE transport: connect to SSE endpoint, get messages URL, POST to it.
+   */
+  const sseUrl = mcpUrl.endsWith('/sse') ? mcpUrl : `${mcpUrl}/sse`;
 
   try {
-    // Try streamable HTTP first (POST with JSON-RPC)
-    const httpUrl = mcpUrl.replace('/sse', '').replace(/\/$/, '');
-    
-    // Initialize session
-    const initRes = await fetch(httpUrl, {
+    spinner.text = `Trying SSE at ${sseUrl}...`;
+
+    // Fetch the SSE stream briefly to get the endpoint event
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10000);
+
+    const sseRes = await fetch(sseUrl, {
+      headers: { 'Accept': 'text/event-stream' },
+      signal: controller.signal,
+    });
+
+    if (!sseRes.ok) return null;
+
+    // Read SSE stream to find endpoint event
+    let messagesUrl = null;
+    const reader = sseRes.body;
+    let buffer = '';
+
+    await new Promise((resolve) => {
+      const onData = (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        for (const line of lines) {
+          if (line.startsWith('data: ') && buffer.includes('event: endpoint')) {
+            messagesUrl = line.slice(6).trim();
+            reader.removeListener('data', onData);
+            clearTimeout(timeout);
+            controller.abort();
+            resolve();
+            return;
+          }
+        }
+      };
+      reader.on('data', onData);
+      setTimeout(() => { reader.removeListener('data', onData); resolve(); }, 8000);
+    });
+
+    if (!messagesUrl) return null;
+
+    // Make messages URL absolute
+    const base = new URL(sseUrl);
+    if (messagesUrl.startsWith('/')) {
+      messagesUrl = `${base.protocol}//${base.host}${messagesUrl}`;
+    }
+
+    spinner.text = 'Initializing via SSE messages endpoint...';
+
+    const initRes = await fetch(messagesUrl, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -34,53 +177,62 @@ async function discoverMcpTools(mcpUrl) {
         params: {
           protocolVersion: '2025-03-26',
           capabilities: {},
-          clientInfo: { name: 'xyz-agent-cli', version: '1.0.0' }
+          clientInfo: { name: 'xyz-agent-cli', version: '1.1.2' }
         }
       }),
-      timeout: 10000,
+      timeout: 15000,
     });
 
-    if (!initRes.ok) {
-      throw new Error(`MCP server returned ${initRes.status}`);
-    }
-
-    const initData = await initRes.json();
-    spinner.text = 'Listing available tools...';
-
-    // Get session ID from response headers if present
-    const sessionId = initRes.headers.get('mcp-session-id') || '';
+    if (!initRes.ok) return null;
 
-    // Call tools/list
-    const headers = { 'Content-Type': 'application/json' };
-    if (sessionId) headers['mcp-session-id'] = sessionId;
+    spinner.text = 'Listing tools via SSE...';
 
-    const toolsRes = await fetch(httpUrl, {
+    const toolsRes = await fetch(messagesUrl, {
       method: 'POST',
-      headers,
+      headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         jsonrpc: '2.0',
         id: 2,
         method: 'tools/list',
         params: {}
       }),
-      timeout: 10000,
+      timeout: 15000,
     });
 
-    const toolsData = await toolsRes.json();
-    const tools = toolsData.result?.tools || [];
+    if (!toolsRes.ok) return null;
+
+    const toolsText = await toolsRes.text();
+    const toolsData = parseSSEResponse(toolsText) || JSON.parse(toolsText);
+    const tools = toolsData?.result?.tools || [];
 
-    spinner.succeed(`Connected! Found ${tools.length} tools`);
+    spinner.succeed(`Connected via SSE! Found ${tools.length} tools`);
     return tools;
-  } catch (e) {
-    spinner.fail(`Failed to connect to MCP server: ${e.message}`);
+  } catch {
     return null;
   }
 }
 
+async function discoverMcpTools(mcpUrl) {
+  const spinner = ora(`Connecting to MCP server...`).start();
+
+  // Try streamable HTTP first (faster, no streaming needed)
+  let tools = await tryStreamableHttp(mcpUrl, spinner);
+  if (tools !== null) return tools;
+
+  // Fallback to SSE transport
+  tools = await trySSETransport(mcpUrl, spinner);
+  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'));
+  return null;
+}
+
 async function connectCommand(opts) {
   console.log('');
   console.log(chalk.bold.cyan('  MCP Bridge — Tool Introspection'));
-  console.log(chalk.dim('  Connect to your local MCP server and discover tools\n'));
+  console.log(chalk.dim('  Connect to your MCP server and discover tools\n'));
 
   if (!isAuthenticated()) {
     console.log(chalk.red('  Not authenticated. Run `xyz-agent auth` first.\n'));
@@ -93,7 +245,7 @@ async function connectCommand(opts) {
     const answer = await inquirer.prompt([{
       type: 'input',
       name: 'mcpUrl',
-      message: 'Local MCP server URL:',
+      message: 'MCP server URL:',
       default: 'http://localhost:3001/mcp',
       validate: (v) => v.startsWith('http') ? true : 'Must be a valid URL',
     }]);
@@ -117,10 +269,11 @@ async function connectCommand(opts) {
     const params = tool.inputSchema?.properties
       ? Object.keys(tool.inputSchema.properties).join(', ')
       : 'none';
+    const desc = (tool.description || 'No description').split('\n')[0].slice(0, 60);
     console.log(
       chalk.white(`  ${chalk.dim(`${i + 1}.`)} ${chalk.cyan(tool.name)}`) +
-      chalk.dim(` — ${tool.description || 'No description'}`) +
-      chalk.dim(` (params: ${params})`)
+      chalk.dim(` — ${desc}`) +
+      chalk.dim(` (${params.length > 40 ? params.slice(0, 40) + '...' : params})`)
     );
   });
 
@@ -130,7 +283,7 @@ async function connectCommand(opts) {
   // Store discovered tools in config for register-service
   config.set('discoveredTools', tools.map(t => ({
     name: t.name,
-    description: t.description || '',
+    description: (t.description || '').split('\n')[0].slice(0, 200),
     input_schema: t.inputSchema || {},
   })));
 }