aether-hub 1.1.7 → 1.1.9

package/commands/doctor.js

@@ -556,7 +556,8 @@ function getFixCommand(check) {
       }
       const repoPath = path.join(workspaceRoot, 'Jelly-legs-unsteady-workshop');
       return `cd "${repoPath}" && cargo build --bin aether-validator --release`;
-      
+    }
+
     case 'Disk':
       // Can't auto-fix disk space, but can suggest cleanup
       if (platform === 'win32') {

package/commands/ping.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+/**
+ * aether-cli ping
+ *
+ * Quick RPC health check — measures latency, verifies connectivity,
+ * and reports node version and slot info.
+ *
+ * Usage:
+ *   aether ping                   Ping default RPC (AETHER_RPC or localhost:8899)
+ *   aether ping --rpc <url>       Ping a specific RPC endpoint
+ *   aether ping --count <n>       Run <n> pings and show avg/min/max (default: 1, max 20)
+ *   aether ping --json            JSON output for scripting/monitoring
+ *
+ * Examples:
+ *   aether ping                          # Single ping, default RPC
+ *   aether ping --rpc https://rpc.example.com  # Ping specific endpoint
+ *   aether ping --count 5 --json         # 5 pings, JSON output for alerting
+ */
+
+const http = require('http');
+const https = require('https');
+
+// ANSI colours
+const C = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+};
+
+const CLI_VERSION = '1.0.6';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+}
+
+function httpRequest(rpcUrl, pathStr, timeoutMs = 8000) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(pathStr, rpcUrl);
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'GET',
+      timeout: timeoutMs,
+      headers: { 'Content-Type': 'application/json' },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve({ raw: data }); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+    req.end();
+  });
+}
+
+function httpPost(rpcUrl, pathStr, body, timeoutMs = 8000) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(pathStr, rpcUrl);
+    const lib = url.protocol === 'https:' ? https : http;
+    const bodyStr = JSON.stringify(body);
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      timeout: timeoutMs,
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(bodyStr) },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve({ raw: data }); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Single ping: measure latency to /v1/slot
+// ---------------------------------------------------------------------------
+
+async function pingOnce(rpcUrl) {
+  const start = Date.now();
+  let slot = null;
+  let error = null;
+  let latencyMs = null;
+
+  try {
+    // Use POST to /v1/slot (some nodes only support POST)
+    const result = await httpPost(rpcUrl, '/v1/slot', {}, 8000);
+    latencyMs = Date.now() - start;
+
+    if (result && result.error) {
+      error = result.error;
+    } else {
+      slot = result.slot ?? result;
+      if (typeof slot === 'object') slot = slot.slot;
+    }
+  } catch (err) {
+    latencyMs = Date.now() - start;
+    error = err.message;
+  }
+
+  return { latencyMs, slot, error, rpcUrl };
+}
+
+// ---------------------------------------------------------------------------
+// Multi-ping: run N pings and aggregate
+// ---------------------------------------------------------------------------
+
+async function pingMulti(rpcUrl, count) {
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    results.push(await pingOnce(rpcUrl));
+    if (i < count - 1) await new Promise(r => setTimeout(r, 100));
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Colour helpers
+// ---------------------------------------------------------------------------
+
+function latencyColor(ms) {
+  if (ms === null) return C.red;
+  if (ms < 50) return C.green;
+  if (ms < 200) return C.cyan;
+  if (ms < 500) return C.yellow;
+  return C.red;
+}
+
+function latencyLabel(ms) {
+  if (ms === null) return '✗ unreachable';
+  if (ms < 50) return `● ${ms}ms  (excellent)`;
+  if (ms < 200) return `● ${ms}ms  (good)`;
+  if (ms < 500) return `○ ${ms}ms  (fair)`;
+  return `○ ${ms}ms  (slow)`;
+}
+
+// ---------------------------------------------------------------------------
+// Output formatters
+// ---------------------------------------------------------------------------
+
+function printResult(ping, asJson) {
+  const { latencyMs, slot, error, rpcUrl } = ping;
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      rpc: rpcUrl,
+      online: error === null,
+      latency_ms: latencyMs,
+      slot,
+      error: error || null,
+      cli_version: CLI_VERSION,
+      timestamp: new Date().toISOString(),
+    }));
+    return;
+  }
+
+  const lc = latencyColor(latencyMs);
+  const bar = latencyMs !== null ? '█'.repeat(Math.min(10, Math.floor(latencyMs / 50))) : '▒';
+
+  console.log(`  ${lc}${bar}${C.reset} ${C.bright}${latencyLabel(latencyMs)}${C.reset}`);
+  if (slot !== null) {
+    console.log(`  ${C.dim}  slot: ${C.reset}${C.cyan}${slot.toLocaleString()}${C.reset}`);
+  }
+  if (error) {
+    console.log(`  ${C.red}  ✗ ${error}${C.reset}`);
+  }
+  console.log(`  ${C.dim}  rpc: ${rpcUrl}${C.reset}`);
+}
+
+function printAggregated(results, rpcUrl, asJson) {
+  const online = results.filter(r => r.error === null);
+  const failed = results.filter(r => r.error !== null);
+
+  if (asJson) {
+    const latencies = online.map(r => r.latencyMs).filter(Boolean);
+    const avg = latencies.length > 0 ? Math.round(latencies.reduce((a, b) => a + b, 0) / latencies.length) : null;
+    const min = latencies.length > 0 ? Math.min(...latencies) : null;
+    const max = latencies.length > 0 ? Math.max(...latencies) : null;
+
+    console.log(JSON.stringify({
+      rpc: rpcUrl,
+      count: results.length,
+      online: online.length,
+      failed: failed.length,
+      latency_ms: { avg, min, max },
+      slots: online.map(r => r.slot).filter(Boolean),
+      errors: failed.map(r => r.error),
+      cli_version: CLI_VERSION,
+      timestamp: new Date().toISOString(),
+    }));
+    return;
+  }
+
+  console.log(`\n${C.bright}${C.cyan}── Ping Results: ${rpcUrl} ──${C.reset}\n`);
+
+  const latencies = online.map(r => r.latencyMs).filter(Boolean);
+
+  if (latencies.length > 0) {
+    const avg = Math.round(latencies.reduce((a, b) => a + b, 0) / latencies.length);
+    const min = Math.min(...latencies);
+    const max = Math.max(...latencies);
+
+    console.log(`  ${C.green}✓${C.reset} ${online.length}/${results.length} successful\n`);
+
+    // Per-ping bars
+    for (let i = 0; i < online.length; i++) {
+      const r = online[i];
+      const lc = latencyColor(r.latencyMs);
+      const bar = '█'.repeat(Math.min(10, Math.floor(r.latencyMs / 50)));
+      const slotStr = r.slot !== null ? `  slot=${C.cyan}${r.slot.toLocaleString()}${C.reset}` : '';
+      console.log(`    ${lc}${bar}${C.reset}  ${r.latencyMs}ms${slotStr}`);
+    }
+
+    console.log();
+    console.log(`  ${C.bright}Latency:${C.reset} avg=${latencyColor(avg)}${avg}ms${C.reset}  min=${latencyColor(min)}${min}ms${C.reset}  max=${latencyColor(max)}${max}ms${C.reset}`);
+    console.log(`  ${C.dim}  Packets: ${results.length}  Lost: ${failed.length}${C.reset}`);
+
+    // Health assessment
+    const healthPct = (online.length / results.length) * 100;
+    if (healthPct === 100 && avg < 50) {
+      console.log(`  ${C.green}  Health: excellent${C.reset}`);
+    } else if (healthPct >= 80 && avg < 200) {
+      console.log(`  ${C.cyan}  Health: good${C.reset}`);
+    } else if (healthPct >= 60) {
+      console.log(`  ${C.yellow}  Health: degraded${C.reset}`);
+    } else {
+      console.log(`  ${C.red}  Health: poor${C.reset}`);
+    }
+  } else {
+    console.log(`  ${C.red}✗ All pings failed${C.reset}`);
+    for (const r of failed) {
+      console.log(`    ${C.red}✗ ${r.error}${C.reset}`);
+    }
+  }
+
+  if (failed.length > 0 && online.length > 0) {
+    console.log();
+    console.log(`  ${C.yellow}⚠ ${failed.length} pings failed:${C.reset}`);
+    for (const r of failed) {
+      console.log(`    ${C.red}✗ ${r.error}${C.reset}`);
+    }
+  }
+  console.log();
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const args = process.argv.slice(3); // [node, index.js, ping, ...]
+
+  const rpcIndex = args.findIndex(a => a === '--rpc' || a === '-r');
+  const rpcUrl = rpcIndex !== -1 && args[rpcIndex + 1] && !args[rpcIndex + 1].startsWith('-')
+    ? args[rpcIndex + 1]
+    : getDefaultRpc();
+
+  const countIndex = args.findIndex(a => a === '--count' || a === '-c');
+  const countRaw = countIndex !== -1 && args[countIndex + 1] && !args[countIndex + 1].startsWith('-')
+    ? parseInt(args[countIndex + 1], 10)
+    : 1;
+  const count = Math.min(Math.max(1, countRaw || 1), 20);
+
+  const asJson = args.includes('--json') || args.includes('-j');
+
+  if (!asJson) {
+    console.log(`\n${C.bright}${C.cyan}── Aether RPC Ping ──────────────────────────────────────${C.reset}`);
+    if (count > 1) {
+      console.log(`  ${C.dim}Running ${count} pings against ${rpcUrl}…${C.reset}`);
+    } else {
+      console.log(`  ${C.dim}RPC: ${rpcUrl}${C.reset}`);
+    }
+    console.log();
+  }
+
+  if (count === 1) {
+    const result = await pingOnce(rpcUrl);
+    printResult(result, asJson);
+    if (!asJson) console.log();
+    // Exit 1 if unreachable
+    if (result.error) process.exit(1);
+  } else {
+    const results = await pingMulti(rpcUrl, count);
+    printAggregated(results, rpcUrl, asJson);
+    // Exit 1 if all failed
+    if (results.every(r => r.error)) process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error(`\n${C.red}✗ Ping failed:${C.reset} ${err.message}\n`);
+  process.exit(1);
+});
+
+module.exports = { pingCommand: main };
+
+if (require.main === module) {
+  main();
+}

package/commands/price.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+/**
+ * aether-cli price
+ *
+ * Show real-time AETH/USD price from free public crypto APIs.
+ * Supports CoinGecko (free tier), and falls back to simulated data
+ * if no API key is available.
+ *
+ * Usage:
+ *   aether price                    Show current AETH/USD price
+ *   aether price --pair AETH/USD   Specify trading pair (default: AETH/USD)
+ *   aether price --json            JSON output for scripting
+ *   aether price --source coingecko Fallback to CoinGecko (no API key needed)
+ */
+
+const https = require('https');
+const http = require('http');
+
+const C = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+const AETHER_CONTRACT = 'ATH'; // Aether token contract (hypothetical)
+const DEFAULT_PAIR = 'AETH/USD';
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    const lib = url.startsWith('https') ? https : http;
+    const parsed = new URL(url);
+    const req = lib.request({
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: 'GET',
+      timeout: 10000,
+      headers: { 'Accept': 'application/json', 'User-Agent': 'Aether-CLI/1.0' },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve({ _raw: data }); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+    req.end();
+  });
+}
+
+function formatPrice(num, decimals = 4) {
+  if (num === null || num === undefined || isNaN(num)) return '—';
+  return num.toFixed(decimals);
+}
+
+function formatTime(date) {
+  return date.toISOString().replace('T', ' ').substring(0, 19) + ' UTC';
+}
+
+/**
+ * Fetch AETH price from CoinGecko (free, no API key).
+ * Coins API: /coins/list → find ATH/AETH → /coins/{id}/market_chart
+ * Fallback: try known Aether token addresses on major DEXes via /simple/price
+ */
+async function fetchFromCoinGecko() {
+  try {
+    // Try CoinGecko simple price for AETH token
+    // We'll try a few known Aether token addresses on Ethereum mainnet as a proxy
+    const url = 'https://api.coingecko.com/api/v3/simple/price?vs_currencies=usd&ids=aether,ath,ath-token,aether-network';
+    const data = await httpGet(url);
+
+    if (data && !data.error) {
+      // Find first available AETH quote
+      const pairs = [
+        { key: 'aether-network', name: 'AETH' },
+        { key: 'aether', name: 'AETH' },
+        { key: 'ath-token', name: 'ATH' },
+        { key: 'ath', name: 'ATH' },
+      ];
+
+      for (const { key, name } of pairs) {
+        if (data[key] && data[key].usd !== undefined) {
+          return {
+            source: 'CoinGecko',
+            symbol: name,
+            price: data[key].usd,
+            currency: 'USD',
+            timestamp: new Date(),
+          };
+        }
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch price data from a public DEX aggregator or mock Aether RPC.
+ * Primary: use the Aether chain's own price oracle if available.
+ * Fallback: use CoinGecko.
+ */
+async function fetchAetherPrice() {
+  // Try Aether chain's built-in price oracle (if validator is running)
+  const rpcUrl = process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+  try {
+    const res = await httpGet(`${rpcUrl}/v1/price`);
+    if (res && !res.error && res.price !== undefined) {
+      return {
+        source: 'Aether Oracle',
+        symbol: 'AETH',
+        price: parseFloat(res.price),
+        currency: res.currency || 'USD',
+        timestamp: new Date(),
+        change_24h: res.change_24h || null,
+        volume_24h: res.volume_24h || null,
+      };
+    }
+  } catch { /* chain oracle not available */ }
+
+  // Try CoinGecko
+  const cg = await fetchFromCoinGecko();
+  if (cg) return cg;
+
+  return null;
+}
+
+/**
+ * Fetch 24h price change using CoinGecko market chart.
+ */
+async function fetchPriceChange24h(symbol) {
+  try {
+    const idMap = {
+      'AETH': 'aether-network',
+      'ATH': 'ath-token',
+    };
+    const id = idMap[symbol] || 'aether-network';
+    const url = `https://api.coingecko.com/api/v3/coins/${id}/market_chart?vs_currency=usd&days=1`;
+    const data = await httpGet(url);
+
+    if (data && data.prices && data.prices.length >= 2) {
+      const latest = data.prices[data.prices.length - 1][1];
+      const yesterday = data.prices[0][1];
+      const change = ((latest - yesterday) / yesterday) * 100;
+      const volume = data.total_volumes ? data.total_volumes[data.total_volumes.length - 1][1] : null;
+      return {
+        change_24h: change,
+        volume_24h: volume,
+      };
+    }
+  } catch { /* ignore */ }
+  return { change_24h: null, volume_24h: null };
+}
+
+async function priceCommand() {
+  const args = process.argv.slice(2);
+  const asJson = args.includes('--json') || args.includes('-j');
+  const pair = args.includes('--pair')
+    ? args[args.indexOf('--pair') + 1] || DEFAULT_PAIR
+    : DEFAULT_PAIR;
+  const source = args.includes('--source') ? args[args.indexOf('--source') + 1] : null;
+
+  // Parse pair
+  const [fromSymbol, toSymbol = 'USD'] = pair.split('/');
+  const symbol = fromSymbol.toUpperCase();
+
+  console.log(`\n${C.bright}${C.cyan}── Aether Price ───────────────────────────────────────${C.reset}\n`);
+
+  let priceData;
+  if (source === 'coingecko') {
+    priceData = await fetchFromCoinGecko();
+  } else {
+    priceData = await fetchAetherPrice();
+  }
+
+  if (!priceData) {
+    if (asJson) {
+      console.log(JSON.stringify({ error: 'Price data unavailable', symbol, pair }, null, 2));
+    } else {
+      console.log(`  ${C.yellow}⚠ Price data temporarily unavailable.${C.reset}`);
+      console.log(`  ${C.dim}Make sure your validator is running or check network connectivity.${C.reset}`);
+      console.log(`  ${C.dim}Set AETHER_RPC env var to your validator's RPC address.${C.reset}`);
+      console.log(`  ${C.dim}Fallback: aether price --source coingecko${C.reset}\n`);
+    }
+    return;
+  }
+
+  // Fetch 24h change if available
+  const changeData = await fetchPriceChange24h(symbol);
+  const priceInfo = { ...priceData, ...changeData };
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      symbol: priceInfo.symbol,
+      pair: `${symbol}/USD`,
+      price_usd: priceInfo.price,
+      change_24h_pct: priceInfo.change_24h !== null ? parseFloat(priceInfo.change_24h.toFixed(4)) : null,
+      volume_24h_usd: priceInfo.volume_24h,
+      source: priceInfo.source,
+      timestamp: formatTime(priceInfo.timestamp),
+    }, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  const change = priceInfo.change_24h;
+  const changeColor = change === null ? C.dim : change >= 0 ? C.green : C.red;
+  const changeStr = change !== null
+    ? `${change >= 0 ? '+' : ''}${change.toFixed(2)}%`
+    : '—';
+
+  const arrow = change === null ? ' ' : change >= 0 ? '▲' : '▼';
+  const volumeStr = priceInfo.volume_24h !== null
+    ? `$${(priceInfo.volume_24h / 1e6).toFixed(2)}M`
+    : null;
+
+  console.log(`  ${C.dim}Pair:${C.reset}       ${C.bright}${symbol}/USD${C.reset}`);
+  console.log(`  ${C.dim}Source:${C.reset}      ${C.bright}${priceInfo.source}${C.reset}`);
+  console.log(`  ${C.dim}Updated:${C.reset}     ${formatTime(priceInfo.timestamp)}`);
+  console.log();
+  console.log(`  ${C.bright}${C.green}$${formatPrice(priceInfo.price)}${C.reset} ${C.dim}USD${C.reset}`);
+  console.log(`  ${C.dim}24h change:  ${changeColor}${arrow} ${changeStr}${C.reset}`);
+  if (volumeStr) {
+    console.log(`  ${C.dim}24h volume:  ${volumeStr}${C.reset}`);
+  }
+  console.log();
+
+  // ASCII box
+  const barLen = 40;
+  const fillLen = change !== null ? Math.min(barLen, Math.round(Math.abs(change) / 2)) : 0;
+  const barColor = change !== null && change < 0 ? C.red : C.green;
+  const bar = barColor + '█'.repeat(fillLen) + C.dim + '░'.repeat(barLen - fillLen) + C.reset;
+  console.log(`  ${C.dim}[${bar}]${C.reset}`);
+  console.log();
+  console.log(`  ${C.dim}Run with ${C.cyan}--json${C.reset}${C.dim} for scripted integrations.${C.reset}`);
+  console.log(`  ${C.dim}Refreshes on each call — set up a cron job for live monitoring.${C.reset}\n`);
+}
+
+priceCommand().catch(err => {
+  console.error(`\n${C.red}Price error:${C.reset}`, err.message, '\n');
+  process.exit(1);
+});
+
+module.exports = { priceCommand };