aether-hub 1.0.3

package/commands/validator-status.js

@@ -0,0 +1,268 @@
+/**
+ * aether-cli validator-status
+ * 
+ * Queries the validator's RPC endpoint and displays status information.
+ * Shows slot height, peer count, block production, and epoch info.
+ */
+
+const http = require('http');
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
+};
+
+/**
+ * Make an RPC call to the validator
+ */
+function rpcCall(url, method, params = []) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    
+    const postData = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method,
+      params,
+    });
+
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || 8899,
+      path: '/',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData),
+      },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.error) {
+            reject(new Error(json.error.message || JSON.stringify(json.error)));
+          } else {
+            resolve(json.result);
+          }
+        } catch (e) {
+          reject(new Error(`Invalid JSON response: ${data}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => {
+      reject(new Error(`Connection failed: ${e.message}`));
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+/**
+ * Parse command line args
+ */
+function parseArgs() {
+  const args = process.argv.slice(3); // Skip 'aether-cli validator status'
+  
+  const options = {
+    rpcUrl: 'http://127.0.0.1:8899',
+    details: false,
+    json: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--rpc-url':
+        options.rpcUrl = args[++i];
+        break;
+      case '-v':
+      case '--verbose':
+      case '--details':
+        options.details = true;
+        break;
+      case '--json':
+        options.json = true;
+        break;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Print the status display
+ */
+function printStatus(status, options) {
+  const epochProgress = options.slotsInEpoch > 0 
+    ? ((options.slotIndex / options.slotsInEpoch) * 100).toFixed(1)
+    : '0.0';
+
+  console.log();
+  console.log(`${colors.cyan}╔═══════════════════════════════════════════════════════════════╗`);
+  console.log(`${colors.cyan}║                                                               ║`);
+  console.log(`${colors.cyan}║   ${colors.bright}AETHER VALIDATOR STATUS${colors.reset}${colors.cyan}                                  ║`);
+  console.log(`${colors.cyan}║                                                               ║`);
+  console.log(`${colors.cyan}╚═══════════════════════════════════════════════════════════════╝${colors.reset}`);
+  console.log();
+  
+  console.log(`  ${colors.bright}🌐 RPC Endpoint:${colors.reset}  ${options.rpcUrl}`);
+  console.log();
+  
+  // Check if connected
+  if (status.error) {
+    console.log(`  ${colors.red}❌ Error:${colors.reset}  ${status.error}`);
+    console.log();
+    console.log(`  ${colors.yellow}Make sure the validator is running:${colors.reset}`);
+    console.log(`    ${colors.bright}aether-cli validator start${colors.reset}`);
+    console.log();
+    return;
+  }
+  
+  console.log(`  ${colors.green}✅ Connected${colors.reset}`);
+  console.log();
+  
+  console.log(`  ${colors.bright}📊 Chain Status${colors.reset}`);
+  console.log(`  ${colors.dim}   ${'─'.repeat(55)}${colors.reset}`);
+  console.log(`     Slot Height:        ${colors.bright}${String(status.slot || 0).padStart(12)}${colors.reset}`);
+  console.log(`     Block Height:       ${colors.bright}${String(status.blockHeight || 0).padStart(12)}${colors.reset}`);
+  console.log(`     Transaction Count:  ${colors.bright}${String(status.transactionCount || 0).padStart(12)}${colors.reset}`);
+  console.log();
+  
+  console.log(`  ${colors.bright}🔗 Network${colors.reset}`);
+  console.log(`  ${colors.dim}   ${'─'.repeat(55)}${colors.reset}`);
+  console.log(`     Peer Count:         ${colors.bright}${String(status.peerCount || 0).padStart(12)}${colors.reset}`);
+  console.log();
+  
+  console.log(`  ${colors.bright}📈 Epoch ${status.epoch || 0}${colors.reset}`);
+  console.log(`  ${colors.dim}   ${'─'.repeat(55)}${colors.reset}`);
+  console.log(`     Progress:          ${colors.bright}${String(epochProgress + '%').padStart(12)}${colors.reset}`);
+  console.log(`     Slot Index:         ${colors.bright}${String(options.slotIndex || 0).padStart(12)}${colors.reset}`);
+  console.log(`     Slots in Epoch:     ${colors.bright}${String(options.slotsInEpoch || 0).padStart(12)}${colors.reset}`);
+  console.log();
+  
+  if (options.details && status.blockProduction) {
+    const bp = status.blockProduction;
+    console.log(`  ${colors.bright}📦 Block Production${colors.reset}`);
+    console.log(`  ${colors.dim}   ${'─'.repeat(55)}${colors.reset}`);
+    console.log(`     Blocks Produced:   ${colors.bright}${String(bp.blocksProduced || 0).padStart(12)}${colors.reset}`);
+    console.log(`     Entries Produced:   ${colors.bright}${String(bp.entriesProduced || 0).padStart(12)}${colors.reset}`);
+    console.log();
+  }
+  
+  console.log(`  ${colors.green}✓ Validator is running normally${colors.reset}`);
+  console.log();
+}
+
+/**
+ * Main status command
+ */
+async function validatorStatus() {
+  const options = parseArgs();
+  
+  let status = {
+    slot: 0,
+    blockHeight: 0,
+    transactionCount: 0,
+    peerCount: 0,
+    epoch: 0,
+  };
+  
+  let epochInfo = {};
+  let blockProduction = {};
+
+  try {
+    // Make parallel RPC calls
+    const [slot, blockHeight, transactionCount, epochInfoResult, blockProdResult] = await Promise.all([
+      rpcCall(options.rpcUrl, 'getSlot').catch(e => ({ error: e.message })),
+      rpcCall(options.rpcUrl, 'getBlockHeight').catch(e => ({ error: e.message })),
+      rpcCall(options.rpcUrl, 'getTransactionCount').catch(e => ({ error: e.message })),
+      rpcCall(options.rpcUrl, 'getEpochInfo').catch(e => ({})),
+      options.details ? rpcCall(options.rpcUrl, 'getBlockProduction').catch(e => ({})) : Promise.resolve({}),
+    ]);
+
+    if (typeof slot === 'object' && slot.error) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: slot.error }, null, 2));
+        process.exit(1);
+      }
+      console.log();
+      console.log(`  ${colors.red}❌ Cannot connect to validator${colors.reset}`);
+      console.log(`     ${colors.yellow}${slot.error}${colors.reset}`);
+      console.log();
+      console.log(`  ${colors.bright}Start the validator first:${colors.reset}`);
+      console.log(`    ${colors.cyan}aether-cli validator start${colors.reset}`);
+      console.log();
+      process.exit(1);
+    }
+
+    status.slot = typeof slot === 'number' ? slot : 0;
+    status.blockHeight = typeof blockHeight === 'number' ? blockHeight : status.slot;
+    status.transactionCount = typeof transactionCount === 'number' ? transactionCount : 0;
+    
+    if (epochInfoResult && typeof epochInfoResult === 'object') {
+      epochInfo = epochInfoResult;
+      status.epoch = epochInfo.epoch || 0;
+      epochInfo.slotIndex = epochInfo.slotIndex || 0;
+      epochInfo.slotsInEpoch = epochInfo.slotsInEpoch || 432000;
+    }
+    
+    if (blockProdResult && typeof blockProdResult === 'object') {
+      blockProduction = blockProdResult;
+    }
+
+    // Get peer count
+    try {
+      status.peerCount = await rpcCall(options.rpcUrl, 'getPeerCount') || 0;
+    } catch (e) {
+      status.peerCount = 0;
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify({
+        slot: status.slot,
+        blockHeight: status.blockHeight,
+        transactionCount: status.transactionCount,
+        peerCount: status.peerCount,
+        epoch: status.epoch,
+        epochInfo,
+        blockProduction,
+      }, null, 2));
+    } else {
+      printStatus(status, { 
+        ...options, 
+        ...epochInfo, 
+        blockProduction,
+      });
+    }
+
+  } catch (err) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: err.message }, null, 2));
+    } else {
+      console.log();
+      console.log(`  ${colors.red}❌ Error querying validator${colors.reset}`);
+      console.log(`     ${colors.yellow}${err.message}${colors.reset}`);
+      console.log();
+    }
+    process.exit(1);
+  }
+}
+
+// Export for use as module
+module.exports = { validatorStatus, rpcCall };
+
+// Run if called directly
+if (require.main === module) {
+  validatorStatus();
+}

package/index.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+/**
+ * aether-cli - AeTHer Validator Command Line Interface
+ * 
+ * Main entry point for the validator CLI tool.
+ * Provides onboarding, system checks, validator management, and KYC integration.
+ */
+
+const { doctorCommand } = require('./commands/doctor');
+const { validatorStart } = require('./commands/validator-start');
+const { validatorStatus } = require('./commands/validator-status');
+const { init } = require('./commands/init');
+const { monitorLoop } = require('./commands/monitor');
+const { logsCommand } = require('./commands/logs');
+const { sdkCommand } = require('./commands/sdk');
+const readline = require('readline');
+
+// CLI version
+const VERSION = '1.0.2';
+
+// Parse args early to support flags on commands
+function getCommandArgs() {
+  return process.argv.slice(2);
+}
+
+// Tier colours
+const TIER_COLORS = {
+  FULL: '\x1b[36m',    // cyan
+  LITE: '\x1b[33m',    // yellow
+  OBSERVER: '\x1b[32m', // green
+  reset: '\x1b[0m',
+};
+
+/**
+ * Display the interactive main menu
+ */
+async function showMenu() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const prompt = (q) => new Promise((res) => rl.question(q, res));
+
+  console.log(
+    TIER_COLORS.FULL + '\n  ╔═══════════════════════════════════════════════╗\n' +
+    '  ║     AETHER CHAIN — Validator Setup Wizard     ║\n' +
+    '  ╚═══════════════════════════════════════════════╝' + TIER_COLORS.reset + '\n'
+  );
+
+  console.log('  Welcome to AeTHer Chain. What would you like to do?\n');
+  console.log('  ' + TIER_COLORS.FULL + '1)' + TIER_COLORS.reset + '  🩺  Doctor  — Check if your system meets requirements');
+  console.log('  ' + TIER_COLORS.FULL + '2)' + TIER_COLORS.reset + '  🚀  Start  — Begin validator onboarding (recommended)');
+  console.log('  ' + TIER_COLORS.FULL + '3)' + TIER_COLORS.reset + '  📊  Monitor — Watch live validator stats');
+  console.log('  ' + TIER_COLORS.FULL + '4)' + TIER_COLORS.reset + '  📋  Logs   — Tail and colourise validator logs');
+  console.log('  ' + TIER_COLORS.FULL + '5)' + TIER_COLORS.reset + '  📦  SDK    — Get SDK links and install tools');
+  console.log('  ' + TIER_COLORS.FULL + '6)' + TIER_COLORS.reset + '  ❓  Help   — Show all commands\n');
+  console.log('  ' + TIER_COLORS.reset + '  Type a number or command name. Press Ctrl+C to exit.\n');
+
+  const VALID_CHOICES = ['1', '2', '3', '4', '5', '6', 'doctor', 'init', 'monitor', 'logs', 'sdk', 'help'];
+
+  while (true) {
+    const answer = (await prompt(`  > `)).trim().toLowerCase();
+
+    if (answer === '' || answer === '1' || answer === 'doctor') {
+      rl.close();
+      const { doctorCommand } = require('./commands/doctor');
+      doctorCommand({ autoFix: false, tier: 'full' });
+      return;
+    }
+
+    if (answer === '2' || answer === 'init' || answer === 'start') {
+      rl.close();
+      const { init } = require('./commands/init');
+      init();
+      return;
+    }
+
+    if (answer === '3' || answer === 'monitor') {
+      rl.close();
+      const { main } = require('./commands/monitor');
+      main();
+      return;
+    }
+
+    if (answer === '4' || answer === 'logs') {
+      rl.close();
+      const { logsCommand } = require('./commands/logs');
+      logsCommand();
+      return;
+    }
+
+    if (answer === '5' || answer === 'sdk') {
+      rl.close();
+      const { sdkCommand } = require('./commands/sdk');
+      sdkCommand();
+      return;
+    }
+
+    if (answer === '6' || answer === 'help') {
+      showHelp();
+      console.log("  Press Ctrl+C to exit or select an option above.\n");
+      continue;
+    }
+
+    console.log(`\n  ⚠️  Unknown option: "${answer}". Type 1-6 or a command name.\n`);
+  }
+}
+
+// Available commands
+const COMMANDS = {
+  start: {
+    description: 'Launch interactive menu (default if no args) — same as running aether-cli with no arguments',
+    handler: () => showMenu(),
+  },
+  doctor: {
+    description: 'Run system requirements checks (CPU/RAM/Disk/Network/Firewall)',
+    handler: () => {
+      const args = getCommandArgs();
+      const autoFix = args.includes('--fix') || args.includes('-f');
+      
+      // Parse --tier flag
+      let tier = 'full';
+      const tierIndex = args.findIndex(arg => arg === '--tier');
+      if (tierIndex !== -1 && args[tierIndex + 1]) {
+        tier = args[tierIndex + 1].toLowerCase();
+      }
+      
+      doctorCommand({ autoFix, tier });
+    },
+  },
+  init: {
+    description: 'Start onboarding wizard (generate identity, create stake account, connect to testnet)',
+    handler: init,
+  },
+  'kyc generate': {
+    description: 'Generate pre-filled KYC link with pubkey, node ID, signature',
+    handler: () => console.log('🚧 kyc generate command under development'),
+  },
+  monitor: {
+    description: 'Real-time validator dashboard (slot, block height, peers, TPS)',
+    handler: () => {
+      // monitor command runs its own loop
+      const { main } = require('./commands/monitor');
+      main();
+    },
+  },
+  logs: {
+    description: 'Tail validator logs with colour-coded output (ERROR=red, WARN=yellow, INFO=green)',
+    handler: logsCommand,
+  },
+  sdk: {
+    description: 'Aether SDK download links and install instructions (JS, Rust, FLUX/ATH tokens)',
+    handler: sdkCommand,
+  },
+  validator: {
+    description: 'Validator node management',
+    handler: () => {
+      // Handle validator subcommands
+      const subcmd = process.argv[3];
+      
+      if (!subcmd) {
+        console.log('Usage: aether-cli validator <command>');
+        console.log('');
+        console.log('Commands:');
+        console.log('  start    Start the validator node');
+        console.log('  status   Check validator status');
+        console.log('');
+        return;
+      }
+      
+      switch (subcmd) {
+        case 'start':
+          validatorStart();
+          break;
+        case 'status':
+          validatorStatus();
+          break;
+        default:
+          console.error(`Unknown validator command: ${subcmd}`);
+          console.error('Valid commands: start, status');
+          process.exit(1);
+      }
+    },
+  },
+  help: {
+    description: 'Show this help message',
+    handler: showHelp,
+  },
+  version: {
+    description: 'Show version number',
+    handler: () => console.log(`aether-cli v${VERSION}`),
+  },
+};
+
+/**
+ * Display help message with ASCII art
+ */
+function showHelp() {
+  const header = `
+███╗   ███╗██╗███████╗███████╗██╗ ██████╗ ███╗   ██╗
+████╗ ████║██║██╔════╝██╔════╝██║██╔═══██╗████╗  ██║
+██╔████╔██║██║███████╗███████╗██║██║   ██║██╔██╗ ██║
+██║╚██╔╝██║██║╚════██║╚════██║██║██║   ██║██║╚██╗██║
+██║ ╚═╝ ██║██║███████║███████║██║╚██████╔╝██║ ╚████║
+╚═╝     ╚═╝╚═╝╚══════╝╚══════╝╚═╝ ╚═════╝ ╚═╝  ╚═══╝
+
+Validator CLI v${VERSION}
+`.trim();
+
+  console.log(header);
+  console.log('\nUsage: aether-cli <command> [options]\n');
+  console.log('Commands:');
+  Object.entries(COMMANDS).forEach(([cmd, info]) => {
+    console.log(`  ${cmd.padEnd(18)} ${info.description}`);
+  });
+  console.log('\nExamples:');
+  console.log('  aether-cli doctor              # Check system requirements');
+  console.log('  aether-cli init                # Start onboarding wizard');
+  console.log('  aether-cli monitor             # Real-time validator dashboard');
+  console.log('  aether-cli validator start     # Start validator node');
+  console.log('  aether-cli validator status    # Check validator status');
+  console.log('  aether-cli --version           # Show version');
+  console.log('\nDocumentation: https://github.com/jelly-legs-ai/Jelly-legs-unsteady-workshop');
+  console.log('Spec: docs/MINING_VALIDATOR_TOOLS.md\n');
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+
+  // Handle flags
+  if (args.includes('--version') || args.includes('-v')) {
+    return 'version';
+  }
+  if (args.includes('--help') || args.includes('-h')) {
+    return 'help';
+  }
+
+  // No args → interactive menu
+  if (args.length === 0) {
+    return 'start';
+  }
+
+  // Handle multi-word commands (e.g., "validator start", "kyc generate")
+  if (args.length >= 2) {
+    const multiCmd = `${args[0]} ${args[1]}`;
+    if (COMMANDS[multiCmd]) {
+      return multiCmd;
+    }
+  }
+
+  // Single word command
+  return args[0] || 'help';
+}
+
+/**
+ * Main CLI entry point
+ */
+function main() {
+  const command = parseArgs();
+  
+  if (COMMANDS[command]) {
+    COMMANDS[command].handler();
+  } else {
+    console.error(`❌ Unknown command: ${command}`);
+    console.error('Run "aether-cli help" for usage.\n');
+    process.exit(1);
+  }
+}
+
+// Run CLI
+main();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "aether-hub",
+  "version": "1.0.3",
+  "description": "AeTHer Validator CLI — tiered validators (Full/Lite/Observer), system checks, onboarding, and node management",
+  "main": "index.js",
+  "bin": {
+    "aether": "./index.js",
+    "aether-hub": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "commands/",
+    "test/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test/doctor.test.js",
+    "start": "node index.js",
+    "doctor": "node index.js doctor",
+    "postinstall": "node -e \"console.log('\\n\\n  [Aether] aether-hub installed!\\n\\n  Run: aether start\\n  Docs: https://github.com/jelly-legs-ai/Jelly-legs-unsteady-workshop\\n')\""
+  },
+  "keywords": [
+    "aether",
+    "validator",
+    "blockchain",
+    "cli",
+    "crypto",
+    "mining"
+  ],
+  "author": "Jelly-legs AI Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jelly-legs-ai/Jelly-legs-unsteady-workshop"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "preferGlobal": true,
+  "dependencies": {
+    "bs58": "^6.0.0",
+    "tweetnacl": "^1.0.3"
+  }
+}
+

package/test/doctor.test.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Test suite for aether-cli doctor command
+ */
+
+const { checkCPU, checkMemory, checkDisk, checkNetwork, checkFirewall } = require('../commands/doctor');
+
+console.log('Running aether-cli doctor tests...\n');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    const result = fn();
+    console.log(`✅ ${name}`);
+    passed++;
+    return result;
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+    failed++;
+    return null;
+  }
+}
+
+// Test CPU check
+test('checkCPU returns valid structure', () => {
+  const cpu = checkCPU();
+  if (!cpu.section) throw new Error('Missing section');
+  if (!('passed' in cpu)) throw new Error('Missing passed');
+  if (!cpu.message) throw new Error('Missing message');
+  console.log(`   CPU: ${cpu.physicalCores} cores, ${cpu.model}`);
+  return cpu;
+});
+
+// Test Memory check
+test('checkMemory returns valid structure', () => {
+  const mem = checkMemory();
+  if (!mem.section) throw new Error('Missing section');
+  if (!('passed' in mem)) throw new Error('Missing passed');
+  if (!mem.message) throw new Error('Missing message');
+  console.log(`   Memory: ${mem.total} total, ${mem.available} available`);
+  return mem;
+});
+
+// Test Disk check
+test('checkDisk returns valid structure', () => {
+  const disk = checkDisk();
+  if (!disk.section) throw new Error('Missing section');
+  if (!('passed' in disk)) throw new Error('Missing passed');
+  if (!disk.message) throw new Error('Missing message');
+  console.log(`   Disk: ${disk.total} total, ${disk.free} free`);
+  return disk;
+});
+
+// Test Network check
+test('checkNetwork returns valid structure', () => {
+  const net = checkNetwork();
+  if (!net.section) throw new Error('Missing section');
+  if (!('passed' in net)) throw new Error('Missing passed');
+  console.log(`   Network: ${net.publicIP}`);
+  return net;
+});
+
+// Test Firewall check
+test('checkFirewall returns valid structure', () => {
+  const fw = checkFirewall();
+  if (!fw.section) throw new Error('Missing section');
+  if (!('passed' in fw)) throw new Error('Missing passed');
+  console.log(`   Firewall: P2P=${fw.p2p}, RPC=${fw.rpc}, SSH=${fw.ssh}`);
+  return fw;
+});
+
+// Summary
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);