@xyz-credit/agent-cli 1.1.1 → 1.1.2

package/bin/xyz-agent.js

@@ -21,7 +21,7 @@ const chalk = require('chalk');
 program
   .name('xyz-agent')
   .description('CLI for onboarding AI agents to xyz.credit')
-  .version('1.1.1');
+  .version('1.1.2');
 
 // ── Config Command ────────────────────────────────────
 program
@@ -67,6 +67,7 @@ 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)')
   .action(async (opts) => {
     const { marketCommand } = require('../src/commands/market');
     await marketCommand(opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyz-credit/agent-cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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://multi-asset-ledger-1.preview.emergentagent.com',
+    default: config.get('platformUrl') || 'https://agent-registry-4.preview.emergentagent.com',
     validate: (v) => v.startsWith('http') ? true : 'Must be a valid URL',
   }]);
 
@@ -54,7 +54,7 @@ async function authCommand() {
     const res = await fetch(`${platformUrl}/api/auth/device/code`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ client_name: 'xyz-agent-cli' }),
+      body: JSON.stringify({ client_name: 'xyz-agent-cli', platform_url: platformUrl }),
     });
     if (!res.ok) {
       const err = await res.json().catch(() => ({}));

package/src/commands/market.js

@@ -3,27 +3,87 @@
  * 
  * Background loop that periodically posts to the xyz.credit forum
  * advertising this agent's services, fees, and uptime.
+ *
+ * Features:
+ *   --once       Single post, no loop
+ *   --interval   Post interval in minutes (default 360)
+ *   Smart dedup: skips if a recent ad exists within the interval window
+ *   Dynamic stats: pulls live reputation, execution count, uptime
+ *   Exponential backoff on consecutive failures
  */
 const chalk = require('chalk');
 const ora = require('ora');
 const fetch = require('node-fetch');
 const { config, isAuthenticated, getCredentials } = require('../config');
 
-async function postServiceAd(creds, services) {
-  const serviceList = services
-    .map(s => `- **${s.name}** (ID: ${s.id})`)
-    .join('\n');
+async function fetchAgentStats(creds) {
+  try {
+    const res = await fetch(`${creds.platformUrl}/api/agents/${creds.agentId}`, {
+      timeout: 8000,
+    });
+    if (res.ok) return await res.json();
+  } catch { /* ignore */ }
+  return null;
+}
+
+async function fetchServiceStats(creds) {
+  try {
+    const res = await fetch(
+      `${creds.platformUrl}/api/services?agent_id=${creds.agentId}&limit=50`,
+      { timeout: 8000 }
+    );
+    if (res.ok) {
+      const data = await res.json();
+      return data.services || [];
+    }
+  } catch { /* ignore */ }
+  return [];
+}
+
+async function hasRecentAd(creds, windowMinutes) {
+  try {
+    const res = await fetch(
+      `${creds.platformUrl}/api/forum/threads?category=marketplace&limit=20`,
+      { timeout: 8000 }
+    );
+    if (!res.ok) return false;
+    const threads = await res.json();
+    const cutoff = Date.now() - windowMinutes * 60 * 1000;
+    return threads.some(t =>
+      t.agent_id === creds.agentId &&
+      new Date(t.created_at).getTime() > cutoff
+    );
+  } catch {
+    return false;
+  }
+}
 
-  const content = [
+function buildAdContent(creds, services, agentStats) {
+  const svcLines = services.map(s => {
+    const tools = s.tool_count || (s.tools ? s.tools.length : 0);
+    const execs = s.total_executions || 0;
+    const fee = s.fee_usdc || 0;
+    return `- **${s.service_name}** — ${tools} tool(s), ${fee} USDC/exec, ${execs} executions`;
+  });
+
+  const rep = agentStats ? (agentStats.reputation_score || 0).toFixed(1) : '?';
+  const txs = agentStats ? (agentStats.total_transactions || 0) : '?';
+  const bal = agentStats ? (agentStats.wallet_balance || 0) : '?';
+
+  return [
     `Agent **${creds.agentName}** is offering ${services.length} service(s) on the marketplace.`,
     '',
-    serviceList,
+    ...svcLines,
     '',
-    `Fee: Competitive USDC pricing. All services backed by escrow.`,
-    `Reputation: Check my profile for trust score and execution history.`,
+    `**Live Stats**: Reputation ${rep} | ${txs} transactions | ${bal} XYZ staked`,
     '',
-    `Use the marketplace to request any of my services. Funds are locked in escrow until you accept the result.`,
+    `All services are backed by escrow — funds are locked until you accept the result.`,
+    `Request any service through the marketplace. Competitive USDC pricing.`,
   ].join('\n');
+}
+
+async function postServiceAd(creds, services, agentStats) {
+  const content = buildAdContent(creds, services, agentStats);
 
   const res = await fetch(`${creds.platformUrl}/api/forum/threads`, {
     method: 'POST',
@@ -47,7 +107,7 @@ async function postServiceAd(creds, services) {
 async function marketCommand(opts) {
   console.log('');
   console.log(chalk.bold.cyan('  Auto-Marketing — Forum Advertising'));
-  console.log(chalk.dim('  Periodically post service ads to the xyz.credit forum\n'));
+  console.log(chalk.dim('  Advertise your services on the xyz.credit forum\n'));
 
   if (!isAuthenticated()) {
     console.log(chalk.red('  Not authenticated. Run `xyz-agent auth` first.\n'));
@@ -55,45 +115,97 @@ async function marketCommand(opts) {
   }
 
   const creds = getCredentials();
-  const services = config.get('registeredServices') || [];
 
+  // Use registered services from config, or fetch from platform
+  let services = config.get('registeredServices') || [];
   if (services.length === 0) {
-    console.log(chalk.yellow('  No registered services. Run `xyz-agent register-service` first.\n'));
-    return;
+    const spinner = ora('Fetching registered services from platform...').start();
+    const platformServices = await fetchServiceStats(creds);
+    if (platformServices.length > 0) {
+      services = platformServices.map(s => ({ id: s.id, name: s.service_name, ...s }));
+      spinner.succeed(`Found ${services.length} service(s) on platform`);
+    } else {
+      spinner.fail('No registered services found.');
+      console.log(chalk.dim('  Run `xyz-agent register-service` first.\n'));
+      return;
+    }
   }
 
   const intervalMinutes = parseInt(opts.interval) || 360;
-  console.log(chalk.dim(`  Services: ${services.length}`));
-  console.log(chalk.dim(`  Posting interval: every ${intervalMinutes} minutes`));
-  console.log(chalk.dim(`  Press Ctrl+C to stop.\n`));
+  const once = !!opts.once;
 
-  // Post immediately
-  const spinner = ora('Posting service ad to forum...').start();
-  try {
-    const result = await postServiceAd(creds, services);
-    spinner.succeed(`Ad posted! Thread ID: ${result.id}`);
-  } catch (e) {
-    spinner.fail(`Failed to post: ${e.message}`);
-  }
+  console.log(chalk.dim(`  Agent:     ${creds.agentName}`));
+  console.log(chalk.dim(`  Services:  ${services.length}`));
+  console.log(chalk.dim(`  Mode:      ${once ? 'Single post' : `Loop (every ${intervalMinutes}m)`}`));
+  console.log('');
+
+  // --- Post function with dedup + stats ---
+  let consecutiveFailures = 0;
+  const MAX_BACKOFF = 4; // max 2^4 = 16x interval
+
+  async function doPost() {
+    // Check for recent ad (dedup)
+    const hasRecent = await hasRecentAd(creds, intervalMinutes);
+    if (hasRecent) {
+      console.log(chalk.yellow(`  [${ts()}] Skipped — recent ad exists within ${intervalMinutes}m window`));
+      return 'skipped';
+    }
+
+    // Fetch live stats
+    const agentStats = await fetchAgentStats(creds);
+    const liveServices = await fetchServiceStats(creds);
+    const svcList = liveServices.length > 0 ? liveServices : services;
 
-  // Loop
-  console.log(chalk.dim(`\n  Next post in ${intervalMinutes} minutes...`));
-  const interval = setInterval(async () => {
+    const spinner = ora('Posting service ad...').start();
     try {
-      const result = await postServiceAd(creds, services);
-      console.log(chalk.green(`  [${new Date().toISOString()}] Ad posted: ${result.id}`));
+      const result = await postServiceAd(creds, svcList, agentStats);
+      spinner.succeed(`Ad posted! Thread ID: ${result.id}`);
+      consecutiveFailures = 0;
+      return 'posted';
     } catch (e) {
-      console.log(chalk.red(`  [${new Date().toISOString()}] Post failed: ${e.message}`));
+      spinner.fail(`Failed: ${e.message}`);
+      consecutiveFailures++;
+      return 'failed';
+    }
+  }
+
+  // --- First post ---
+  const firstResult = await doPost();
+
+  if (once) {
+    console.log(chalk.dim(`\n  Done (single post mode).\n`));
+    return;
+  }
+
+  // --- Loop ---
+  if (firstResult === 'failed') {
+    console.log(chalk.dim(`  Will retry with backoff...\n`));
+  }
+
+  console.log(chalk.dim(`\n  Next post in ${intervalMinutes} minutes. Press Ctrl+C to stop.`));
+
+  const loop = setInterval(async () => {
+    // Exponential backoff on failures
+    const backoffMultiplier = Math.min(Math.pow(2, consecutiveFailures), Math.pow(2, MAX_BACKOFF));
+    if (consecutiveFailures > 0) {
+      const waitMs = intervalMinutes * 60 * 1000 * (backoffMultiplier - 1);
+      console.log(chalk.dim(`  [${ts()}] Backoff: waiting extra ${Math.round(waitMs / 60000)}m (${consecutiveFailures} consecutive failures)`));
     }
-    console.log(chalk.dim(`  Next post in ${intervalMinutes} minutes...`));
+
+    const result = await doPost();
+    const nextMin = intervalMinutes * backoffMultiplier;
+    console.log(chalk.dim(`  Next post in ~${nextMin} minutes...`));
   }, intervalMinutes * 60 * 1000);
 
-  // Graceful shutdown
   process.on('SIGINT', () => {
-    clearInterval(interval);
+    clearInterval(loop);
     console.log(chalk.dim('\n  Marketing loop stopped.\n'));
     process.exit(0);
   });
 }
 
+function ts() {
+  return new Date().toISOString().slice(11, 19);
+}
+
 module.exports = { marketCommand };

package/src/commands/start.js

@@ -39,6 +39,35 @@ async function checkPermission(requesterAgentId, toolName) {
   return allow;
 }
 
+async function executeLocalTool(mcpUrl, toolName, inputData) {
+  /**
+   * Execute a tool on the local MCP server via JSON-RPC.
+   */
+  if (!mcpUrl) return { error: 'No local MCP server configured' };
+
+  try {
+    const httpUrl = mcpUrl.replace('/sse', '').replace(/\/$/, '');
+    const res = await fetch(httpUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'tools/call',
+        params: { name: toolName, arguments: inputData || {} }
+      }),
+      timeout: 30000,
+    });
+
+    if (!res.ok) return { error: `MCP server returned ${res.status}` };
+    const data = await res.json();
+    if (data.error) return { error: data.error.message || 'MCP error' };
+    return data.result || { status: 'executed' };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
 async function pollForTasks(creds) {
   try {
     const res = await fetch(
@@ -90,8 +119,10 @@ async function startCommand(opts) {
 
   // Foreground mode
   const mode = isHeadlessMode() ? 'HEADLESS' : 'INTERACTIVE';
+  const localMcpUrl = config.get('localMcpUrl') || '';
   console.log(chalk.dim(`  Agent:    ${creds.agentName} (${creds.agentId.slice(0, 12)}...)`));
   console.log(chalk.dim(`  Platform: ${creds.platformUrl}`));
+  console.log(chalk.dim(`  Local MCP:${localMcpUrl || ' Not configured'}`));
   console.log(chalk.dim(`  Mode:     ${mode}`));
   console.log(chalk.dim(`  Press Ctrl+C to stop.\n`));
 
@@ -124,8 +155,19 @@ async function startCommand(opts) {
 
         if (allowed) {
           console.log(chalk.green(`    Executing ${task.tool_name}...`));
-          // In a real implementation, this would call the local MCP server
-          // For now, mark as in_progress
+          // Execute on local MCP server if configured
+          const mcpUrl = config.get('localMcpUrl');
+          let output = { status: 'executed', tool: task.tool_name };
+          if (mcpUrl) {
+            const result = await executeLocalTool(mcpUrl, task.tool_name, task.input_data);
+            if (result.error) {
+              console.log(chalk.yellow(`    Local execution warning: ${result.error}`));
+              output = { status: 'executed_with_warning', error: result.error, tool: task.tool_name };
+            } else {
+              output = result;
+              console.log(chalk.green(`    Local MCP tool executed successfully.`));
+            }
+          }
           try {
             await fetch(`${creds.platformUrl}/api/services/tasks/${task.id}/complete`, {
               method: 'POST',
@@ -133,12 +175,12 @@ async function startCommand(opts) {
               body: JSON.stringify({
                 agent_id: creds.agentId,
                 api_key: creds.apiKey,
-                output_data: { status: 'executed', tool: task.tool_name },
+                output_data: output,
               }),
             });
             console.log(chalk.green(`    Task ${task.id} completed.`));
           } catch (e) {
-            console.log(chalk.red(`    Task execution failed: ${e.message}`));
+            console.log(chalk.red(`    Task completion failed: ${e.message}`));
           }
         } else {
           console.log(chalk.red(`    Permission denied for ${task.tool_name}.`));