@0xobelisk/sui-cli 1.2.0-pre.21 → 1.2.0-pre.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.2.0-pre.21",
+  "version": "1.2.0-pre.24",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -37,6 +37,7 @@
     "chalk": "^5.0.1",
     "child_process": "^1.0.2",
     "chokidar": "^3.5.3",
+    "cli-table3": "^0.6.5",
     "dotenv": "^16.0.3",
     "ejs": "^3.1.8",
     "execa": "^7.0.0",
@@ -50,8 +51,8 @@
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-client": "1.2.0-pre.21",
-    "@0xobelisk/sui-common": "1.2.0-pre.21"
+    "@0xobelisk/sui-client": "1.2.0-pre.24",
+    "@0xobelisk/sui-common": "1.2.0-pre.24"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.1",

package/src/commands/build.ts

@@ -1,5 +1,5 @@
 import type { CommandModule } from 'yargs';
-import { execSync } from 'child_process';
+import { execSync, exec } from 'child_process';
 import chalk from 'chalk';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 import { switchEnv, updateDubheDependency } from '../utils';
@@ -52,6 +52,7 @@ const commandModule: CommandModule<Options, Options> = {
       }`;
       const output = execSync(command, { encoding: 'utf-8' });
       console.log(output);
+      exec(`pnpm dubhe convert-json --config-path ${configPath}`)
     } catch (error: any) {
       console.error(chalk.red('Error executing sui move build:'));
       console.log(error.stdout);

package/src/commands/call.ts

@@ -1,90 +1,90 @@
-import type { CommandModule } from 'yargs';
-import { logError } from '../utils/errors';
-import { callHandler } from '../utils';
-import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+// import type { CommandModule } from 'yargs';
+// import { logError } from '../utils/errors';
+// import { callHandler } from '../utils';
+// import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
 
-type Options = {
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-  module: string;
-  function: string;
-  'config-path'?: string;
-  'package-id'?: string;
-  'metadata-path'?: string;
-  params?: any[];
-};
+// type Options = {
+//   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+//   module: string;
+//   function: string;
+//   'config-path'?: string;
+//   'package-id'?: string;
+//   'metadata-path'?: string;
+//   params?: any[];
+// };
 
-/**
- * CLI command for calling a function in a module
- */
-const commandModule: CommandModule<Options, Options> = {
-  command: 'call',
+// /**
+//  * CLI command for calling a function in a module
+//  */
+// const commandModule: CommandModule<Options, Options> = {
+//   command: 'call',
 
-  describe: 'Call a function in a module',
+//   describe: 'Call a function in a module',
 
-  builder: {
-    network: {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-      desc: 'Node network (mainnet/testnet/devnet/localnet)',
-      default: 'localnet'
-    },
-    module: {
-      type: 'string',
-      desc: 'Module name',
-      demandOption: true
-    },
-    function: {
-      type: 'string',
-      desc: 'Function name',
-      demandOption: true
-    },
-    'config-path': {
-      type: 'string',
-      default: 'dubhe.config.ts',
-      desc: 'Configuration file path'
-    },
-    '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 the function',
-      string: true
-    }
-  },
+//   builder: {
+//     network: {
+//       type: 'string',
+//       choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+//       desc: 'Node network (mainnet/testnet/devnet/localnet)',
+//       default: 'localnet'
+//     },
+//     module: {
+//       type: 'string',
+//       desc: 'Module name',
+//       demandOption: true
+//     },
+//     function: {
+//       type: 'string',
+//       desc: 'Function name',
+//       demandOption: true
+//     },
+//     'config-path': {
+//       type: 'string',
+//       default: 'dubhe.config.ts',
+//       desc: 'Configuration file path'
+//     },
+//     '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 the function',
+//       string: true
+//     }
+//   },
 
-  async handler({
-    network,
-    'config-path': configPath,
-    module: moduleName,
-    function: funcName,
-    'package-id': packageId,
-    'metadata-path': metadataPath,
-    params
-  }) {
-    try {
-      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+//   async handler({
+//     network,
+//     'config-path': configPath,
+//     module: moduleName,
+//     function: funcName,
+//     'package-id': packageId,
+//     'metadata-path': metadataPath,
+//     params
+//   }) {
+//     try {
+//       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
 
-      await callHandler({
-        dubheConfig,
-        moduleName,
-        funcName,
-        network,
-        packageId,
-        metadataFilePath: metadataPath,
-        params
-      });
-    } catch (error: any) {
-      logError(error);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-};
+//       await callHandler({
+//         dubheConfig,
+//         moduleName,
+//         funcName,
+//         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/convertJson.ts

@@ -0,0 +1,49 @@
+import type { CommandModule } from 'yargs';
+import chalk from 'chalk';
+import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
+import { generateConfigJson } from '../utils';
+import fs from 'fs';
+
+type Options = {
+  'config-path': string;
+  'output-path': string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: 'convert-json',
+  describe: 'Convert JSON from Dubhe config to config.json',
+  builder(yargs) {
+    return yargs.options({
+      'config-path': {
+        type: 'string',
+        default: 'dubhe.config.ts',
+        description: 'Options to pass to forge test'
+      },
+      'output-path': {
+        type: 'string',
+        default: 'dubhe.config.json',
+        description: 'Output path for the config.json file'
+      }
+    });
+  },
+
+  async handler({
+    'config-path': configPath,
+    'output-path': outputPath
+  }) {
+    // Start an internal anvil process if no world address is provided
+    try {
+      console.log('🚀 Running convert json');
+      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+      const json = generateConfigJson(dubheConfig);
+      // write to file
+      fs.writeFileSync(outputPath, json);
+    } catch (error: any) {
+      console.error(chalk.red('Error executing convert json:'));
+      console.log(error.stdout);
+      process.exit(0);
+    }
+  }
+};
+
+export default commandModule;

package/src/commands/doctor.ts

@@ -0,0 +1,348 @@
+import type { CommandModule } from 'yargs';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import Table from 'cli-table3';
+
+// Check result type
+interface CheckResult {
+  name: string;
+  status: 'success' | 'warning' | 'error';
+  message: string;
+  fixSuggestion?: string;
+}
+
+// Execute shell command and return output
+async function execCommand(
+  command: string,
+  args: string[] = []
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { shell: true });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve({ code: code || 0, stdout, stderr });
+    });
+
+    child.on('error', () => {
+      resolve({ code: -1, stdout, stderr });
+    });
+  });
+}
+
+// Check if command is available in PATH
+async function checkCommand(
+  command: string,
+  versionFlag: string = '--version'
+): Promise<CheckResult> {
+  try {
+    const result = await execCommand(command, [versionFlag]);
+    if (result.code === 0) {
+      const version = result.stdout.trim().split('\n')[0];
+      return {
+        name: command,
+        status: 'success',
+        message: `Installed ${version}`
+      };
+    } else {
+      return {
+        name: command,
+        status: 'error',
+        message: 'Not installed',
+        fixSuggestion: getInstallSuggestion(command)
+      };
+    }
+  } catch (error) {
+    return {
+      name: command,
+      status: 'error',
+      message: 'Not installed',
+      fixSuggestion: getInstallSuggestion(command)
+    };
+  }
+}
+
+// Get installation suggestions
+function getInstallSuggestion(command: string): string {
+  const suggestions: Record<string, string> = {
+    docker: 'Visit https://docs.docker.com/get-docker/ to install Docker',
+    'docker-compose': 'Visit https://docs.docker.com/compose/install/ to install Docker Compose',
+    sui: 'Visit https://docs.sui.io/guides/developer/getting-started/sui-install to install Sui CLI',
+    pnpm: 'Run: npm install -g pnpm',
+    node: 'Visit https://nodejs.org/ to download and install Node.js',
+    git: 'Visit https://git-scm.com/downloads to install Git'
+  };
+
+  return suggestions[command] || `Please install ${command}`;
+}
+
+// Check if file exists
+function checkFileExists(filePath: string, description: string): CheckResult {
+  const exists = existsSync(filePath);
+  return {
+    name: description,
+    status: exists ? 'success' : 'warning',
+    message: exists ? 'Available' : 'Not found',
+    fixSuggestion: exists ? undefined : `Please create file: ${filePath}`
+  };
+}
+
+// Check Node.js version
+async function checkNodeVersion(): Promise<CheckResult> {
+  try {
+    const result = await execCommand('node', ['--version']);
+    if (result.code === 0) {
+      const version = result.stdout.trim();
+      const versionNumber = parseFloat(version.replace('v', ''));
+
+      if (versionNumber >= 18) {
+        return {
+          name: 'Node.js version',
+          status: 'success',
+          message: `${version} (meets requirement >=18.0)`
+        };
+      } else {
+        return {
+          name: 'Node.js version',
+          status: 'warning',
+          message: `${version} (recommend upgrade to >=18.0)`,
+          fixSuggestion: 'Please upgrade Node.js to 18.0 or higher'
+        };
+      }
+    } else {
+      return {
+        name: 'Node.js version',
+        status: 'error',
+        message: 'Not installed',
+        fixSuggestion: 'Please install Node.js 18.0 or higher'
+      };
+    }
+  } catch (error) {
+    return {
+      name: 'Node.js version',
+      status: 'error',
+      message: 'Check failed',
+      fixSuggestion: 'Please install Node.js'
+    };
+  }
+}
+
+// Check Docker service status
+async function checkDockerService(): Promise<CheckResult> {
+  try {
+    const result = await execCommand('docker', ['info']);
+    if (result.code === 0) {
+      return {
+        name: 'Docker service',
+        status: 'success',
+        message: 'Running'
+      };
+    } else {
+      return {
+        name: 'Docker service',
+        status: 'warning',
+        message: 'Not running',
+        fixSuggestion: 'Please start Docker service'
+      };
+    }
+  } catch (error) {
+    return {
+      name: 'Docker service',
+      status: 'error',
+      message: 'Check failed',
+      fixSuggestion: 'Please install and start Docker'
+    };
+  }
+}
+
+// Check NPM configuration
+async function checkNpmConfig(): Promise<CheckResult> {
+  try {
+    const result = await execCommand('npm', ['config', 'get', 'registry']);
+    if (result.code === 0) {
+      const registry = result.stdout.trim();
+      return {
+        name: 'NPM configuration',
+        status: 'success',
+        message: `Configured (${registry})`
+      };
+    } else {
+      return {
+        name: 'NPM configuration',
+        status: 'warning',
+        message: 'Configuration issue',
+        fixSuggestion: 'Check NPM config: npm config list'
+      };
+    }
+  } catch (error) {
+    return {
+      name: 'NPM configuration',
+      status: 'warning',
+      message: 'Check failed',
+      fixSuggestion: 'Please install Node.js and NPM'
+    };
+  }
+}
+
+// Create table row data
+function formatTableRow(result: CheckResult): string[] {
+  const statusIcon = {
+    success: chalk.green('✓'),
+    warning: chalk.yellow('!'),
+    error: chalk.red('✗')
+  };
+
+  const statusText = {
+    success: chalk.green('YES'),
+    warning: chalk.yellow('WARN'),
+    error: chalk.red('NO')
+  };
+
+  // Decide what content to display based on status
+  let fixContent = '';
+  if (result.status === 'success') {
+    fixContent = result.message;
+  } else {
+    fixContent = result.fixSuggestion || result.message;
+  }
+
+  return [result.name, `${statusIcon[result.status]} ${statusText[result.status]}`, fixContent];
+}
+
+// Main check function
+async function runDoctorChecks() {
+  console.log(chalk.bold.blue('\n🔍 Dubhe Doctor - Environment Check Tool\n'));
+  console.log(chalk.gray('Checking your development environment...\n'));
+
+  const results: CheckResult[] = [];
+
+  // Execute all checks
+  console.log('Running checks...\n');
+
+  // Required tools check
+  const nodeCheck = await checkNodeVersion();
+  results.push(nodeCheck);
+
+  const pnpmCheck = await checkCommand('pnpm');
+  results.push(pnpmCheck);
+
+  const gitCheck = await checkCommand('git');
+  results.push(gitCheck);
+
+  // Package manager configuration check
+  const npmConfigCheck = await checkNpmConfig();
+  // Treat npm config as optional, don't affect overall status
+  if (npmConfigCheck.status === 'error') {
+    npmConfigCheck.status = 'warning';
+  }
+  results.push(npmConfigCheck);
+
+  // Docker related checks
+  const dockerCheck = await checkCommand('docker');
+  results.push(dockerCheck);
+
+  let dockerServiceCheck: CheckResult | null = null;
+  if (dockerCheck.status === 'success') {
+    dockerServiceCheck = await checkDockerService();
+    results.push(dockerServiceCheck);
+  }
+
+  const dockerComposeCheck = await checkCommand('docker-compose');
+  results.push(dockerComposeCheck);
+
+  // Sui CLI check
+  const suiCheck = await checkCommand('sui');
+  results.push(suiCheck);
+
+  // Configuration files check
+  const gitConfigCheck = checkFileExists(join(homedir(), '.gitconfig'), 'Git configuration');
+  results.push(gitConfigCheck);
+
+  // Create and display table
+  const table = new Table({
+    head: [chalk.bold.cyan('Criteria'), chalk.bold.cyan('Result'), chalk.bold.cyan('Fix')],
+    colWidths: [25, 15, 50],
+    style: {
+      head: ['cyan'],
+      border: ['grey']
+    },
+    wordWrap: true
+  });
+
+  // Add table rows
+  results.forEach((result) => {
+    table.push(formatTableRow(result));
+  });
+
+  console.log(table.toString());
+
+  // Summarize results
+  const summary = {
+    success: results.filter((r) => r.status === 'success').length,
+    warning: results.filter((r) => r.status === 'warning').length,
+    error: results.filter((r) => r.status === 'error').length
+  };
+
+  console.log('\n' + chalk.bold('📊 Check Summary:'));
+  console.log(`   ${chalk.green('✓ Passed:')} ${summary.success} items`);
+  console.log(`   ${chalk.yellow('! Warning:')} ${summary.warning} items`);
+  console.log(`   ${chalk.red('✗ Error:')} ${summary.error} items`);
+
+  if (summary.error > 0) {
+    console.log(
+      chalk.red(
+        '\n❌ Your environment has some issues, please fix them according to the suggestions above.'
+      )
+    );
+    process.exit(1);
+  } else if (summary.warning > 0) {
+    console.log(
+      chalk.yellow(
+        '\n⚠️  Your environment is basically ready, but it is recommended to fix warning items for a better development experience.'
+      )
+    );
+  } else {
+    console.log(chalk.green('\n✅ Congratulations! Your development environment is fully ready!'));
+  }
+
+  console.log(
+    chalk.gray(
+      '\n💡 Tip: For more help, visit https://docs.sui.io/ or https://github.com/0xobelisk/dubhe'
+    )
+  );
+}
+
+const commandModule: CommandModule = {
+  command: 'doctor',
+  describe: 'Check if local development environment is ready',
+  builder(yargs) {
+    return yargs.option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      description: 'Show verbose output',
+      default: false
+    });
+  },
+  async handler() {
+    try {
+      await runDoctorChecks();
+    } catch (error) {
+      console.error(chalk.red('Error occurred during check:'), error);
+      process.exit(1);
+    }
+  }
+};
+
+export default commandModule;

package/src/commands/index.ts

@@ -4,29 +4,29 @@ import localnode from './localnode';
 import faucet from './faucet';
 import schemagen from './schemagen';
 import publish from './publish';
-import upgrade from './upgrade';
 import test from './test';
 import build from './build';
 import hello from './hello';
 import generateKey from './generateKey';
 import checkBalance from './checkBalance';
 import configStore from './configStore';
-import query from './query';
-import call from './call';
 import watch from './watch';
 import wait from './wait';
 import switchEnv from './switchEnv';
 import info from './info';
+import loadMetadata from './loadMetadata';
+import doctor from './doctor';
+import convertJson from './convertJson';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
   localnode,
   publish,
-  call,
-  query,
+  // call,
+  // query,
   faucet,
   schemagen,
-  upgrade,
+  // upgrade,
   test,
   build,
   hello,
@@ -36,5 +36,8 @@ export const commands: CommandModule<any, any>[] = [
   watch,
   wait,
   switchEnv,
-  info
+  info,
+  loadMetadata,
+  doctor,
+  convertJson
 ];