diff --git a/cfg_checker/common/settings.py b/cfg_checker/common/settings.py
index c654970..dac917e 100644
--- a/cfg_checker/common/settings.py
+++ b/cfg_checker/common/settings.py
@@ -2,6 +2,7 @@
 import json
 import pwd
 import sys
+import yaml
 
 from cfg_checker.common.const import ENV_TYPE_GLOB, ENV_TYPE_SALT
 from cfg_checker.common.const import ENV_TYPE_KUBE, ENV_TYPE_LINUX, ENV_LOCAL
@@ -26,14 +27,14 @@
 def _extract_salt_return(_raw):
     if not isinstance(_raw, str):
         _json = _raw
-        logger_cli.debug("...ambigious return detected")
+        logger_cli.debug("... ambigious return detected")
     else:
         try:
             _json = json.loads(_raw)
         except ValueError:
             _json = _raw
             logger_cli.debug(
-                "...return value is not a json: '{}'".format(_raw)
+                "... return value is not a json: '{}'".format(_raw)
             )
 
     return _json
@@ -53,7 +54,7 @@
             return None
 
     def _detect(self, _type):
-        logger_cli.debug("...detecting '{}'".format(_type))
+        logger_cli.debug("... detecting '{}'".format(_type))
         if _type is None:
             raise ConfigException("# Unexpected supported env type")
         elif _type == ENV_TYPE_SALT:
@@ -64,7 +65,7 @@
             )
             # Try to call salt API on target host
             _r = None
-            logger_cli.debug("...trying to detect env type '{}'".format(_type))
+            logger_cli.debug("... detecting env type '{}'".format(_type))
             if self.env_name == ENV_LOCAL:
                 _r = shell(" ".join(_detect_cmd))
             else:
@@ -90,7 +91,7 @@
             _kube = get_kube_remote(self)
             if not _kube.initialized:
                 logger_cli.debug(
-                    "... failed to load config from '{}'".format(
+                    "... failed to init kube using '{}'".format(
                         _kube.kConfigPath
                     )
                 )
@@ -107,12 +108,11 @@
                 if hasattr(_v, "platform") and \
                         hasattr(_v, "major") and \
                         hasattr(_v, "minor"):
-                    _host = "localhost" if _kube.is_local else _kube.kConf.host
                     logger_cli.info(
                         "# Kube server found: {}:{} on '{}'".format(
                             _v.major,
                             _v.minor,
-                            _host
+                            _kube.kConfigPath
                         )
                     )
                     return True
@@ -130,7 +130,7 @@
             from platform import system, release
             _s = system()
             _r = release()
-            logger_cli.debug("...running on {} {}".format(_s, _r))
+            logger_cli.debug("... running on {} {}".format(_s, _r))
             if _s in ['Linux', 'Darwin']:
                 return True
             else:
@@ -163,6 +163,10 @@
         self.salt_vars = []
         self.kube_vars = []
         for _key, _value in self.vars:
+            if _key in os.environ:
+                logger_cli.info(
+                    "-> Using env var '{}={}'".format(_key, os.environ[_key])
+                )
             if _key.startswith(ENV_TYPE_GLOB):
                 os.environ[_key] = _value
             elif _key.startswith(ENV_TYPE_SALT):
@@ -213,23 +217,28 @@
     def _init_env_values(self):
         if ENV_TYPE_SALT in self.detected_envs:
             for _key, _value in self.salt_vars:
-                os.environ[_key] = _value
+                if _key not in os.environ:
+                    os.environ[_key] = _value
 
             self.salt_user = os.environ.get('SALT_USER', 'salt')
             self.salt_timeout = os.environ.get('SALT_TIMEOUT', 30)
-            self.salt_file_root = os.environ.get('SALT_FILE_ROOT', None)
+            self.salt_file_root = os.environ.get(
+                'SALT_FILE_ROOT',
+                "/usr/share/salt-formulas/env/"
+            )
             self.salt_scripts_folder = os.environ.get(
                 'SALT_SCRIPTS_FOLDER',
                 'cfg_checker_scripts'
             )
         elif ENV_TYPE_KUBE in self.detected_envs:
             for _key, _value in self.kube_vars:
-                os.environ[_key] = _value
+                if _key not in os.environ:
+                    os.environ[_key] = _value
 
-            self.kube_config_root = os.environ.get('KUBE_CONFIG_ROOT', None)
+            self.kube_config_root = os.environ.get('KUBE_CONFIG_ROOT', "/root")
             self.kube_scripts_folder = os.environ.get(
                 'KUBE_SCRIPTS_FOLDER',
-                None
+                "cfg-checker-scripts"
             )
             self.kube_node_user = os.environ.get(
                 'KUBE_NODE_USER',
@@ -286,6 +295,57 @@
             ConfigException -- on IO error when loading env file
             ConfigException -- on env file failed validation
         """
+        # detect kubeconfig placement
+        _env_kubeconf_path = os.environ.get('KUBECONFIG', None)
+        if not os.path.exists(self.kube_config_path):
+            logger_cli.debug(
+                "... kubeconfig not detected at '{}'".format(
+                    self.kube_config_path
+                )
+            )
+            # not exists, get KUBECONFIG var
+            if _env_kubeconf_path:
+                # get the env var path
+                self.kube_config_path = _env_kubeconf_path
+                logger_cli.debug(
+                    "... KUBECONFIG var points to '{}'".format(
+                        self.kube_config_path
+                    )
+                )
+                self.kube_config_detected = True
+            else:
+                logger_cli.debug("... KUBECONFIG env var not found")
+                self.kube_config_path = None
+                self.kube_config_detected = False
+        else:
+            logger_cli.debug(
+                "... kubeconfig detected at '{}'".format(
+                    self.kube_config_path
+                )
+            )
+            self.kube_config_detected = True
+
+        # try to load values from KUBECONF
+        _kube_conf = None
+        if self.kube_config_path:
+            with open(self.kube_config_path) as kF:
+                _kube_conf = yaml.load(kF, Loader=yaml.SafeLoader)
+            # extract host ip
+            try:
+                _server = _kube_conf["clusters"][0]["cluster"]["server"]
+            except KeyError as e:
+                logger_cli.debug(
+                    "... failed to extract server ip: "
+                    "no '{}' key in 'clusters/[0]/cluster/server".format(e)
+                )
+            except IndexError:
+                logger_cli.debug(
+                    "... failed to extract server ip: empty cluster list"
+                )
+            _ip = _server.split(':')
+            self.remote_ip = _ip[1].replace('/', '')
+            logger_cli.debug("... detected ip: '{}'".format(self.remote_ip))
+
         # load env file as init os.environment with its values
         if os.path.isfile(config_path):
             with open(config_path) as _f:
@@ -326,7 +386,7 @@
             )
         else:
             logger_cli.debug(
-                "-> ...loaded total of '{}' vars".format(
+                "... loaded total of '{}' vars".format(
                     len(_list)
                 )
             )