@0xobelisk/sui-cli 1.2.0-pre.12 → 1.2.0-pre.121

package/src/commands/test.ts

@@ -1,51 +1,163 @@
 import type { CommandModule } from 'yargs';
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
+import { handlerExit } from './shell';
+import { lintSystemGuards, formatLintWarnings } from '../utils';
 
-type Options = {
+/**
+ * Returns the active Sui client environment (e.g. "localnet", "testnet").
+ * Falls back to "testnet" if the command fails.
+ */
+function getActiveSuiEnv(): string {
+  try {
+    return execSync('sui client active-env', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+  } catch {
+    return 'testnet';
+  }
+}
+
+export type RunMoveTestOptions = {
+  /** Substring matched against each test's fully qualified name (`addr::module::fun`). */
+  filter?: string;
+  'gas-limit'?: string;
+  /** Same as `gas-limit` (programmatic API). */
+  gasLimit?: string;
+  buildEnv?: string;
+  /** When true, passes `-l` to list tests instead of running them. */
+  list?: boolean;
+};
+
+type CliOptions = {
   'config-path': string;
+  /** Positional from `test [filter]` */
+  filter?: string;
   test?: string;
-  'gas-limit'?: string;
+  'gas-limit': string;
+  list?: boolean;
 };
 
-const commandModule: CommandModule<Options, Options> = {
-  command: 'test',
+/**
+ * Builds argv for `sui move test` (argument array — no shell interpolation).
+ *
+ * Sui expects an optional filter as a **positional** argument at the end of the command.
+ * The `--test` flag on `sui move test` is unrelated (it enables compiling the `tests/` tree).
+ *
+ * @see `sui move test --help`
+ */
+export function buildSuiMoveTestArgv(options: {
+  projectPath: string;
+  gasLimit: string;
+  buildEnv?: string;
+  filter?: string;
+  list?: boolean;
+}): string[] {
+  const args = ['move', 'test'];
+  if (options.buildEnv) {
+    args.push('--build-env', options.buildEnv);
+  }
+  args.push('--path', options.projectPath);
+  if (options.list) {
+    args.push('-l');
+  }
+  args.push('--gas-limit', options.gasLimit);
+  if (options.filter && !options.list) {
+    args.push(options.filter);
+  }
+  return args;
+}
+
+/**
+ * Core Move test runner for Dubhe contracts.
+ * Runs `sui move test` against the package at `src/<dubheConfig.name>`.
+ *
+ * Move unit tests compile packages locally — no network or published address required.
+ */
+export async function testHandler(
+  dubheConfig: DubheConfig,
+  options: RunMoveTestOptions = {}
+): Promise<string> {
+  const gasLimit = options['gas-limit'] ?? options.gasLimit ?? '100000000';
+  const cwd = process.cwd();
+  const projectPath = `${cwd}/src/${dubheConfig.name}`;
+  const argv = buildSuiMoveTestArgv({
+    projectPath,
+    gasLimit,
+    buildEnv: options.buildEnv,
+    filter: options.filter,
+    list: options.list
+  });
+  return execFileSync('sui', argv, { stdio: 'pipe', encoding: 'utf-8' });
+}
+
+function resolveTestFilter(argv: { filter?: string; test?: string }): string | undefined {
+  return argv.filter ?? argv.test;
+}
+
+const commandModule: CommandModule<CliOptions, CliOptions> = {
+  command: 'test [filter]',
 
-  describe: 'Run tests in Dubhe contracts',
+  describe: 'Run Move unit tests in Dubhe contracts',
 
   builder(yargs) {
-    return yargs.options({
-      'config-path': {
-        type: 'string',
-        default: 'dubhe.config.ts',
-        description: 'Options to pass to forge test'
-      },
-      test: {
-        type: 'string',
-        desc: 'Run a specific test'
-      },
-      'gas-limit': {
+    return yargs
+      .positional('filter', {
         type: 'string',
-        desc: 'Set the gas limit for the test',
-        default: '100000000'
-      }
-    });
+        describe:
+          'Substring of fully qualified test name (see `sui move test --help`); optional when using --list'
+      })
+      .options({
+        'config-path': {
+          type: 'string',
+          default: 'dubhe.config.ts',
+          description: 'Path to the Dubhe config file'
+        },
+        test: {
+          type: 'string',
+          describe: 'Same as positional [filter] (kept for backward compatibility)'
+        },
+        'gas-limit': {
+          type: 'string',
+          desc: 'Set the gas limit for the test',
+          default: '100000000'
+        },
+        list: {
+          type: 'boolean',
+          default: false,
+          describe: 'List all Move unit tests (`sui move test -l`)'
+        }
+      });
   },
 
-  async handler({ 'config-path': configPath, test, 'gas-limit': gasLimit }) {
-    // Start an internal anvil process if no world address is provided
+  async handler(argv) {
+    const { 'config-path': configPath, 'gas-limit': gasLimit, list } = argv;
+    const filter = resolveTestFilter(argv);
+
     try {
-      console.log('🚀 Running move test');
+      console.log(list ? '🚀 Listing Move unit tests' : '🚀 Running move test');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      const path = process.cwd();
-      const projectPath = `${path}/src/${dubheConfig.name}`;
-      const command = `sui move test --path ${projectPath} ${
-        test ? ` --test ${test}` : ''
-      } --gas-limit ${gasLimit}`;
-      execSync(command, { stdio: 'inherit', encoding: 'utf-8' });
+
+      const projectPath = `${process.cwd()}/src/${dubheConfig.name}`;
+      const lintResults = lintSystemGuards(projectPath);
+      const warnings = formatLintWarnings(lintResults);
+      if (warnings) process.stdout.write(warnings);
+
+      const activeEnv = getActiveSuiEnv();
+      const buildEnv = activeEnv === 'localnet' || activeEnv === 'devnet' ? 'testnet' : undefined;
+
+      const output = await testHandler(dubheConfig, {
+        filter,
+        'gas-limit': gasLimit,
+        buildEnv,
+        list
+      });
+      if (output) process.stdout.write(output);
     } catch (error: any) {
-      process.exit(0);
+      if (error.stdout) process.stdout.write(error.stdout);
+      if (error.stderr) process.stderr.write(error.stderr);
+      if (!error.stdout && !error.stderr && error.message) process.stderr.write(error.message);
+      handlerExit(1);
     }
+    handlerExit();
   }
 };
 

package/src/commands/upgrade.ts

@@ -2,10 +2,16 @@ import type { CommandModule } from 'yargs';
 import { logError } from '../utils/errors';
 import { upgradeHandler } from '../utils/upgradeHandler';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
+import { handlerExit } from './shell';
+import { getDefaultNetwork, lintSystemGuards, formatLintWarnings, confirm } from '../utils';
+import { join as pathJoin } from 'path';
+import chalk from 'chalk';
 
 type Options = {
   network: any;
   'config-path': string;
+  'bump-version': boolean;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -17,27 +23,61 @@ const commandModule: CommandModule<Options, Options> = {
     return yargs.options({
       network: {
         type: 'string',
-        choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-        default: 'localnet',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        default: 'default',
         desc: 'Network of the node (mainnet/testnet/devnet/localnet)'
       },
       'config-path': {
         type: 'string',
         default: 'dubhe.config.ts',
         decs: 'Path to the config file'
+      },
+      'bump-version': {
+        type: 'boolean',
+        default: false,
+        desc: 'Force a version bump even when no new resources were added (use for breaking logic changes or security fixes that must invalidate old clients)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, 'config-path': configPath }) {
+  async handler({
+    network,
+    'config-path': configPath,
+    'bump-version': bumpVersion,
+    'rpc-url': rpcUrl
+  }) {
     try {
+      if (network == 'default') {
+        network = await getDefaultNetwork();
+        console.log(chalk.yellow(`Use default network: [${network}]`));
+      }
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      await upgradeHandler(dubheConfig, dubheConfig.name, network);
+
+      const projectPath = pathJoin(process.cwd(), 'src', dubheConfig.name);
+      const lintResults = lintSystemGuards(projectPath);
+      if (lintResults.length > 0) {
+        process.stdout.write(formatLintWarnings(lintResults));
+        const proceed = await confirm(
+          'Some entry functions are missing ensure_latest_version. Proceed with upgrade anyway?'
+        );
+        if (!proceed) {
+          console.log(chalk.red('Upgrade cancelled.'));
+          handlerExit(1);
+          return;
+        }
+      }
+
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await upgradeHandler(dubheConfig, dubheConfig.name, network, bumpVersion, fullnodeUrls);
     } catch (error: any) {
       logError(error);
-      process.exit(1);
+      handlerExit(1);
     }
-    process.exit(0);
+    handlerExit();
   }
 };
 

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);
     }
   }
 };