@jellylegsai/aether-cli 1.8.0

package/commands/validator-start.js

@@ -0,0 +1,323 @@
+/**
+ * aether-cli validator-start
+ * 
+ * Spawns the aether-validator binary as a child process.
+ * Handles startup, logging, and graceful shutdown.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+};
+
+/**
+ * Find the aether-validator binary
+ * Searches common locations based on OS and repo layout
+ */
+function findValidatorBinary() {
+  const platform = os.platform();
+  const isWindows = platform === 'win32';
+  const binaryName = isWindows ? 'aether-validator.exe' : 'aether-validator';
+  
+  // Check common locations
+  const locations = [
+    // Sibling repo: Jelly-legs-unsteady-workshop/target/debug/
+    path.join(__dirname, '..', '..', 'Jelly-legs-unsteady-workshop', 'target', 'debug', binaryName),
+    path.join(__dirname, '..', '..', 'Jelly-legs-unsteady-workshop', 'target', 'release', binaryName),
+    // Local build in aether-cli (if someone built here)
+    path.join(__dirname, '..', 'target', 'debug', binaryName),
+    path.join(__dirname, '..', 'target', 'release', binaryName),
+    // System PATH
+    'aether-validator' + (isWindows ? '.exe' : ''),
+  ];
+
+  for (const loc of locations) {
+    if (loc.startsWith('aether-validator')) {
+      // Check if it's in PATH
+      try {
+        const { execSync } = require('child_process');
+        const checkCmd = isWindows ? 'where' : 'which';
+        execSync(`${checkCmd} ${loc}`, { stdio: 'pipe' });
+        return { type: 'binary', path: loc, inPath: true };
+      } catch {
+        // Not in PATH, continue
+      }
+    }
+    if (fs.existsSync(loc)) {
+      return { type: 'binary', path: loc };
+    }
+  }
+
+  // Binary not found - offer to build it
+  return { type: 'missing', path: null };
+}
+
+/**
+ * Parse command line args for validator-start
+ * @param {Object} overrideOptions - Options passed directly (e.g. from init.js)
+ */
+function parseArgs(overrideOptions = {}) {
+  const args = process.argv.slice(3); // Skip 'aether-cli validator start'
+  
+  const options = {
+    testnet: false,
+    rpcAddr: '127.0.0.1:8899',
+    p2pAddr: '0.0.0.0:8001',
+    identity: null,
+    verbose: false,
+    tier: 'full',
+    ...overrideOptions, // Allow init.js to pass testnet/tier directly
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--testnet':
+        options.testnet = true;
+        break;
+      case '--rpc-addr':
+        options.rpcAddr = args[++i];
+        break;
+      case '--p2p-addr':
+        options.p2pAddr = args[++i];
+        break;
+      case '--identity':
+        options.identity = args[++i];
+        break;
+      case '--tier':
+        options.tier = args[++i];
+        break;
+      case '-v':
+      case '--verbose':
+        options.verbose = true;
+        break;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Print startup banner
+ */
+function printBanner(options) {
+  const tierBadge = options.tier.toUpperCase();
+  const tierLabel = `[${tierBadge}]`;
+  
+  console.log(`
+${colors.cyan}╔═══════════════════════════════════════════════════════════════╗
+${colors.cyan}║                                                               ║
+${colors.cyan}║   ${colors.bright}AETHER VALIDATOR${colors.reset}${colors.cyan}                                          ║
+${colors.cyan}║   ${colors.bright}Starting Validator Node${colors.reset}${colors.cyan}                                 ║
+${colors.cyan}║   ${colors.bright}${tierLabel}${colors.reset}${colors.cyan}                                              ║
+${colors.cyan}╚═══════════════════════════════════════════════════════════════╝${colors.reset}
+  `);
+  
+  console.log(`  ${colors.bright}Network:${colors.reset}`);
+  const modeStr = options.testnet
+    ? colors.yellow + 'TESTNET'
+    : colors.red + 'MAINNET';
+  console.log(`    Mode:      ${modeStr}`);
+  console.log(`    Tier:      ${tierLabel}`);
+  console.log(`    RPC:       http://${options.rpcAddr}`);
+  console.log(`    P2P:       ${options.p2pAddr}`);
+  if (options.identity) {
+    console.log(`    Identity:  ${options.identity}`);
+  }
+  console.log();
+}
+
+/**
+ * Build the validator binary if missing
+ */
+function buildValidator() {
+  const { execSync } = require('child_process');
+  const platform = os.platform();
+  const isWindows = platform === 'win32';
+  const workspaceRoot = path.join(__dirname, '..', '..');
+  const repoPath = path.join(workspaceRoot, 'Jelly-legs-unsteady-workshop');
+  
+  console.log(`  ${colors.cyan}Building aether-validator...${colors.reset}`);
+  
+  try {
+    // Use full cargo path on Windows to avoid spawnSync ENOENT
+    const cargoPaths = isWindows
+      ? [
+          path.join(process.env.USERPROFILE || '', '.cargo', 'bin', 'cargo.exe'),
+          path.join(process.env.LOCALAPPDATA || '', 'Rust', 'bin', 'cargo.exe'),
+          'C:\\Users\\RM_Ga\\.cargo\\bin\\cargo.exe',
+          'cargo',
+        ]
+      : ['cargo'];
+    
+    let cargoCmd = 'cargo';
+    for (const cp of cargoPaths) {
+      if (cp === 'cargo' || fs.existsSync(cp)) {
+        cargoCmd = cp;
+        break;
+      }
+    }
+    
+    console.log(`  ${colors.cyan}Running: ${cargoCmd} build --release --package aether-validator${colors.reset}`);
+    
+    // Use execSync WITHOUT shell:true — avoids Windows spawnSync cmd.exe ENOENT
+    execSync(`${cargoCmd} build --release --package aether-validator`, {
+      cwd: repoPath,
+      stdio: 'inherit',
+    });
+    
+    // Re-check for binary
+    const result = findValidatorBinary();
+    if (result.type === 'binary') {
+      console.log(`  ${colors.green}✓ Build successful!${colors.reset}`);
+      return result;
+    }
+    
+    console.error(`  ${colors.red}✗ Build completed but binary not found${colors.reset}`);
+    return null;
+  } catch (err) {
+    console.error(`  ${colors.red}✗ Build failed: ${err.message}${colors.reset}`);
+    return null;
+  }
+}
+
+/**
+ * Main validator start command
+ * @param {Object|null} options - { testnet?: boolean, tier?: string }
+ */
+function validatorStart(options = {}) {
+  // Support both old string-style (tier only) and new object-style { testnet, tier }
+  const parsedArgs = parseArgs(typeof options === 'object' ? options : { tier: options });
+  const optionsObj = typeof options === 'object' ? options : {};
+  
+  // Merge: explicit options override parseArgs defaults
+  const finalOptions = {
+    ...parsedArgs,
+    ...optionsObj,
+    tier: optionsObj.tier || parsedArgs.tier,
+    testnet: optionsObj.testnet !== undefined ? optionsObj.testnet : parsedArgs.testnet,
+  };
+  
+  let result = findValidatorBinary();
+
+  printBanner(finalOptions);
+
+  // Handle missing binary
+  if (result.type === 'missing') {
+    console.log(`  ${colors.yellow}⚠ Validator binary not found${colors.reset}`);
+    console.log(`  ${colors.cyan}Would you like to build it now? (cargo build --bin aether-validator)${colors.reset}`);
+    console.log();
+    
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    
+    rl.question('  Build now? [Y/n] ', (answer) => {
+      rl.close();
+      
+      if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
+        console.log(`  ${colors.red}Aborted. Build the validator first, then try again.${colors.reset}`);
+        process.exit(1);
+      }
+      
+      const built = buildValidator();
+      if (!built) {
+        process.exit(1);
+      }
+      result = built;
+      startValidatorProcess(result, finalOptions);
+    });
+    return;
+  }
+
+  startValidatorProcess(result, finalOptions);
+}
+
+/**
+ * Spawn the validator process
+ */
+function startValidatorProcess({ type, path: binaryPath, inPath }, options) {
+  // Build command args
+  const validatorArgs = ['start'];
+  
+  if (options.testnet) {
+    validatorArgs.push('--testnet');
+  }
+  validatorArgs.push('--tier', options.tier.toLowerCase());
+  validatorArgs.push('--rpc-addr', options.rpcAddr);
+  validatorArgs.push('--p2p-addr', options.p2pAddr);
+  if (options.identity) {
+    validatorArgs.push('--identity', options.identity);
+  }
+  if (options.verbose) {
+    validatorArgs.push('-vvv');
+  }
+
+  const commandDisplay = inPath ? binaryPath : binaryPath || 'cargo run --bin aether-validator';
+  console.log(`  ${colors.bright}Command:${colors.reset} ${commandDisplay} ${validatorArgs.join(' ')}`);
+  console.log();
+  console.log(`  ${colors.yellow}Starting validator (press Ctrl+C to stop)...${colors.reset}`);
+  console.log();
+
+  // Determine working directory
+  const workspaceRoot = path.join(__dirname, '..', '..');
+  const repoPath = path.join(workspaceRoot, 'Jelly-legs-unsteady-workshop');
+  
+  // Spawn the validator process
+  const child = inPath || binaryPath === 'aether-validator' || binaryPath === 'aether-validator.exe'
+    ? spawn(binaryPath, validatorArgs, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+      })
+    : spawn(binaryPath, validatorArgs, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        cwd: repoPath,
+      });
+
+  // Colorize output
+  const outputColorizer = (data, isError = false) => {
+    const str = data.toString();
+    const color = isError ? colors.red : colors.reset;
+    process.stdout.write(`${color}${str}${colors.reset}`);
+  };
+
+  child.stdout.on('data', (data) => outputColorizer(data));
+  child.stderr.on('data', (data) => outputColorizer(data, true));
+
+  child.on('error', (err) => {
+    console.error(`${colors.red}Failed to start validator: ${err.message}${colors.reset}`);
+    process.exit(1);
+  });
+
+  child.on('close', (code) => {
+    console.log(`\n${colors.yellow}Validator exited with code ${code}${colors.reset}`);
+    process.exit(code);
+  });
+
+  // Handle Ctrl+C
+  process.on('SIGINT', () => {
+    console.log(`\n${colors.yellow}Shutting down validator...${colors.reset}`);
+    child.kill('SIGINT');
+    setTimeout(() => {
+      child.kill('SIGTERM');
+    }, 1000);
+  });
+}
+
+// Export for use as module
+module.exports = { validatorStart };
+
+// Run if called directly
+if (require.main === module) {
+  validatorStart();
+}

package/commands/validator-status.js

@@ -0,0 +1,227 @@
+/**
+ * aether-cli validator-status
+ * 
+ * Queries the validator's RPC endpoint and displays status information.
+ * Shows slot height, peer count, block production, and epoch info.
+ * 
+ * Uses @jellylegsai/aether-sdk for real blockchain RPC calls.
+ */
+
+const path = require('path');
+
+// Import SDK for real blockchain RPC calls
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
+
+// 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',
+};
+
+/**
+ * Create SDK client
+ */
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
+}
+
+/**
+ * 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 = {};
+
+  const client = createClient(options.rpcUrl);
+
+  try {
+    // Make parallel RPC calls using SDK
+    const [slotResult, blockHeightResult, epochInfoResult, peersResult] = await Promise.all([
+      client.getSlot().catch(e => ({ error: e.message })),
+      client.getBlockHeight().catch(e => ({ error: e.message })),
+      client.getEpochInfo().catch(e => ({})),
+      client.getClusterPeers().catch(e => ([])),
+    ]);
+
+    if (typeof slotResult === 'object' && slotResult.error) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: slotResult.error }, null, 2));
+        process.exit(1);
+      }
+      console.log();
+      console.log(`  ${colors.red}❌ Cannot connect to validator${colors.reset}`);
+      console.log(`     ${colors.yellow}${slotResult.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 slotResult === 'number' ? slotResult : (slotResult.slot || 0);
+    status.blockHeight = typeof blockHeightResult === 'number' ? blockHeightResult : status.slot;
+    status.transactionCount = 0; // Transaction count not available via SDK
+    status.peerCount = Array.isArray(peersResult) ? peersResult.length : 0;
+    
+    if (epochInfoResult && typeof epochInfoResult === 'object') {
+      epochInfo = epochInfoResult;
+      status.epoch = epochInfo.epoch || 0;
+      epochInfo.slotIndex = epochInfo.slotIndex || epochInfo.slot_index || 0;
+      epochInfo.slotsInEpoch = epochInfo.slotsInEpoch || epochInfo.slots_in_epoch || 432000;
+    }
+    
+    if (options.details) {
+      try {
+        blockProduction = await client.getSlotProduction();
+      } catch { /* Block production not available */ }
+    }
+
+    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 };
+
+// Run if called directly
+if (require.main === module) {
+  validatorStatus();
+}