diff --git a/index.html b/index.html
index d2ed49c..a9117d5 100644
--- a/index.html
+++ b/index.html
@@ -42,13 +42,15 @@ <h1><a href="https://github.com/syntaxseed/terminalfaker">Terminal Faker Demo</a
         </p>
     </div>
 
-    <script src="js/bundle.min.js"></script>
-    <!-- The above minified bundle contains:-->
-    <!-- <script src="js/src/terminal.js"></script>
+
+    <!-- <script src="js/bundle.min.js"></script> -->
+    <!-- The above minified bundle contains: -->
+    <script src="js/filesystem.js"></script>
+    <script src="js/src/cmdUtilities.js"></script>
+    <script src="js/src/terminal.js"></script>
     <script src="js/src/boot.js"></script>
     <script src="js/src/crypto.js"></script>
-    <script src="js/src/system.js"></script>-->
-    <script src="js/filesystem.js"></script>
+    <script src="js/src/system.js"></script>
     <script src="js/commands.js"></script>
 
     <script>
diff --git a/js/filesystem.js b/js/filesystem.js
index 8a70871..28427e8 100644
--- a/js/filesystem.js
+++ b/js/filesystem.js
@@ -1,44 +1,458 @@
+const FS_UNIT_TYPE = {
+  FILE: 'f',
+  DIR: 'd',
+  LINK: 'ln'
+};
+
+const FS_ROOT_NAME = ':';
+
+/**
+ * Generic class for file system objects
+ * 
+ * @param {String} name 
+ * @param {String} type From FS_UNIT_TYPE enum 
+ */
+class FsUnit {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+    this.access = '';
+    this.lastMod = Date.now()
+    this._content = {};
+    this._size = 0;
+  }
+ 
+  get content() {
+    return this._content;
+  }
+
+  /**
+   * Content size in bytes
+   * 
+   * @returns {Number}
+   */
+  get size() {
+    return this._size;
+  }
+
+  /**
+   * @returns {String[]}
+   */
+  get path() {
+    let current = this;
+    const path = [];
+    if (current.name !== FS_ROOT_NAME) {
+      do {
+        path.push(current.name);
+        current = current.parentDir;    
+      } while (current.name !== FS_ROOT_NAME);
+    }
+    return path.reverse();
+  }
+
+  /**
+   * Set link to parent FsUnit Object
+   * 
+   * @param {FsUnit} parentDir
+   */
+  set parentDir(parentDir) {
+    if (parentDir.type !== FS_UNIT_TYPE.DIR) {
+      throw new Error('Parent should be FsDir!');
+    }
+    this._parent = parentDir;
+  }
+
+  /**
+   * Link to parent FsUnit Object
+   * 
+   * @returns {FsUnit} parentDir
+   */
+  get parentDir() {
+    return this._parent;
+  }
+
+  /**
+   * @returns {Boolean}
+   */
+  isFile() {
+    return this.type === FS_UNIT_TYPE.FILE;
+  }
+
+  /**
+   * @returns {Boolean}
+   */
+  isDir() {
+    return this.type === FS_UNIT_TYPE.DIR;
+  }
+}
+
+/**
+ * File
+ * 
+ * @param {String} name
+ * @param {String} content
+ */
+class FsFile extends FsUnit {
+  constructor(name, content) {
+    super(name, FS_UNIT_TYPE.FILE);
+    this._checkContent(content);
+    this._content = content;
+    this._setSize(content);
+    this._parent = undefined;
+  }
+
+  /**
+   * Set file content. recalculate size
+   * 
+   * @param {String} content 
+   */
+  update(content) {
+    this._checkContent(content);
+    this._content = content;
+    this._setSize(content);
+  }
+
+  /**
+   * Check is content is string
+   * 
+   * @param {String} content 
+   */
+  _checkContent(content) {
+    if (typeof content !== 'string') {
+      throw new Error('Invalid file content');
+    }
+  }
+
+  /**
+   * Set content byte size
+   * 
+   * @param {String} content 
+   */
+  _setSize(content) {    
+    if (Blob) {
+      this._size = new Blob([content]).size;
+    } else {
+      this._size = Buffer.byteLength(content, 'utf-8');
+    }
+  }
+}
+
+/**
+ * Directory. Has a Map structure under the hood
+ * 
+ * @param {String} name
+ */
+class FsDir extends FsUnit {
+  constructor(name) {
+    super(name, FS_UNIT_TYPE.DIR);
+    this._content = new Map();
+    this._parent = this;
+  }
+
+  /**
+   * Add file or dir into directory
+   * 
+   * @param {FsUnit} fsUnit 
+   */
+  add(fsUnit) {
+    return this.update(fsUnit);
+  }
+
+  /**
+   * Add file or dir into directory
+   * 
+   * @param {FsUnit} fsUnit 
+   * @returns {FsUnit}
+   */
+  update(fsUnit) {
+    fsUnit.parentDir = this;
+    
+    this._content.set(fsUnit.name, fsUnit);
+    return fsUnit;
+  }
+
+  /**
+   * Delete directory content
+   * 
+   * @param {FsUnit} fsUnit 
+   * @returns {Boolean}
+   */
+  remove(fsUnit) {
+    this._content.delete(fsUnit.name);
+    return true;
+  }
+
+  /**
+   * Get directory content as list
+   * 
+   * @returns {FsUnit[]}
+   */
+  get content() {
+    const dirContent = [];
+    for (const [key] of this._content) {
+      dirContent.push(this._content.get(key));    
+    }  
+    return dirContent;
+  }
+
+  /**
+   * Get directory byte size.
+   * Calculate overallsize of every element of dir
+   * 
+   * @returns {Number}
+   */
+  get size() {
+    let overallSize = 0;
+    this.content.forEach(it => {
+      overallSize += it.size
+    });
+    return overallSize;
+  }
+
+  /**
+   * Get directory element by name
+   * 
+   * @param {String} name Name of file or dir
+   * @returns {FsUnit|undefined}
+   */
+  get(name) {
+    return this._content.get(name);
+  }
+}
+
+/**
+ * File system management. Contain current user pointer.
+ * Creates root directory
+ * TODO: Add restore method, that will allow to recreate fs from plain object
+ * TOOD: Add toPlain method
+ * With such methods we could be able to store fs in user storage
+ */
+class FileSystem {
+  constructor() {
+    this.root = new FsDir(FS_ROOT_NAME);
+    this.pointer = this.root;
+  }
+
+  /**
+   * Change pointer to passed directory
+   * TODO: Fix exception throwing
+   * 
+   * @param {String[]} pathTo 
+   */
+  cd(pathTo) {
+    const unit = this.get(pathTo);
+    if (!unit) {
+      throw new Error('Invalid path');
+    }
+    if (unit.type != FS_UNIT_TYPE.DIR) {
+      throw new Error(`${pathTo} is not a directory`);
+    }
+    this.pointer = unit;
+  }
+
+  /**
+   * Get formatted path according to pointer
+   * 
+   * @returns {String}
+   */
+  pwd() {
+    let current = this.pointer;
+    
+    if (current === this.root) {
+      return '/';
+    } else {
+      const path = [];
+      do {
+        path.push(current.name)
+        current = current.parentDir;
+      } while (current !== this.root);
+      return `/${path.reverse().join('/')}`;
+    }
+  }
+
+  /**
+   * Get root dir content
+   * 
+   * @returns {FsUnit[]}
+   */
+  get content() {
+    return this.root.content;
+  }
+
+  /**
+   * Get byte size of root dir
+   * 
+   * @returns {Number}
+   */
+  get size() {
+    return this.root.size;
+  }
+
+  /**
+   * Create new dir or file in passed location.
+   * Check if location exists
+   * TODO: Fix exceptions
+   * 
+   * @param {FsUnit} fsUnit
+   * @param {String[]} fsUnitPath  Full path to fsUnit. Should not contain new unit name
+   * @returns {FsUnit} 
+   */
+  add(fsUnit, fsUnitPath) {
+    if (fsUnitPath.length > 1) {
+      if (fsUnit.name !== fsUnitPath[fsUnitPath - 1]) {
+        throw new Error('Last element of path should contain fs unit name');
+      }
+      const parentUnit = this.get(fsUnitPath.slice(0, -1));
+      if (!parentUnit) {
+        throw new Error('Unit not exists');
+      }
+      if (parentUnit.type !== FS_UNIT_TYPE.DIR) {
+        throw new Error('Should be directory');
+      }
+      fsUnit.parentDir = parentUnit;
+      parentUnit.update(fsUnit);
+    } else {
+      fsUnit.parentDir = this.root;
+      this.root.update(fsUnit);
+    }
+    return fsUnit;
+  }
+
+  // TODO: implement removal method
+  remove(fsUnit) {
+    if (fsUnitPath.length > 1) {
+
+    } else {
+      fsUnit.parentDir = this.root;
+      this.root.remove(fsUnit);
+    }
+  }
+
+  /**
+   * Get file or dir by full path
+   * 
+   * @param {String[]} fsUnitPath 
+   * @returns {FsUnit|undefined}
+   */
+  get(fsUnitPath) {
+    if (fsUnitPath.length >= 1) {
+      let unit = undefined;
+      let unitPosition = 0;
+      do {
+        if (unitPosition == 0) {
+          unit = this.root.get(fsUnitPath[unitPosition]);
+        } else if (unit.type == FS_UNIT_TYPE.DIR) {
+          unit = unit.get(fsUnitPath[unitPosition]);
+        }
+        unitPosition++;
+      } while(unitPosition < fsUnitPath.length && unit);
+      return unit;
+    } else {
+      return this.root;
+    }
+  }
+}
+
+// Here we create initial file system structure
+var myFs = new FileSystem();
+
+myFs
+  .add(new FsDir('.tmp-dir'), [])
+
+myFs
+  .add(new FsFile('.hidden', 'There is a hidden file.'), []);
+
+myFs
+  .add(new FsDir('docs'), [])
+
+myFs
+  .get(['docs'])
+  .add(new FsFile('moretodo.txt', 'A, B, C.'))
+
+myFs
+  .get(['docs'])
+  .add(new FsFile('ok.txt', 'I am ok.'))
+
+myFs
+  .get(['docs'])
+  .add(new FsFile(
+    'shoplist.txt', 
+      `-Apples\n-Bananas\n-Cookies`
+      )
+    );
+
+myFs
+  .get(['docs'])
+  .add(new FsDir('private'))
+
+myFs
+  .get(['docs', 'private'])
+  .add(new FsFile('secret.txt', 'PxNmGkl6M+jDP4AYAKZET18SEnWD5qw5LIP9174lONWslF144K9VHFIk1JA='))
+
+myFs
+  .get(['docs', 'private'])
+  .add(new FsDir('opt'))
+
+myFs
+  .get(['docs'])
+  .add(new FsDir('tmp'))
+
+myFs
+  .add(new FsDir('more'), [])
+  .add(new FsFile('moretodo.txt', `Don't forget this other stuff.`))
+
+myFs
+  .add(new FsDir('stuff'), [])
+
+myFs
+  .add(new FsFile('cool.txt', 'There is a hidden command in this terminal called \'secret\'.'), []);
+
+
+/**
+ * Convert FsUnit object into xml format
+ * 
+ * @param {FsUnit} fsUnit 
+ * @returns {String}
+ */
+function fsUnitToXML(fsUnit) {
+  if (fsUnit.type == FS_UNIT_TYPE.FILE) {
+    const filePath = fsUnit.path.slice(0, -1);
+    const renderedPath = filePath.length ?
+    `/${filePath.join('/')}/` :
+    `/`
+    return `
+      <f name='${fsUnit.name}' path='${renderedPath}'>
+        <contents>${fsUnit.content}</contents>
+      </f>
+    `;
+
+  } else if (fsUnit.type == FS_UNIT_TYPE.DIR) {
+    // Recursevly process directory element
+    return `
+      <d name='${fsUnit.name}' path='/${fsUnit.path.join('/')}/'>
+        <c>
+          ${fsUnit.content.map(it => fsUnitToXML(it)).join('\n')}
+        </c>
+      </d>
+    `;
+  }
+}
+
 /**
- * The initial state of the filesystem in XML format.
- * As users make changes the new filesystem is stored in local storage.
- * Reset to this initial state with the reboot command.
+ * Convert whole file system into xml
+ * 
+ * @param {FileSystem} fs
+ * @returns {String} 
  */
+function fsToXML(fs) {
+  return `
+    <d name='/' path='/'>
+      <c>
+        ${fs.content.map(it => fsUnitToXML(it)).join('\n')}
+      </c>
+    </d>
+  `
+}
 
-var originalFilesystem="<d name='/' path='/'>\
-            <c>\
-            <d name='docs' path='/docs/'>\
-                <c>\
-                    <d name='private' path='/docs/private/'>\
-                        <c>\
-                            <f name='secret.txt' path='/docs/private/'>\
-                                <contents>PxNmGkl6M+jDP4AYAKZET18SEnWD5qw5LIP9174lONWslF144K9VHFIk1JA=</contents>\
-                            </f>\
-                        </c>\
-                    </d>\
-                    <f name='shoplist.txt' path='/docs/'>\
-                        <contents>-Apples\n-Bananas\n-Cookies</contents>\
-                    </f>\
-                    <f name='ok.txt' path='/docs/'>\
-                        <contents>I am ok.</contents>\
-                    </f>\
-                    <f name='moretodo.txt' path='/docs/'>\
-                        <contents>A, B, C.</contents>\
-                    </f>\
-                </c>\
-            </d>\
-            <d name='more' path='/more/'>\
-                <c>\
-                    <f name='moretodo.txt' path='/more/'>\
-                        <contents>Don't forget this other stuff.</contents>\
-                    </f>\
-                </c>\
-            </d>\
-            <d name='stuff' path='/stuff/'>\
-                <c>\
-                </c>\
-            </d>\
-            <f name='cool.txt' path='/'>\
-                <contents>There is a hidden command in this terminal called 'secret'.</contents>\
-            </f>\
-            </c>\
-        </d>";
+// Creation of initial fs in xml
+var originalFilesystem = fsToXML(myFs);
diff --git a/js/src/cmdUtilities.js b/js/src/cmdUtilities.js
new file mode 100644
index 0000000..2e7febf
--- /dev/null
+++ b/js/src/cmdUtilities.js
@@ -0,0 +1,121 @@
+class TerminalUtilities {
+  /**
+   * Function parsing path for commands like: cmd [flags] [path]
+   * Parse absolute and relative paths. If relative - takes current dir
+   * and resolves with '..' notation
+   * 
+   * @param {String[]} args Args in format ['cmd', 'flag1', 'flag2', 'path']
+   * @returns {Object} root
+   * @returns {FsUnit} [root.listingUnit] Dir or File
+   * @returns {String} root.path
+   */
+  static getFsUnit(args) {
+    let listingUnit = term.tmp_fs.pointer;
+    const path = args.slice(1).filter(it => it.indexOf('-') !== 0)[0] || '.'; 
+    if (args.length > 1) {
+        if (path !== '.') {
+            const preparedPath = TerminalUtilities.createFullPath(path);
+            listingUnit = term.tmp_fs.get(preparedPath);
+            if (!listingUnit) {
+                return {
+                    path
+                };
+            }
+        }
+    }
+    return {
+        listingUnit,
+        path
+    };
+  }
+
+  /**
+   * Create absolute path from passed param. Param could be
+   * relative or absolute path
+   * 
+   * @param {String} path Path to filesistem unit in unix format
+   * @returns {String[]}
+   */
+  static createFullPath(pathToUnit) {
+    const startDir = pathToUnit.indexOf('/') === 0 ? 
+      '/' : 
+      term.tmp_fs.pwd();
+    return term.pathMgr.resolveToArray(startDir, pathToUnit);
+  }
+
+ /**
+  * Take every element from arg array with dash '-',
+  * remove duplicates and invalid flags
+  * 
+  * @param {String[]} args In format ['ls', '-la', '/'] 
+  * @param {String[]} supportedFlagsList Such as ['a', 'l]
+  * @returns {Set}
+  */
+  static parseFlags(args, supportedFlagsList) {
+    return new Set(
+        args
+        .filter(option => option.indexOf('-') === 0)
+        .map(option => option.replace('-', ''))
+        .join('')
+        .split('')
+        .filter(option => supportedFlagsList.includes(option))
+    );
+  }
+
+
+ /**
+  * Format date to DD MMM HH:mm
+  * 
+  * @param {Date} date Js Date type
+  * @returns {String}
+  */
+  static formatDate(date) {
+    const [
+        _weekDay,
+        day,
+        mon,
+        _year,
+        time
+    ] = date.toUTCString().split(' ');
+    return [day, mon, time.split(':').slice(0, -1).join(':')].join(' ');
+  }
+
+ /**
+  * Render for ls -l flag
+  * 
+  * @param {FsUnit} fsUnit File, Dir or Link
+  * @returns {String}
+  */
+  static lsRenderFullLine(fsUnit) {
+    const unitType = fsUnit.isFile() ? '-' : 'd';
+    return `<span>${unitType}rw-r--r--</span>&nbsp;&nbsp;` +
+        `<span>11</span>&nbsp;&nbsp;` +
+        `<span>guest</span>&nbsp;&nbsp;` +
+        `<span>guest</span>&nbsp;&nbsp;` +
+        `<span>${fsUnit.size}</span>&nbsp;&nbsp;` +
+        `<span>${TerminalUtilities.formatDate(new Date(fsUnit.lastMod))}</span>&nbsp;&nbsp;` +
+        `<span class='filesystem-${fsUnit.type}'>${fsUnit.name}</span>`;
+  }
+
+ /**
+  * Render for default ls
+  * 
+  * @param {FsUnit} fsUnit File, Dir or Link
+  * @returns {String}
+  */
+  static lsRenderOneLine(fsUnit) {
+    return `<span class='filesystem-${fsUnit.type}'>${fsUnit.name}</span>`;
+  }
+}
+
+
+class CmdValidationError extends Error {
+  /**
+   * @param {String} cmd Command name 
+   * @param {String} msg Error msg
+   */
+  constructor(cmd, msg) {
+      super(`${cmd}: ${msg}`);
+      this.type = 'CmdValidationError';
+  }
+}
diff --git a/js/src/system.js b/js/src/system.js
index a2ade2f..6cd131b 100644
--- a/js/src/system.js
+++ b/js/src/system.js
@@ -8,15 +8,17 @@ var builtInCommands = {};
 builtInCommands.cat = {
     about: "cat [file]<br>&nbsp;&nbsp;Display the contents of the specified file.",
     exe: function (args) {
+
         if(args.length != 2){
-            return "No such file.";
+            throw new CmdValidationError('cat', "No such file.");
         }
-        var result = term.catFile(args[1]);
-        if(result === false){
-            return "No such file, or argument is a directory.";
+        const { listingUnit, path } = TerminalUtilities.getFsUnit(args);
+
+        if (!listingUnit || (listingUnit && !listingUnit.isFile())) {
+            throw new CmdValidationError('cat', `${path}: No such file, or argument is a directory.`);
         }
-        result = (result + '').replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, '$1' + '<br>' + '$2');
-        return result;
+        const content = listingUnit.content || '';
+        return content.replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, '$1' + '<br>' + '$2');
     }
 }
 
@@ -134,19 +136,31 @@ builtInCommands.history = {
  **/
 builtInCommands.ls = {
     about: "ls [-l]<br>&nbsp;&nbsp;List directory contents.<br>&nbsp;&nbsp;-l list contents vertically.",
-    exe: function (args) {
-        var listing = "";
-        var children = Array.prototype.slice.call(term.filesystemPointer.querySelector('c').children);
-        children.forEach(function(element, index){
-            listing += "<span class='filesystem-"+element.nodeName+"'>"+element.getAttribute('name')+"</span>";
-            if( args[1] && args[1] == "-l"){
-                listing += "<br>";
-            }else{
-                listing += "&nbsp;&nbsp;";
-            }
-        });
+    exe: (args) => {
+        // TOOD: Add to constant
+        const supportedFlagsList = ['a', 'l'];
+        const { listingUnit, path } = TerminalUtilities.getFsUnit(args);
+        if (!listingUnit) {
+            throw new CmdValidationError('ls', `${path}: No such file or directory`);
+        }
+        const flagList = TerminalUtilities.parseFlags(args, supportedFlagsList)
+        
+        switch (listingUnit.type) {
+            case FS_UNIT_TYPE.FILE:
+                return flagList.has('l') ? 
+                    [TerminalUtilities.lsRenderFullLine(listingUnit)].join('<br>') :
+                    [TerminalUtilities.lsRenderOneLine(listingUnit)].join('<br>');
+            case FS_UNIT_TYPE.DIR: 
+                const dirContent = flagList.has('a') ?
+                    listingUnit.content :
+                    listingUnit.content.filter(it => it.name[0] !== '.');
 
-        return listing;
+                return flagList.has('l') ?
+                    dirContent.map(fsUnit => TerminalUtilities.lsRenderFullLine(fsUnit)).join('<br>') :
+                    dirContent.map(fsUnit => TerminalUtilities.lsRenderOneLine(fsUnit)).join('&nbsp;&nbsp;'); 
+            default:
+                return ''
+        }
     }
 }
 
@@ -156,7 +170,7 @@ builtInCommands.ls = {
 builtInCommands.pwd = {
     about: "pwd<br>&nbsp;&nbsp;Print the name of the current working directory.",
     exe: function () {
-        return term.path
+        return term.tmp_fs.pwd();
     }
 }
 
@@ -179,20 +193,36 @@ builtInCommands.reboot = {
 
 /**
  * Delete a file with the given name.
+ * TODO: Check if error messages are rigth
  **/
 builtInCommands.rm = {
     about: "rm [name]<br>&nbsp;&nbsp;Delete the file with the specified name in the current directory.",
     exe: function (args) {
         if(args.length == 1){
-            return "No filename specified.";
+            throw new CmdValidationError('rm', "No filename specified.");
         }
         if(args.length > 2){
-            return "Too many parameters supplied.";
+            throw new CmdValidationError('rm', "Too many parameters supplied.");
         }
-        var result = term.deleteFile(args[1]);
-        if(result !== true){
-            return result;
+        const { listingUnit, path } = TerminalUtilities.getFsUnit(args);
+        if (!listingUnit) {
+            throw new CmdValidationError('rm', `${path}: No such file, or directory.`);
         }
+        const preparedPath = path.split('/').filter(it => it.length);
+        const targetUnit = term.tmp_fs.get(preparedPath);
+
+        // TODO: Add flag support here 
+        if (targetUnit.name === FS_ROOT_NAME) {
+            throw new CmdValidationError('rm', `${path}: Unable to remove root catalogue`);
+        }
+        if (targetUnit.isDir()) {
+            throw new CmdValidationError('rm', `${path}: Unable to remove directory.`);
+        }
+        
+        targetUnit
+            .parentDir
+            .remove(targetUnit)
+            
         return "";
     }
 }
@@ -204,15 +234,32 @@ builtInCommands.touch = {
     about: "touch [name]<br>&nbsp;&nbsp;Create a file with the specified name in the current directory.",
     exe: function (args) {
         if(args.length == 1){
-            return "No filename specified.";
+            throw new CmdValidationError('touch', "No filename specified.");
         }
+
         if(args.length > 2){
-            return "Too many parameters supplied.";
+            throw new CmdValidationError('touch', "Too many parameters supplied.");
         }
-        var result = term.makeFile(args[1]);
-        if(result !== true){
-            return result;
+
+        const { listingUnit, path } = TerminalUtilities.getFsUnit(args);
+        
+        const preparedPath = TerminalUtilities.createFullPath(path);
+        const newFileName = preparedPath.pop();
+        
+        if (!term.pathMgr.isValidFilename(newFileName)) {
+            throw new CmdValidationError('touch', `${path}: Invalid file name.`);
+        }
+        if (listingUnit && listingUnit.isDir()) {
+            throw new CmdValidationError('touch', `${path}: Unable to create directory.`);
         }
+        if (listingUnit && listingUnit.isFile()) {
+            throw new CmdValidationError('touch', `${path}: File already exists.`);
+        }
+        
+        term.tmp_fs
+            .get(preparedPath)
+            .add(new FsFile(newFileName, ""));
+
         return "";
     }
 }
diff --git a/js/src/terminal.js b/js/src/terminal.js
index 355fdc7..74f6d3e 100644
--- a/js/src/terminal.js
+++ b/js/src/terminal.js
@@ -3,12 +3,41 @@
  * A JavaScript Bash terminal simulation.
  */
 
+ // TODO: Migrate to ES6
 var version = '1.4.4';  // Used in various commands.
 
 function Path() {
 
     this.path = "/";
 
+    /**
+     * 
+     * @param {String} path1 
+     * @param {String} path2 Unix-like path. Absolute or relative
+     * @returns {String[]}
+     */
+    Path.prototype.resolveToArray = function(path1, path2) {
+        const goingBackwardsSymb = '..';
+        const mainPath = path1.split('/').filter(it => it.length);
+        const foreignPath = path2.split('/').filter(it => it.length);
+    
+        if (foreignPath.includes('..')) {
+            foreignPath.forEach(pathElement => {
+                if (pathElement !== goingBackwardsSymb) {
+                    mainPath.push(pathElement);
+                } else {
+                    if (!mainPath[mainPath.length - 1]) {
+                        throw new Error('Invalid path');
+                    }
+                    mainPath.pop();
+                }
+            });
+            return mainPath;
+        } else {
+            return mainPath.concat(foreignPath);
+        } 
+    } 
+
     /**
      * Determine if the passed value is the proper format for a directory.
      */
@@ -122,6 +151,7 @@ function Path() {
 
 var Terminal = (function () {
     var self = {};
+    self.tmp_fs = myFs;
     self.pathMgr = new Path();
 
     var KEY_UP = 38,
@@ -158,7 +188,15 @@ var Terminal = (function () {
 
 
     var runCommand = function (terminal, cmd, args) {
-        terminal.innerHTML += "<div>" + (self.commands[cmd].exe(args)) + "</div>";
+        let cmdRunResult = '';
+        try {
+            cmdRunResult = self.commands[cmd].exe(args);
+        } catch (error) {
+            if (error.type === 'CmdValidationError') {
+                cmdRunResult = error.message;
+            }
+        }
+        terminal.innerHTML += `<div>${cmdRunResult}</div>`;
     };
 
     var updateHistory = function (cmd) {
@@ -259,62 +297,38 @@ var Terminal = (function () {
         }
     };
 
+    /**
+     * @param {string} path
+     */
     self.catFile = function (path) {
-        // First, is the path present in the current location (add given path to the current path)?
-        var foundNode = null;
-        var selector = '';
-        if (path.substr(0, 1) != '/') {
-            // Search in and below current directory (add given path to the current path):
-            var selector = self.pathMgr.parseFilePathToSelector(self.path + path);
-            var foundNode = self.filesystemPointer.querySelector(selector);
-        }
-        if (typeof foundNode === 'undefined' || foundNode == null || foundNode.nodeName != 'f') {
-            // Not found in current directory, search globally:
-            selector = self.pathMgr.parseFilePathToSelector(path);
-            var foundNode = self.filesystem.querySelector(selector);
-            if (typeof foundNode === 'undefined' || foundNode == null || foundNode.nodeName != 'f') {
-                return false;
-            }
+        const file = self.tmp_fs.get(path.split('/').filter(it => it.length));
+        if (!file || (file && !file.isFile())) {
+            return false;
         }
-
-        // We found a node! Output the file contents.
-        return foundNode.querySelector('contents').innerHTML;
+        return file.content;
     }
 
     self.changeDirectory = function (path) {
-        if (path == "..") {
-            // Go up one level as long as we aren't already at the filesystem root.
-            if (self.filesystemPointer.getAttribute('name') != "/") {
-                self.filesystemPointer = self.filesystemPointer.parentNode.parentNode; // Skip the children (c) element.
-                self.path = self.filesystemPointer.getAttribute('path');
-                path = self.path;
-                return true;
-            }
-            return true;
-        }
-
-        // We are looking for the current directory.
-        if (path == ".") {
+        // if (!self.pathMgr.isValidDirectoryPath(path)) {
+        //     return false;
+        // }  
+        if (path === '.') {
             return true;
         }
-
-        if (!self.pathMgr.isValidDirectoryPath(path)) {
-            return false;
-        }
-
-        // Search for the directory.
-        var foundNode = self.findDirectory(path);
-        if (foundNode === false) {
+        try {
+            const startDir = path.indexOf('/') === 0 ? 
+                '/' : 
+                self.tmp_fs.pwd();
+            const preparedPath = self.pathMgr.resolveToArray(startDir, path);
+            
+            self.tmp_fs.cd(preparedPath);
+        } catch {
             return false;
         }
-
-        // We found a node! Update the saved pointer and path.
-        self.path = foundNode.getAttribute('path');
-        if (self.path.substr(-1) != '/') self.path += '/'; // If there isn't a trailing slash, add one.
-        path = self.path;
-        self.filesystemPointer = foundNode;
-
+        self.path = self.tmp_fs.pwd();
+       
         return true;
+
     };
 
     /**