@0xobelisk/sui-cli 1.2.0-pre.1 → 1.2.0-pre.100

package/src/commands/wait.ts

@@ -2,56 +2,367 @@ import type { CommandModule } from 'yargs';
 import waitOn from 'wait-on';
 import ora from 'ora';
 import chalk from 'chalk';
+import net from 'net';
+import { handlerExit } from './shell';
 
 interface WaitOptions {
-  url: string;
+  url?: string;
+  localnet?: boolean;
+  'local-database'?: boolean;
+  'local-node'?: boolean;
+  'local-indexer'?: boolean;
   timeout: number;
   interval: number;
 }
 
+async function withoutProxy<T>(fn: () => Promise<T>): Promise<T> {
+  const originalProxy = {
+    HTTP_PROXY: process.env.HTTP_PROXY,
+    HTTPS_PROXY: process.env.HTTPS_PROXY,
+    http_proxy: process.env.http_proxy,
+    https_proxy: process.env.https_proxy,
+    NO_PROXY: process.env.NO_PROXY,
+    no_proxy: process.env.no_proxy
+  };
+
+  delete process.env.HTTP_PROXY;
+  delete process.env.HTTPS_PROXY;
+  delete process.env.http_proxy;
+  delete process.env.https_proxy;
+  process.env.NO_PROXY = '127.0.0.1,localhost,*.local';
+  process.env.no_proxy = '127.0.0.1,localhost,*.local';
+
+  try {
+    return await fn();
+  } finally {
+    Object.keys(originalProxy).forEach((key) => {
+      const value = originalProxy[key as keyof typeof originalProxy];
+      if (value !== undefined) {
+        process.env[key] = value;
+      } else {
+        delete process.env[key];
+      }
+    });
+  }
+}
+
+// Check if PostgreSQL port is occupied (service is running)
+async function checkPostgreSQLRunning(): Promise<boolean> {
+  return checkPortRunning(5432);
+}
+
+// Generic port checking function
+async function checkPortRunning(port: number, host: string = '127.0.0.1'): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let isConnected = false;
+
+    // Set timeout for connection attempt
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      if (!isConnected) {
+        resolve(false);
+      }
+    }, 2000);
+
+    socket.connect(port, host, () => {
+      isConnected = true;
+      clearTimeout(timeout);
+      socket.destroy();
+      resolve(true); // Port is occupied, service is running
+    });
+
+    socket.on('error', () => {
+      clearTimeout(timeout);
+      if (!isConnected) {
+        resolve(false); // Connection failed, service not running
+      }
+    });
+  });
+}
+
+// Check indexer health endpoint
+async function checkIndexerHealth(): Promise<boolean> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+
+    const response = await fetch('http://127.0.0.1:8080/health', {
+      signal: controller.signal,
+      headers: {
+        Accept: 'application/json'
+      }
+    });
+
+    clearTimeout(timeout);
+    return response.status === 200;
+  } catch {
+    return false;
+  }
+}
+
+// Wait for all localnet services with custom checks
+async function waitForLocalnetServices(options: WaitOptions): Promise<void> {
+  const spinner = ora({
+    text: 'Waiting for dubhe localnet services...',
+    color: 'cyan'
+  });
+
+  spinner.start();
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < options.timeout) {
+    try {
+      // Check HTTP services using wait-on (excluding 9000 port)
+      await withoutProxy(() =>
+        waitOn({
+          resources: [
+            'http://127.0.0.1:9123', // Sui faucet
+            'http://127.0.0.1:4000' // GraphQL server
+          ],
+          timeout: options.interval,
+          interval: 500,
+          validateStatus: (status: number) => status === 200
+        })
+      );
+
+      // Check PostgreSQL separately
+      const postgresRunning = await checkPostgreSQLRunning();
+
+      if (postgresRunning) {
+        spinner.succeed(chalk.green('All dubhe localnet services are ready!'));
+        return;
+      }
+    } catch (_error) {
+      // Continue waiting...
+    }
+
+    // Wait before next check
+    await new Promise((resolve) => setTimeout(resolve, options.interval));
+  }
+
+  // Timeout reached
+  throw new Error('Timeout waiting for services');
+}
+
+// Wait for local database
+async function waitForLocalDatabase(options: WaitOptions): Promise<void> {
+  const spinner = ora({
+    text: 'Waiting for local database...',
+    color: 'cyan'
+  });
+
+  spinner.start();
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < options.timeout) {
+    const isRunning = await checkPostgreSQLRunning();
+
+    if (isRunning) {
+      spinner.succeed(chalk.green('Local database is ready!'));
+      return;
+    }
+
+    // Wait before next check
+    await new Promise((resolve) => setTimeout(resolve, options.interval));
+  }
+
+  // Timeout reached
+  throw new Error('Timeout waiting for local database');
+}
+
+// Wait for local Sui node
+async function waitForLocalNode(options: WaitOptions): Promise<void> {
+  const spinner = ora({
+    text: 'Waiting for local Sui node...',
+    color: 'cyan'
+  });
+
+  spinner.start();
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < options.timeout) {
+    const isRunning = await checkPortRunning(9123);
+
+    if (isRunning) {
+      spinner.succeed(chalk.green('Local Sui node is ready!'));
+      return;
+    }
+
+    // Wait before next check
+    await new Promise((resolve) => setTimeout(resolve, options.interval));
+  }
+
+  // Timeout reached
+  throw new Error('Timeout waiting for local Sui node');
+}
+
+// Wait for local indexer
+async function waitForLocalIndexer(options: WaitOptions): Promise<void> {
+  const spinner = ora({
+    text: 'Waiting for local indexer...',
+    color: 'cyan'
+  });
+
+  spinner.start();
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < options.timeout) {
+    const isRunning = await checkIndexerHealth();
+
+    if (isRunning) {
+      spinner.succeed(chalk.green('Local indexer is ready!'));
+      return;
+    }
+
+    // Wait before next check
+    await new Promise((resolve) => setTimeout(resolve, options.interval));
+  }
+
+  // Timeout reached
+  throw new Error('Timeout waiting for local indexer');
+}
+
 const commandModule: CommandModule = {
   command: 'wait',
-  describe: 'Wait for service to be ready',
+  describe: 'Wait for service(s) to be ready',
   builder(yargs) {
     return yargs
       .option('url', {
         type: 'string',
-        description: 'URL to wait for'
+        description: 'URL to wait for (single service)'
+      })
+      .option('localnet', {
+        type: 'boolean',
+        description:
+          'Wait for all dubhe localnet services (sui localnode:9000&9123, postgres:5432, graphql:4000)',
+        default: false
+      })
+      .option('local-database', {
+        type: 'boolean',
+        description: 'Wait for local database (PostgreSQL on port 5432)',
+        default: false
+      })
+      .option('local-node', {
+        type: 'boolean',
+        description: 'Wait for local Sui node (port 9123)',
+        default: false
+      })
+      .option('local-indexer', {
+        type: 'boolean',
+        description: 'Wait for local indexer (health check at http://127.0.0.1:8080/health)',
+        default: false
       })
       .option('timeout', {
         type: 'number',
         description: 'Timeout (in milliseconds)',
-        default: 180000
+        default: 24 * 60 * 60 * 1000 // 24 hours, effectively no timeout
       })
       .option('interval', {
         type: 'number',
         description: 'Check interval (in milliseconds)',
         default: 1000
+      })
+      .check((argv) => {
+        const hasUrl = !!argv.url;
+        const hasLocalnet = !!argv.localnet;
+        const hasLocalDatabase = !!argv['local-database'];
+        const hasLocalNode = !!argv['local-node'];
+        const hasLocalIndexer = !!argv['local-indexer'];
+
+        const optionCount = [
+          hasUrl,
+          hasLocalnet,
+          hasLocalDatabase,
+          hasLocalNode,
+          hasLocalIndexer
+        ].filter(Boolean).length;
+
+        if (optionCount === 0) {
+          throw new Error(
+            'Please provide at least one option: --url, --localnet, --local-database, --local-node, or --local-indexer'
+          );
+        }
+
+        if (hasUrl && optionCount > 1) {
+          throw new Error('Cannot use --url together with other options');
+        }
+
+        if (hasLocalnet && (hasLocalDatabase || hasLocalNode || hasLocalIndexer)) {
+          throw new Error('Cannot use --localnet together with individual service options');
+        }
+
+        return true;
       });
   },
   async handler(argv) {
     const options = argv as unknown as WaitOptions;
-    const spinner = ora({
-      text: `Waiting for service to start ${chalk.cyan(options.url)}...`,
-      color: 'cyan'
-    });
-
-    spinner.start();
 
     try {
-      await waitOn({
-        resources: [options.url],
-        timeout: options.timeout,
-        interval: options.interval,
-        validateStatus: (status: number) => status === 200
-      });
+      if (options.localnet) {
+        await waitForLocalnetServices(options);
+      } else if (options['local-database']) {
+        await waitForLocalDatabase(options);
+      } else if (options['local-node']) {
+        await waitForLocalNode(options);
+      } else if (options['local-indexer']) {
+        await waitForLocalIndexer(options);
+      } else {
+        // Single URL mode - use original wait-on logic
+        const spinner = ora({
+          text: `Waiting for ${options.url}...`,
+          color: 'cyan'
+        });
+
+        spinner.start();
+
+        await withoutProxy(() =>
+          waitOn({
+            resources: [options.url!],
+            timeout: options.timeout,
+            interval: options.interval,
+            validateStatus: (status: number) => status === 200
+          })
+        );
+
+        spinner.succeed(chalk.green('Service is ready!'));
+      }
+
+      handlerExit();
+    } catch (_error) {
+      const spinner = ora();
+
+      let errorMessage = 'Timeout waiting for service';
+      let helpMessage = 'Please make sure the service is running...';
+
+      if (options.localnet) {
+        errorMessage = 'Timeout waiting for dubhe localnet services';
+        helpMessage =
+          'Please make sure all required services are running:\n' +
+          '- Sui localnode on port 9000\n' +
+          '- Sui faucet on port 9123\n' +
+          '- PostgreSQL database on port 5432\n' +
+          '- Dubhe GraphQL server on port 4000';
+      } else if (options['local-database']) {
+        errorMessage = 'Timeout waiting for local database';
+        helpMessage = 'Please make sure PostgreSQL is running on port 5432';
+      } else if (options['local-node']) {
+        errorMessage = 'Timeout waiting for local Sui node';
+        helpMessage = 'Please make sure Sui localnode is running on port 9123';
+      } else if (options['local-indexer']) {
+        errorMessage = 'Timeout waiting for local indexer';
+        helpMessage =
+          'Please make sure indexer is running and health endpoint is available at http://127.0.0.1:8080/health';
+      }
+
+      spinner.fail(chalk.red(errorMessage));
+      console.error(chalk.yellow(helpMessage));
 
-      spinner.succeed(chalk.green('Service is ready!'));
-      process.exit(0);
-    } catch (error) {
-      spinner.fail(chalk.red('Timeout waiting for service'));
-      console.error(chalk.yellow('Please make sure the service is running...'));
-      process.exit(1);
+      handlerExit(1);
     }
   }
 };

package/src/commands/watch.ts

@@ -1,6 +1,7 @@
 import type { CommandModule } from 'yargs';
 import chokidar from 'chokidar';
 import { exec } from 'child_process';
+import { handlerExit } from './shell';
 
 const commandModule: CommandModule = {
   command: 'watch',
@@ -42,7 +43,7 @@ const commandModule: CommandModule = {
     process.on('SIGINT', () => {
       watcher.close();
       console.log('\nWatch stopped.');
-      process.exit();
+      handlerExit();
     });
   }
 };

package/src/dubhe.ts

@@ -2,25 +2,30 @@
 
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import chalk from 'chalk';
 import { commands } from './commands';
 import { logError } from './utils/errors';
+import packageJson from '../package.json';
 
 // Load .env file into process.env
 import * as dotenv from 'dotenv';
-import chalk from 'chalk';
 dotenv.config();
 
 yargs(hideBin(process.argv))
   // Explicit name to display in help (by default it's the entry file, which may not be "dubhe" for e.g. ts-node)
   .scriptName('dubhe')
   // Use the commands directory to scaffold
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
+
   .command(commands as any)
+  .version(packageJson.version)
+  .demandCommand(1, 'Please provide a command')
+  .recommendCommands()
   // Enable strict mode.
   .strict()
   // Custom error handler
   .fail((msg, err) => {
     console.error(chalk.red(msg));
+
     if (msg.includes('Missing required argument')) {
       console.log(
         chalk.yellow(
@@ -29,8 +34,11 @@ yargs(hideBin(process.argv))
       );
     }
     console.log('');
-    logError(err);
-    console.log('');
+    // Even though `.fail` type says we should get an `Error`, this can sometimes be undefined
+    if (err != null) {
+      logError(err);
+      console.log('');
+    }
 
     process.exit(1);
   })

package/src/utils/axios-downloader.ts

@@ -0,0 +1,116 @@
+// Better download implementation using axios
+import chalk from 'chalk';
+import * as cliProgress from 'cli-progress';
+import * as fs from 'fs';
+import axios from 'axios';
+
+/**
+ * Download file using axios
+ */
+export async function downloadWithAxios(url: string, outputPath: string): Promise<void> {
+  try {
+    const response = await axios.get(url, {
+      responseType: 'stream',
+      timeout: 30000,
+      headers: { 'User-Agent': 'dubhe-cli' },
+      maxRedirects: 5,
+      validateStatus: (status) => status < 400 // Accept all status codes < 400
+    });
+
+    await streamToFile(response, outputPath);
+    console.log(chalk.green(`   ✓ Successfully downloaded`));
+  } catch (error: any) {
+    // Handle specific network error cases with more descriptive messages
+    if (error.code === 'ENOTFOUND') {
+      throw new Error(
+        `DNS resolution failed: ${error.message}. Please check your internet connection.`
+      );
+    } else if (error.code === 'ECONNRESET') {
+      throw new Error(`Connection reset: ${error.message}. Please check your network connection.`);
+    } else if (error.code === 'ETIMEDOUT') {
+      throw new Error(
+        `Connection timeout: ${error.message}. Please check your network connection.`
+      );
+    } else if (error.message.includes('protocol mismatch')) {
+      throw new Error(
+        `Protocol mismatch: ${error.message}. Please check your network configuration.`
+      );
+    } else if (error.response) {
+      throw new Error(`HTTP ${error.response.status}: ${error.response.statusText}`);
+    } else {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Download failed: ${errorMsg}`);
+    }
+  }
+}
+
+/**
+ * Stream response data to file with progress bar
+ */
+async function streamToFile(response: any, outputPath: string): Promise<void> {
+  const totalSize = parseInt(response.headers['content-length'] || '0');
+
+  // Create progress bar
+  const progressBar = new cliProgress.SingleBar({
+    format:
+      chalk.cyan('Download Progress') +
+      ' |{bar}| {percentage}% | {value}/{total} MB | Speed: {speed} MB/s | ETA: {eta}s',
+    barCompleteChar: '\u2588',
+    barIncompleteChar: '\u2591',
+    hideCursor: true,
+    barsize: 30,
+    forceRedraw: true
+  });
+
+  if (totalSize > 0) {
+    progressBar.start(Math.round((totalSize / 1024 / 1024) * 100) / 100, 0, {
+      speed: '0.00'
+    });
+  } else {
+    console.log(chalk.blue('📥 Downloading... (unable to get file size)'));
+  }
+
+  const writer = fs.createWriteStream(outputPath);
+  let downloadedBytes = 0;
+  const startTime = Date.now();
+
+  return new Promise((resolve, reject) => {
+    response.data.on('data', (chunk: Buffer) => {
+      downloadedBytes += chunk.length;
+
+      if (totalSize > 0) {
+        const downloadedMB = Math.round((downloadedBytes / 1024 / 1024) * 100) / 100;
+        const elapsedTime = (Date.now() - startTime) / 1000;
+        const speed = elapsedTime > 0 ? Math.round((downloadedMB / elapsedTime) * 100) / 100 : 0;
+
+        progressBar.update(downloadedMB, {
+          speed: speed.toFixed(2)
+        });
+      }
+    });
+
+    response.data.pipe(writer);
+
+    writer.on('finish', () => {
+      if (totalSize > 0) {
+        progressBar.stop();
+      }
+
+      const totalMB = Math.round((downloadedBytes / 1024 / 1024) * 100) / 100;
+      const elapsedTime = (Date.now() - startTime) / 1000;
+      const avgSpeed = elapsedTime > 0 ? Math.round((totalMB / elapsedTime) * 100) / 100 : 0;
+
+      console.log(
+        chalk.green(`✓ Download completed! ${totalMB} MB, average speed: ${avgSpeed} MB/s`)
+      );
+      resolve();
+    });
+
+    writer.on('error', (error) => {
+      if (totalSize > 0) {
+        progressBar.stop();
+      }
+      reject(error);
+    });
+  });
+}