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

package/src/commands/query.ts

@@ -1,108 +1,108 @@
-import type { CommandModule } from 'yargs';
-import { logError } from '../utils/errors';
-import { queryStorage } from '../utils';
-import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+// import type { CommandModule } from 'yargs';
+// import { logError } from '../utils/errors';
+// import { queryStorage } from '../utils';
+// import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
 
-type Options = {
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-  'config-path'?: string;
-  schema: string;
-  'object-id'?: string;
-  'package-id'?: string;
-  'metadata-path'?: string;
-  params?: any[];
-};
+// type Options = {
+//   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+//   'config-path'?: string;
+//   schema: string;
+//   'object-id'?: string;
+//   'package-id'?: string;
+//   'metadata-path'?: string;
+//   params?: any[];
+// };
 
-/**
- * CLI command module for querying schema struct state
- *
- * Examples:
- *
- * 1. Query StorageValue (no params required):
- * ```bash
- * dubhe query --config-path dubhe.config.ts --network devnet --schema counter --field value
- * ```
- *
- * 2. Query StorageMap (one param required):
- * ```bash
- * dubhe query --config-path dubhe.config.ts --network devnet --schema token --field balances \
- *   --params "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
- * ```
- *
- * 3. Query StorageDoubleMap (two params required):
- * ```bash
- * dubhe query --config-path dubhe.config.ts --network devnet --schema game --field player_relations \
- *   --params "0x123...456" "0x789...abc"
- * ```
- */
-const commandModule: CommandModule<Options, Options> = {
-  command: 'query',
+// /**
+//  * CLI command module for querying schema struct state
+//  *
+//  * Examples:
+//  *
+//  * 1. Query StorageValue (no params required):
+//  * ```bash
+//  * dubhe query --config-path dubhe.config.ts --network devnet --schema counter --field value
+//  * ```
+//  *
+//  * 2. Query StorageMap (one param required):
+//  * ```bash
+//  * dubhe query --config-path dubhe.config.ts --network devnet --schema token --field balances \
+//  *   --params "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+//  * ```
+//  *
+//  * 3. Query StorageDoubleMap (two params required):
+//  * ```bash
+//  * dubhe query --config-path dubhe.config.ts --network devnet --schema game --field player_relations \
+//  *   --params "0x123...456" "0x789...abc"
+//  * ```
+//  */
+// const commandModule: CommandModule<Options, Options> = {
+//   command: 'query',
 
-  describe: 'Query dubhe schema struct state',
+//   describe: 'Query dubhe schema struct state',
 
-  builder: {
-    network: {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-      default: 'localnet',
-      desc: 'Node network (mainnet/testnet/devnet/localnet)'
-    },
-    'config-path': {
-      type: 'string',
-      default: 'dubhe.config.ts',
-      desc: 'Configuration file path'
-    },
-    schema: {
-      type: 'string',
-      desc: 'Schema name',
-      demandOption: true
-    },
-    'object-id': {
-      type: 'string',
-      desc: 'Object ID (optional)'
-    },
-    'package-id': {
-      type: 'string',
-      desc: 'Package ID (optional)'
-    },
-    'metadata-path': {
-      type: 'string',
-      desc: 'Path to metadata JSON file (optional)'
-    },
-    params: {
-      type: 'array',
-      desc: 'Params for storage type: StorageValue(no params), StorageMap(1 param), StorageDoubleMap(2 params)',
-      string: true
-    }
-  },
+//   builder: {
+//     network: {
+//       type: 'string',
+//       choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+//       default: 'localnet',
+//       desc: 'Node network (mainnet/testnet/devnet/localnet)'
+//     },
+//     'config-path': {
+//       type: 'string',
+//       default: 'dubhe.config.ts',
+//       desc: 'Configuration file path'
+//     },
+//     schema: {
+//       type: 'string',
+//       desc: 'Schema name',
+//       demandOption: true
+//     },
+//     'object-id': {
+//       type: 'string',
+//       desc: 'Object ID (optional)'
+//     },
+//     'package-id': {
+//       type: 'string',
+//       desc: 'Package ID (optional)'
+//     },
+//     'metadata-path': {
+//       type: 'string',
+//       desc: 'Path to metadata JSON file (optional)'
+//     },
+//     params: {
+//       type: 'array',
+//       desc: 'Params for storage type: StorageValue(no params), StorageMap(1 param), StorageDoubleMap(2 params)',
+//       string: true
+//     }
+//   },
 
-  async handler({
-    network,
-    'config-path': configPath,
-    schema,
-    'object-id': objectId,
-    'package-id': packageId,
-    'metadata-path': metadataPath,
-    params
-  }) {
-    try {
-      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+//   async handler({
+//     network,
+//     'config-path': configPath,
+//     schema,
+//     'object-id': objectId,
+//     'package-id': packageId,
+//     'metadata-path': metadataPath,
+//     params
+//   }) {
+//     try {
+//       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
 
-      await queryStorage({
-        dubheConfig,
-        schema,
-        objectId,
-        network,
-        packageId,
-        metadataFilePath: metadataPath,
-        params
-      });
-    } catch (error: any) {
-      logError(error);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-};
+//       await queryStorage({
+//         dubheConfig,
+//         schema,
+//         objectId,
+//         network,
+//         packageId,
+//         metadataFilePath: metadataPath,
+//         params
+//       });
+//     } catch (error: any) {
+//       logError(error);
+//       process.exit(1);
+//     }
+//     process.exit(0);
+//   }
+// };
 
-export default commandModule;
+// export default commandModule;

package/src/commands/shell.ts

@@ -0,0 +1,208 @@
+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;
+  'rpc-url'?: string;
+};
+
+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)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL injected into every sub-command (overrides the default for the selected network)'
+      }
+    });
+  },
+  handler: async ({ network, 'rpc-url': rpcUrl }) => {
+    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)}${
+        rpcUrl ? chalk.gray('[custom-rpc]') : ''
+      }) ${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 userArgs = parts.slice(1);
+            const hasNetworkFlag = userArgs.includes('--network') || userArgs.includes('-n');
+            const hasRpcUrlFlag = userArgs.includes('--rpc-url');
+            const argv = yargsInstance.parseSync([
+              commandName,
+              ...(hasNetworkFlag ? [] : ['--network', network]),
+              ...(hasRpcUrlFlag || !rpcUrl ? [] : ['--rpc-url', rpcUrl]),
+              ...userArgs
+            ]);
+            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/{configStore.ts → storeConfig.ts}

@@ -1,15 +1,18 @@
 import type { CommandModule } from 'yargs';
 import { storeConfigHandler } from '../utils/storeConfig';
 import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+import { handlerExit } from './shell';
+import chalk from 'chalk';
+import { getDefaultNetwork } from '../utils';
 
 type Options = {
   'config-path': string;
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
   'output-ts-path': string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
-  command: 'config-store',
+  command: 'store-config',
 
   describe: 'Store configuration for the Dubhe project',
 
@@ -21,7 +24,8 @@ const commandModule: CommandModule<Options, Options> = {
     },
     network: {
       type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+      choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+      default: 'default',
       desc: 'Network to store config for'
     },
     'output-ts-path': {
@@ -31,13 +35,17 @@ const commandModule: CommandModule<Options, Options> = {
   },
   async handler({ 'config-path': configPath, network, 'output-ts-path': outputTsPath }) {
     try {
+      if (network == 'default') {
+        network = await getDefaultNetwork();
+        console.log(chalk.yellow(`Use default network: [${network}]`));
+      }
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
       await storeConfigHandler(dubheConfig, network, outputTsPath);
     } catch (error) {
       console.error('Error storing config:', error);
-      process.exit(1);
+      handlerExit(1);
     }
-    process.exit(0);
+    handlerExit();
   }
 };
 

package/src/commands/switchEnv.ts

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