genlayer 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 
 
+## 0.5.0 (2024-12-03)
+
+
+### Features
+
+* chack cli version ([#143](https://github.com/yeagerai/genlayer-cli/issues/143)) ([00ada3b](https://github.com/yeagerai/genlayer-cli/commit/00ada3b01ab8f727dbeadc2da0b810dc4211b6c9))
+
 ## 0.4.0 (2024-11-22)
 
 

package/dist/index.js

@@ -15689,6 +15689,944 @@ var require_semver2 = __commonJS({
   }
 });
 
+// node_modules/rc/node_modules/ini/ini.js
+var require_ini = __commonJS({
+  "node_modules/rc/node_modules/ini/ini.js"(exports2) {
+    "use strict";
+    exports2.parse = exports2.decode = decode;
+    exports2.stringify = exports2.encode = encode;
+    exports2.safe = safe;
+    exports2.unsafe = unsafe;
+    var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+    function encode(obj, opt) {
+      var children = [];
+      var out = "";
+      if (typeof opt === "string") {
+        opt = {
+          section: opt,
+          whitespace: false
+        };
+      } else {
+        opt = opt || {};
+        opt.whitespace = opt.whitespace === true;
+      }
+      var separator = opt.whitespace ? " = " : "=";
+      Object.keys(obj).forEach(function(k, _3, __) {
+        var val = obj[k];
+        if (val && Array.isArray(val)) {
+          val.forEach(function(item) {
+            out += safe(k + "[]") + separator + safe(item) + "\n";
+          });
+        } else if (val && typeof val === "object")
+          children.push(k);
+        else
+          out += safe(k) + separator + safe(val) + eol;
+      });
+      if (opt.section && out.length)
+        out = "[" + safe(opt.section) + "]" + eol + out;
+      children.forEach(function(k, _3, __) {
+        var nk = dotSplit(k).join("\\.");
+        var section = (opt.section ? opt.section + "." : "") + nk;
+        var child = encode(obj[k], {
+          section,
+          whitespace: opt.whitespace
+        });
+        if (out.length && child.length)
+          out += eol;
+        out += child;
+      });
+      return out;
+    }
+    function dotSplit(str) {
+      return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "
").split(/\./).map(function(part) {
+        return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "
");
+      });
+    }
+    function decode(str) {
+      var out = {};
+      var p = out;
+      var section = null;
+      var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+      var lines = str.split(/[\r\n]+/g);
+      lines.forEach(function(line, _3, __) {
+        if (!line || line.match(/^\s*[;#]/))
+          return;
+        var match = line.match(re);
+        if (!match)
+          return;
+        if (match[1] !== void 0) {
+          section = unsafe(match[1]);
+          if (section === "__proto__") {
+            p = {};
+            return;
+          }
+          p = out[section] = out[section] || {};
+          return;
+        }
+        var key = unsafe(match[2]);
+        if (key === "__proto__")
+          return;
+        var value = match[3] ? unsafe(match[4]) : true;
+        switch (value) {
+          case "true":
+          case "false":
+          case "null":
+            value = JSON.parse(value);
+        }
+        if (key.length > 2 && key.slice(-2) === "[]") {
+          key = key.substring(0, key.length - 2);
+          if (key === "__proto__")
+            return;
+          if (!p[key])
+            p[key] = [];
+          else if (!Array.isArray(p[key]))
+            p[key] = [p[key]];
+        }
+        if (Array.isArray(p[key]))
+          p[key].push(value);
+        else
+          p[key] = value;
+      });
+      Object.keys(out).filter(function(k, _3, __) {
+        if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k]))
+          return false;
+        var parts = dotSplit(k);
+        var p2 = out;
+        var l = parts.pop();
+        var nl = l.replace(/\\\./g, ".");
+        parts.forEach(function(part, _4, __2) {
+          if (part === "__proto__")
+            return;
+          if (!p2[part] || typeof p2[part] !== "object")
+            p2[part] = {};
+          p2 = p2[part];
+        });
+        if (p2 === out && nl === l)
+          return false;
+        p2[nl] = out[k];
+        return true;
+      }).forEach(function(del, _3, __) {
+        delete out[del];
+      });
+      return out;
+    }
+    function isQuoted(val) {
+      return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
+    }
+    function safe(val) {
+      return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
+    }
+    function unsafe(val, doUnesc) {
+      val = (val || "").trim();
+      if (isQuoted(val)) {
+        if (val.charAt(0) === "'")
+          val = val.substr(1, val.length - 2);
+        try {
+          val = JSON.parse(val);
+        } catch (_3) {
+        }
+      } else {
+        var esc = false;
+        var unesc = "";
+        for (var i = 0, l = val.length; i < l; i++) {
+          var c = val.charAt(i);
+          if (esc) {
+            if ("\\;#".indexOf(c) !== -1)
+              unesc += c;
+            else
+              unesc += "\\" + c;
+            esc = false;
+          } else if (";#".indexOf(c) !== -1)
+            break;
+          else if (c === "\\")
+            esc = true;
+          else
+            unesc += c;
+        }
+        if (esc)
+          unesc += "\\";
+        return unesc.trim();
+      }
+      return val;
+    }
+  }
+});
+
+// node_modules/rc/node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+  "node_modules/rc/node_modules/strip-json-comments/index.js"(exports2, module2) {
+    "use strict";
+    var singleComment = 1;
+    var multiComment = 2;
+    function stripWithoutWhitespace() {
+      return "";
+    }
+    function stripWithWhitespace(str, start, end) {
+      return str.slice(start, end).replace(/\S/g, " ");
+    }
+    module2.exports = function(str, opts) {
+      opts = opts || {};
+      var currentChar;
+      var nextChar;
+      var insideString = false;
+      var insideComment = false;
+      var offset = 0;
+      var ret = "";
+      var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      for (var i = 0; i < str.length; i++) {
+        currentChar = str[i];
+        nextChar = str[i + 1];
+        if (!insideComment && currentChar === '"') {
+          var escaped = str[i - 1] === "\\" && str[i - 2] !== "\\";
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentChar + nextChar === "//") {
+          ret += str.slice(offset, i);
+          offset = i;
+          insideComment = singleComment;
+          i++;
+        } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
+          i++;
+          insideComment = false;
+          ret += strip(str, offset, i);
+          offset = i;
+          continue;
+        } else if (insideComment === singleComment && currentChar === "\n") {
+          insideComment = false;
+          ret += strip(str, offset, i);
+          offset = i;
+        } else if (!insideComment && currentChar + nextChar === "/*") {
+          ret += str.slice(offset, i);
+          offset = i;
+          insideComment = multiComment;
+          i++;
+          continue;
+        } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
+          i++;
+          insideComment = false;
+          ret += strip(str, offset, i + 1);
+          offset = i + 1;
+          continue;
+        }
+      }
+      return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
+    };
+  }
+});
+
+// node_modules/rc/lib/utils.js
+var require_utils2 = __commonJS({
+  "node_modules/rc/lib/utils.js"(exports2) {
+    "use strict";
+    var fs6 = require("fs");
+    var ini = require_ini();
+    var path3 = require("path");
+    var stripJsonComments = require_strip_json_comments();
+    var parse2 = exports2.parse = function(content) {
+      if (/^\s*{/.test(content))
+        return JSON.parse(stripJsonComments(content));
+      return ini.parse(content);
+    };
+    var file = exports2.file = function() {
+      var args = [].slice.call(arguments).filter(function(arg) {
+        return arg != null;
+      });
+      for (var i in args)
+        if ("string" !== typeof args[i])
+          return;
+      var file2 = path3.join.apply(null, args);
+      var content;
+      try {
+        return fs6.readFileSync(file2, "utf-8");
+      } catch (err) {
+        return;
+      }
+    };
+    var json = exports2.json = function() {
+      var content = file.apply(null, arguments);
+      return content ? parse2(content) : null;
+    };
+    var env2 = exports2.env = function(prefix, env3) {
+      env3 = env3 || process.env;
+      var obj = {};
+      var l = prefix.length;
+      for (var k in env3) {
+        if (k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+          var keypath = k.substring(l).split("__");
+          var _emptyStringIndex;
+          while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
+            keypath.splice(_emptyStringIndex, 1);
+          }
+          var cursor = obj;
+          keypath.forEach(function _buildSubObj(_subkey, i) {
+            if (!_subkey || typeof cursor !== "object")
+              return;
+            if (i === keypath.length - 1)
+              cursor[_subkey] = env3[k];
+            if (cursor[_subkey] === void 0)
+              cursor[_subkey] = {};
+            cursor = cursor[_subkey];
+          });
+        }
+      }
+      return obj;
+    };
+    var find = exports2.find = function() {
+      var rel = path3.join.apply(null, [].slice.call(arguments));
+      function find2(start, rel2) {
+        var file2 = path3.join(start, rel2);
+        try {
+          fs6.statSync(file2);
+          return file2;
+        } catch (err) {
+          if (path3.dirname(start) !== start)
+            return find2(path3.dirname(start), rel2);
+        }
+      }
+      return find2(process.cwd(), rel);
+    };
+  }
+});
+
+// node_modules/deep-extend/lib/deep-extend.js
+var require_deep_extend = __commonJS({
+  "node_modules/deep-extend/lib/deep-extend.js"(exports2, module2) {
+    "use strict";
+    function isSpecificValue(val) {
+      return val instanceof Buffer || val instanceof Date || val instanceof RegExp ? true : false;
+    }
+    function cloneSpecificValue(val) {
+      if (val instanceof Buffer) {
+        var x = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length);
+        val.copy(x);
+        return x;
+      } else if (val instanceof Date) {
+        return new Date(val.getTime());
+      } else if (val instanceof RegExp) {
+        return new RegExp(val);
+      } else {
+        throw new Error("Unexpected situation");
+      }
+    }
+    function deepCloneArray(arr) {
+      var clone2 = [];
+      arr.forEach(function(item, index) {
+        if (typeof item === "object" && item !== null) {
+          if (Array.isArray(item)) {
+            clone2[index] = deepCloneArray(item);
+          } else if (isSpecificValue(item)) {
+            clone2[index] = cloneSpecificValue(item);
+          } else {
+            clone2[index] = deepExtend({}, item);
+          }
+        } else {
+          clone2[index] = item;
+        }
+      });
+      return clone2;
+    }
+    function safeGetProperty(object, property) {
+      return property === "__proto__" ? void 0 : object[property];
+    }
+    var deepExtend = module2.exports = function() {
+      if (arguments.length < 1 || typeof arguments[0] !== "object") {
+        return false;
+      }
+      if (arguments.length < 2) {
+        return arguments[0];
+      }
+      var target = arguments[0];
+      var args = Array.prototype.slice.call(arguments, 1);
+      var val, src, clone2;
+      args.forEach(function(obj) {
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+          return;
+        }
+        Object.keys(obj).forEach(function(key) {
+          src = safeGetProperty(target, key);
+          val = safeGetProperty(obj, key);
+          if (val === target) {
+            return;
+          } else if (typeof val !== "object" || val === null) {
+            target[key] = val;
+            return;
+          } else if (Array.isArray(val)) {
+            target[key] = deepCloneArray(val);
+            return;
+          } else if (isSpecificValue(val)) {
+            target[key] = cloneSpecificValue(val);
+            return;
+          } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
+            target[key] = deepExtend({}, val);
+            return;
+          } else {
+            target[key] = deepExtend(src, val);
+            return;
+          }
+        });
+      });
+      return target;
+    };
+  }
+});
+
+// node_modules/minimist/index.js
+var require_minimist = __commonJS({
+  "node_modules/minimist/index.js"(exports2, module2) {
+    "use strict";
+    function hasKey(obj, keys) {
+      var o = obj;
+      keys.slice(0, -1).forEach(function(key2) {
+        o = o[key2] || {};
+      });
+      var key = keys[keys.length - 1];
+      return key in o;
+    }
+    function isNumber(x) {
+      if (typeof x === "number") {
+        return true;
+      }
+      if (/^0x[0-9a-f]+$/i.test(x)) {
+        return true;
+      }
+      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+    }
+    function isConstructorOrProto(obj, key) {
+      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    }
+    module2.exports = function(args, opts) {
+      if (!opts) {
+        opts = {};
+      }
+      var flags = {
+        bools: {},
+        strings: {},
+        unknownFn: null
+      };
+      if (typeof opts.unknown === "function") {
+        flags.unknownFn = opts.unknown;
+      }
+      if (typeof opts.boolean === "boolean" && opts.boolean) {
+        flags.allBools = true;
+      } else {
+        [].concat(opts.boolean).filter(Boolean).forEach(function(key2) {
+          flags.bools[key2] = true;
+        });
+      }
+      var aliases = {};
+      function aliasIsBoolean(key2) {
+        return aliases[key2].some(function(x) {
+          return flags.bools[x];
+        });
+      }
+      Object.keys(opts.alias || {}).forEach(function(key2) {
+        aliases[key2] = [].concat(opts.alias[key2]);
+        aliases[key2].forEach(function(x) {
+          aliases[x] = [key2].concat(aliases[key2].filter(function(y) {
+            return x !== y;
+          }));
+        });
+      });
+      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+        flags.strings[key2] = true;
+        if (aliases[key2]) {
+          [].concat(aliases[key2]).forEach(function(k) {
+            flags.strings[k] = true;
+          });
+        }
+      });
+      var defaults2 = opts.default || {};
+      var argv = { _: [] };
+      function argDefined(key2, arg2) {
+        return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
+      }
+      function setKey(obj, keys, value2) {
+        var o = obj;
+        for (var i2 = 0; i2 < keys.length - 1; i2++) {
+          var key2 = keys[i2];
+          if (isConstructorOrProto(o, key2)) {
+            return;
+          }
+          if (o[key2] === void 0) {
+            o[key2] = {};
+          }
+          if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype) {
+            o[key2] = {};
+          }
+          if (o[key2] === Array.prototype) {
+            o[key2] = [];
+          }
+          o = o[key2];
+        }
+        var lastKey = keys[keys.length - 1];
+        if (isConstructorOrProto(o, lastKey)) {
+          return;
+        }
+        if (o === Object.prototype || o === Number.prototype || o === String.prototype) {
+          o = {};
+        }
+        if (o === Array.prototype) {
+          o = [];
+        }
+        if (o[lastKey] === void 0 || flags.bools[lastKey] || typeof o[lastKey] === "boolean") {
+          o[lastKey] = value2;
+        } else if (Array.isArray(o[lastKey])) {
+          o[lastKey].push(value2);
+        } else {
+          o[lastKey] = [o[lastKey], value2];
+        }
+      }
+      function setArg(key2, val, arg2) {
+        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+          if (flags.unknownFn(arg2) === false) {
+            return;
+          }
+        }
+        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+        setKey(argv, key2.split("."), value2);
+        (aliases[key2] || []).forEach(function(x) {
+          setKey(argv, x.split("."), value2);
+        });
+      }
+      Object.keys(flags.bools).forEach(function(key2) {
+        setArg(key2, defaults2[key2] === void 0 ? false : defaults2[key2]);
+      });
+      var notFlags = [];
+      if (args.indexOf("--") !== -1) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+      }
+      for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        var key;
+        var next;
+        if (/^--.+=/.test(arg)) {
+          var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+          key = m[1];
+          var value = m[2];
+          if (flags.bools[key]) {
+            value = value !== "false";
+          }
+          setArg(key, value, arg);
+        } else if (/^--no-.+/.test(arg)) {
+          key = arg.match(/^--no-(.+)/)[1];
+          setArg(key, false, arg);
+        } else if (/^--.+/.test(arg)) {
+          key = arg.match(/^--(.+)/)[1];
+          next = args[i + 1];
+          if (next !== void 0 && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+            setArg(key, next, arg);
+            i += 1;
+          } else if (/^(true|false)$/.test(next)) {
+            setArg(key, next === "true", arg);
+            i += 1;
+          } else {
+            setArg(key, flags.strings[key] ? "" : true, arg);
+          }
+        } else if (/^-[^-]+/.test(arg)) {
+          var letters = arg.slice(1, -1).split("");
+          var broken = false;
+          for (var j = 0; j < letters.length; j++) {
+            next = arg.slice(j + 2);
+            if (next === "-") {
+              setArg(letters[j], next, arg);
+              continue;
+            }
+            if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") {
+              setArg(letters[j], next.slice(1), arg);
+              broken = true;
+              break;
+            }
+            if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+              setArg(letters[j], next, arg);
+              broken = true;
+              break;
+            }
+            if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+              setArg(letters[j], arg.slice(j + 2), arg);
+              broken = true;
+              break;
+            } else {
+              setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
+            }
+          }
+          key = arg.slice(-1)[0];
+          if (!broken && key !== "-") {
+            if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+              setArg(key, args[i + 1], arg);
+              i += 1;
+            } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+              setArg(key, args[i + 1] === "true", arg);
+              i += 1;
+            } else {
+              setArg(key, flags.strings[key] ? "" : true, arg);
+            }
+          }
+        } else {
+          if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+            argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+          }
+          if (opts.stopEarly) {
+            argv._.push.apply(argv._, args.slice(i + 1));
+            break;
+          }
+        }
+      }
+      Object.keys(defaults2).forEach(function(k) {
+        if (!hasKey(argv, k.split("."))) {
+          setKey(argv, k.split("."), defaults2[k]);
+          (aliases[k] || []).forEach(function(x) {
+            setKey(argv, x.split("."), defaults2[k]);
+          });
+        }
+      });
+      if (opts["--"]) {
+        argv["--"] = notFlags.slice();
+      } else {
+        notFlags.forEach(function(k) {
+          argv._.push(k);
+        });
+      }
+      return argv;
+    };
+  }
+});
+
+// node_modules/rc/index.js
+var require_rc = __commonJS({
+  "node_modules/rc/index.js"(exports2, module2) {
+    "use strict";
+    var cc = require_utils2();
+    var join2 = require("path").join;
+    var deepExtend = require_deep_extend();
+    var etc = "/etc";
+    var win = process.platform === "win32";
+    var home = win ? process.env.USERPROFILE : process.env.HOME;
+    module2.exports = function(name, defaults2, argv, parse2) {
+      if ("string" !== typeof name)
+        throw new Error("rc(name): name *must* be string");
+      if (!argv)
+        argv = require_minimist()(process.argv.slice(2));
+      defaults2 = ("string" === typeof defaults2 ? cc.json(defaults2) : defaults2) || {};
+      parse2 = parse2 || cc.parse;
+      var env2 = cc.env(name + "_");
+      var configs = [defaults2];
+      var configFiles = [];
+      function addConfigFile(file) {
+        if (configFiles.indexOf(file) >= 0) return;
+        var fileConfig = cc.file(file);
+        if (fileConfig) {
+          configs.push(parse2(fileConfig));
+          configFiles.push(file);
+        }
+      }
+      if (!win)
+        [
+          join2(etc, name, "config"),
+          join2(etc, name + "rc")
+        ].forEach(addConfigFile);
+      if (home)
+        [
+          join2(home, ".config", name, "config"),
+          join2(home, ".config", name),
+          join2(home, "." + name, "config"),
+          join2(home, "." + name + "rc")
+        ].forEach(addConfigFile);
+      addConfigFile(cc.find("." + name + "rc"));
+      if (env2.config) addConfigFile(env2.config);
+      if (argv.config) addConfigFile(argv.config);
+      return deepExtend.apply(null, configs.concat([
+        env2,
+        argv,
+        configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
+      ]));
+    };
+  }
+});
+
+// node_modules/update-check/node_modules/registry-url/index.js
+var require_registry_url = __commonJS({
+  "node_modules/update-check/node_modules/registry-url/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(scope) {
+      var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      var url = rc[scope + ":registry"] || rc.registry;
+      return url.slice(-1) === "/" ? url : url + "/";
+    };
+  }
+});
+
+// node_modules/update-check/node_modules/registry-auth-token/base64.js
+var require_base64 = __commonJS({
+  "node_modules/update-check/node_modules/registry-auth-token/base64.js"(exports2, module2) {
+    "use strict";
+    var safeBuffer = require_safe_buffer().Buffer;
+    function decodeBase64(base64) {
+      return safeBuffer.from(base64, "base64").toString("utf8");
+    }
+    function encodeBase64(string) {
+      return safeBuffer.from(string, "utf8").toString("base64");
+    }
+    module2.exports = {
+      decodeBase64,
+      encodeBase64
+    };
+  }
+});
+
+// node_modules/update-check/node_modules/registry-auth-token/index.js
+var require_registry_auth_token = __commonJS({
+  "node_modules/update-check/node_modules/registry-auth-token/index.js"(exports2, module2) {
+    "use strict";
+    var url = require("url");
+    var base64 = require_base64();
+    var decodeBase64 = base64.decodeBase64;
+    var encodeBase64 = base64.encodeBase64;
+    var tokenKey = ":_authToken";
+    var userKey = ":username";
+    var passwordKey = ":_password";
+    module2.exports = function() {
+      var checkUrl;
+      var options;
+      if (arguments.length >= 2) {
+        checkUrl = arguments[0];
+        options = arguments[1];
+      } else if (typeof arguments[0] === "string") {
+        checkUrl = arguments[0];
+      } else {
+        options = arguments[0];
+      }
+      options = options || {};
+      options.npmrc = options.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      checkUrl = checkUrl || options.npmrc.registry;
+      return getRegistryAuthInfo(checkUrl, options) || getLegacyAuthInfo(options.npmrc);
+    };
+    function getRegistryAuthInfo(checkUrl, options) {
+      var parsed = url.parse(checkUrl, false, true);
+      var pathname;
+      while (pathname !== "/" && parsed.pathname !== pathname) {
+        pathname = parsed.pathname || "/";
+        var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
+        var authInfo = getAuthInfoForUrl(regUrl, options.npmrc);
+        if (authInfo) {
+          return authInfo;
+        }
+        if (!options.recursive) {
+          return /\/$/.test(checkUrl) ? void 0 : getRegistryAuthInfo(url.resolve(checkUrl, "."), options);
+        }
+        parsed.pathname = url.resolve(normalizePath(pathname), "..") || "/";
+      }
+      return void 0;
+    }
+    function getLegacyAuthInfo(npmrc) {
+      if (npmrc._auth) {
+        return { token: npmrc._auth, type: "Basic" };
+      }
+      return void 0;
+    }
+    function normalizePath(path3) {
+      return path3[path3.length - 1] === "/" ? path3 : path3 + "/";
+    }
+    function getAuthInfoForUrl(regUrl, npmrc) {
+      var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
+      if (bearerAuth) {
+        return bearerAuth;
+      }
+      var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
+      var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
+      var basicAuth = getTokenForUsernameAndPassword(username, password);
+      if (basicAuth) {
+        return basicAuth;
+      }
+      return void 0;
+    }
+    function getBearerToken(tok) {
+      if (!tok) {
+        return void 0;
+      }
+      var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      });
+      return { token, type: "Bearer" };
+    }
+    function getTokenForUsernameAndPassword(username, password) {
+      if (!username || !password) {
+        return void 0;
+      }
+      var pass = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      }));
+      var token = encodeBase64(username + ":" + pass);
+      return {
+        token,
+        type: "Basic",
+        password: pass,
+        username
+      };
+    }
+  }
+});
+
+// node_modules/update-check/index.js
+var require_update_check = __commonJS({
+  "node_modules/update-check/index.js"(exports2, module2) {
+    "use strict";
+    var { URL: URL2 } = require("url");
+    var { join: join2 } = require("path");
+    var fs6 = require("fs");
+    var { promisify: promisify5 } = require("util");
+    var { tmpdir } = require("os");
+    var registryUrl = require_registry_url();
+    var writeFile = promisify5(fs6.writeFile);
+    var mkdir = promisify5(fs6.mkdir);
+    var readFile = promisify5(fs6.readFile);
+    var compareVersions = (a, b) => a.localeCompare(b, "en-US", { numeric: true });
+    var encode = (value) => encodeURIComponent(value).replace(/^%40/, "@");
+    var getFile = (details, distTag) => __async(exports2, null, function* () {
+      const rootDir = tmpdir();
+      const subDir = join2(rootDir, "update-check");
+      if (!fs6.existsSync(subDir)) {
+        yield mkdir(subDir);
+      }
+      let name = `${details.name}-${distTag}.json`;
+      if (details.scope) {
+        name = `${details.scope}-${name}`;
+      }
+      return join2(subDir, name);
+    });
+    var evaluateCache = (file, time, interval) => __async(exports2, null, function* () {
+      if (fs6.existsSync(file)) {
+        const content = yield readFile(file, "utf8");
+        const { lastUpdate, latest } = JSON.parse(content);
+        const nextCheck = lastUpdate + interval;
+        if (nextCheck > time) {
+          return {
+            shouldCheck: false,
+            latest
+          };
+        }
+      }
+      return {
+        shouldCheck: true,
+        latest: null
+      };
+    });
+    var updateCache = (file, latest, lastUpdate) => __async(exports2, null, function* () {
+      const content = JSON.stringify({
+        latest,
+        lastUpdate
+      });
+      yield writeFile(file, content, "utf8");
+    });
+    var loadPackage = (url, authInfo) => new Promise((resolve, reject) => {
+      const options = {
+        host: url.hostname,
+        path: url.pathname,
+        port: url.port,
+        headers: {
+          accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+        },
+        timeout: 2e3
+      };
+      if (authInfo) {
+        options.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+      }
+      const { get: get2 } = url.protocol === "https:" ? require("https") : require("http");
+      get2(options, (response) => {
+        const { statusCode } = response;
+        if (statusCode !== 200) {
+          const error = new Error(`Request failed with code ${statusCode}`);
+          error.code = statusCode;
+          reject(error);
+          response.resume();
+          return;
+        }
+        let rawData = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          rawData += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsedData = JSON.parse(rawData);
+            resolve(parsedData);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }).on("error", reject).on("timeout", reject);
+    });
+    var getMostRecent = (_0, _1) => __async(exports2, [_0, _1], function* ({ full, scope }, distTag) {
+      const regURL = registryUrl(scope);
+      const url = new URL2(full, regURL);
+      let spec = null;
+      try {
+        spec = yield loadPackage(url);
+      } catch (err) {
+        if (err.code && String(err.code).startsWith(4)) {
+          const registryAuthToken = require_registry_auth_token();
+          const authInfo = registryAuthToken(regURL, { recursive: true });
+          spec = yield loadPackage(url, authInfo);
+        } else {
+          throw err;
+        }
+      }
+      const version2 = spec["dist-tags"][distTag];
+      if (!version2) {
+        throw new Error(`Distribution tag ${distTag} is not available`);
+      }
+      return version2;
+    });
+    var defaultConfig = {
+      interval: 36e5,
+      distTag: "latest"
+    };
+    var getDetails = (name) => {
+      const spec = {
+        full: encode(name)
+      };
+      if (name.includes("/")) {
+        const parts = name.split("/");
+        spec.scope = parts[0];
+        spec.name = parts[1];
+      } else {
+        spec.scope = null;
+        spec.name = name;
+      }
+      return spec;
+    };
+    module2.exports = (pkg, config) => __async(exports2, null, function* () {
+      if (typeof pkg !== "object") {
+        throw new Error("The first parameter should be your package.json file content");
+      }
+      const details = getDetails(pkg.name);
+      const time = Date.now();
+      const { distTag, interval } = Object.assign({}, defaultConfig, config);
+      const file = yield getFile(details, distTag);
+      let latest = null;
+      let shouldCheck = true;
+      ({ shouldCheck, latest } = yield evaluateCache(file, time, interval));
+      if (shouldCheck) {
+        latest = yield getMostRecent(details, distTag);
+        yield updateCache(file, latest, time);
+      }
+      const comparision = compareVersions(pkg.version, latest);
+      if (comparision === -1) {
+        return {
+          latest,
+          fromCache: !shouldCheck
+        };
+      }
+      return null;
+    });
+  }
+});
+
 // node_modules/webidl-conversions/lib/index.js
 var require_lib = __commonJS({
   "node_modules/webidl-conversions/lib/index.js"(exports2, module2) {
@@ -15843,7 +16781,7 @@ var require_lib = __commonJS({
 });
 
 // node_modules/whatwg-url/lib/utils.js
-var require_utils2 = __commonJS({
+var require_utils3 = __commonJS({
   "node_modules/whatwg-url/lib/utils.js"(exports2, module2) {
     "use strict";
     module2.exports.mixin = function mixin(target, source) {
@@ -17265,7 +18203,7 @@ var require_URL = __commonJS({
   "node_modules/whatwg-url/lib/URL.js"(exports2, module2) {
     "use strict";
     var conversions = require_lib();
-    var utils = require_utils2();
+    var utils = require_utils3();
     var Impl = require_URL_impl();
     var impl = utils.implSymbol;
     function URL2(url) {
@@ -46421,7 +47359,75 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.4.0";
+var version = "0.5.0";
+var package_default = {
+  name: "genlayer",
+  version,
+  description: "GenLayer Command Line Tool",
+  main: "src/index.ts",
+  bin: {
+    genlayer: "./dist/index.js"
+  },
+  scripts: {
+    test: "vitest",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest run --coverage",
+    dev: "cross-env NODE_ENV=development node esbuild.config.js",
+    build: "cross-env NODE_ENV=production node esbuild.config.js",
+    release: "release-it --ci",
+    "release-beta": "release-it --ci --preRelease=beta"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/yeagerai/genlayer-cli.git"
+  },
+  keywords: [
+    "genlayer",
+    "intelligent",
+    "contract",
+    "simulator",
+    "cli"
+  ],
+  author: "GenLayer",
+  license: "MIT",
+  bugs: {
+    url: "https://github.com/yeagerai/genlayer-cli/issues"
+  },
+  homepage: "https://github.com/yeagerai/genlayer-cli#readme",
+  devDependencies: {
+    "@release-it/conventional-changelog": "^8.0.1",
+    "@types/dockerode": "^3.3.31",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.12.7",
+    "@types/sinon": "^17.0.3",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^7.7.0",
+    "@typescript-eslint/parser": "^7.7.0",
+    "@vitest/coverage-v8": "^2.1.4",
+    "cross-env": "^7.0.3",
+    esbuild: "^0.24.0",
+    eslint: "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    jsdom: "^25.0.1",
+    prettier: "^3.2.5",
+    "release-it": "^17.2.0",
+    "ts-node": "^10.9.2",
+    typescript: "^5.4.5"
+  },
+  dependencies: {
+    commander: "^12.0.0",
+    dockerode: "^4.0.2",
+    dotenv: "^16.4.5",
+    inquirer: "^9.2.19",
+    "node-fetch": "^2.7.0",
+    open: "^10.1.0",
+    "update-check": "^1.5.4",
+    uuid: "^9.0.1",
+    vitest: "^2.1.4"
+  }
+};
 
 // src/lib/config/text.ts
 var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";
@@ -46432,6 +47438,7 @@ var fs5 = __toESM(require("fs"));
 var dotenv = __toESM(require_main());
 var path2 = __toESM(require("path"));
 var semver = __toESM(require_semver2());
+var import_update_check = __toESM(require_update_check());
 
 // src/lib/clients/jsonRpcClient.ts
 var import_node_fetch = __toESM(require_lib2());
@@ -47126,6 +48133,17 @@ var SimulatorService = class {
     }).join("\n");
     fs5.writeFileSync(envFilePath, updatedConfig);
   }
+  checkCliVersion() {
+    return __async(this, null, function* () {
+      const update = yield (0, import_update_check.default)(package_default);
+      if (update && update.latest !== package_default.version) {
+        console.warn(`
+A new version (${update.latest}) is available! You're using version ${package_default.version}.
+Run npm install -g genlayer to update
+`);
+      }
+    });
+  }
   checkInstallRequirements() {
     return __async(this, null, function* () {
       const requirementsInstalled = {
@@ -49961,6 +50979,7 @@ function initAction(options, simulatorService) {
   return __async(this, null, function* () {
     simulatorService.setSimulatorLocation(options.location);
     simulatorService.setComposeOptions(options.headless);
+    yield simulatorService.checkCliVersion();
     try {
       const requirementsInstalled = yield simulatorService.checkInstallRequirements();
       const requirementErrorMessage = getRequirementsErrorMessage(requirementsInstalled);
@@ -50132,6 +51151,7 @@ function startAction(options, simulatorService) {
     const { resetValidators, numValidators, branch, location, headless, resetDb } = options;
     simulatorService.setComposeOptions(headless);
     simulatorService.setSimulatorLocation(location);
+    yield simulatorService.checkCliVersion();
     const restartValidatorsHintText = resetValidators ? `creating new ${numValidators} random validators` : "keeping the existing validators";
     console.log(`Starting GenLayer simulator ${restartValidatorsHintText}`);
     console.log(`Updating GenLayer Simulator...`);
@@ -50260,6 +51280,34 @@ safe-buffer/index.js:
    * ------------------------------------------------------------------------
    *)
 
+deep-extend/lib/deep-extend.js:
+  (*!
+   * @description Recursive object extending
+   * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+   * @license MIT
+   *
+   * The MIT License (MIT)
+   *
+   * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+   *
+   * Permission is hereby granted, free of charge, to any person obtaining a copy of
+   * this software and associated documentation files (the "Software"), to deal in
+   * the Software without restriction, including without limitation the rights to
+   * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+   * the Software, and to permit persons to whom the Software is furnished to do so,
+   * subject to the following conditions:
+   *
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+   * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+   * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+   * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   *)
+
 tmp/lib/tmp.js:
   (*!
    * Tmp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {
@@ -61,6 +61,7 @@
     "inquirer": "^9.2.19",
     "node-fetch": "^2.7.0",
     "open": "^10.1.0",
+    "update-check": "^1.5.4",
     "uuid": "^9.0.1",
     "vitest": "^2.1.4"
   }

package/src/commands/general/init.ts

@@ -42,6 +42,8 @@ export async function initAction(options: InitActionOptions, simulatorService: I
   simulatorService.setSimulatorLocation(options.location);
   simulatorService.setComposeOptions(options.headless);
 
+  await simulatorService.checkCliVersion();
+
   // Check if requirements are installed
   try {
     const requirementsInstalled = await simulatorService.checkInstallRequirements();

package/src/commands/general/start.ts

@@ -17,6 +17,7 @@ export async function startAction(options: StartActionOptions, simulatorService:
   simulatorService.setComposeOptions(headless);
   simulatorService.setSimulatorLocation(location);
 
+  await simulatorService.checkCliVersion();
 
   const restartValidatorsHintText = resetValidators
     ? `creating new ${numValidators} random validators`

package/src/lib/interfaces/ISimulatorService.ts

@@ -20,6 +20,7 @@ export interface ISimulatorService {
   openFrontend(): Promise<boolean>;
   resetDockerContainers(): Promise<boolean>;
   resetDockerImages(): Promise<boolean>;
+  checkCliVersion(): Promise<void>;
   cleanDatabase(): Promise<boolean>;
 }
 

package/src/lib/services/simulator.ts

@@ -3,6 +3,8 @@ import * as fs from "fs";
 import * as dotenv from "dotenv";
 import * as path from "path";
 import * as semver from "semver";
+import updateCheck from "update-check";
+import pkg from '../../../package.json'
 
 import {rpcClient} from "../clients/jsonRpcClient";
 import {
@@ -93,6 +95,13 @@ export class SimulatorService implements ISimulatorService {
     fs.writeFileSync(envFilePath, updatedConfig);
   }
 
+  public async checkCliVersion(): Promise<void> {
+    const update = await updateCheck(pkg);
+    if (update && update.latest !== pkg.version) {
+      console.warn(`\nA new version (${update.latest}) is available! You're using version ${pkg.version}.\nRun npm install -g genlayer to update\n`);
+    }
+  }
+
   public async checkInstallRequirements(): Promise<Record<string, boolean>> {
     const requirementsInstalled = {
       git: false,

package/tests/actions/start.test.ts

@@ -32,6 +32,7 @@ describe("startAction - Additional Tests", () => {
       openFrontend: vi.fn().mockResolvedValue(undefined),
       setSimulatorLocation: vi.fn().mockResolvedValue(undefined),
       setComposeOptions: vi.fn(),
+      checkCliVersion: vi.fn(),
       getAiProvidersOptions: vi.fn(() => [
         { name: "Provider A", value: "providerA" },
         { name: "Provider B", value: "providerB" },

package/tests/services/simulator.test.ts

@@ -21,7 +21,15 @@ import { rpcClient } from "../../src/lib/clients/jsonRpcClient";
 import * as semver from "semver";
 import Docker from "dockerode";
 import {VersionRequiredError} from "../../src/lib/errors/versionRequired";
+import updateCheck from "update-check";
 
+vi.mock("../../package.json", () => ({
+  default: { version: "1.0.0", name: "genlayer" },
+}));
+
+vi.mock("update-check", () => ({
+  default: vi.fn(),
+}));
 vi.mock("dockerode");
 vi.mock("fs");
 vi.mock("path");
@@ -410,4 +418,44 @@ describe("SimulatorService - Docker Tests", () => {
     mockPing.mockRejectedValueOnce("Unexpected docker error");
     await expect(simulatorService.checkInstallRequirements()).rejects.toThrow("Unexpected docker error");
   });
+
+  test("should warn the user when an update is available", async () => {
+    const update = { latest: "1.1.0" };
+    (updateCheck as any).mockResolvedValue(update);
+
+    const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await simulatorService.checkCliVersion();
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      `\nA new version (${update.latest}) is available! You're using version 1.0.0.\nRun npm install -g genlayer to update\n`
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+
+  test("should not warn the user when the CLI is up-to-date", async () => {
+    const update = { latest: "1.0.0" };
+    (updateCheck as any).mockResolvedValue(update);
+
+    const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await simulatorService.checkCliVersion();
+
+    expect(consoleWarnSpy).not.toHaveBeenCalled();
+
+    consoleWarnSpy.mockRestore();
+  });
+
+  test("should handle update-check returning undefined", async () => {
+    (updateCheck as any).mockResolvedValue(undefined);
+
+    const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await simulatorService.checkCliVersion();
+
+    expect(consoleWarnSpy).not.toHaveBeenCalled();
+
+    consoleWarnSpy.mockRestore();
+  });
 });