diff --git a/keeperapi/src/browser/platform.ts b/keeperapi/src/browser/platform.ts
index c3a00dfa..1d6d42b2 100644
--- a/keeperapi/src/browser/platform.ts
+++ b/keeperapi/src/browser/platform.ts
@@ -96,7 +96,8 @@ export const browserPlatform: Platform = class {
             if (storage.saveObject) {
                 await storage.saveObject(this.getStorageKeyId(keyId, 'cbc'), cbcKey)
                 await storage.saveObject(this.getStorageKeyId(keyId, 'gcm'), gcmKey)
-            } else {
+            }
+            if (extractable && storage.saveKeyBytes) {
                 await storage.saveKeyBytes(keyId, key)
             }
         }
@@ -106,7 +107,8 @@ export const browserPlatform: Platform = class {
         keyId: string,
         privateKey: Uint8Array,
         publicKey: Uint8Array,
-        storage?: KeyStorage
+        storage?: KeyStorage,
+        canExport?: boolean
     ): Promise<void> {
         const key = await this.importPrivateKeyEC(privateKey, publicKey)
         cryptoKeysCache['ecc'][keyId] = key
@@ -114,7 +116,8 @@ export const browserPlatform: Platform = class {
         if (storage) {
             if (storage.saveObject) {
                 await storage.saveObject(this.getStorageKeyId(keyId, 'ecc'), key)
-            } else {
+            }
+            if (canExport && storage.saveKeyBytes) {
                 const jwk = await crypto.subtle.exportKey('jwk', key)
                 const keyBytes = this.stringToBytes(JSON.stringify(jwk))
                 await storage.saveKeyBytes(keyId, keyBytes)
@@ -168,10 +171,9 @@ export const browserPlatform: Platform = class {
         if (storage?.getObject) {
             const storageKeyId = this.getStorageKeyId(keyId, keyType)
             const storedKey = await storage.getObject<CryptoKey>(storageKeyId)
-            if (!storedKey) {
-                throw new Error('Unable to load crypto key ' + keyId)
+            if (storedKey) {
+                return storedKey
             }
-            return storedKey
         }
 
         const keyBytes = await this.loadKeyBytes(keyId, storage)
@@ -298,7 +300,7 @@ export const browserPlatform: Platform = class {
                 break
             // TODO: add something like this, need to find pub/priv key pair
             case 'ecc':
-                if (cryptoKeysCache['gcm'][keyId]) {
+                if (cryptoKeysCache['ecc'][keyId]) {
                     return
                 }
 
@@ -394,7 +396,8 @@ export const browserPlatform: Platform = class {
             if (storage.saveObject) {
                 await storage.saveObject(this.getStorageKeyId(keyId, 'cbc'), cbcKey)
                 await storage.saveObject(this.getStorageKeyId(keyId, 'gcm'), gcmKey)
-            } else {
+            }
+            if (canExtract && storage.saveKeyBytes) {
                 const keyBuffer = await crypto.subtle.exportKey('raw', gcmKey)
                 await storage.saveKeyBytes(keyId, new Uint8Array(keyBuffer))
             }
diff --git a/keeperapi/src/commands.ts b/keeperapi/src/commands.ts
index 6e566b34..ba50ba08 100644
--- a/keeperapi/src/commands.ts
+++ b/keeperapi/src/commands.ts
@@ -211,6 +211,25 @@ export const enterpriseAllocateIdsCommand = (
 ): RestCommand<EnterpriseAllocateIdsRequest, KeeperResponse & { base_id: number; number_allocated: number }> =>
     createCommand(request, 'enterprise_allocate_ids')
 
+export type NodeEditRequest = {
+    node_id: number
+    parent_id?: number
+    encrypted_data: string
+}
+
+export const nodeAddCommand = (request: NodeEditRequest): RestCommand<NodeEditRequest, KeeperResponse> =>
+    createCommand(request, 'node_add')
+
+export const nodeUpdateCommand = (request: NodeEditRequest): RestCommand<NodeEditRequest, KeeperResponse> =>
+    createCommand(request, 'node_update')
+
+export type NodeDeleteRequest = {
+    node_id: number
+}
+
+export const nodeDeleteCommand = (request: NodeDeleteRequest): RestCommand<NodeDeleteRequest, KeeperResponse> =>
+    createCommand(request, 'node_delete')
+
 export type RoleEditRequest = {
     role_id: number
     node_id: number
@@ -232,6 +251,114 @@ export type RoleDeleteRequest = {
 export const roleDeleteCommand = (request: RoleDeleteRequest): RestCommand<RoleDeleteRequest, KeeperResponse> =>
     createCommand(request, 'role_delete')
 
+export type RoleUserAddRequest = {
+    role_id: number
+    enterprise_user_id: number
+    tree_key?: string
+    tree_key_type?: string | number
+    role_admin_key?: string
+    role_admin_key_type?: string | number
+}
+
+export const roleUserAddCommand = (request: RoleUserAddRequest): RestCommand<RoleUserAddRequest, KeeperResponse> =>
+    createCommand(request, 'role_user_add')
+
+export type RoleUserRemoveRequest = {
+    role_id: number
+    enterprise_user_id: number
+}
+
+export const roleUserRemoveCommand = (
+    request: RoleUserRemoveRequest
+): RestCommand<RoleUserRemoveRequest, KeeperResponse> => createCommand(request, 'role_user_remove')
+
+export type RoleManagedNodeTreeKey = {
+    enterprise_user_id: number
+    tree_key: string
+    tree_key_type?: string | number
+}
+
+export type RoleManagedNodeAddResponse = KeeperResponse & {
+    missing_tree_keys?: Record<string, string>
+    missing_ecc_tree_keys?: Record<string, string>
+}
+
+export type RoleManagedNodeAddRequest = {
+    role_id: number
+    managed_node_id: number
+    cascade_node_management: boolean
+    tree_keys?: RoleManagedNodeTreeKey[]
+}
+
+export const roleManagedNodeAddCommand = (
+    request: RoleManagedNodeAddRequest
+): RestCommand<RoleManagedNodeAddRequest, RoleManagedNodeAddResponse> => createCommand(request, 'role_managed_node_add')
+
+export type RoleManagedNodeUpdateRequest = {
+    role_id: number
+    managed_node_id: number
+    cascade_node_management?: boolean
+}
+
+export const roleManagedNodeUpdateCommand = (
+    request: RoleManagedNodeUpdateRequest
+): RestCommand<RoleManagedNodeUpdateRequest, KeeperResponse> => createCommand(request, 'role_managed_node_update')
+
+export type RoleManagedNodeRemoveRequest = {
+    role_id: number
+    managed_node_id: number
+}
+
+export const roleManagedNodeRemoveCommand = (
+    request: RoleManagedNodeRemoveRequest
+): RestCommand<RoleManagedNodeRemoveRequest, KeeperResponse> => createCommand(request, 'role_managed_node_remove')
+
+export type ManagedNodeRoleKey = {
+    enterprise_user_id: number
+    role_key: string
+    tree_key_type?: string | number
+}
+
+export type ManagedNodeMspKey = {
+    mc_enterprise_id: number
+    tree_key: string
+}
+
+export type ManagedNodePrivilegeAddRequest = {
+    role_id: number
+    managed_node_id: number
+    privilege: string
+    role_key_enc_with_tree_key?: string
+    role_public_key?: string
+    role_private_key?: string
+    role_keys?: ManagedNodeRoleKey[]
+    msp_keys?: ManagedNodeMspKey[]
+}
+
+export type ManagedNodePrivilegeAddResponse = KeeperResponse & {
+    status?: {
+        missing_keys?: Record<string, string>
+        invalid_users?: number[]
+        cant_be_pending?: number[]
+    }
+}
+
+export const managedNodePrivilegeAddCommand = (
+    request: ManagedNodePrivilegeAddRequest
+): RestCommand<ManagedNodePrivilegeAddRequest, ManagedNodePrivilegeAddResponse> =>
+    createCommand(request, 'managed_node_privilege_add')
+
+export type ManagedNodePrivilegeRemoveRequest = {
+    role_id: number
+    managed_node_id: number
+    privilege: string
+}
+
+export const managedNodePrivilegeRemoveCommand = (
+    request: ManagedNodePrivilegeRemoveRequest
+): RestCommand<ManagedNodePrivilegeRemoveRequest, KeeperResponse> =>
+    createCommand(request, 'managed_node_privilege_remove')
+
 export type MoveRequest = {
     to_type: 'user_folder' | 'shared_folder' | 'shared_folder_folder'
     to_uid?: string
@@ -379,6 +506,16 @@ export const teamEnterpriseUserRemoveCommand = (
     request: TeamUserCommandRequest
 ): RestCommand<TeamUserCommandRequest, KeeperResponse> => createCommand(request, 'team_enterprise_user_remove')
 
+export type TeamEnterpriseUserUpdateRequest = {
+    team_uid: string
+    enterprise_user_id: number
+    user_type: number
+}
+
+export const teamEnterpriseUserUpdateCommand = (
+    request: TeamEnterpriseUserUpdateRequest
+): RestCommand<TeamEnterpriseUserUpdateRequest, KeeperResponse> => createCommand(request, 'team_enterprise_user_update')
+
 export type TeamGetKeysRequest = {
     teams: string[]
 }
diff --git a/keeperapi/src/restMessages.ts b/keeperapi/src/restMessages.ts
index e8301747..7fbd629d 100644
--- a/keeperapi/src/restMessages.ts
+++ b/keeperapi/src/restMessages.ts
@@ -640,6 +640,11 @@ export const enterpriseUsersLockMessage = (
 ): RestMessage<Enterprise.ILockUsersRequest, Enterprise.ILockUsersResponse> =>
     createMessage(data, 'enterprise/enterprise_users_lock', Enterprise.LockUsersRequest, Enterprise.LockUsersResponse)
 
+export const disableTwoFaMessage = (
+    data: Enterprise.IEnterpriseUserIds
+): RestInMessage<Enterprise.IEnterpriseUserIds> =>
+    createInMessage(data, 'enterprise/disable_two_fa', Enterprise.EnterpriseUserIds)
+
 export const setV2AlternatePasswordMessage = (
     data: Authentication.IUserAuthRequest
 ): RestInMessage<Authentication.IUserAuthRequest> =>