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

package/src/commands/shell.ts

@@ -0,0 +1,198 @@
+import readline from 'readline';
+
+import yargs, { CommandModule } from 'yargs';
+import { commands } from '.';
+import chalk from 'chalk';
+import { getDefaultNetwork, printDubhe } from '../utils';
+import dotenv from 'dotenv';
+import { spawn } from 'child_process';
+
+dotenv.config();
+
+let shouldHandlerExit = true;
+
+// Blacklist of commands not available inside shell
+const SHELL_BLACKLIST_COMMANDS = ['shell', 'wait'];
+
+export const handlerExit = (status: number = 0) => {
+  if (shouldHandlerExit) process.exit(status);
+};
+
+type Options = {
+  network: any;
+};
+
+const parseCommandNames = () => {
+  return commands
+    .filter((command) => !SHELL_BLACKLIST_COMMANDS.includes(command.command as string))
+    .map((command) => command.command);
+};
+
+const ShellCommand: CommandModule<Options, Options> = {
+  command: 'shell',
+  describe: 'Open a shell to interact with the Dubhe System',
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        default: 'default',
+        desc: 'Node network (mainnet/testnet/devnet/localnet)'
+      }
+    });
+  },
+  handler: async ({ network }) => {
+    if (network == 'default') {
+      network = await getDefaultNetwork();
+      console.log(chalk.yellow(`Use default network: [${network}]`));
+    }
+    shouldHandlerExit = false;
+    const commandHistory: string[] = [];
+
+    function completer(line: string) {
+      const hits = parseCommandNames().filter((c) => {
+        if (!c) return false;
+        return (c as string).startsWith(line.toLowerCase());
+      });
+      return [hits.length ? hits : parseCommandNames(), line];
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: `dubhe(${chalk.green(network)}) ${chalk.bold('>')} `,
+      completer: completer,
+      historySize: 200
+    });
+
+    rl.on('line', async (line) => {
+      const fullCommand = line.trim();
+      if (!fullCommand) {
+        rl.prompt();
+        return;
+      }
+
+      // Add command to history
+      commandHistory.push(fullCommand);
+
+      const parts = fullCommand.split(/\s+/);
+      const commandName = parts[0].toLowerCase();
+
+      const command = commands.find(
+        (c) => c.command === commandName && !SHELL_BLACKLIST_COMMANDS.includes(commandName)
+      );
+
+      // Check if user is asking for help
+      if (parts.includes('--help') || parts.includes('-h')) {
+        if (command) {
+          try {
+            // Use spawn to call dubhe help externally to avoid validation issues
+            const dubheProcess = spawn('node', [process.argv[1], commandName, '--help'], {
+              stdio: 'inherit',
+              env: { ...process.env }
+            });
+
+            dubheProcess.on('exit', () => {
+              rl.prompt();
+            });
+
+            dubheProcess.on('error', () => {
+              // Fallback: show basic help information
+              console.log(`\n${command.describe || `${commandName} command`}`);
+              console.log(`\nUsage: ${commandName} [options]`);
+              console.log('\nFor complete help with all options, please exit shell and run:');
+              console.log(chalk.cyan(`  dubhe ${commandName} --help`));
+              rl.prompt();
+            });
+
+            return; // Don't call rl.prompt() here as it's handled in the callbacks
+          } catch {
+            // Fallback: show basic help information
+            console.log(`\n${command.describe || `${commandName} command`}`);
+            console.log(`\nUsage: ${commandName} [options]`);
+            console.log('\nFor complete help with all options, please exit shell and run:');
+            console.log(chalk.cyan(`  dubhe ${commandName} --help`));
+          }
+        } else {
+          console.log(
+            `🤷 Unknown command: "${commandName}". Type 'help' to see available commands.`
+          );
+        }
+        rl.prompt();
+        return;
+      }
+
+      if (command) {
+        try {
+          const { builder, handler } = command;
+          const yargsInstance = yargs().exitProcess(false);
+          if (builder) {
+            if (typeof builder === 'function') {
+              builder(yargsInstance);
+            } else {
+              yargsInstance.options(builder);
+            }
+            const argv = yargsInstance.parseSync([
+              commandName,
+              '--network',
+              network,
+              ...parts.slice(1)
+            ]);
+            if (handler) {
+              await handler(argv);
+            }
+          }
+        } catch (error) {
+          console.log(chalk.red(error));
+        }
+      } else if (commandName == 'help') {
+        console.log('Available dubhe commands:');
+
+        // Find the longest command name for alignment (excluding blacklisted commands)
+        const availableCommands = commands.filter(
+          (c) => !SHELL_BLACKLIST_COMMANDS.includes(c.command as string)
+        );
+        const maxCommandLength = Math.max(
+          ...availableCommands.map((c) => {
+            const command =
+              typeof c.command === 'string'
+                ? c.command
+                : Array.isArray(c.command)
+                ? c.command[0]
+                : '';
+            return command.length;
+          })
+        );
+
+        availableCommands.forEach((c) => {
+          const command =
+            typeof c.command === 'string'
+              ? c.command
+              : Array.isArray(c.command)
+              ? c.command[0]
+              : '';
+          const paddedCommand = command.padEnd(maxCommandLength);
+          console.log(`  ${chalk.green(paddedCommand)}  ${c.describe}`);
+        });
+        rl.prompt();
+        return;
+      } else if (['exit', 'quit'].indexOf(commandName) !== -1) {
+        console.log('Goodbye You will have a nice day! 👋');
+        rl.close();
+        return;
+      } else {
+        console.log(`🤷 Unknown command: "${fullCommand}". Type 'help' to see available commands.`);
+      }
+      rl.prompt();
+    });
+
+    rl.on('close', () => {
+      process.exit(0);
+    });
+
+    printDubhe();
+    rl.prompt();
+  }
+};
+
+export default ShellCommand;

package/src/commands/switchEnv.ts

@@ -0,0 +1,26 @@
+import type { CommandModule, ArgumentsCamelCase } from 'yargs';
+import { switchEnv } from '../utils';
+import { handlerExit } from './shell';
+
+type Options = {
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: 'switch-env',
+  describe: 'Switch environment',
+  builder(yargs) {
+    return yargs.option('network', {
+      type: 'string',
+      choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
+      default: 'localnet',
+      desc: 'Switch to node network (mainnet/testnet/devnet/localnet)'
+    }) as any;
+  },
+  async handler(argv: ArgumentsCamelCase<Options>) {
+    await switchEnv(argv.network as 'mainnet' | 'testnet' | 'devnet' | 'localnet');
+    handlerExit();
+  }
+};
+
+export default commandModule;

package/src/commands/test.ts

@@ -1,6 +1,19 @@
 import type { CommandModule } from 'yargs';
 import { execSync } from 'child_process';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
+import { handlerExit } from './shell';
+
+/**
+ * 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';
+  }
+}
 
 type Options = {
   'config-path': string;
@@ -8,21 +21,45 @@ type Options = {
   'gas-limit'?: string;
 };
 
+/**
+ * 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,
+  test?: string,
+  gasLimit: string = '100000000',
+  buildEnv?: string
+): Promise<string> {
+  const cwd = process.cwd();
+  const projectPath = `${cwd}/src/${dubheConfig.name}`;
+  // --build-env overrides the active Sui client environment for dependency resolution.
+  // Required for localnet (which is not in Move.toml [environments]) when the
+  // active client env has been set to localnet from a previous run.
+  const buildEnvFlag = buildEnv ? `--build-env ${buildEnv}` : '';
+  const command = `sui move test ${buildEnvFlag} --path ${projectPath} ${
+    test ? `--test ${test}` : ''
+  } --gas-limit ${gasLimit}`;
+  return execSync(command, { stdio: 'pipe', encoding: 'utf-8' });
+}
+
 const commandModule: CommandModule<Options, Options> = {
   command: 'test',
 
-  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'
+        description: 'Path to the Dubhe config file'
       },
       test: {
         type: 'string',
-        desc: 'Run a specific test'
+        desc: 'Run a specific test by name'
       },
       'gas-limit': {
         type: 'string',
@@ -33,19 +70,25 @@ const commandModule: CommandModule<Options, Options> = {
   },
 
   async handler({ 'config-path': configPath, test, 'gas-limit': gasLimit }) {
-    // Start an internal anvil process if no world address is provided
     try {
       console.log('🚀 Running move test');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      const path = process.cwd();
-      const projectPath = `${path}/contracts/${dubheConfig.name}`;
-      const command = `sui move test --path ${projectPath} ${
-        test ? ` --test ${test}` : ''
-      } --gas-limit ${gasLimit}`;
-      execSync(command, { stdio: 'inherit', encoding: 'utf-8' });
+
+      // Ephemeral networks (localnet/devnet) are not defined in Move.toml [environments].
+      // Use --build-env testnet for dependency resolution so `sui move test` can resolve
+      // git dependencies without requiring a localnet env entry.
+      const activeEnv = getActiveSuiEnv();
+      const buildEnv = activeEnv === 'localnet' || activeEnv === 'devnet' ? 'testnet' : undefined;
+
+      const output = await testHandler(dubheConfig, test, gasLimit, buildEnv);
+      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,6 +2,9 @@ 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 } from '../utils';
+import chalk from 'chalk';
 
 type Options = {
   network: any;
@@ -17,8 +20,8 @@ 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': {
@@ -31,13 +34,17 @@ const commandModule: CommandModule<Options, Options> = {
 
   async handler({ network, 'config-path': configPath }) {
     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);
     } catch (error: any) {
       logError(error);
-      process.exit(1);
+      handlerExit(1);
     }
-    process.exit(0);
+    handlerExit();
   }
 };