@0xobelisk/sui-cli 1.2.0-pre.15 → 1.2.0-pre.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.2.0-pre.15",
+  "version": "1.2.0-pre.16",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -50,8 +50,8 @@
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-client": "1.2.0-pre.15",
-    "@0xobelisk/sui-common": "1.2.0-pre.15"
+    "@0xobelisk/sui-client": "1.2.0-pre.16",
+    "@0xobelisk/sui-common": "1.2.0-pre.16"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.1",

package/src/commands/index.ts

@@ -15,6 +15,7 @@ import query from './query';
 import call from './call';
 import watch from './watch';
 import wait from './wait';
+import switchEnv from './switchEnv';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -32,5 +33,6 @@ export const commands: CommandModule<any, any>[] = [
   checkBalance,
   configStore,
   watch,
-  wait
+  wait,
+  switchEnv
 ];

package/src/commands/switchEnv.ts

@@ -0,0 +1,24 @@
+import type { CommandModule, ArgumentsCamelCase } from 'yargs';
+import { switchEnv } from '../utils';
+
+type Options = {
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+};
+
+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');
+  }
+};
+
+export default commandModule;

package/src/utils/utils.ts

@@ -207,32 +207,147 @@ export async function updateDubheDependency(
   fs.writeFileSync(filePath, updatedContent, 'utf-8');
   console.log(`Updated Dubhe dependency in ${filePath} for ${network}.`);
 }
+
+async function checkRpcAvailability(rpcUrl: string): Promise<boolean> {
+  try {
+    const response = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'sui_getLatestCheckpointSequenceNumber',
+        params: []
+      })
+    });
+
+    if (!response.ok) {
+      return false;
+    }
+
+    const data = await response.json();
+    return !data.error;
+  } catch (error) {
+    return false;
+  }
+}
+
+export async function addEnv(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+): Promise<void> {
+  const rpcMap = {
+    localnet: 'http://127.0.0.1:9000',
+    devnet: 'https://fullnode.devnet.sui.io:443/',
+    testnet: 'https://fullnode.testnet.sui.io:443/',
+    mainnet: 'https://fullnode.mainnet.sui.io:443/'
+  };
+
+  const rpcUrl = rpcMap[network];
+
+  // Check RPC availability first
+  const isRpcAvailable = await checkRpcAvailability(rpcUrl);
+  if (!isRpcAvailable) {
+    throw new Error(
+      `RPC endpoint ${rpcUrl} is not available. Please check your network connection or try again later.`
+    );
+  }
+
+  return new Promise<void>((resolve, reject) => {
+    let errorOutput = '';
+    let stdoutOutput = '';
+
+    const suiProcess = spawn(
+      'sui',
+      ['client', 'new-env', '--alias', network, '--rpc', rpcMap[network]],
+      {
+        env: { ...process.env },
+        stdio: 'pipe'
+      }
+    );
+
+    // Capture standard output
+    suiProcess.stdout.on('data', (data) => {
+      stdoutOutput += data.toString();
+    });
+
+    // Capture error output
+    suiProcess.stderr.on('data', (data) => {
+      errorOutput += data.toString();
+    });
+
+    // Handle process errors (e.g., command not found)
+    suiProcess.on('error', (error) => {
+      console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+      reject(new Error(`Failed to execute sui command: ${error.message}`));
+    });
+
+    // Handle process exit
+    suiProcess.on('exit', (code) => {
+      // Check if "already exists" message is present
+      if (errorOutput.includes('already exists') || stdoutOutput.includes('already exists')) {
+        console.log(chalk.yellow(`Environment ${network} already exists, proceeding...`));
+        resolve();
+        return;
+      }
+
+      if (code === 0) {
+        console.log(chalk.green(`Successfully added environment ${network}`));
+        resolve();
+      } else {
+        const finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+        console.error(chalk.red(`\n❌ Failed to add environment ${network}`));
+        console.error(chalk.red(`  └─ ${finalError.trim()}`));
+        reject(new Error(finalError));
+      }
+    });
+  });
+}
+
 export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
   try {
+    // First, try to add the environment
+    await addEnv(network);
+
+    // Then switch to the specified environment
     return new Promise<void>((resolve, reject) => {
+      let errorOutput = '';
+      let stdoutOutput = '';
+
       const suiProcess = spawn('sui', ['client', 'switch', '--env', network], {
         env: { ...process.env },
         stdio: 'pipe'
       });
 
+      suiProcess.stdout.on('data', (data) => {
+        stdoutOutput += data.toString();
+      });
+
+      suiProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
       suiProcess.on('error', (error) => {
-        console.error(chalk.red('\n❌ Failed to Switch Env'));
-        console.error(chalk.red(`  Error: ${error.message}`));
-        reject(error); // Reject promise on error
+        console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+        reject(new Error(`Failed to execute sui command: ${error.message}`));
       });
 
       suiProcess.on('exit', (code) => {
-        if (code !== 0) {
-          console.error(chalk.red(`\n❌ Process exited with code: ${code}`));
-          reject(new Error(`Process exited with code: ${code}`));
+        if (code === 0) {
+          console.log(chalk.green(`Successfully switched to environment ${network}`));
+          resolve();
         } else {
-          resolve(); // Resolve promise on successful exit
+          const finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+          console.error(chalk.red(`\n❌ Failed to switch to environment ${network}`));
+          console.error(chalk.red(`  └─ ${finalError.trim()}`));
+          reject(new Error(finalError));
         }
       });
     });
   } catch (error) {
-    console.error(chalk.red('\n❌ Failed to Switch Env'));
-    console.error(chalk.red(`  └─ Error: ${error}`));
+    // Re-throw the error for the caller to handle
+    throw error;
   }
 }