diff --git a/web_hosting_manager/README.md b/web_hosting_manager/README.md
index 5041c9a..4345736 100644
--- a/web_hosting_manager/README.md
+++ b/web_hosting_manager/README.md
@@ -68,6 +68,11 @@ To run the application without packaging run
 $ npm run build
 $ npm start
 ```
+#### Clear Access Data
+#####macOs
+ Click `SAFE Hosting Manager -> Clear Access Data` from the menu.
+#####Windows and Linux
+ Click `File -> Clear Access Data` from the menu.
 
 # License
 
diff --git a/web_hosting_manager/app/actions/actionTypes.js b/web_hosting_manager/app/actions/actionTypes.js
index 8cdcb3f..33bad11 100644
--- a/web_hosting_manager/app/actions/actionTypes.js
+++ b/web_hosting_manager/app/actions/actionTypes.js
@@ -1,4 +1,5 @@
 const ACTION_TYPES = {
+  CLEAR_ACCESS_DATA: 'CLEAR_ACCESS_DATA',
   RESET: 'RESET',
   AUTH_REQUEST_SENT: 'AUTH_REQUEST_SENT',
   AUTH_REQUEST_SEND_FAILED: 'AUTH_REQUEST_SEND_FAILED',
diff --git a/web_hosting_manager/app/actions/app.js b/web_hosting_manager/app/actions/app.js
index 8c0aa1c..a27d41b 100644
--- a/web_hosting_manager/app/actions/app.js
+++ b/web_hosting_manager/app/actions/app.js
@@ -1,8 +1,10 @@
 // @flow
 
-import * as api from '../lib/api';
+import api from '../lib/api';
 import { I18n } from 'react-redux-i18n';
 import ACTION_TYPES from './actionTypes';
+import CONSTANTS from '../lib/constants';
+import * as utils from '../lib/utils';
 
 const sendAuthRequest = () => {
   const action = api.authorise() ? ACTION_TYPES.AUTH_REQUEST_SENT : ACTION_TYPES.AUTH_REQUEST_SEND_FAILED;
@@ -24,19 +26,14 @@ export const revoked = () => {
 };
 
 export const connect = (authRes: String) => {
-  if (!authRes && !api.hasLocalAuthInfo()) {
+  if (!authRes && !utils.localAuthInfo.get()) {
     return sendAuthRequest();
   }
   return (dispatch) => {
     return dispatch({
       type: ACTION_TYPES.CONNECT,
       payload: api.connect(authRes)
-        .then((resType) => {
-          if (resType === api.AUTH_RES_TYPES.revoked) {
-            return dispatch(revoked());
-          }
-        })
-    })
+    });
   };
 };
 
@@ -56,7 +53,7 @@ export const onAuthFailure = (error: Object) => {
 export const getAccessInfo = () => {
   return {
     type: ACTION_TYPES.FETCH_ACCESS_INFO,
-    payload: api.fetchAccessInfo()
+    payload: api.canAccessContainers()
   };
 };
 
@@ -70,7 +67,7 @@ export const getPublicNames = () => {
 export const createPublicId = (publicId: string) => {
   return {
     type: ACTION_TYPES.CREATE_PUBLIC_ID,
-    payload: api.createPublicId(publicId)
+    payload: api.createPublicName(publicId)
       .then(() => {
         return api.fetchPublicNames(publicId);
       })
@@ -82,10 +79,10 @@ export const createContainerAndService = (publicId: string, service: string,
   const path = `${parentConatiner}/${publicId}/${conatinerName}`;
   return {
     type: ACTION_TYPES.CREATE_CONTAINER_AND_SERVICE,
-    payload: api.checkServiceExist(publicId, service, path)
+    payload: api.updateServiceIfExist(publicId, service, path)
       .then((exist) => {
         if (!exist) {
-          return api.createContainer(path)
+          return api.createServiceContainer(path)
             .then((name) => {
               return api.createService(publicId, service, name);
             });
@@ -99,7 +96,9 @@ export const createContainerAndService = (publicId: string, service: string,
 export const createService = (publicId: string, service: string, containerPath: string) => {
   return {
     type: ACTION_TYPES.CREATE_SERVICE,
-    payload: api.createService(publicId, service, containerPath)
+    payload: api.getServiceContainerMeta(containerPath)
+      .then((meta) => api.createService(publicId, service, meta.name))
+      .then(() => api.fetchServices())
   };
 };
 
@@ -121,14 +120,14 @@ export const getServices = () => {
 export const getPublicContainers = () => {
   return {
     type: ACTION_TYPES.FETCH_PUBLIC_CONTAINERS,
-    payload: api.getPublicContainers()
+    payload: api.getPublicContainerKeys()
   };
 };
 
 export const remapService = (service: string, publicId: string, containerPath: string) => {
   return {
     type: ACTION_TYPES.REMAP_SERVICE,
-    payload: api.remapService(service, publicId, containerPath)
+    payload: api.remapService(publicId, service, containerPath)
       .then(() => api.fetchServices())
   };
 };
@@ -136,7 +135,7 @@ export const remapService = (service: string, publicId: string, containerPath: s
 export const getContainer = (containerPath: string) => {
   return {
     type: ACTION_TYPES.FETCH_CONTAINER,
-    payload: api.getContainer(containerPath)
+    payload: api.getServiceContainer(containerPath)
   };
 };
 
@@ -157,7 +156,7 @@ export const upload = (localPath: string, networkPath: string) => {
         payload: error
       });
     };
-    api.upload(localPath, networkPath, progressCallback, errorCallback);
+    api.fileUpload(localPath, networkPath, progressCallback, errorCallback);
     dispatch({
       type: ACTION_TYPES.UPLOAD_STARTED
     });
@@ -165,7 +164,7 @@ export const upload = (localPath: string, networkPath: string) => {
 };
 
 export const cancelUpload = () => {
-  api.cancelUpload();
+  api.cancelFileUpload();
   const err = new Error(I18n.t('messages.uploadCancelled'));
   return {
     type: ACTION_TYPES.UPLOAD_FAILED,
@@ -178,7 +177,7 @@ export const download = (networkPath: string) => {
     dispatch({
       type: ACTION_TYPES.DOWNLOAD_STARTED
     });
-    api.download(networkPath, (err, status) => {
+    api.fileDownload(networkPath, (err, status) => {
       if (err) {
         return dispatch({
           type: ACTION_TYPES.DOWNLOAD_FAILED,
@@ -194,7 +193,7 @@ export const download = (networkPath: string) => {
 };
 
 export const cancelDownload = () => {
-  api.cancelDownload();
+  api.cancelFileDownload();
   const err = new Error(I18n.t('messages.downloadCancelled'));
   return {
     type: ACTION_TYPES.DOWNLOAD_FAILED,
@@ -205,9 +204,9 @@ export const cancelDownload = () => {
 export const deleteItem = (containerPath, name) => {
   return {
     type: ACTION_TYPES.DELETE,
-    payload: api.deleteItem(`${containerPath}/${name}`)
+    payload: api.deleteFileOrDir(`${containerPath}/${name}`)
       .then(() => {
-        return api.getContainer(containerPath);
+        return api.getServiceContainer(containerPath);
       })
   };
 };
@@ -217,3 +216,10 @@ export const clearNotification = () => {
     type: ACTION_TYPES.CLEAR_NOTIFICATION
   }
 };
+
+export const clearAccessData = () => {
+  utils.localAuthInfo.clear();
+  return {
+    type: ACTION_TYPES.CLEAR_ACCESS_DATA
+  };
+};
diff --git a/web_hosting_manager/app/components/Auth.js b/web_hosting_manager/app/components/Auth.js
index 2a153c1..ad15a82 100644
--- a/web_hosting_manager/app/components/Auth.js
+++ b/web_hosting_manager/app/components/Auth.js
@@ -5,28 +5,26 @@ import { I18n } from 'react-redux-i18n';
 
 export default class Auth extends Component {
   componentDidMount() {
-    if (!this.props.isRevoked) {
-      this.props.connect();
-    }
+    this.props.connect();
   }
 
   componentWillUpdate(props) {
-    if (!this.props.isRevoked && props.fetchedServices && !props.serviceError) {
+    if (props.fetchedServices && !props.serviceError) {
       props.router.replace('/home');
     }
   }
 
   componentDidUpdate() {
-    if (this.props.isConnected && !this.props.fetchedAccessInfo && !this.props.accessInfoError) {
+    if (this.props.isConnected && !this.props.fetchingAccessInfo && !this.props.fetchedAccessInfo && !this.props.accessInfoError) {
       return this.props.getAccessInfo();
     }
-    if (this.props.fetchedAccessInfo && !this.props.fetchedPublicNames && !this.props.publicNameError) {
+    if (this.props.fetchedAccessInfo && !this.props.fetchingPublicNames && !this.props.fetchedPublicNames && !this.props.publicNameError) {
       return this.props.getPublicNames();
     }
-    if (this.props.fetchedPublicNames && !this.props.fetchedPublicContainers && !this.props.publicContainersError) {
+    if (this.props.fetchedPublicNames && !this.props.fetchingPublicContainers && !this.props.fetchedPublicContainers && !this.props.publicContainersError) {
       return this.props.getPublicContainers();
     }
-    if (this.props.fetchedPublicContainers && !this.props.fetchedServices && !this.props.serviceError) {
+    if (this.props.fetchedPublicContainers && !this.props.fetchingServices && !this.props.fetchedServices && !this.props.serviceError) {
       return this.props.getServices();
     }
   }
diff --git a/web_hosting_manager/app/components/CreateService.js b/web_hosting_manager/app/components/CreateService.js
index 8321459..019696e 100644
--- a/web_hosting_manager/app/components/CreateService.js
+++ b/web_hosting_manager/app/components/CreateService.js
@@ -2,6 +2,7 @@ import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { Button, Card, Input, Select, Icon } from 'antd';
 import { I18n } from 'react-redux-i18n';
+import { domainCheck } from '../utils/app_utils';
 
 import Nav from './Nav';
 
@@ -35,7 +36,8 @@ export default class CreateService extends Component {
         isCreatingContainerAndService: false
       });
     } else if (this.props.creatingService && !nextProps.creatingService) {
-      this.props.router.goBack();
+      const servicePath = this.state.isCreatingContainerAndService ? `_public/${this.props.params.publicId}/${this.state.containerName}` : this.containerName;
+      this.props.router.replace(`files/${this.state.serviceName}/${this.props.params.publicId}/${encodeURIComponent(servicePath)}`);
     }
   }
 
@@ -63,6 +65,11 @@ export default class CreateService extends Component {
         containerError: containerNameErrorMsg
       });
       valid = false;
+    } else if(!domainCheck(this.state.serviceName)) {
+      this.setState({
+        serviceError: I18n.t('messages.serviceNameInvalid')
+      });
+      valid = false;
     }
     return valid;
   }
@@ -192,4 +199,4 @@ CreateService.propTypes = {
   createContainerAndService: PropTypes.func.isRequired,
   createService: PropTypes.func.isRequired,
   getPublicContainers: PropTypes.func.isRequired,
-}
+};
diff --git a/web_hosting_manager/app/components/Home.js b/web_hosting_manager/app/components/Home.js
index 48e1c9e..8393ad5 100644
--- a/web_hosting_manager/app/components/Home.js
+++ b/web_hosting_manager/app/components/Home.js
@@ -5,6 +5,7 @@ import ReactDOM from 'react-dom';
 import { I18n } from 'react-redux-i18n';
 import { Link } from 'react-router';
 import NetworkStatus from './NetworkStatus';
+import { domainCheck } from '../utils/app_utils';
 
 import Nav from './Nav';
 
@@ -14,7 +15,8 @@ export default class Auth extends Component {
     this.state = {
       newPublicId: '',
       publicIdVisible: false,
-      showRemapModal: false
+      showRemapModal: false,
+      publicNameErr: ''
     };
     this.remap = {
       containerName: '',
@@ -31,9 +33,6 @@ export default class Auth extends Component {
   }
 
   componentWillUpdate(nextProps) {
-    if (nextProps.isRevoked) {
-      nextProps.router.replace('/');
-    }
     if (nextProps.fetchingPublicContainers) {
       this.reloadingContainer = true;
     }
@@ -54,6 +53,9 @@ export default class Auth extends Component {
   }
 
   createPublicId() {
+    if (!domainCheck(this.state.newPublicId)) {
+      return this.setState({ publicNameErr: I18n.t('messages.publicNameInvalid') });
+    }
     if (this.props.creatingPublicId) {
       return;
     }
@@ -61,8 +63,10 @@ export default class Auth extends Component {
   }
 
   cancelpublicId() {
+    this.setState({ publicNameErr: null });
     this.refs.publicId.refs.input.value = '';
     this.resetPublicIdModal();
+    this.props.clearNotification();
   }
 
   resetPublicIdModal() {
@@ -102,7 +106,7 @@ export default class Auth extends Component {
               placeholder={I18n.t('label.enterPublicId')}
               onPressEnter={this.createPublicId.bind(this)}
             />
-            <div className="error-msg">{this.props.creatingPublicId ? '' : this.props.publicIdError}</div>
+            <div className="error-msg withMar">{this.props.creatingPublicId ? '' : this.props.publicIdError || this.state.publicNameErr}</div>
           </div>
         </Modal>
       </div>
@@ -174,6 +178,7 @@ export default class Auth extends Component {
     this.setState({
       showRemapModal: false
     });
+    this.props.clearNotification();
   }
 
   showRemapModal(service, publicId) {
@@ -200,7 +205,7 @@ export default class Auth extends Component {
             defaultValue={this.state.newPublicId} placeholder={I18n.t('messages.publicIdPlaceholder')}
             onPressEnter={this.createPublicId.bind(this)}
           />
-          <div className="error-msg">{this.props.creatingPublicId ? '' : this.props.publicIdError}</div>
+          <div className="error-msg">{this.props.creatingPublicId ? '' : this.props.publicIdError || this.state.publicNameErr}</div>
           <Button
             type="primary" onClick={this.createPublicId.bind(this)}
             loading={this.props.creatingPublicId}
diff --git a/web_hosting_manager/app/index.js b/web_hosting_manager/app/index.js
index fb1338a..eca8abc 100644
--- a/web_hosting_manager/app/index.js
+++ b/web_hosting_manager/app/index.js
@@ -12,7 +12,7 @@ import { initTempFolder } from './lib/temp';
 import routes from './routes';
 import configureStore from './store/configureStore';
 import loadLocale from './locales/loader';
-import { connect, onAuthSuccess, onAuthFailure } from './actions/app';
+import { connect, onAuthSuccess, onAuthFailure, clearAccessData } from './actions/app';
 import './app.global.css';
 
 const store = configureStore();
@@ -42,6 +42,13 @@ const listenForAuthReponse = (event, response) => {
 
 ipc.on('auth-response', listenForAuthReponse);
 
+ipc.on('clear-access-data', (event, res) => {
+  if (res) {
+    store.dispatch(clearAccessData());
+  }
+});
+
+
 render(
   <Provider store={store}>
     <Router history={history} routes={routes} />
diff --git a/web_hosting_manager/app/lib/Downloader.js b/web_hosting_manager/app/lib/Downloader.js
index 4914d41..7a3164f 100644
--- a/web_hosting_manager/app/lib/Downloader.js
+++ b/web_hosting_manager/app/lib/Downloader.js
@@ -2,7 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import { getPath } from './temp';
 import { shell } from 'electron';
-import { safe, TAG_TYPE_WWW, accessContainers } from './api';
+import safeApi from './api';
+import CONSTANTS from './constants';
 
 export default class Downloader {
   constructor(networkPath, callback) {
@@ -12,6 +13,7 @@ export default class Downloader {
   }
 
   start() {
+
     const containerPath = {
       dir: this.path.split('/').slice(0, 3).join('/'),
       file: this.path.split('/').slice(3).join('/')
@@ -19,15 +21,13 @@ export default class Downloader {
     const tokens = this.path.split('/');
     const filePath = path.join(getPath(), tokens.pop());
 
-    return safe.auth.getContainer(accessContainers.public)
-      .then((mdata) => mdata.encryptKey(containerPath.dir).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-      .then((val) => safe.mutableData.newPublic(val, TAG_TYPE_WWW))
+    return safeApi.getPublicContainer()
+      .then((md) => safeApi.getMDataValueForKey(md, containerPath.dir))
+      .then((val) => app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.WWW))
       .then((mdata) => {
         const nfs = mdata.emulateAs('NFS');
         return nfs.fetch(containerPath.file)
-          .then((file) => {
-            return safe.immutableData.fetch(file.dataMapName);
-          })
+          .then((file) => app.immutableData.fetch(file.dataMapName))
           .then((i) => i.read());
       })
       .then((data) => {
diff --git a/web_hosting_manager/app/lib/api.js b/web_hosting_manager/app/lib/api.js
index 4a59b18..cc4320c 100644
--- a/web_hosting_manager/app/lib/api.js
+++ b/web_hosting_manager/app/lib/api.js
@@ -1,500 +1,474 @@
-import { shell } from 'electron';
+/**
+ * SafeApi class expose all api requested for web hosting manager.
+ */
 import path from 'path';
-import keytar from 'keytar';
+import safeApp from 'safe-app';
+import { I18n } from 'react-redux-i18n';
+
 import Uploader from './Uploader';
 import Downloader from './Downloader';
-import { I18n } from 'react-redux-i18n';
-import safeApp from 'safe-app';
-import pkg from '../package.json';
-import { parseUrl } from './utils';
-
-const SERVICE = 'WEB_HOST_MANAGER';
-const ACCOUNT = 'SAFE_USER';
-const APP_INFO = {
-  data: {
-    id: pkg.identifier,
-    scope: null,
-    name: pkg.name,
-    vendor: pkg.author.name
-  },
-  opt: {
-    own_container: false
-  },
-  permissions: { // TODO check permissions are right
-    _public: [
-      'Read',
-      'Insert',
-      'Update',
-      'Delete',
-      'ManagePermissions'
-    ],
-    _publicNames: [
-      'Read',
-      'Insert',
-      'Update',
-      'Delete',
-      'ManagePermissions'
-    ]
+import * as utils from './utils';
+import CONSTANTS from './constants';
+
+class SafeApi {
+  constructor() {
+    this.app = null;
+    this.APP_INFO = CONSTANTS.APP_INFO;
+    this.publicNames = {};
+    this.uploader = null;
+    this.downloader = null;
   }
-};
-
-export const AUTH_RES_TYPES = {
-  containers: 'containers',
-  revoked: 'revoked'
-};
-
-export const accessContainers = {
-  public: '_public',
-  publicNames: '_publicNames'
-};
 
-export const TAG_TYPE_DNS = 15001;
-export const TAG_TYPE_WWW = 15002;
-
-
-let publicIds = {};
-let uploader;
-let downloader;
-
-export let safe = null;
-
-const getLocalAuthInfo = () => {
-  return keytar.getPassword(SERVICE, ACCOUNT);
-};
+  /**
+   * Authorise with SAFE Authenticator
+   * @return {Promise}
+   */
+  authorise() {
+    const authInfo = utils.localAuthInfo.get();
+    if (authInfo) {
+      return authInfo;
+    }
+    return safeApp.initializeApp(this.APP_INFO.data)
+      .then((app) => app.auth.genAuthUri(this.APP_INFO.permissions, this.APP_INFO.opt))
+      .then((res) => utils.openExternal(res.uri));
+  }
 
-const clearLocalAuthInfo = () => {
-  return keytar.deletePassword(SERVICE, ACCOUNT);
-};
+  /**
+   * CONNECT with SAFE Network
+   * @param uri
+   * @return {*}
+   */
+  connect(uri) {
+    const authInfo = uri || JSON.parse(utils.localAuthInfo.get());
+    if (!authInfo) {
+      // FIXME shankar - handle from action
+      // return Promise.reject(new Error('Missing Authorisation information.'));
+      return this.authorise();
+    }
+    return safeApp.fromAuthURI(this.APP_INFO.data, authInfo)
+      .then((app) => {
+        // store Auth response
+        if (uri) {
+          utils.localAuthInfo.save(uri);
+        }
+        this.app = app;
+      })
+      .catch((err) => {
+        if (err[0] === CONSTANTS.AUTH_RES_TYPE.CONTAINERS) {
+          return Promise.resolve(CONSTANTS.AUTH_RES_TYPE.CONTAINERS);
+        } else if (err[0] === CONSTANTS.AUTH_RES_TYPE.REVOKED) {
+          utils.localAuthInfo.clear();
+          return Promise.resolve(CONSTANTS.AUTH_RES_TYPE.REVOKED);
+        } else {
+          utils.localAuthInfo.clear();
+          return Promise.reject(err);
+        }
+      });
+  }
 
-export const hasLocalAuthInfo = () => {
-  return getLocalAuthInfo();
-};
+  /**
+   * Check access containers accessible
+   * @return {*}
+   */
+  canAccessContainers() {
+    if (!this.app) {
+      return Promise.reject(new Error('Application is not connected.'));
+    }
+    return this.app.auth.refreshContainersPermissions()
+      .then(() => {
+        return Promise.all(
+          Object.keys(CONSTANTS.ACCESS_CONTAINERS).map((cont) => {
+            return this.app.auth.canAccessContainer(CONSTANTS.ACCESS_CONTAINERS[cont])
+          })
+        );
+      })
+      .catch((err) => {
+        utils.localAuthInfo.clear();
+        return Promise.reject(err);
+      });
+  }
 
-export const saveAuthInfo = (authInfo) => {
-  return keytar.addPassword(SERVICE, ACCOUNT, JSON.stringify(authInfo)); // TODO check authInfo type
-};
+  /**
+   * Fetch Public Names
+   */
+  fetchPublicNames() {
+    const self = this;
+    return this.getPublicNamesContainer()
+      .then((md) => md.getKeys()
+        .then((keys) => keys.len()
+          .then((keysLen) => {
+            if (keysLen === 0) {
+              console.warn('No Public Names found');
+              return;
+            }
+            const encPublicNames = [];
+            return keys.forEach(function (key) {
+              encPublicNames.push(key);
+            }).then(() => Promise.all(encPublicNames.map((key) => {
+              return md.decrypt(key)
+                .then((decKey) => {
+                  const decPubId = decKey.toString();
+                  if (!self.publicNames[decPubId] || typeof self.publicNames[decPubId] !== 'object') {
+                    self.publicNames[decPubId] = {};
+                  }
+                })
+                .catch((err) => { // FIXME shankar - to be removed once fixed symmetric decipher failure for unknown key decryption.
+                  if (err.code === CONSTANTS.ERROR_CODE.SYMMETRIC_DECIPHER_FAILURE) {
+                    return Promise.resolve();
+                  }
+                  return Promise.reject(err);
+                });
+            })));
+          })))
+      .then(() => (self.publicNames));
+  }
 
-export const authorise = () => {
-  const authInfo = getLocalAuthInfo(); // TODO if authInfo is null => authorise app
-  if (authInfo) {
-    return authInfo;
+  /**
+   * Fetch Service of Public Names
+   * @return {Promise}
+   */
+  fetchServices() {
+    const self = this;
+    const publicNames = Object.getOwnPropertyNames(this.publicNames);
+    return Promise.all(publicNames.map((publicName) => {
+      const services = {};
+      return this.getPublicNamesContainer()
+        .then((md) => this.getMDataValueForKey(md, publicName))
+        .then((value) => this.app.mutableData.newPublic(value, CONSTANTS.TAG_TYPE.DNS))
+        .then((md) => md.getEntries()
+          .then((entries) => entries.forEach((key, val) => {
+            const service = key.toString();
+            // check service is not an email or deleted
+            if ((service.indexOf('@email') !== -1) || (val.buf.length === 0)) {
+              return;
+            }
+            services[service] = val;
+          })))
+        .then(() => Promise.all(Object.keys(services).map((service) => (
+          self._getServicePath(services[service])
+            .then((path) => {
+              services[service] = path;
+            })
+        ))))
+        .then(() => (self.publicNames[publicName] = services))
+        .catch(Promise.reject);
+    })).then(() => (self.publicNames));
   }
-  return safeApp.initializeApp(APP_INFO.data)
-    .then((app) => app.auth.genAuthUri(APP_INFO.permissions, APP_INFO.opt))
-    .then((res) => {
-      shell.openExternal(parseUrl(res.uri))
-    });
-};
-
-export const connect = (res) => {
-  const authInfo = res || JSON.parse(getLocalAuthInfo());
-  if (!authInfo) {
-    return authorise();
+
+  /**
+   * Create new Public Name
+   * @param publicName
+   * @return {Promise<R>|Promise.<*>}
+   */
+  createPublicName(publicName) {
+    const name = publicName.trim();
+    if (!name) {
+      // FIXME correct error message to public name
+      const err = new Error(I18n.t('messages.cannotBeEmpty', { name: 'Public Id' }));
+      return Promise.reject(err);
+    }
+
+    return this.app.crypto.sha3Hash(name)
+      .then((hashedName) => this.app.mutableData.newPublic(hashedName, CONSTANTS.TAG_TYPE.DNS))
+      .then((md) => {
+        return this.app.mutableData.newPermissionSet()
+          .then((permSet) => permSet.setAllow('Insert')
+            .then(() => permSet.setAllow('Update'))
+            .then(() => permSet.setAllow('Delete'))
+            .then(() => permSet))
+          .then((permSet) => this.app.crypto.getAppPubSignKey()
+            .then((signKey) => this.app.mutableData.newPermissions()
+              .then((perm) => perm.insertPermissionSet(signKey, permSet).then(() => perm))))
+          .then((perm) => this.app.mutableData.newEntries()
+            .then((entries) => md.put(perm, entries)))
+          .then(() => md.getNameAndTag())
+          .then((mdMeta) => this.getPublicNamesContainer()
+            .then((pubMd) => this._insertToMData(pubMd, name, mdMeta.name, true)));
+      });
   }
-  return safeApp.fromAuthURI(APP_INFO.data, authInfo)
-    .then((app) => {
-      if (res) {
-        saveAuthInfo(res);
-      }
-      (safe = app)
-    })
-    .catch((err) => {
-      if (err[0] === AUTH_RES_TYPES.containers) {
-        return Promise.resolve(AUTH_RES_TYPES.containers);
-      } else if (err[0] === AUTH_RES_TYPES.revoked) {
-        clearLocalAuthInfo();
-        return Promise.resolve(AUTH_RES_TYPES.revoked);
-      } else {
-        clearLocalAuthInfo();
-        return Promise.reject(err);
-      }
-    });
-};
-
-export const fetchAccessInfo = () => {
-  return safe.auth.refreshContainersPermissions()
-    .then(() => safe.auth.canAccessContainer(accessContainers.public))
-    .then((hasAccess) => {
-      if (!hasAccess) {
-        return Promise.reject(new Error(`No access to ${accessContainers.public} container`));
-      }
-    })
-    .then(() => safe.auth.canAccessContainer(accessContainers.publicNames))
-    .then((hasAccess) => {
-      if (!hasAccess) {
-        return Promise.reject(new Error(`No access to ${accessContainers.publicNames} container`));
-      }
-    })
-    .catch((e) => {
-      clearLocalAuthInfo();
-      return Promise.reject(e);
-    });
-};
-
-export const fetchPublicNames = () => {
-  return safe.auth.getContainer(accessContainers.publicNames)
-    .then((mdata) => mdata.getKeys()
-      .then((keys) => keys.len()
-        .then((len) => {
-          if (len === 0) {
-            console.log('No public Ids found');
-            return;
-          }
-          const encPublicIds = [];
-          return keys.forEach(function (key) {
-            encPublicIds.push(key);
-          })
-            .then(() => {
-              return Promise.all(encPublicIds.map((pubId) => {
-                return mdata.decrypt(pubId)
-                  .then((decKey) => {
-                    const decPubId = decKey.toString()
-                    if (!publicIds[decPubId] || typeof publicIds[decPubId] !== 'object') {
-                      publicIds[decPubId] = {};
-                    }
-                  })
-              }));
-            })
-        })))
-    .then(() => publicIds);
-};
-
-export const fetchServices = () => {
-  const publicNamesKeys = Object.getOwnPropertyNames(publicIds);
-  return Promise.all(publicNamesKeys.map((publicId) => {
-    const services = {};
-    return safe.auth.getContainer(accessContainers.publicNames)
-      .then((mdata) => mdata.encryptKey(publicId).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-      .then((decVal) => {
-        return safe.mutableData.newPublic(decVal, TAG_TYPE_DNS)
-      })
-      .then((mut) => mut.getEntries()
-        .then((entries) => entries.forEach((key, val) => {
-          const service = key.toString();
-          if ((service.indexOf('@email') !== -1) || (val.buf.length === 0)) {
-            return;
+
+  /**
+   * Create new Service
+   * @param publicName
+   * @param serviceName
+   * @param path
+   * @return {*}
+   */
+  createService(publicName, serviceName, pathXORName) {
+    if (!publicName) {
+      return Promise.reject(new Error(I18n.t('messages.cannotBeEmpty', { name: 'Public Id' })));
+    }
+    if (!serviceName) {
+      return Promise.reject(new Error(I18n.t('messages.cannotBeEmpty', { name: 'Service' })));
+    }
+    if (!path) {
+      return Promise.reject(new Error(I18n.t('messages.cannotBeEmpty', { name: 'Container path' })));
+    }
+
+    return this.getPublicNamesContainer()
+      .then((md) => this.getMDataValueForKey(md, publicName))
+      .then((decVal) => this.app.mutableData.newPublic(decVal, CONSTANTS.TAG_TYPE.DNS))
+      .then((md) => this._insertToMData(md, serviceName, pathXORName)
+        .catch((err) => {
+          if (err.code !== CONSTANTS.ERROR_CODE.ENTRY_EXISTS) {
+            return Promise.reject(err);
           }
-          services[service] = val;
-        })))
-      .then(() => {
-        return Promise.all(Object.keys(services).map((key) => {
-          return getContainerName(services[key])
-            .then((val) => {
-              services[key] = val;
-            });
-        }))
-      })
-      .then(() => publicIds[publicId] = services)
-      .catch(Promise.reject);
-  })).then(() => publicIds);
-};
-
-export const createPublicId = (publicId) => {
-  publicId = publicId.trim();
-  if (!publicId) {
-    const err = new Error(I18n.t('messages.cannotBeEmpty', { name: 'Public Id' }));
-    return Promise.reject(err);
+          return this._updateMDataKey(md, serviceName, pathXORName);
+        }));
   }
-  let publicIdName = null;
-
-  return safe.crypto.sha3Hash(publicId)
-    .then((hashVal) => safe.mutableData.newPublic(hashVal, TAG_TYPE_DNS))
-    .then((mdata) => {
-      let permissionSet = null;
-      let permissions = null;
-      let pubSignKey = null;
-
-      return safe.mutableData.newPermissionSet()
-        .then((permSet) => (permissionSet = permSet))
-        .then(() => permissionSet.setAllow('Insert'))
-        .then(() => permissionSet.setAllow('Update'))
-        .then(() => permissionSet.setAllow('Delete'))
-        .then(() => permissionSet.setAllow('ManagePermissions'))
-        .then(() => safe.crypto.getAppPubSignKey())
-        .then((signKey) => (pubSignKey = signKey))
-        .then(() => safe.mutableData.newPermissions())
-        .then((perm) => (permissions = perm))
-        .then(() => permissions.insertPermissionSet(pubSignKey, permissionSet))
-        .then(() => safe.mutableData.newEntries())
-        .then((entries) => mdata.put(permissions, entries))
-        .then(() => mdata.getNameAndTag())
-    })
-    .then((data) => (publicIdName = data.name))
-    .then(() => safe.auth.getContainer(accessContainers.publicNames))
-    .then((mdata) => mdata.getEntries()
-      .then((entries) => entries.mutate()
-        .then((mut) => mdata.encryptKey(publicId)
-          .then((encKey) => mdata.encryptValue(publicIdName)
-            .then((encVal) => mut.insert(encKey, encVal)))
-          .then(() => mdata.applyEntriesMutation(mut)))));
-};
-
-export const createService = (publicId, service, container) => {
-  if (!publicId) {
-    return Promise.reject(new Error(I18n.t('messages.cannotBeEmpty', { name: 'Public Id' })));
-  }
-  if (!service) {
-    return Promise.reject(new Error(I18n.t('messages.cannotBeEmpty', { name: 'Service' })));
+
+  /**
+   * Delete Service
+   * @param publicName
+   * @param serviceName
+   */
+  deleteService(publicName, serviceName) {
+    return this.app.crypto.sha3Hash(publicName)
+      .then((hashedPubName) => this.app.mutableData.newPublic(hashedPubName, CONSTANTS.TAG_TYPE.DNS))
+      .then((md) => this._removeFromMData(md, serviceName));
   }
-  if (!container) {
-    return Promise.reject(new Error(I18n.t('messages.cannotBeEmpty', { name: 'Container path' })));
+
+  createServiceContainer(path) {
+    return this.app.mutableData.newRandomPublic(CONSTANTS.TAG_TYPE.WWW)
+      .then((md) => md.quickSetup({}).then(() => md.getNameAndTag()))
+      .then((mdMeta) => this.getPublicContainer()
+        .then((pubMd) => this._insertToMData(pubMd, path, mdMeta.name))
+        .then(() => mdMeta.name));
   }
 
-  return safe.auth.getContainer(accessContainers.publicNames)
-    .then((mdata) => {
-      return mdata.encryptKey(publicId).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf));
-    })
-    .then((val) => {
-      return safe.mutableData.newPublic(val, TAG_TYPE_DNS);
-    })
-    .then((publicIdMData) => {
-      return publicIdMData.getEntries()
-        .then((entries) => {
-          return entries.mutate()
-            .then((mut) => {
-              return mut.insert(service, container)
-                .then(() => publicIdMData.applyEntriesMutation(mut));
-            });
-        })
-    });
-};
-
-export const deleteService = (publicId, service) => {
-  return safe.crypto.sha3Hash(publicId)
-    .then((hashVal) => safe.mutableData.newPublic(hashVal, TAG_TYPE_DNS))
-    .then((mdata) => mdata.getEntries()
-      .then((entries) => entries.get(service)
-        .then((val) => entries.mutate()
-          .then((mut) => mut.remove(service, val.version + 1)
-            .then(() => mdata.applyEntriesMutation(mut))))));
-};
-
-export const createContainer = (path) => {
-  return safe.mutableData.newRandomPublic(TAG_TYPE_WWW)
-    .then((mdata) => {
-      return mdata.quickSetup({})
-        .then(() => {
-          return mdata.getNameAndTag();
-        })
-    })
-    .then((data) => {
-      return safe.auth.getContainer(accessContainers.public)
-        .then((mdata) => {
-          return mdata.getEntries()
-            .then((entries) => {
-              return entries.mutate()
-                .then((mut) => {
-                  return mdata.encryptKey(path)
-                    .then((encKey) => mdata.encryptValue(data.name)
-                      .then((encVal) => mut.insert(encKey, encVal)))
-                    .then(() => mdata.applyEntriesMutation(mut));
-                });
-            });
-        })
-        .then(() => {
-          return data.name;
-        });
-    });
-};
-
-export const getPublicContainers = () => {
-  const publicKeys = [];
-  return safe.auth.getContainer(accessContainers.public)
-    .then((mdata) => mdata.getKeys())
-    .then((keys) => {
-      return keys.len()
+  getPublicContainerKeys() {
+    const publicKeys = [];
+    return this.getPublicContainer()
+      .then((pubMd) => pubMd.getKeys())
+      .then((keys) => keys.len()
         .then((len) => {
           if (len === 0) {
             return Promise.resolve([]);
           }
           return keys.forEach((key) => {
+            if (!key) {
+              return;
+            }
             publicKeys.unshift(key.toString());
-          });
-        });
-    })
-    .then(() => publicKeys);
-};
-
-export const deleteItem = (nwPath) => {
-  let dirName = nwPath;
-  let fileName = null;
-  if (path.extname(nwPath)) {
-    dirName = path.dirname(nwPath);
-    fileName = path.basename(nwPath);
+          }).then(() => publicKeys);
+        }));
   }
 
-  return safe.auth.getContainer(accessContainers.public)
-  // .then((mdata) => mdata.getEntries()
-    .then((mdata) => {
-      if (fileName) {
-        return mdata.encryptKey(dirName).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf))
-          .then((val) => {
-            return safe.mutableData.newPublic(val, TAG_TYPE_WWW)
-              .then((dirMdata) => dirMdata.getEntries()
-                .then(() => dirMdata.getEntries()
-                  .then((dirEntries) => dirEntries.get(fileName)
-                    .then((val) => dirEntries.mutate()
-                      .then((mut) => mut.remove(fileName, val.version + 1)
-                        .then(() => dirMdata.applyEntriesMutation(mut)))))))
-          });
-      } else {
-        return mdata.encryptKey(nwPath.split('/').slice(0, -1).join('/')).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf))
-          .then((val) => {
-            return safe.mutableData.newPublic(val, TAG_TYPE_WWW)
-              .then((tarMdata) => {
-                const targetKeys = [];
-                return tarMdata.getEntries()
-                  .then((entries) => entries.forEach((key, val) => {
-                    const keyStr = key.toString();
-                    const dirname = nwPath.split('/').slice(-1).toString()
-                    if (keyStr.indexOf(dirname) !== 0) {
-                      return;
-                    }
-                    targetKeys.push({key: keyStr, version: val.version});
-                  })
-                    .then(() => Promise.all(targetKeys.map((tar) => {
-                      return entries.mutate()
-                        .then((mut) => {
-                          return mut.remove(tar.key, tar.version + 1)
-                            .then(() => tarMdata.applyEntriesMutation(mut))
-                        });
-                    }))));
-              });
+  deleteFileOrDir(netPath) {
+    let dirName = netPath;
+    let fileName = null;
+    if (path.extname(netPath)) {
+      dirName = path.dirname(netPath);
+      fileName = path.basename(netPath);
+    }
+
+    return this.getPublicContainer()
+      .then((pubMd) => {
+        // delete file
+        if (fileName) {
+          return this.getMDataValueForKey(pubMd, dirName)
+            .then((val) => this.app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.WWW))
+            .then((md) => this._removeFromMData(md, fileName));
+        }
+
+        // delete directory
+        return this.getMDataValueForKey(pubMd, netPath.split('/').slice(0, -1).join('/'))
+          .then((val) => this.app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.WWW))
+          .then((dirMd) => {
+            const fileKeys = [];
+            const nameOfDir = netPath.split('/').slice(-1).toString();
+            return dirMd.getEntries()
+              .then((entries) => entries.forEach((key, val) => {
+                const keyStr = key.toString();
+                if (keyStr.indexOf(nameOfDir) !== 0) {
+                  return;
+                }
+                fileKeys.push({ key: keyStr, version: val.version });
+              }).then(() => Promise.all(fileKeys.map((file) => {
+                return entries.mutate()
+                  .then((mut) => {
+                    return mut.remove(file.key, file.version + 1)
+                      .then(() => dirMd.applyEntriesMutation(mut))
+                  });
+              }))));
           });
-      }
-    });
-};
-
-export const remapService = (service, publicId, container) => {
-  let containerName = null;
-  return safe.auth.getContainer(accessContainers.public)
-    .then((mdata) => mdata.encryptKey(container).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-    // .then((entries) => entries.get(container))
-    .then((val) => (containerName = val))
-    .then(() => safe.auth.getContainer(accessContainers.publicNames))
-    .then((mdata) => mdata.encryptKey(publicId).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-    // .then((entries) => entries.get(publicId))
-    .then((val) => safe.mutableData.newPublic(val, TAG_TYPE_DNS))
-    .then((publicIdMData) => publicIdMData.getEntries()
-      .then(() => publicIdMData.getEntries()
-        .then((entries) => entries.get(service)
-          .then((val) => entries.mutate()
-            .then((mut) => mut.update(service, containerName, val.version + 1)
-              .then(() => publicIdMData.applyEntriesMutation(mut)))))));
-};
-
-export const getContainer = (path) => {
-  let result = [];
-  return safe.auth.getContainer(accessContainers.public)
-    .then((mdata) => mdata.encryptKey(path.split('/').slice(0, 3).join('/'))
-      .then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-    // .then((entries) => entries.get(path.split('/').slice(0, 3).join('/')))
-    .then((val) => safe.mutableData.newPublic(val, TAG_TYPE_WWW))
-    .then((mdata) => {
-      const files = [];
-      const nfs = mdata.emulateAs('NFS');
-      return mdata.getEntries()
-        .then((entries) => entries.forEach((key, value) => {
-          if (value.buf.length === 0) {
-            return
-          }
-          let keyStr = key.toString();
-          const rootName = path.split('/').slice(3).join('/');
-          if (rootName && (keyStr.indexOf(rootName) !== 0)) {
-            return
-          }
-          let keyStrTrimmed = keyStr;
-          if (rootName.length > 0) {
-            keyStrTrimmed = keyStr.substr(rootName.length + 1);
-          }
-          if (keyStrTrimmed.split('/').length > 1) {
-            const dirName = keyStrTrimmed.split('/')[0];
-            if (result.filter((files) => files.name === dirName).length === 0) {
-              return result.unshift({ isFile: false, name: dirName });
+      });
+  }
+
+  remapService(publicName, serviceName, path) {
+    return this.getPublicContainer()
+      .then((pubMd) => this.getMDataValueForKey(pubMd, path))
+      .then((containerVal) => {
+        return this.getPublicNamesContainer()
+          .then((pnMd) => this.getMDataValueForKey(pnMd, publicName))
+          .then((pnVal) => this.app.mutableData.newPublic(pnVal, CONSTANTS.TAG_TYPE.DNS))
+          .then((md) => this._updateMDataKey(md, serviceName, containerVal));
+      });
+  }
+
+  getServiceContainer(path) {
+    return this.getPublicContainer()
+      .then((md) => this.getMDataValueForKey(md, path.split('/').slice(0, 3).join('/')))
+      .then((val) => this.app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.WWW))
+      .then((serMd) => {
+        const files = [];
+        let result = [];
+        const rootName = path.split('/').slice(3).join('/');
+        return serMd.getEntries()
+          .then((entries) => entries.forEach((key, val) => {
+            if (val.buf.length === 0) {
+              return;
             }
-            return;
-          }
-          files.unshift(keyStr);
-        }))
-        .then(() => {
-          return Promise.all(files.map((file) => {
-            return nfs.fetch(file)
-              .then((f) => safe.immutableData.fetch(f.dataMapName))
-              .then((i) => i.read())
-              .then((co) => {
-                const dirName = path.split('/').slice(3).join('/');
-                result.unshift({
-                  isFile: true,
-                  name: dirName ? file.substr(dirName.length + 1) : file,
-                  size: co.length
-                });
-              });
-          }));
-        });
-    })
-    .then(() => result);
-};
-
-export const upload = (localPath, networkPath, progressCallback, errorCallback) => {
-  uploader = new Uploader(localPath, networkPath, progressCallback, errorCallback);
-  uploader.start();
-};
-
-export const cancelUpload = () => {
-  uploader.cancel();
-};
-
-export const download = (networkPath, callback) => {
-  downloader = new Downloader(networkPath, callback);
-  downloader.start();
-};
-
-export const cancelDownload = () => {
-  downloader.cancel();
-};
-
-export const checkServiceExist = (publicId, service, path) => {
-  return safe.auth.getContainer(accessContainers.publicNames)
-    .then((mdata) => mdata.encryptKey(publicId).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-    .then((decVal) => {
-      return safe.mutableData.newPublic(decVal, TAG_TYPE_DNS)
-    })
-    .then((pubMut) => {
-      return pubMut.get(service)
-        .then((value) => {
-          if (value.buf.length !== 0) {
-            return;
-          }
-          return safe.auth.getContainer(accessContainers.public)
-            .then((mdata) => {
-              return mdata.encryptKey(path).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf))
-            })
-            .then((val) => {
-              return pubMut.getEntries()
-                .then((entries) => {
-                  return entries.mutate().then((mut) => {
-                    return mut.update(service, val, value.version + 1).then(() => pubMut.applyEntriesMutation(mut));
+            let keyStr = key.toString();
+            if (rootName && (keyStr.indexOf(rootName) !== 0)) {
+              return;
+            }
+            let keyStrTrimmed = keyStr;
+            if (rootName.length > 0) {
+              keyStrTrimmed = keyStr.substr(rootName.length + 1);
+            }
+            if (keyStrTrimmed.split('/').length > 1) {
+              const dirName = keyStrTrimmed.split('/')[0];
+              if (result.filter((files) => (files.name === dirName)).length === 0) {
+                return result.unshift({ isFile: false, name: dirName });
+              }
+              return;
+            }
+            files.unshift(keyStr);
+          })).then(() => {
+            const nfs = serMd.emulateAs('NFS');
+            return Promise.all(files.map((file) => {
+              return nfs.fetch(file)
+                .then((f) => this.app.immutableData.fetch(f.dataMapName))
+                .then((i) => i.read())
+                .then((co) => {
+                  const dirName = path.split('/').slice(3).join('/');
+                  result.unshift({
+                    isFile: true,
+                    name: dirName ? file.substr(dirName.length + 1) : file,
+                    size: co.length
                   });
                 });
-            });
+            })).then(() => result);
+          });
+      });
+  }
+
+  getServiceContainerMeta(path) {
+    return this.getPublicContainer()
+      .then((md) => this.getMDataValueForKey(md, path))
+      .then((val) => this.app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.WWW))
+      .then((serMd) => serMd.getNameAndTag());
+  }
+
+  updateServiceIfExist(publicName, serviceName, path) {
+    return this.getPublicNamesContainer()
+      .then((pnMd) => this.getMDataValueForKey(pnMd, publicName))
+      .then((val) => this.app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.DNS))
+      .then((md) => {
+        return md.get(serviceName)
+          .then((value) => {
+            if (value.buf.length !== 0) {
+              return;
+            }
+            return this.getPublicContainer()
+              .then((pubMd) => this.getMDataValueForKey(pubMd, path))
+              .then((val) => this._updateMDataKey(md, serviceName, val));
+          })
+          .catch((err) => {
+            if (err.code === CONSTANTS.ERROR_CODE.NO_SUCH_ENTRY) {
+              return Promise.resolve(false);
+            }
+            return Promise.reject();
+          });
+      });
+  }
+
+  fileUpload(localPath, networkPath, progressCallback, errorCallback) {
+    this.uploader = new Uploader(localPath, networkPath, progressCallback, errorCallback);
+    this.uploader.start();
+  };
+
+  cancelFileUpload() {
+    this.uploader.cancel();
+  }
+
+  fileDownload(networkPath, callback) {
+    this.downloader = new Downloader(networkPath, callback);
+    this.downloader.start();
+  }
+
+  cancelFileDownload = () => {
+    this.downloader.cancel();
+  }
+
+  getPublicContainer() {
+    if (!this.app) {
+      return Promise.reject(new Error('Application is not connected.'));
+    }
+    return this.app.auth.getContainer(CONSTANTS.ACCESS_CONTAINERS.PUBLIC);
+  }
+
+  getPublicNamesContainer() {
+    if (!this.app) {
+      return Promise.reject(new Error('Application is not connected.'));
+    }
+    return this.app.auth.getContainer(CONSTANTS.ACCESS_CONTAINERS.PUBLIC_NAMES);
+  }
+
+  getMDataValueForKey(md, key) {
+    return md.encryptKey(key)
+      .then((encKey) => md.get(encKey))
+      .then((value) => md.decrypt(value.buf));
+  }
+
+  _updateMDataKey(md, key, value) {
+    return md.getEntries()
+      .then((entries) => entries.get(key)
+        .then((val) => entries.mutate()
+          .then((mut) => mut.update(key, value, val.version + 1)
+            .then(() => md.applyEntriesMutation(mut)))));
+  }
+
+  _removeFromMData(md, key) {
+    return md.getEntries()
+      .then((entries) => entries.get(key)
+        .then((value) => entries.mutate()
+          .then((mut) => mut.remove(key, value.version + 1)
+            .then(() => md.applyEntriesMutation(mut)))));
+  }
+
+  _insertToMData(md, key, val, toEncrypt) {
+    let keyToInsert = key;
+    let valToInsert = val;
+
+    return md.getEntries()
+      .then((entries) => entries.mutate()
+        .then((mut) => {
+          if (toEncrypt) {
+            return md.encryptKey(key)
+              .then((encKey) => md.encryptValue(val)
+                .then((encVal) => {
+                  keyToInsert = encKey;
+                  valToInsert = encVal
+                })).then(() => mut);
+          }
+          return mut;
         })
-        .catch((err) => {
-          if (err.code === -106) {
-            return Promise.resolve(false);
+        .then((mut) => mut.insert(keyToInsert, valToInsert)
+          .then(() => md.applyEntriesMutation(mut))));
+  }
+
+  _getServicePath(serviceXorName) {
+    let path = null;
+    return this.getPublicContainer()
+      .then((md) => md.getEntries()
+        .then((entries) => entries.forEach((key, val) => {
+          if (val.buf.equals(serviceXorName.buf)) {
+            path = key.toString();
           }
-          return Promise.reject();
-        });
-    });
-};
-
-const getContainerName = (mdataName) => {
-  let res = null;
-  return safe.auth.getContainer(accessContainers.public)
-    .then((mdata) => mdata.getEntries()
-      .then((entries) => entries.forEach((key, val) => {
-        if (val.buf.equals(mdataName.buf)) {
-          res = key.toString();
-        }
-      })))
-    .then(() => res);
-};
+        }))).then(() => path);
+  }
+}
+const safeApi = new SafeApi();
+export default safeApi;
diff --git a/web_hosting_manager/app/lib/constants.js b/web_hosting_manager/app/lib/constants.js
new file mode 100644
index 0000000..d282087
--- /dev/null
+++ b/web_hosting_manager/app/lib/constants.js
@@ -0,0 +1,53 @@
+import pkg from '../package.json';
+const CONSTANTS = {
+  TAG_TYPE: {
+    DNS: 15001,
+    WWW: 15002
+  },
+  KEY_TAR: {
+    SERVICE: 'WEB_HOST_MANAGER',
+    ACCOUNT: 'SAFE_USER'
+  },
+  APP_INFO: {
+    data: {
+      id: pkg.identifier,
+      scope: null,
+      name: pkg.name,
+      vendor: pkg.author.name
+    },
+    opt: {
+      own_container: false
+    },
+    permissions: {
+      _public: [
+        'Read',
+        'Insert',
+        'Update',
+        'Delete',
+        'ManagePermissions'
+      ],
+      _publicNames: [
+        'Read',
+        'Insert',
+        'Update',
+        'Delete',
+        'ManagePermissions'
+      ]
+    }
+  },
+  ACCESS_CONTAINERS: {
+    PUBLIC: '_public',
+    PUBLIC_NAMES: '_publicNames'
+  },
+  AUTH_RES_TYPE: {
+    CONTAINERS: 'containers',
+    REVOKED: 'revoked'
+  },
+  ERROR_CODE: {
+    SYMMETRIC_DECIPHER_FAILURE: -3,
+    NO_SUCH_ENTRY: -106,
+    ENTRY_EXISTS: -107
+  },
+  MAX_FILE_SIZE: 20 * 1024 * 1024
+};
+export default CONSTANTS;
diff --git a/web_hosting_manager/app/lib/tasks.js b/web_hosting_manager/app/lib/tasks.js
index b2ec813..90b4c77 100644
--- a/web_hosting_manager/app/lib/tasks.js
+++ b/web_hosting_manager/app/lib/tasks.js
@@ -1,7 +1,9 @@
 import path from 'path';
 import fs from 'fs';
 import { I18n } from 'react-redux-i18n';
-import { safe, TAG_TYPE_WWW, accessContainers } from './api';
+
+import safeApi from './api';
+import CONSTANTS from './constants';
 
 const parseContainerPath = (targetPath) => {
   if (!targetPath) {
@@ -31,20 +33,21 @@ export class FileUploadTask extends Task {
   }
 
   execute(callback) {
-    if (!safe) {
+    const app = safeApi.app;
+    if (!app) {
       return callback(new Error('App not registered'));
     }
     const containerPath = parseContainerPath(this.networkPath);
 
-    return safe.auth.getContainer(accessContainers.public)
-      .then((mdata) => mdata.encryptKey(containerPath.target).then((encKey) => mdata.get(encKey)).then((value) => mdata.decrypt(value.buf)))
-      .then((val) => safe.mutableData.newPublic(val, TAG_TYPE_WWW))
+    return safeApi.getPublicContainer()
+      .then((md) => safeApi.getMDataValueForKey(md, containerPath.target))
+      .then((val) => app.mutableData.newPublic(val, CONSTANTS.TAG_TYPE.WWW))
       .then((mdata) => {
         const nfs = mdata.emulateAs('NFS');
         return nfs.create(fs.readFileSync(this.localPath))
           .then((file) => nfs.insert(containerPath.file, file)
             .catch((err) => {
-              if (err.code === -106) {
+              if (err.code !== CONSTANTS.ERROR_CODE.ENTRY_EXISTS) {
                 return Promise.reject(err);
               }
               return mdata.get(containerPath.file)
@@ -64,4 +67,3 @@ export class FileUploadTask extends Task {
       .catch(callback);
   }
 }
-
diff --git a/web_hosting_manager/app/lib/utils.js b/web_hosting_manager/app/lib/utils.js
index 1c9fb44..a4b94e0 100644
--- a/web_hosting_manager/app/lib/utils.js
+++ b/web_hosting_manager/app/lib/utils.js
@@ -1,11 +1,27 @@
+import { shell } from 'electron';
+import keytar from 'keytar';
 import fs from 'fs';
 import path from 'path';
-import crypto from 'crypto';
 import { I18n } from 'react-redux-i18n';
 
 import * as Task from './tasks';
+import CONSTANTS from './constants';
 
-const MAX_FILE_SIZE = 20 * 1024 * 1024;
+class LocalAuthInfo {
+  constructor() {
+    this.SERVICE = CONSTANTS.KEY_TAR.SERVICE;
+    this.ACCOUNT = CONSTANTS.KEY_TAR.ACCOUNT;
+  }
+  save(info) {
+    return keytar.addPassword(this.SERVICE, this.ACCOUNT, JSON.stringify(info));
+  }
+  get() {
+    return keytar.getPassword(this.SERVICE, this.ACCOUNT);
+  }
+  clear() {
+    return keytar.deletePassword(this.SERVICE, this.ACCOUNT);
+  }
+}
 
 class TaskQueue {
 
@@ -49,6 +65,10 @@ export class DirStats {
   }
 }
 
+const parseUrl = (url) => (
+  (url.indexOf('safe-auth://') === -1) ? url.replace('safe-auth:', 'safe-auth://') : url
+);
+
 export const getDirectoryStats = (localPath) => {
   let stat;
   let tempStat;
@@ -68,8 +88,8 @@ export const getDirectoryStats = (localPath) => {
       stats.files += tempStat.files;
       stats.directories += tempStat.directories;
     } else {
-      if (stat.size > MAX_FILE_SIZE) {
-        throw new Error(I18n.t('messages.restrictedFileSize', { size: (MAX_FILE_SIZE / 1000000) }));
+      if (stat.size > CONSTANTS.MAX_FILE_SIZE) {
+        throw new Error(I18n.t('messages.restrictedFileSize', { size: (CONSTANTS.MAX_FILE_SIZE / 1000000) }));
       }
       stats.files += 1;
       stats.size += stat.size;
@@ -99,15 +119,8 @@ export const generateUploadTaskQueue = (localPath, networkPath, callback) => {
   return taskQueue;
 };
 
-export const strToPtrBuf = (str) => {
-  const buf = new Buffer(str);
-  return { ptr: buf, len: buf.length };
-};
-
-export const randomStr = () => (
-  crypto.randomBytes(50).toString('hex')
+export const openExternal = (url) => (
+  shell.openExternal(parseUrl(url))
 );
 
-export const parseUrl = (url) => (
-  (url.indexOf('safe-auth://') === -1) ? url.replace('safe-auth:', 'safe-auth://') : url
-);
+export const localAuthInfo = new LocalAuthInfo();
diff --git a/web_hosting_manager/app/locales/en.js b/web_hosting_manager/app/locales/en.js
index 010c1fd..aaef78d 100644
--- a/web_hosting_manager/app/locales/en.js
+++ b/web_hosting_manager/app/locales/en.js
@@ -54,6 +54,8 @@ const en = {
   messages: {
     emptyServiceName: 'Service name must be filled',
     emptyContainerName: 'Container name must be filled',
+    serviceNameInvalid: 'Service name must container only alphanumeric characters or - and should contain a min of 3 characters and a max of 62 characters',
+    publicNameInvalid: 'Public name must container only alphanumeric characters or - and should contain a min of 3 characters and a max of 62 characters',
     serviceNamePlaceholder: 'Enter Service Name',
     containerNamePlaceholder: 'Container Name. Eg, <service-name>-root',
     noContainerPlaceHolder: 'No Public Container Available',
diff --git a/web_hosting_manager/app/main.development.js b/web_hosting_manager/app/main.development.js
index fa0494e..3263c93 100644
--- a/web_hosting_manager/app/main.development.js
+++ b/web_hosting_manager/app/main.development.js
@@ -8,6 +8,11 @@ const sendResponse = (success) => {
   mainWindow.webContents.send('auth-response', success ? success : '');
 };
 
+const clearAccessData = () => {
+  mainWindow.webContents.send('clear-access-data', true);
+};
+
+
 if (process.env.NODE_ENV === 'production') {
   const sourceMapSupport = require('source-map-support'); // eslint-disable-line
   sourceMapSupport.install();
@@ -98,6 +103,11 @@ app.on('ready', async () => {
       submenu: [{
         label: 'About',
         selector: 'orderFrontStandardAboutPanel:'
+      }, {
+        label: '&Clear Access Data',
+        click() {
+          clearAccessData();
+        }
       }, {
         type: 'separator'
       }, {
diff --git a/web_hosting_manager/app/reducers/public_id.js b/web_hosting_manager/app/reducers/public_id.js
index b6a02f8..ca1cd3d 100644
--- a/web_hosting_manager/app/reducers/public_id.js
+++ b/web_hosting_manager/app/reducers/public_id.js
@@ -113,7 +113,7 @@ const publicId = (state: Object = initialState, action: Object) => {
     }
       break;
 
-    case `${ACTION_TYPES.FETCH_SERVICES}_FULFILLED`:
+    case `${ACTION_TYPES.CREATE_SERVICE}_FULFILLED`:
     {
       const publicNames = {};
       let pkey = null;
@@ -127,6 +127,21 @@ const publicId = (state: Object = initialState, action: Object) => {
     }
       break;
 
+    case `${ACTION_TYPES.FETCH_SERVICES}_FULFILLED`:
+    {
+      const publicNames = {};
+      let pkey = null;
+
+      for (pkey in action.payload) {
+        publicNames[pkey] = { ...action.payload[pkey] };
+      }
+      state = {
+        ...state,
+        publicNames
+      };
+    }
+      break;
+
     case `${ACTION_TYPES.REMAP_SERVICE}_FULFILLED`:
       const publicNames = {};
       let pkey = null;
@@ -138,6 +153,13 @@ const publicId = (state: Object = initialState, action: Object) => {
         publicNames
       };
       break;
+    case ACTION_TYPES.CLEAR_NOTIFICATION:
+      state = {
+        ...state,
+        creatingPublicId: false,
+        error: undefined
+      };
+      break;
   }
   return state;
 };
diff --git a/web_hosting_manager/app/reducers/service.js b/web_hosting_manager/app/reducers/service.js
index f175418..c851fb0 100644
--- a/web_hosting_manager/app/reducers/service.js
+++ b/web_hosting_manager/app/reducers/service.js
@@ -118,7 +118,8 @@ const service = (state: Object = initialState, action: Object) => {
     case ACTION_TYPES.CLEAR_NOTIFICATION:
       state = {
         ...state,
-        error: undefined
+        error: undefined,
+        remapping: false
       };
       break;
   }
diff --git a/web_hosting_manager/app/styles/app.css b/web_hosting_manager/app/styles/app.css
index d53c786..ee40164 100644
--- a/web_hosting_manager/app/styles/app.css
+++ b/web_hosting_manager/app/styles/app.css
@@ -7,6 +7,10 @@ body {
   padding: 0;
   margin: 0;
   background-color: #f4f4f4;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
 }
 
 #root, #root > div {
@@ -117,10 +121,14 @@ nav {
 
 .error-msg {
   color: #e26464;
-  line-height: 30px;
+  line-height: normal;
   min-height: 20px;
 }
 
+.error-msg.withMar {
+  margin: 5px 0;
+}
+
 .service-link {
   margin: 0 0 20px 0;
 }
@@ -173,6 +181,10 @@ nav {
   width: 100% !important;
 }
 
+.create-service-input .error-msg {
+  padding-top: 5px;
+}
+
 .split-cntr {
   position: relative;
 }
@@ -204,9 +216,13 @@ nav {
   font-weight: normal;
 }
 
+.split-cntr-i .error-msg {
+  margin: 5px 0;
+}
+
 .split-cntr-i .ant-select, .split-cntr-i .ant-input-wrapper {
   width: 80%;
-  margin: 0 auto 20px;
+  margin: 0 auto 30px;
   display: inline-block;
 }
 
@@ -284,7 +300,7 @@ nav {
 }
 
 .custom-card .ant-card-body .ant-input-wrapper {
-  margin-bottom: 16px;
+  margin-bottom: 0;
 }
 
 .explorer {
diff --git a/web_hosting_manager/app/utils/app_utils.js b/web_hosting_manager/app/utils/app_utils.js
index e9d62b8..b5c385d 100644
--- a/web_hosting_manager/app/utils/app_utils.js
+++ b/web_hosting_manager/app/utils/app_utils.js
@@ -3,3 +3,8 @@ export const trimErrorMsg = (msg) => {
   index = (index === -1) ? 0 : index + 2;
   return msg.slice(index).trim()
 };
+
+export const domainCheck = (str) => {
+  const regex = /^[a-z0-9][a-z0-9-]{1,60}[a-z0-9](?:)+$/;
+  return regex.test(str);
+};