Increase version

This reverts commit b87ec9f348.

.gitattributes

@@ -0,0 +1,3 @@
+# Git will handle the files in whatever way it thinks is best.
+# Overwrites global core.autocrlf git setting
+* text=auto

.gitignore

@@ -1,5 +1,8 @@
 # Project specific
 FluentTerminal.App/Win32
+FluentTerminal.App/Client/
+FluentTerminal.Client/dist
+/.sonarqube
 
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
@@ -289,3 +292,5 @@ __pycache__/
 *.btm.cs
 *.odx.cs
 *.xsd.cs
+
+!FluentTerminal.App/MoshExecutables/*

Explorer Context Menu Integration/Install.bat

@@ -0,0 +1,3 @@
+reg add "HKCU\Software\Classes\Directory\shell\Open Fluent Terminal here\command" /d "\"%LOCALAPPDATA%\Microsoft\WindowsApps\flute.exe\" new \"%%1\"" /f
+reg add "HKCU\Software\Classes\Directory\Background\shell\Open Fluent Terminal here\command" /d "\"%LOCALAPPDATA%\Microsoft\WindowsApps\flute.exe\" new \"%%V\"" /f
+reg add "HKCU\Software\Classes\LibraryFolder\Background\shell\Open Fluent Terminal here\command" /d "\"%LOCALAPPDATA%\Microsoft\WindowsApps\flute.exe\" new \"%%V\"" /f

Explorer Context Menu Integration/Uninstall.bat

@@ -0,0 +1,3 @@
+reg delete "HKCU\Software\Classes\Directory\shell\Open Fluent Terminal here" /f
+reg delete "HKCU\Software\Classes\Directory\Background\shell\Open Fluent Terminal here" /f
+reg delete "HKCU\Software\Classes\LibraryFolder\Background\shell\Open Fluent Terminal here" /f

FluentTerminal.App.Services.Test/DefaultValueProviderTests.cs

@@ -0,0 +1,157 @@
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.Models.Enums;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class DefaultValueProviderTests
+    {
+        public static IEnumerable<object[]> Commands => System.Enum.GetValues(typeof(Command)).Cast<Command>().Select(x => new object[] { x });
+
+        [Fact]
+        public void GetDefaultApplicationSettings_Default_DoesNotReturnNull()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var applicationSettings = defaultValueProvider.GetDefaultApplicationSettings();
+
+            applicationSettings.Should().NotBeNull();
+        }
+
+        [Theory]
+        [MemberData(nameof(Commands))]
+        public void GetDefaultKeyBindings_AllCommands_ReturnsANonEmptyList(Command command)
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var keyBindings = defaultValueProvider.GetDefaultKeyBindings(command);
+
+            keyBindings.Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public void GetDefaultShellProfileId_Default_DoesNotReturnEmptyGuid()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var defaultShellProfileId = defaultValueProvider.GetDefaultShellProfileId();
+
+            defaultShellProfileId.Should().NotBeEmpty();
+        }
+
+        [Fact]
+        public void GetDefaultShellProfileId_Default_IdIsOneOfThePreInstalledShellProfiles()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+            var shellProfiles = defaultValueProvider.GetPreinstalledShellProfiles();
+
+            var defaultShellProfileId = defaultValueProvider.GetDefaultShellProfileId();
+
+            shellProfiles.Select(x => x.Id).Should().Contain(defaultShellProfileId);
+        }
+
+        [Fact]
+        public void GetDefaultTerminalOptions_Default_DoesNotReturnNull()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var defaultTerminalOptions = defaultValueProvider.GetDefaultTerminalOptions();
+
+            defaultTerminalOptions.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void GetDefaultThemeId_Default_DoesNotReturnEmptyGuid()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var defaultThemeId = defaultValueProvider.GetDefaultThemeId();
+
+            defaultThemeId.Should().NotBeEmpty();
+        }
+
+        [Fact]
+        public void GetDefaultThemeId_Default_IdIsOneOfThePreInstalledThemes()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+            var themes = defaultValueProvider.GetPreInstalledThemes();
+
+            var defaultThemeId = defaultValueProvider.GetDefaultThemeId();
+
+            themes.Select(x => x.Id).Should().Contain(defaultThemeId);
+        }
+
+        [Fact]
+        public void GetPreinstalledShellProfiles_Default_ReturnsANonEmptyList()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var shellProfiles = defaultValueProvider.GetPreinstalledShellProfiles();
+
+            shellProfiles.Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public void GetPreinstalledShellProfiles_Default_HaveUniqueIds()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var shellProfiles = defaultValueProvider.GetPreinstalledShellProfiles();
+
+            shellProfiles.Select(x => x.Id).Should().OnlyHaveUniqueItems();
+        }
+
+        [Fact]
+        public void GetPreinstalledShellProfiles_Default_HavePreInstalledSetToTrue()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var shellProfiles = defaultValueProvider.GetPreinstalledShellProfiles();
+
+            shellProfiles.Select(x => x.PreInstalled).Should().AllBeEquivalentTo(true);
+        }
+
+        [Fact]
+        public void GetPreinstalledShellProfiles_Default_HaveNonEmptyLocations()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var shellProfiles = defaultValueProvider.GetPreinstalledShellProfiles();
+
+            shellProfiles.Select(x => x.Location).Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public void GetPreInstalledThemes_Default_ReturnsANonEmptyList()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var themes = defaultValueProvider.GetPreInstalledThemes();
+
+            themes.Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public void GetPreinstalledThemes_Default_HaveUniqueIds()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var themes = defaultValueProvider.GetPreInstalledThemes();
+
+            themes.Select(x => x.Id).Should().OnlyHaveUniqueItems();
+        }
+
+        [Fact]
+        public void GetPreinstalledThemes_Default_HavePreInstalledSetToTrue()
+        {
+            var defaultValueProvider = new DefaultValueProvider();
+
+            var themes = defaultValueProvider.GetPreInstalledThemes();
+
+            themes.Select(x => x.PreInstalled).Should().AllBeEquivalentTo(true);
+        }
+    }
+}

FluentTerminal.App.Services.Test/DialogServiceTests.cs

@@ -0,0 +1,109 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Dialogs;
+using FluentTerminal.App.Services.Implementation;
+using Moq;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class DialogServiceTests
+    {
+        private readonly Fixture _fixture;
+
+        public DialogServiceTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Fact]
+        public void ShowCreateKeyBindingDialog_Default_UsesCreateKeyBindingDialog()
+        {
+            var createKeyBindingDialog = new Mock<ICreateKeyBindingDialog>();
+            var dialogService = new DialogService(Mock.Of<IShellProfileSelectionDialog>, Mock.Of<IMessageDialog>, () => createKeyBindingDialog.Object, Mock.Of<IInputDialog>, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            dialogService.ShowCreateKeyBindingDialog();
+
+            createKeyBindingDialog.Verify(x => x.CreateKeyBinding(), Times.Once);
+        }
+
+        [Fact]
+        public void ShowMessageDialogAsnyc_TitleIsEmpty_ThrowsArgumentNullException()
+        {
+            var title = string.Empty;
+            var content = _fixture.Create<string>();
+            var buttons = _fixture.CreateMany<DialogButton>(2);
+            var dialogService = new DialogService(Mock.Of<IShellProfileSelectionDialog>, Mock.Of<IMessageDialog>, Mock.Of<ICreateKeyBindingDialog>, Mock.Of<IInputDialog>, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            Func<Task<DialogButton>> showMessageDialogAsnyc = () => dialogService.ShowMessageDialogAsnyc(title, content, buttons.ElementAt(0), buttons.ElementAt(1));
+
+            showMessageDialogAsnyc.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("title");
+        }
+
+        [Fact]
+        public void ShowMessageDialogAsnyc_ContentIsEmpty_ThrowsArgumentNullException()
+        {
+            var title = _fixture.Create<string>();
+            var content = string.Empty;
+            var buttons = _fixture.CreateMany<DialogButton>(2);
+            var dialogService = new DialogService(Mock.Of<IShellProfileSelectionDialog>, Mock.Of<IMessageDialog>, Mock.Of<ICreateKeyBindingDialog>, Mock.Of<IInputDialog>, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            Func<Task<DialogButton>> showMessageDialogAsnyc = () => dialogService.ShowMessageDialogAsnyc(title, content, buttons.ElementAt(0), buttons.ElementAt(1));
+
+            showMessageDialogAsnyc.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("content");
+        }
+
+        [Fact]
+        public void ShowMessageDialogAsnyc_NoButtonsPassed_ThrowsArgumentException()
+        {
+            var title = _fixture.Create<string>();
+            var content = _fixture.Create<string>();
+            var dialogService = new DialogService(Mock.Of<IShellProfileSelectionDialog>, Mock.Of<IMessageDialog>, Mock.Of<ICreateKeyBindingDialog>, Mock.Of<IInputDialog>, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            Func<Task<DialogButton>> showMessageDialogAsnyc = () => dialogService.ShowMessageDialogAsnyc(title, content);
+
+            showMessageDialogAsnyc.Should().Throw<ArgumentException>().And.ParamName.Should().Be("buttons");
+        }
+
+        [Fact]
+        public void ShowMessageDialogAsnyc_Default_UsesMessageDialog()
+        {
+            var title = _fixture.Create<string>();
+            var content = _fixture.Create<string>();
+            var buttons = _fixture.CreateMany<DialogButton>(2);
+            var messageDialog = new Mock<IMessageDialog>();
+            var dialogService = new DialogService(Mock.Of<IShellProfileSelectionDialog>, () => messageDialog.Object, Mock.Of<ICreateKeyBindingDialog>, Mock.Of<IInputDialog>, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            dialogService.ShowMessageDialogAsnyc(title, content, buttons.ElementAt(0), buttons.ElementAt(1));
+
+            messageDialog.Verify(x => x.ShowAsync(), Times.Once);
+        }
+
+        [Fact]
+        public void ShowProfileSelectionDialogAsync_Default_UsesShellProfileSelectionDialog()
+        {
+            var shellProfileSelectionDialog = new Mock<IShellProfileSelectionDialog>();
+            var dialogService = new DialogService(() => shellProfileSelectionDialog.Object, Mock.Of<IMessageDialog>, Mock.Of<ICreateKeyBindingDialog>, Mock.Of<IInputDialog>, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            dialogService.ShowProfileSelectionDialogAsync();
+
+            shellProfileSelectionDialog.Verify(x => x.SelectProfile(), Times.Once);
+        }
+        
+        [Fact]
+        public void ShowInputDialogAsync_UsesIInputDialogSetTitle()
+        {
+            var title = "title";
+            var inputDialog = new Mock<IInputDialog>();            
+            var dialogService = new DialogService(Mock.Of<IShellProfileSelectionDialog>, Mock.Of<IMessageDialog>, Mock.Of<ICreateKeyBindingDialog>, () => inputDialog.Object, Mock.Of<ISshConnectionInfoDialog>, Mock.Of<ISshProfileSelectionDialog>);
+
+            dialogService.ShowInputDialogAsync(title);
+
+            inputDialog.Verify(x => x.SetTitle(title), Times.Once);
+            inputDialog.Verify(x => x.GetInput(), Times.Once);
+        }
+    }
+}

FluentTerminal.App.Services.Test/FluentTerminal.App.Services.Test.csproj

@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="TestData\AdventureTime.itermcolors" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoFixture" Version="4.10.0" />
+    <PackageReference Include="FluentAssertions" Version="5.7.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+    <PackageReference Include="Moq" Version="4.12.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="TestData\AdventureTime.itermcolors">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </EmbeddedResource>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\FluentTerminal.App.Services\FluentTerminal.App.Services.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="Windows.Foundation.FoundationContract">
+      <HintPath>$(MSBuildProgramFiles32)\Windows Kits\10\References\10.0.16299.0\Windows.Foundation.FoundationContract\3.0.0.0\Windows.Foundation.FoundationContract.winmd</HintPath>
+      <Private>False</Private>
+    </Reference>
+  </ItemGroup>
+
+</Project>

FluentTerminal.App.Services.Test/FluentTerminalThemeParserTests.cs

@@ -0,0 +1,80 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.Models;
+using Newtonsoft.Json;
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class FluentTerminalThemeParserTests
+    {
+        private readonly Fixture _fixture;
+
+        public FluentTerminalThemeParserTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Fact]
+        public async Task Parse_ValidFileStream_ReturnsTheme()
+        {
+            var theme = _fixture.Create<TerminalTheme>();
+            var serialized = JsonConvert.SerializeObject(theme);
+            var stream = new MemoryStream(Encoding.UTF8.GetBytes(serialized));
+            var parser = new FluentTerminalThemeParser();
+
+            var parsedTheme = await parser.Parse(theme.Name, stream);
+
+            parsedTheme.Name.Should().Be(theme.Name);
+            parsedTheme.Author.Should().Be(theme.Author);
+            parsedTheme.PreInstalled.Should().Be(false);
+            parsedTheme.Colors.Should().BeEquivalentTo(theme.Colors);
+        }
+
+        [Fact]
+        public void Parse_InvalidFileStream_ThrowsException()
+        {
+            var fileName = _fixture.Create<string>();
+            var serialized = _fixture.Create<string>();
+            var stream = new MemoryStream(Encoding.UTF8.GetBytes(serialized));
+            var parser = new FluentTerminalThemeParser();
+
+            Func<Task<TerminalTheme>> parse = () => parser.Parse(fileName, stream);
+
+            parse.Should().Throw<Exception>();
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData(" ")]
+        public void Parse_InvalidFileName_ThrowsArgumentNullException(string fileName)
+        {
+            var theme = _fixture.Create<TerminalTheme>();
+            var serialized = JsonConvert.SerializeObject(theme);
+            var stream = new MemoryStream(Encoding.UTF8.GetBytes(serialized));
+            var parser = new FluentTerminalThemeParser();
+
+            Func<Task<TerminalTheme>> parse = () => parser.Parse(fileName, stream);
+
+            parse.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("fileName");
+        }
+
+        [Fact]
+        public void Parse_FileStreamIsNull_ThrowsArgumentNullException()
+        {
+            var fileName = _fixture.Create<string>();
+            Stream stream = null;
+            var parser = new FluentTerminalThemeParser();
+
+            Func<Task<TerminalTheme>> parse = () => parser.Parse(fileName, stream);
+
+            parse.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("fileContent");
+        }
+    }
+}

FluentTerminal.App.Services.Test/ITermThemeParserTests.cs

@@ -0,0 +1,91 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.Models;
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class ITermThemeParserTests
+    {
+        private readonly Fixture _fixture;
+
+        public ITermThemeParserTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData(" ")]
+        public void Parse_InvalidFileName_ThrowsArgumentNullException(string fileName)
+        {
+            var stream = typeof(ITermThemeParserTests).Assembly.GetManifestResourceStream("FluentTerminal.App.Services.Test.TestData.AdventureTime.itermcolors");
+            var parser = new ITermThemeParser();
+
+            Func<Task<TerminalTheme>> parse = () => parser.Parse(fileName, stream);
+
+            parse.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("fileName");
+        }
+
+        [Fact]
+        public void Parse_FileStreamIsNull_ThrowsArgumentNullException()
+        {
+            var fileName = _fixture.Create<string>();
+            Stream stream = null;
+            var parser = new ITermThemeParser();
+
+            Func<Task<TerminalTheme>> parse = () => parser.Parse(fileName, stream);
+
+            parse.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("fileContent");
+        }
+
+        [Fact]
+        public void Parse_InvalidFileStream_ThrowsException()
+        {
+            var fileName = _fixture.Create<string>();
+            var serialized = _fixture.Create<string>();
+            var stream = new MemoryStream(Encoding.UTF8.GetBytes(serialized));
+            var parser = new ITermThemeParser();
+
+            Func<Task<TerminalTheme>> parse = () => parser.Parse(fileName, stream);
+
+            parse.Should().Throw<Exception>();
+        }
+
+        [Fact]
+        public async Task Parse_ValidThemeFile_ParsesCorrectly()
+        {
+            var fileName = _fixture.Create<string>();
+            var stream = typeof(ITermThemeParserTests).Assembly.GetManifestResourceStream("FluentTerminal.App.Services.Test.TestData.AdventureTime.itermcolors");
+            var parser = new ITermThemeParser();
+
+            var theme = await parser.Parse(fileName, stream);
+
+            theme.Colors.Background.ToLower().Should().Be("#1f1d45");
+            theme.Colors.Cursor.ToLower().Should().Be("#efbf38");
+            theme.Colors.Foreground.ToLower().Should().Be("#f8dcc0");
+            theme.Colors.Black.ToLower().Should().Be("#050404");
+            theme.Colors.Red.ToLower().Should().Be("#bd0013");
+            theme.Colors.Green.ToLower().Should().Be("#4ab118");
+            theme.Colors.Yellow.ToLower().Should().Be("#e7741e");
+            theme.Colors.Blue.ToLower().Should().Be("#0f4ac6");
+            theme.Colors.Magenta.ToLower().Should().Be("#665993");
+            theme.Colors.Cyan.ToLower().Should().Be("#70a598");
+            theme.Colors.White.ToLower().Should().Be("#f8dcc0");
+            theme.Colors.BrightBlack.ToLower().Should().Be("#4e7cbf");
+            theme.Colors.BrightRed.ToLower().Should().Be("#fc5f5a");
+            theme.Colors.BrightGreen.ToLower().Should().Be("#9eff6e");
+            theme.Colors.BrightYellow.ToLower().Should().Be("#efc11a");
+            theme.Colors.BrightBlue.ToLower().Should().Be("#1997c6");
+            theme.Colors.BrightMagenta.ToLower().Should().Be("#9b5953");
+            theme.Colors.BrightCyan.ToLower().Should().Be("#c8faf4");
+            theme.Colors.BrightWhite.ToLower().Should().Be("#f6f5fb");
+        }
+    }
+}

FluentTerminal.App.Services.Test/KeyboardCommandServiceTests.cs

@@ -0,0 +1,115 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.Models.Enums;
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class KeyboardCommandServiceTests
+    {
+        private readonly Fixture _fixture;
+
+        public KeyboardCommandServiceTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Fact]
+        public void RegisterCommandHandler_HandlerIsNull_ThrowsArgumentNullException()
+        {
+            var command = ((Command)new Random().Next(1, Enum.GetValues(typeof(Command)).Length)).ToString();
+            Action handler = null;
+            var keyboardCommandService = new KeyboardCommandService();
+
+            Action invoke = () => keyboardCommandService.RegisterCommandHandler(command, handler);
+
+            invoke.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("handler");
+        }
+
+        [Fact]
+        public void RegisterCommandHandler_CommandAlreadyRegisted_ThrowsInvalidOperationException()
+        {
+            var command = ((Command)new Random().Next(1, Enum.GetValues(typeof(Command)).Length)).ToString();
+            var handler = _fixture.Create<Action>();
+            var keyboardCommandService = new KeyboardCommandService();
+            keyboardCommandService.RegisterCommandHandler(command, handler);
+
+            Action invoke = () => keyboardCommandService.RegisterCommandHandler(command, handler);
+
+            invoke.Should().Throw<InvalidOperationException>();
+        }
+        
+        [Fact]
+        public void DeregisterCommandHandler_CommandIsNull_ThrowsArgumentNullException()
+        {
+            var keyboardCommandService = new KeyboardCommandService();
+
+            Action invoke = () => keyboardCommandService.DeregisterCommandHandler(null);
+
+            invoke.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void DeregisterCommandHandler_CommandRegistered_HandlerGetsRemoved()
+        {
+            var command = ((Command)new Random().Next(1, Enum.GetValues(typeof(Command)).Length)).ToString();
+            var handler = _fixture.Create<Action>();
+            var keyboardCommandService = new KeyboardCommandService();
+
+            keyboardCommandService.RegisterCommandHandler(command, handler);
+
+            Action invoke = () => keyboardCommandService.DeregisterCommandHandler(command);
+
+            invoke.Should().NotThrow();
+        }
+
+        [Fact]
+        public void DeregisterCommandHandler_CommandNotRegistered_ShouldNotThrow()
+        {
+            var command = ((Command)new Random().Next(1, Enum.GetValues(typeof(Command)).Length)).ToString();
+            var keyboardCommandService = new KeyboardCommandService();
+
+            Action invoke = () => keyboardCommandService.DeregisterCommandHandler(command);
+
+            invoke.Should().NotThrow();
+        }
+
+        [Fact]
+        public void SendCommand_CommandIsRegistered_HandlerGetsInvoked()
+        {
+            var command = ((Command)new Random().Next(1, Enum.GetValues(typeof(Command)).Length)).ToString();
+            var handlerCalled = false;
+            var keyboardCommandService = new KeyboardCommandService();
+            keyboardCommandService.RegisterCommandHandler(command, () => handlerCalled = true);
+
+            keyboardCommandService.SendCommand(command);
+
+            handlerCalled.Should().BeTrue();
+        }
+
+        [Fact]
+        public void SendCommand_CommandIsNotRegisted_KeyNotFoundExceptionIsThrown()
+        {
+            var command = ((Command)new Random().Next(1, Enum.GetValues(typeof(Command)).Length)).ToString();
+            var keyboardCommandService = new KeyboardCommandService();
+
+            Action invoke = () => keyboardCommandService.SendCommand(command);
+
+            invoke.Should().Throw<KeyNotFoundException>();
+        }
+        
+        [Fact]
+        public void SendCommand_CommandIsToggleWindow_ShouldNotThrow()
+        {
+            var command = nameof(Command.ToggleWindow);
+            var keyboardCommandService = new KeyboardCommandService();
+
+            Action invoke = () => keyboardCommandService.SendCommand(command);
+
+            invoke.Should().NotThrow();
+        }
+    }
+}

FluentTerminal.App.Services.Test/SettingsServiceTests.cs

@@ -0,0 +1,754 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using Moq;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class SettingsServiceTests
+    {
+        private readonly Fixture _fixture;
+
+        public SettingsServiceTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Fact]
+        public void Constructor_Default_WritesAllPreinstalledThemesInThemeContainer()
+        {
+            var themes = _fixture.CreateMany<TerminalTheme>(3);
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            defaultValueProvider.Setup(x => x.GetPreInstalledThemes()).Returns(themes);
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+
+            new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            defaultValueProvider.Verify(x => x.GetPreInstalledThemes(), Times.Once);
+            foreach (var theme in themes)
+            {
+                themesContainer.Verify(x => x.WriteValueAsJson(theme.Id.ToString(), theme), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void Constructor_Default_WritesAllPreinstalledShellProfilesInShellProfilesContainer()
+        {
+            var shellProfiles = _fixture.CreateMany<ShellProfile>(3);
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            defaultValueProvider.Setup(x => x.GetPreinstalledShellProfiles()).Returns(shellProfiles);
+            var shellProfilesContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                ShellProfiles = shellProfilesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+
+            new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            defaultValueProvider.Verify(x => x.GetPreinstalledShellProfiles(), Times.Once);
+            foreach (var shellProfile in shellProfiles)
+            {
+                shellProfilesContainer.Verify(x => x.WriteValueAsJson(shellProfile.Id.ToString(), shellProfile), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void GetCurrentThemeId_ValueExistsInRoamingSettings_ReturnsCurrentThemeId()
+        {
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var currentThemeId = (object)_fixture.Create<Guid>();
+            roamingSettings.Setup(x => x.TryGetValue(SettingsService.CurrentThemeKey, out currentThemeId)).Returns(true);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetCurrentThemeId();
+
+            result.Should().Be((Guid)currentThemeId);
+            roamingSettings.Verify(x => x.TryGetValue(SettingsService.CurrentThemeKey, out currentThemeId), Times.Once);
+        }
+
+        [Fact]
+        public void GetCurrentThemeId_ValueDoesNotExistInRoamingSettings_ReturnsDefaultThemeIdFromDefaultValueProvider()
+        {
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            var defaultThemeId = _fixture.Create<Guid>();
+            defaultValueProvider.Setup(x => x.GetDefaultThemeId()).Returns(defaultThemeId);
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var currentThemeId = (object)_fixture.Create<Guid>();
+            roamingSettings.Setup(x => x.TryGetValue(SettingsService.CurrentThemeKey, out currentThemeId)).Returns(false);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            var result = settingsService.GetCurrentThemeId();
+
+            result.Should().Be(defaultThemeId);
+            defaultValueProvider.Verify(x => x.GetDefaultThemeId(), Times.Once);
+            roamingSettings.Verify(x => x.TryGetValue(SettingsService.CurrentThemeKey, out currentThemeId), Times.Once);
+        }
+
+        [Fact]
+        public void SaveCurrentThemeId_Default_SetsValueOnRoamingSettings()
+        {
+            var currentThemeId = _fixture.Create<Guid>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.SaveCurrentThemeId(currentThemeId);
+
+            roamingSettings.Verify(x => x.SetValue(SettingsService.CurrentThemeKey, currentThemeId), Times.Once);
+        }
+
+        [Fact]
+        public void SaveCurrentThemeId_Default_InvokesCurrentThemeChangedEvent()
+        {
+            var currentThemeId = _fixture.Create<Guid>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var currentThemeChangedEventInvoked = false;
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+            settingsService.CurrentThemeChanged += (s, e) => currentThemeChangedEventInvoked = true;
+
+            settingsService.SaveCurrentThemeId(currentThemeId);
+
+            currentThemeChangedEventInvoked.Should().BeTrue();
+        }
+
+        [Fact]
+        public void SaveTheme_Default_WritesToThemesContainer()
+        {
+            var theme = _fixture.Create<TerminalTheme>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.SaveTheme(theme);
+
+            themesContainer.Verify(x => x.WriteValueAsJson(theme.Id.ToString(), theme), Times.Once);
+        }
+
+        [Fact]
+        public void SaveTheme_ThemeIsCurrentTheme_InvokesCurrentThemeChangedEvent()
+        {
+            var theme = _fixture.Create<TerminalTheme>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var currentThemeId = (object)theme.Id;
+            roamingSettings.Setup(x => x.TryGetValue(SettingsService.CurrentThemeKey, out currentThemeId)).Returns(true);
+            var currentThemeChangedEventInvoked = false;
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = roamingSettings.Object,
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+            settingsService.CurrentThemeChanged += (s, e) => currentThemeChangedEventInvoked = true;
+
+            settingsService.SaveTheme(theme);
+
+            currentThemeChangedEventInvoked.Should().BeTrue();
+        }
+
+        [Fact]
+        public void DeleteTheme_Default_CallsDeleteOnThemesContainer()
+        {
+            var themeId = _fixture.Create<Guid>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.DeleteTheme(themeId);
+
+            themesContainer.Verify(x => x.Delete(themeId.ToString()), Times.Once);
+        }
+
+        [Fact]
+        public void GetThemes_Default_CallsGetAllOnThemesContainer()
+        {
+            var themes = _fixture.CreateMany<TerminalTheme>(3);
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            themesContainer.Setup(x => x.GetAll()).Returns(themes.Select(JsonConvert.SerializeObject));
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetThemes();
+
+            result.Should().BeEquivalentTo(themes);
+            themesContainer.Verify(x => x.GetAll(), Times.Once);
+        }
+
+        [Fact]
+        public void GetTheme_ValidThemeId_ReturnsThemeFromThemesContainer()
+        {
+            var theme = _fixture.Create<TerminalTheme>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            themesContainer.Setup(x => x.ReadValueFromJson(theme.Id.ToString(), default(TerminalTheme))).Returns(theme);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetTheme(theme.Id);
+
+            result.Should().BeEquivalentTo(theme);
+            themesContainer.Verify(x => x.ReadValueFromJson(theme.Id.ToString(), default(TerminalTheme)), Times.Once);
+        }
+
+        [Fact]
+        public void GetTheme_UnknownThemeId_ReturnsNull()
+        {
+            var themeId = _fixture.Create<Guid>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            themesContainer.Setup(x => x.ReadValueFromJson(themeId.ToString(), default(TerminalTheme))).Returns(value: null);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                Themes = themesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetTheme(themeId);
+
+            result.Should().BeNull();
+            themesContainer.Verify(x => x.ReadValueFromJson(themeId.ToString(), default(TerminalTheme)), Times.Once);
+        }
+
+        [Fact]
+        public void GetTerminalOptions_Default_ReturnsTerminalOptionsFromRoamingSettings()
+        {
+            var terminalOptions = _fixture.Create<TerminalOptions>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            roamingSettings.Setup(x => x.ReadValueFromJson(nameof(TerminalOptions), It.IsAny<TerminalOptions>())).Returns(terminalOptions);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetTerminalOptions();
+
+            result.Should().BeEquivalentTo(terminalOptions);
+            roamingSettings.Verify(x => x.ReadValueFromJson(nameof(TerminalOptions), It.IsAny<TerminalOptions>()), Times.Once);
+        }
+
+        [Fact]
+        public void SaveTerminalOptions_Default_WritesToRoamingSettings()
+        {
+            var terminalOptions = _fixture.Create<TerminalOptions>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.SaveTerminalOptions(terminalOptions);
+
+            roamingSettings.Verify(x => x.WriteValueAsJson(nameof(TerminalOptions), terminalOptions), Times.Once);
+        }
+
+        [Fact]
+        public void SaveTerminalOptions_Default_InvokesTerminalOptionsChangedEvent()
+        {
+            var terminalOptions = _fixture.Create<TerminalOptions>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var terminalOptionsChangedEventInvoked = false;
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+            settingsService.TerminalOptionsChanged += (s, e) => terminalOptionsChangedEventInvoked = true;
+
+            settingsService.SaveTerminalOptions(terminalOptions);
+
+            terminalOptionsChangedEventInvoked.Should().BeTrue();
+        }
+
+        [Fact]
+        public void GetApplicationSettings_Default_ReturnsApplicationSettingsFromRoamingSettings()
+        {
+            var applicationSettings = _fixture.Create<ApplicationSettings>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            roamingSettings.Setup(x => x.ReadValueFromJson(nameof(ApplicationSettings), It.IsAny<ApplicationSettings>())).Returns(applicationSettings);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetApplicationSettings();
+
+            result.Should().BeEquivalentTo(applicationSettings);
+            roamingSettings.Verify(x => x.ReadValueFromJson(nameof(ApplicationSettings), It.IsAny<ApplicationSettings>()), Times.Once);
+        }
+
+        [Fact]
+        public void SaveApplicationSettings_Default_WritesToRoamingSettings()
+        {
+            var applicationSettings = _fixture.Create<ApplicationSettings>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.SaveApplicationSettings(applicationSettings);
+
+            roamingSettings.Verify(x => x.WriteValueAsJson(nameof(ApplicationSettings), applicationSettings), Times.Once);
+        }
+
+        [Fact]
+        public void SaveApplicationSettings_Default_InvokesApplicationSettingsChangedEvent()
+        {
+            var applicationSettings = _fixture.Create<ApplicationSettings>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var applicationSettingsChangedEventInvoked = false;
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                RoamingSettings = roamingSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+            settingsService.ApplicationSettingsChanged += (s, e) => applicationSettingsChangedEventInvoked = true;
+
+            settingsService.SaveApplicationSettings(applicationSettings);
+
+            applicationSettingsChangedEventInvoked.Should().BeTrue();
+        }
+
+        [Fact]
+        public void GetKeyBindings_KeyBindingsInKeyBindingsContainer_ReturnsKeyBindingsFromKeyBindingsContainer()
+        {
+            var commands = _fixture.CreateMany<Command>(5);
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var keyBindingsContainer = new Mock<IApplicationDataContainer>();
+            foreach (var command in commands)
+            {
+                keyBindingsContainer.Setup(x => x.ReadValueFromJson<Collection<KeyBinding>>(command.ToString(), null)).Returns(new Collection<KeyBinding> { });
+            }
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                KeyBindings = keyBindingsContainer.Object,
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetCommandKeyBindings();
+
+            foreach (var command in commands)
+            {
+                keyBindingsContainer.Verify(x => x.ReadValueFromJson<Collection<KeyBinding>>(command.ToString(), null), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void GetKeyBindings_KeyBindingsNotInKeyBindingsContainer_ReturnsKeyBindingsFromDefaultValueProvider()
+        {
+            var commands = _fixture.CreateMany<Command>(5);
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            var keyBindingsContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                KeyBindings = keyBindingsContainer.Object,
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            var result = settingsService.GetCommandKeyBindings();
+
+            foreach (Command command in Enum.GetValues(typeof(Command)))
+            {
+                defaultValueProvider.Verify(x => x.GetDefaultKeyBindings(command), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void SaveKeyBindings_Default_WritesToKeyBindingsContainer()
+        {
+            var command = _fixture.Create<Command>();
+            var keyBindings = _fixture.Create<ICollection<KeyBinding>>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var keyBindingsContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                KeyBindings = keyBindingsContainer.Object,
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.SaveKeyBindings(command.ToString(), keyBindings);
+
+            keyBindingsContainer.Verify(x => x.WriteValueAsJson(command.ToString(), keyBindings), Times.Once);
+        }
+
+        [Fact]
+        public void SaveKeyBindings_Default_InvokesKeyBindingsChangedEvent()
+        {
+            var command = _fixture.Create<Command>();
+            var keyBindings = _fixture.Create<Collection<KeyBinding>>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var keyBindingsContainer = new Mock<IApplicationDataContainer>();
+            var keyBindingsChangedEventInvoked = false;
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                KeyBindings = keyBindingsContainer.Object,
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+            settingsService.KeyBindingsChanged += (s, e) => keyBindingsChangedEventInvoked = true;
+
+            settingsService.SaveKeyBindings(command.ToString(), keyBindings);
+
+            keyBindingsChangedEventInvoked.Should().BeTrue();
+        }
+
+        [Fact]
+        public void ResetKeyBindings_Default_WritesToKeyBindingsContainerFromDefaultValueProvider()
+        {
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            var keyBindingsContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                KeyBindings = keyBindingsContainer.Object,
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            settingsService.ResetKeyBindings();
+
+            foreach (Command command in Enum.GetValues(typeof(Command)))
+            {
+                keyBindingsContainer.Verify(x => x.WriteValueAsJson(command.ToString(), It.IsAny<ICollection<KeyBinding>>()), Times.Once);
+                defaultValueProvider.Verify(x => x.GetDefaultKeyBindings(command), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void ResetKeyBindings_Default_InvokesKeyBindingsChangedEvent()
+        {
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var keyBindingsContainer = new Mock<IApplicationDataContainer>();
+            var keyBindingsChangedEventInvoked = false;
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                KeyBindings = keyBindingsContainer.Object,
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+            settingsService.KeyBindingsChanged += (s, e) => keyBindingsChangedEventInvoked = true;
+
+            settingsService.ResetKeyBindings();
+
+            keyBindingsChangedEventInvoked.Should().BeTrue();
+        }
+
+        [Fact]
+        public void GetDefaultShellProfileId_ValueExistsInRoamingSettings_ReturnsDefaultShellProfileId()
+        {
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var localSettings = new Mock<IApplicationDataContainer>();
+            var defaultShellProfileId = (object)_fixture.Create<Guid>();
+            localSettings.Setup(x => x.TryGetValue(SettingsService.DefaultShellProfileKey, out defaultShellProfileId)).Returns(true);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                LocalSettings = localSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetDefaultShellProfileId();
+
+            result.Should().Be((Guid)defaultShellProfileId);
+            localSettings.Verify(x => x.TryGetValue(SettingsService.DefaultShellProfileKey, out defaultShellProfileId), Times.Once);
+        }
+
+        [Fact]
+        public void GetDefaultShellProfileId_ValueDoesNotExistInRoamingSettings_ReturnsDefaultShellProfileIdFromDefaultValueProvider()
+        {
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            var defaultShellProfileId = _fixture.Create<Guid>();
+            defaultValueProvider.Setup(x => x.GetDefaultShellProfileId()).Returns(defaultShellProfileId);
+            var localSettings = new Mock<IApplicationDataContainer>();
+            var currentDefaultShellProfileId = (object)_fixture.Create<Guid>();
+            localSettings.Setup(x => x.TryGetValue(SettingsService.DefaultShellProfileKey, out currentDefaultShellProfileId)).Returns(false);
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                LocalSettings = localSettings.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            var result = settingsService.GetDefaultShellProfileId();
+
+            result.Should().Be(defaultShellProfileId);
+            defaultValueProvider.Verify(x => x.GetDefaultShellProfileId(), Times.Once);
+            localSettings.Verify(x => x.TryGetValue(SettingsService.DefaultShellProfileKey, out currentDefaultShellProfileId), Times.Once);
+        }
+
+        [Fact]
+        public void GetShellProfiles_Default_CallsGetAllOnShellProfilesContainer()
+        {
+            var shellProfiles = _fixture.CreateMany<ShellProfile>(3);
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var shellProfilesContainer = new Mock<IApplicationDataContainer>();
+            shellProfilesContainer.Setup(x => x.GetAll()).Returns(shellProfiles.Select(JsonConvert.SerializeObject));
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                ShellProfiles = shellProfilesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            var result = settingsService.GetShellProfiles();
+
+            result.Should().BeEquivalentTo(shellProfiles);
+            shellProfilesContainer.Verify(x => x.GetAll(), Times.Once);
+        }
+
+        [Fact]
+        public void SaveShellProfile_Default_WritesToShellProfilesContainer()
+        {
+            var shellProfile = _fixture.Create<ShellProfile>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var shellProfilesContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                ShellProfiles = shellProfilesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.SaveShellProfile(shellProfile);
+
+            shellProfilesContainer.Verify(x => x.WriteValueAsJson(shellProfile.Id.ToString(), shellProfile), Times.Once);
+        }
+
+        [Fact]
+        public void DeleteShellProfile_Default_CallsDeleteOnShellProfilesContainer()
+        {
+            var shellProfileId = _fixture.Create<Guid>();
+            var defaultValueProvider = Mock.Of<IDefaultValueProvider>();
+            var shellProfilesContainer = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                ShellProfiles = shellProfilesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            var settingsService = new SettingsService(defaultValueProvider, applicationDataContainers);
+
+            settingsService.DeleteShellProfile(shellProfileId);
+
+            shellProfilesContainer.Verify(x => x.Delete(shellProfileId.ToString()), Times.Once);
+        }
+
+        [Fact]
+        public void GetDefaultShellProfile_ProfileNotFound_DefaultShellProfileIdGetsResetToDefault()
+        {
+            var currentShellProfileId = (object)_fixture.Create<Guid>();
+            var defaultShellProfile = _fixture.Create<ShellProfile>();
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            defaultValueProvider.Setup(x => x.GetDefaultShellProfileId()).Returns(defaultShellProfile.Id);
+            var shellProfilesContainer = new Mock<IApplicationDataContainer>();
+            var localSettings = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                ShellProfiles = shellProfilesContainer.Object,
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = localSettings.Object,
+                Themes = Mock.Of<IApplicationDataContainer>()
+            };
+            shellProfilesContainer.Setup(x => x.ReadValueFromJson(currentShellProfileId.ToString(), default(ShellProfile))).Returns(value: null);
+            shellProfilesContainer.Setup(x => x.ReadValueFromJson(defaultShellProfile.Id.ToString(), default(ShellProfile))).Returns(defaultShellProfile);
+            localSettings.Setup(x => x.TryGetValue(SettingsService.DefaultShellProfileKey, out currentShellProfileId)).Returns(true);
+            var settingsService = new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            var result = settingsService.GetDefaultShellProfile();
+
+            result.Should().Be(defaultShellProfile);
+            localSettings.Verify(x => x.SetValue(SettingsService.DefaultShellProfileKey, defaultShellProfile.Id), Times.Once);
+        }
+
+        [Fact]
+        public void GetCurrentTheme_ThemeNotFound_CurrentThemeIdGetsResetToDefault()
+        {
+            var currentThemeId = (object)_fixture.Create<Guid>();
+            var defaultTheme = _fixture.Create<TerminalTheme>();
+            var defaultValueProvider = new Mock<IDefaultValueProvider>();
+            defaultValueProvider.Setup(x => x.GetDefaultThemeId()).Returns(defaultTheme.Id);
+            var themesContainer = new Mock<IApplicationDataContainer>();
+            var roamingSettings = new Mock<IApplicationDataContainer>();
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                ShellProfiles = Mock.Of<IApplicationDataContainer>(),
+                KeyBindings = Mock.Of<IApplicationDataContainer>(),
+                LocalSettings = Mock.Of<IApplicationDataContainer>(),
+                RoamingSettings = roamingSettings.Object,
+                Themes = themesContainer.Object
+            };
+            themesContainer.Setup(x => x.ReadValueFromJson(currentThemeId.ToString(), default(TerminalTheme))).Returns(value: null);
+            themesContainer.Setup(x => x.ReadValueFromJson(defaultTheme.Id.ToString(), default(TerminalTheme))).Returns(defaultTheme);
+            roamingSettings.Setup(x => x.TryGetValue(SettingsService.CurrentThemeKey, out currentThemeId)).Returns(true);
+            var settingsService = new SettingsService(defaultValueProvider.Object, applicationDataContainers);
+
+            var result = settingsService.GetCurrentTheme();
+
+            result.Should().Be(defaultTheme);
+            roamingSettings.Verify(x => x.SetValue(SettingsService.CurrentThemeKey, defaultTheme.Id), Times.Once);
+        }
+    }
+}

FluentTerminal.App.Services.Test/TestData/AdventureTime.itermcolors

@@ -0,0 +1,213 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Ansi 0 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.016337040811777115</real>
+		<key>Green Component</key>
+		<real>0.016232240945100784</real>
+		<key>Red Component</key>
+		<real>0.020433688536286354</real>
+	</dict>
+	<key>Ansi 1 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.075083047151565552</real>
+		<key>Green Component</key>
+		<real>0.0</real>
+		<key>Red Component</key>
+		<real>0.73976802825927734</real>
+	</dict>
+	<key>Ansi 10 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.43171143531799316</real>
+		<key>Green Component</key>
+		<real>1</real>
+		<key>Red Component</key>
+		<real>0.61819148063659668</real>
+	</dict>
+	<key>Ansi 11 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.10242157429456711</real>
+		<key>Green Component</key>
+		<real>0.7578997015953064</real>
+		<key>Red Component</key>
+		<real>0.93761706352233887</real>
+	</dict>
+	<key>Ansi 12 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.77801346778869629</real>
+		<key>Green Component</key>
+		<real>0.59102588891983032</real>
+		<key>Red Component</key>
+		<real>0.096501544117927551</real>
+	</dict>
+	<key>Ansi 13 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.32394066452980042</real>
+		<key>Green Component</key>
+		<real>0.34950375556945801</real>
+		<key>Red Component</key>
+		<real>0.60686224699020386</real>
+	</dict>
+	<key>Ansi 14 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.95550096035003662</real>
+		<key>Green Component</key>
+		<real>0.97915208339691162</real>
+		<key>Red Component</key>
+		<real>0.78500419855117798</real>
+	</dict>
+	<key>Ansi 15 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.98438382148742676</real>
+		<key>Green Component</key>
+		<real>0.96043074131011963</real>
+		<key>Red Component</key>
+		<real>0.96449893712997437</real>
+	</dict>
+	<key>Ansi 2 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.092498354613780975</real>
+		<key>Green Component</key>
+		<real>0.6950421929359436</real>
+		<key>Red Component</key>
+		<real>0.28945007920265198</real>
+	</dict>
+	<key>Ansi 3 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.1164485365152359</real>
+		<key>Green Component</key>
+		<real>0.45553147792816162</real>
+		<key>Red Component</key>
+		<real>0.90543299913406372</real>
+	</dict>
+	<key>Ansi 4 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.77829605340957642</real>
+		<key>Green Component</key>
+		<real>0.28880593180656433</real>
+		<key>Red Component</key>
+		<real>0.059818677604198456</real>
+	</dict>
+	<key>Ansi 5 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.57602518796920776</real>
+		<key>Green Component</key>
+		<real>0.35004982352256775</real>
+		<key>Red Component</key>
+		<real>0.40191537141799927</real>
+	</dict>
+	<key>Ansi 6 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.59465551376342773</real>
+		<key>Green Component</key>
+		<real>0.64633101224899292</real>
+		<key>Red Component</key>
+		<real>0.43781715631484985</real>
+	</dict>
+	<key>Ansi 7 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.75428962707519531</real>
+		<key>Green Component</key>
+		<real>0.86175870895385742</real>
+		<key>Red Component</key>
+		<real>0.97308963537216187</real>
+	</dict>
+	<key>Ansi 8 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.7491685152053833</real>
+		<key>Green Component</key>
+		<real>0.48549851775169373</real>
+		<key>Red Component</key>
+		<real>0.30726605653762817</real>
+	</dict>
+	<key>Ansi 9 Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.35247993469238281</real>
+		<key>Green Component</key>
+		<real>0.37095117568969727</real>
+		<key>Red Component</key>
+		<real>0.98876720666885376</real>
+	</dict>
+	<key>Background Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.27054747939109802</real>
+		<key>Green Component</key>
+		<real>0.11274909973144531</real>
+		<key>Red Component</key>
+		<real>0.12003477662801743</real>
+	</dict>
+	<key>Bold Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.075083047151565552</real>
+		<key>Green Component</key>
+		<real>0.0</real>
+		<key>Red Component</key>
+		<real>0.73976802825927734</real>
+	</dict>
+	<key>Cursor Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.21945112943649292</real>
+		<key>Green Component</key>
+		<real>0.74987590312957764</real>
+		<key>Red Component</key>
+		<real>0.93704277276992798</real>
+	</dict>
+	<key>Cursor Text Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.037519864737987518</real>
+		<key>Green Component</key>
+		<real>0.032785907387733459</real>
+		<key>Red Component</key>
+		<real>0.02988031692802906</real>
+	</dict>
+	<key>Foreground Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.75428962707519531</real>
+		<key>Green Component</key>
+		<real>0.86175870895385742</real>
+		<key>Red Component</key>
+		<real>0.97308963537216187</real>
+	</dict>
+	<key>Selected Text Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.767447829246521</real>
+		<key>Green Component</key>
+		<real>0.85237473249435425</real>
+		<key>Red Component</key>
+		<real>0.95287787914276123</real>
+	</dict>
+	<key>Selection Color</key>
+	<dict>
+		<key>Blue Component</key>
+		<real>0.30699285864830017</real>
+		<key>Green Component</key>
+		<real>0.41871801018714905</real>
+		<key>Red Component</key>
+		<real>0.43789717555046082</real>
+	</dict>
+</dict>
+</plist>

FluentTerminal.App.Services.Test/ThemeParserFactoryTests.cs

@@ -0,0 +1,45 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using Moq;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class ThemeParserFactoryTests
+    {
+        private readonly Fixture _fixture;
+
+        public ThemeParserFactoryTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Fact]
+        public void GetParser_SupportedFileType_ReturnsParser()
+        {
+            var supportedFileType = _fixture.Create<string>();
+            var parser = new Mock<IThemeParser>();
+            parser.Setup(x => x.SupportedFileTypes).Returns(new string[] { supportedFileType });
+            var themeParserFactory = new ThemeParserFactory(new IThemeParser[] { parser.Object });
+
+            var result = themeParserFactory.GetParser(supportedFileType);
+
+            parser.Should().Be(parser);
+        }
+
+        [Fact]
+        public void GetParser_UnsupportedFileType_ReturnsNull()
+        {
+            var unSupportedFileType = _fixture.Create<string>();
+            var supportedFileType = _fixture.Create<string>();
+            var parser = new Mock<IThemeParser>();
+            parser.Setup(x => x.SupportedFileTypes).Returns(new string[] { supportedFileType });
+            var themeParserFactory = new ThemeParserFactory(new IThemeParser[] { parser.Object });
+
+            var result = themeParserFactory.GetParser(unSupportedFileType);
+
+            result.Should().BeNull();
+        }
+    }
+}

FluentTerminal.App.Services.Test/TrayProcessCommunicationServiceTests.cs

@@ -0,0 +1,179 @@
+using AutoFixture;
+using FluentAssertions;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using FluentTerminal.Models.Requests;
+using FluentTerminal.Models.Responses;
+using Moq;
+using Newtonsoft.Json;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.Foundation.Collections;
+using Xunit;
+
+namespace FluentTerminal.App.Services.Test
+{
+    public class TrayProcessCommunicationServiceTests
+    {
+        private readonly Fixture _fixture;
+
+        public TrayProcessCommunicationServiceTests()
+        {
+            _fixture = new Fixture();
+        }
+
+        [Fact]
+        public async Task CreateTerminal_Default_ReturnsResponseFromAppServiceConnection()
+        {
+            var settingsService = new Mock<ISettingsService>();
+            var keyBindings = _fixture.CreateMany<KeyBinding>(3);
+            settingsService.Setup(x => x.GetCommandKeyBindings()).Returns(new Dictionary<string, ICollection<KeyBinding>>
+            {
+                [nameof(Command.ToggleWindow)] = keyBindings.ToList()
+            });
+            var appServiceConnection = new Mock<IAppServiceConnection>();
+            var response = _fixture.Create<CreateTerminalResponse>();
+            var responseMessage = new ValueSet
+            {
+                [MessageKeys.Type] = _fixture.Create<string>(),
+                [MessageKeys.Content] = JsonConvert.SerializeObject(response)
+            };
+            appServiceConnection.Setup(x => x.SendMessageAsync(It.IsAny<ValueSet>())).Returns(Task.FromResult(responseMessage));
+            var terminalSize = _fixture.Create<TerminalSize>();
+            var shellProfile = _fixture.Create<ShellProfile>();
+            var sessionType = _fixture.Create<SessionType>();
+            var id = _fixture.Create<byte>();
+            var trayProcessCommunicationService = new TrayProcessCommunicationService(settingsService.Object);
+            trayProcessCommunicationService.Initialize(appServiceConnection.Object);
+
+            var result = await trayProcessCommunicationService.CreateTerminal(id, terminalSize, shellProfile, sessionType);
+
+            result.Should().BeEquivalentTo(response);
+        }
+
+        [Fact]
+        public async Task ResizeTerminal_Default_SendsResizeTerminalRequest()
+        {
+            var terminalId = _fixture.Create<byte>();
+            var terminalSize = _fixture.Create<TerminalSize>();
+            var settingsService = new Mock<ISettingsService>();
+            var keyBindings = _fixture.CreateMany<KeyBinding>(3);
+            settingsService.Setup(x => x.GetCommandKeyBindings()).Returns(new Dictionary<string, ICollection<KeyBinding>>
+            {
+                [nameof(Command.ToggleWindow)] = keyBindings.ToList()
+            });
+            var appServiceConnection = new Mock<IAppServiceConnection>();
+            var trayProcessCommunicationService = new TrayProcessCommunicationService(settingsService.Object);
+            trayProcessCommunicationService.Initialize(appServiceConnection.Object);
+
+            await trayProcessCommunicationService.ResizeTerminal(terminalId, terminalSize);
+
+            appServiceConnection.Verify(x => x.SendMessageAsync(It.Is<ValueSet>(d => (byte)d[MessageKeys.Type] == ResizeTerminalRequest.Identifier)), Times.Once);
+        }
+
+        [Fact]
+        public async Task Write_Default_SendsWriteDataRequest()
+        {
+            var terminalId = _fixture.Create<byte>();
+            var data = _fixture.Create<byte[]>();
+            var settingsService = new Mock<ISettingsService>();
+            var keyBindings = _fixture.CreateMany<KeyBinding>(3);
+            settingsService.Setup(x => x.GetCommandKeyBindings()).Returns(new Dictionary<string, ICollection<KeyBinding>>
+            {
+                [nameof(Command.ToggleWindow)] = keyBindings.ToList()
+            });
+            var appServiceConnection = new Mock<IAppServiceConnection>();
+            var trayProcessCommunicationService = new TrayProcessCommunicationService(settingsService.Object);
+            trayProcessCommunicationService.Initialize(appServiceConnection.Object);
+
+            await trayProcessCommunicationService.Write(terminalId, data);
+
+            appServiceConnection.Verify(x => x.SendMessageAsync(It.Is<ValueSet>(d => (byte)d[MessageKeys.Type] == Constants.TerminalBufferRequestIdentifier)), Times.Once);
+        }
+
+        [Fact]
+        public async Task CloseTerminal_Default_SendsTerminalExitedRequest()
+        {
+            var terminalId = _fixture.Create<byte>();
+            var settingsService = new Mock<ISettingsService>();
+            var keyBindings = _fixture.CreateMany<KeyBinding>(3);
+            settingsService.Setup(x => x.GetCommandKeyBindings()).Returns(new Dictionary<string, ICollection<KeyBinding>>
+            {
+                [nameof(Command.ToggleWindow)] = keyBindings.ToList()
+            });
+            var appServiceConnection = new Mock<IAppServiceConnection>();
+            var trayProcessCommunicationService = new TrayProcessCommunicationService(settingsService.Object);
+            trayProcessCommunicationService.Initialize(appServiceConnection.Object);
+
+            await trayProcessCommunicationService.CloseTerminal(terminalId);
+
+            appServiceConnection.Verify(x => x.SendMessageAsync(It.Is<ValueSet>(d => (byte)d[MessageKeys.Type] == TerminalExitedRequest.Identifier)), Times.Once);
+        }
+
+        [Fact]
+        public void OnMessageReceived_TerminalExitedRequest_InvokesTerminalExitedEvent()
+        {
+            var request = new TerminalExitedRequest(_fixture.Create<byte>(), _fixture.Create<int>());
+
+            var receivedExitStatus = (TerminalExitStatus) null;
+
+            var message = new ValueSet
+            {
+                [MessageKeys.Type] = TerminalExitedRequest.Identifier,
+                [MessageKeys.Content] = JsonConvert.SerializeObject(request)
+            };
+            var settingsService = new Mock<ISettingsService>();
+            var keyBindings = _fixture.CreateMany<KeyBinding>(3);
+            settingsService.Setup(x => x.GetCommandKeyBindings()).Returns(new Dictionary<string, ICollection<KeyBinding>>
+            {
+                [nameof(Command.ToggleWindow)] = keyBindings.ToList()
+            });
+            var trayProcessCommunicationService = new TrayProcessCommunicationService(settingsService.Object);
+            var appServiceConnection = new Mock<IAppServiceConnection>();
+            trayProcessCommunicationService.Initialize(appServiceConnection.Object);
+            trayProcessCommunicationService.TerminalExited += (s, status) =>
+            {
+                receivedExitStatus = status;
+            };
+
+            appServiceConnection.Raise(x => x.MessageReceived += null, null, message);
+
+            receivedExitStatus.Should().NotBeNull();
+            receivedExitStatus.TerminalId.Should().Be(request.TerminalId);
+            receivedExitStatus.ExitCode.Should().Be(request.ExitCode);
+        }
+
+        [Fact]
+        public void OnMessageReceived_DisplayTerminalOutputRequest_InvokesCorrectOutputHandler()
+        {
+            var terminalId = _fixture.Create<byte>();
+            var output = _fixture.Create<byte[]>();
+            var receivedOutput = default(byte[]);
+            var message = new ValueSet
+            {
+                [MessageKeys.Type] = Constants.TerminalBufferRequestIdentifier,
+                [MessageKeys.TerminalId] = terminalId,
+                [MessageKeys.Content] = output
+            };
+            var settingsService = new Mock<ISettingsService>();
+            var keyBindings = _fixture.CreateMany<KeyBinding>(3);
+            settingsService.Setup(x => x.GetCommandKeyBindings()).Returns(new Dictionary<string, ICollection<KeyBinding>>
+            {
+                [nameof(Command.ToggleWindow)] = keyBindings.ToList()
+            });
+            var trayProcessCommunicationService = new TrayProcessCommunicationService(settingsService.Object);
+            var appServiceConnection = new Mock<IAppServiceConnection>();
+            trayProcessCommunicationService.Initialize(appServiceConnection.Object);
+            trayProcessCommunicationService.SubscribeForTerminalOutput(terminalId, o =>
+            {
+                receivedOutput = o;
+            });
+
+            appServiceConnection.Raise(x => x.MessageReceived += null, null, message);
+
+            receivedOutput.Should().BeEquivalentTo(output);
+        }
+    }
+}

FluentTerminal.App.Services/Adapters/ApplicationDataContainerAdapter.cs

@@ -0,0 +1,57 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Windows.Storage;
+
+namespace FluentTerminal.App.Services.Adapters
+{
+    public class ApplicationDataContainerAdapter : IApplicationDataContainer
+    {
+        private readonly ApplicationDataContainer _applicationDataContainer;
+
+        public ApplicationDataContainerAdapter(ApplicationDataContainer applicationDataContainer)
+        {
+            _applicationDataContainer = applicationDataContainer;
+        }
+
+        public void Delete(string key)
+        {
+            _applicationDataContainer.Values.Remove(key);
+        }
+
+        public IEnumerable<object> GetAll()
+        {
+            return _applicationDataContainer.Values.Select(x => x.Value);
+        }
+
+        public T ReadValueFromJson<T>(string name, T fallbackValue)
+        {
+            if (_applicationDataContainer.Values.TryGetValue(name, out object value))
+            {
+                if (EqualityComparer<T>.Default.Equals(fallbackValue, default))
+                {
+                    fallbackValue = Activator.CreateInstance<T>();
+                }
+
+                JsonConvert.PopulateObject((string)value, fallbackValue);
+            }
+            return fallbackValue;
+        }
+
+        public void SetValue(string key, object value)
+        {
+            _applicationDataContainer.Values[key] = value;
+        }
+
+        public bool TryGetValue(string key, out object value)
+        {
+            return _applicationDataContainer.Values.TryGetValue(key, out value);
+        }
+
+        public void WriteValueAsJson<T>(string name, T value)
+        {
+            _applicationDataContainer.Values[name] = JsonConvert.SerializeObject(value);
+        }
+    }
+}

FluentTerminal.App.Services/ApplicationDataContainers.cs

@@ -0,0 +1,13 @@
+namespace FluentTerminal.App.Services
+{
+    public class ApplicationDataContainers
+    {
+        public IApplicationDataContainer LocalSettings { get; set; }
+        public IApplicationDataContainer RoamingSettings { get; set; }
+        public IApplicationDataContainer Themes { get; set; }
+        public IApplicationDataContainer KeyBindings { get; set; }
+        public IApplicationDataContainer ShellProfiles { get; set; }
+        public IApplicationDataContainer SshProfiles { get; set; }
+        public IApplicationDataContainer HistoryContainer { get; set; }
+    }
+}

FluentTerminal.App.Services/Constants.cs

@@ -0,0 +1,14 @@
+namespace FluentTerminal.App.Services
+{
+    public static class Constants
+    {
+        public const string ThemesContainerName = "Themes";
+        public const string KeyBindingsContainerName = "KeyBindings";
+        public const string ShellProfilesContainerName = "ShellProfiles";
+        public const string SshProfilesContainerName = "SshProfiles";
+        public const byte TerminalBufferRequestIdentifier = 0;
+        public const string SshCommandName = "ssh";
+        public const string MoshCommandName = "mosh";
+        public const string ExecutedCommandsContainerName = "HistoryContainer";
+    }
+}

FluentTerminal.App.Services/Dialogs/ICreateKeyBindingDialog.cs

@@ -0,0 +1,10 @@
+using FluentTerminal.Models;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Dialogs
+{
+    public interface ICreateKeyBindingDialog
+    {
+        Task<KeyBinding> CreateKeyBinding();
+    }
+}

FluentTerminal.App.Services/Dialogs/IInputDialog.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Dialogs
+{
+    public interface IInputDialog
+    {
+        void SetTitle(string title);
+        Task<string> GetInput();
+    }
+}

FluentTerminal.App.Services/Dialogs/IMessageDialog.cs

@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Dialogs
+{
+    public interface IMessageDialog
+    {
+        string Title { get; set; }
+        string Content { get; set; }
+
+        void AddButton(DialogButton button);
+
+        Task<DialogButton> ShowAsync();
+    }
+}

FluentTerminal.App.Services/Dialogs/IShellProfileSelectionDialog.cs

@@ -0,0 +1,12 @@
+using FluentTerminal.Models;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Dialogs
+{
+    public interface IShellProfileSelectionDialog
+    {
+        ShellProfile SelectedProfile { get; }
+
+        Task<ShellProfile> SelectProfile();
+    }
+}

FluentTerminal.App.Services/Dialogs/ISshConnectionInfoDialog.cs

@@ -0,0 +1,10 @@
+using FluentTerminal.Models;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Dialogs
+{
+    public interface ISshConnectionInfoDialog
+    {
+        Task<SshProfile> GetSshConnectionInfoAsync(SshProfile input = null);
+    }
+}

FluentTerminal.App.Services/Dialogs/ISshProfileSelectionDialog.cs

@@ -0,0 +1,12 @@
+using FluentTerminal.Models;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Dialogs
+{
+    public interface ISshProfileSelectionDialog
+    {
+        SshProfile SelectedProfile { get; }
+
+        Task<SshProfile> SelectProfile();
+    }
+}

FluentTerminal.App.Services/EventArgs/CancelableEventArgs.cs

@@ -0,0 +1,7 @@
+namespace FluentTerminal.App.Services.EventArgs
+{
+    public class CancelableEventArgs : System.EventArgs
+    {
+        public bool Cancelled { get; set; }
+    }
+}

FluentTerminal.App.Services/EventArgs/NewWindowRequestedEventArgs.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace FluentTerminal.App.Services.EventArgs
+{
+    public class NewWindowRequestedEventArgs : System.EventArgs
+    {
+        public Models.Enums.NewWindowAction Action { get; set; }
+        public Guid ProfileId { get; set; }
+    }
+}

FluentTerminal.App.Services/Exceptions/ParseThemeException.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace FluentTerminal.App.Services.Exceptions
+{
+    public class ParseThemeException : Exception
+    {
+        public ParseThemeException() : base()
+        {
+        }
+
+        public ParseThemeException(string message) : base(message)
+        {
+        }
+
+        public ParseThemeException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        protected ParseThemeException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context)
+        {
+        }
+    }
+}

FluentTerminal.App.Services/FluentTerminal.App.Services.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>7.1</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CSharp" Version="4.5.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
+    <PackageReference Include="PListNet" Version="3.0.0" />
+    <PackageReference Include="RestSharp" Version="106.6.9" />
+    <PackageReference Include="Serilog.Sinks.Async" Version="1.4.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="4.0.0" />
+    <PackageReference Include="System.Runtime.InteropServices.WindowsRuntime" Version="4.3.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\FluentTerminal.Models\FluentTerminal.Models.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="Windows.Foundation.FoundationContract">
+      <HintPath>$(MSBuildProgramFiles32)\Windows Kits\10\References\10.0.16299.0\Windows.Foundation.FoundationContract\3.0.0.0\Windows.Foundation.FoundationContract.winmd</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Windows.Foundation.UniversalApiContract">
+      <HintPath>$(MSBuildProgramFiles32)\Windows Kits\10\References\10.0.16299.0\Windows.Foundation.UniversalApiContract\5.0.0.0\Windows.Foundation.UniversalApiContract.winmd</HintPath>
+      <Private>False</Private>
+    </Reference>
+  </ItemGroup>
+
+</Project>

FluentTerminal.App.Services/IAppServiceConnection.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Threading.Tasks;
+using Windows.Foundation.Collections;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IAppServiceConnection
+    {
+        event EventHandler<ValueSet> MessageReceived;
+
+        Task<ValueSet> SendMessageAsync(ValueSet message);
+    }
+}

FluentTerminal.App.Services/IApplicationDataContainer.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IApplicationDataContainer
+    {
+        T ReadValueFromJson<T>(string name, T fallbackValue);
+
+        void WriteValueAsJson<T>(string name, T value);
+
+        bool TryGetValue(string key, out object value);
+
+        void SetValue(string key, object value);
+
+        void Delete(string key);
+
+        IEnumerable<object> GetAll();
+    }
+}

FluentTerminal.App.Services/IApplicationLanguageService.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IApplicationLanguageService
+    {
+        IEnumerable<string> Languages { get; }
+
+        void SetLanguage(string language);
+
+        string GetCurrentLanguage();
+    }
+}

FluentTerminal.App.Services/IApplicationView.cs

@@ -0,0 +1,24 @@
+using FluentTerminal.App.Services.EventArgs;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public delegate Task CloseRequestedHandler(object sender, CancelableEventArgs args);
+
+    public interface IApplicationView
+    {
+        event CloseRequestedHandler CloseRequested;
+        event EventHandler Closed;
+
+        int Id { get; }
+        string Title { get; set; }
+
+        Task RunOnDispatcherThread(Action action, bool enforceNewSchedule = true);
+
+        Task<bool> TryClose();
+
+        bool ToggleFullScreen();
+        bool IsApiContractPresent(string api, ushort version);
+    }
+}

FluentTerminal.App.Services/IClipboardService.cs

@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IClipboardService
+    {
+        Task<string> GetText();
+
+        void SetText(string text);
+    }
+}

FluentTerminal.App.Services/IDefaultValueProvider.cs

@@ -0,0 +1,26 @@
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using System;
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IDefaultValueProvider
+    {
+        ApplicationSettings GetDefaultApplicationSettings();
+
+        ICollection<KeyBinding> GetDefaultKeyBindings(Command command);
+
+        Guid GetDefaultShellProfileId();
+
+        IEnumerable<TabTheme> GetDefaultTabThemes();
+
+        TerminalOptions GetDefaultTerminalOptions();
+
+        Guid GetDefaultThemeId();
+
+        IEnumerable<ShellProfile> GetPreinstalledShellProfiles();
+
+        IEnumerable<TerminalTheme> GetPreInstalledThemes();
+    }
+}

FluentTerminal.App.Services/IDialogService.cs

@@ -0,0 +1,25 @@
+using FluentTerminal.Models;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public enum DialogButton
+    {
+        OK,
+        Cancel
+    }
+
+    public interface IDialogService
+    {
+        Task<DialogButton> ShowMessageDialogAsnyc(string title, string content, params DialogButton[] buttons);
+
+        Task<ShellProfile> ShowProfileSelectionDialogAsync();
+
+        Task<KeyBinding> ShowCreateKeyBindingDialog();
+        Task<string> ShowInputDialogAsync(string title);
+
+        Task<SshProfile> ShowSshConnectionInfoDialogAsync(SshProfile input = null);
+
+        Task<SshProfile> ShowSshProfileSelectionDialogAsync();
+    }
+}

FluentTerminal.App.Services/IDispatcherTimer.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IDispatcherTimer
+    {
+        void Start();
+
+        void Stop();
+
+        TimeSpan Interval { get; set; }
+        bool IsEnabled { get; }
+
+        event EventHandler<object> Tick;
+    }
+}

FluentTerminal.App.Services/IFileSystemService.cs

@@ -0,0 +1,15 @@
+using FluentTerminal.Models;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IFileSystemService
+    {
+        Task<File> OpenFile(IEnumerable<string> fileTypes);
+
+        Task<string> BrowseForDirectory();
+
+        Task SaveTextFile(string name, string fileTypeDescription, string fileType, string content);
+    }
+}

FluentTerminal.App.Services/IKeyboardCommandService.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IKeyboardCommandService
+    {
+        void RegisterCommandHandler(string command, Action handler);
+
+        void SendCommand(string command);
+        void DeregisterCommandHandler(string command);
+    }
+}

FluentTerminal.App.Services/INotificationService.cs

@@ -0,0 +1,7 @@
+namespace FluentTerminal.App.Services
+{
+    public interface INotificationService
+    {
+        void ShowNotification(string title, string content, string url = null);
+    }
+}

FluentTerminal.App.Services/ISettingsService.cs

@@ -0,0 +1,52 @@
+using FluentTerminal.Models;
+using System;
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services
+{
+    public interface ISettingsService
+    {
+        event EventHandler<ApplicationSettings> ApplicationSettingsChanged;
+        event EventHandler<Guid> CurrentThemeChanged;
+        event EventHandler KeyBindingsChanged;
+        event EventHandler<ShellProfile> ShellProfileAdded;
+        event EventHandler<Guid> ShellProfileDeleted;
+        event EventHandler<SshProfile> SshProfileAdded;
+        event EventHandler<Guid> SshProfileDeleted;
+        event EventHandler<TerminalOptions> TerminalOptionsChanged;
+        event EventHandler<Guid> ThemeDeleted;
+        event EventHandler<TerminalTheme> ThemeAdded;
+
+        void DeleteShellProfile(Guid id);
+        void DeleteSshProfile(Guid id);
+        void DeleteTheme(Guid id);
+        ApplicationSettings GetApplicationSettings();
+        TerminalTheme GetCurrentTheme();
+        Guid GetCurrentThemeId();
+        ShellProfile GetDefaultShellProfile();
+        SshProfile GetDefaultSshProfile();
+        Guid GetDefaultShellProfileId();
+        Guid GetDefaultSshProfileId();
+        IDictionary<string, ICollection<KeyBinding>> GetCommandKeyBindings();
+        IEnumerable<ShellProfile> GetShellProfiles();
+        IEnumerable<SshProfile> GetSshProfiles();
+        IEnumerable<TabTheme> GetTabThemes();
+        TerminalOptions GetTerminalOptions();
+        TerminalTheme GetTheme(Guid id);
+        IEnumerable<TerminalTheme> GetThemes();
+        void ResetKeyBindings();
+        void SaveApplicationSettings(ApplicationSettings applicationSettings);
+        void SaveCurrentThemeId(Guid id);
+        void SaveDefaultShellProfileId(Guid id);
+        void SaveDefaultSshProfileId(Guid id);
+        void SaveKeyBindings(string command, ICollection<KeyBinding> keyBindings);
+        void SaveShellProfile(ShellProfile shellProfile, bool newShell = false);
+        void SaveSshProfile(SshProfile shellProfile, bool newShell = false);
+        void SaveTerminalOptions(TerminalOptions terminalOptions);
+        void SaveTheme(TerminalTheme theme, bool newTheme = false);
+        ShellProfile GetShellProfile(Guid id);
+        SshProfile GetSshProfile(Guid id);
+        string ExportSettings();
+        void ImportSettings(string serializedSettings);
+    }
+}

FluentTerminal.App.Services/IStartupTaskService.cs

@@ -0,0 +1,12 @@
+using FluentTerminal.Models.Enums;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IStartupTaskService
+    {
+        Task DisableStartupTask();
+        Task<StartupTaskStatus> EnableStartupTask();
+        Task<StartupTaskStatus> GetStatus();
+    }
+}

FluentTerminal.App.Services/ISystemFontService.cs

@@ -0,0 +1,10 @@
+using FluentTerminal.Models;
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services
+{
+    public interface ISystemFontService
+    {
+        IEnumerable<FontInfo> GetSystemFontFamilies();
+    }
+}

FluentTerminal.App.Services/IThemeParser.cs

@@ -0,0 +1,14 @@
+using FluentTerminal.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IThemeParser
+    {
+        IEnumerable<string> SupportedFileTypes { get; }
+
+        Task<TerminalTheme> Parse(string fileName, Stream fileContent);
+    }
+}

FluentTerminal.App.Services/IThemeParserFactory.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IThemeParserFactory
+    {
+        IEnumerable<string> SupportedFileTypes { get; }
+
+        IThemeParser GetParser(string fileType);
+    }
+}

FluentTerminal.App.Services/ITrayProcessCommunicationService.cs

@@ -0,0 +1,41 @@
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using FluentTerminal.Models.Responses;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public interface ITrayProcessCommunicationService
+    {
+        event EventHandler<TerminalExitStatus> TerminalExited;
+
+        void Initialize(IAppServiceConnection appServiceConnection);
+
+        Task<CreateTerminalResponse> CreateTerminal(byte id, TerminalSize size, ShellProfile shellProfile, SessionType sessionType);
+
+        Task ResizeTerminal(byte id, TerminalSize size);
+
+        Task UpdateToggleWindowKeyBindings();
+
+        Task Write(byte terminalId, byte[] data);
+
+        void SubscribeForTerminalOutput(byte terminalId, Action<byte[]> callback);
+
+        Task CloseTerminal(byte terminalId);
+        Task<GetAvailablePortResponse> GetAvailablePort();
+        byte GetNextTerminalId();
+
+        Task<string> GetUserName();
+
+        Task SaveTextFileAsync(string path, string content);
+
+        Task<string> GetSshConfigDirAsync();
+
+        Task<string[]> GetFilesFromSshConfigDirAsync();
+
+        Task<bool> CheckFileExistsAsync(string path);
+
+        void MuteTerminal(bool mute);
+    }
+}

FluentTerminal.App.Services/IUpdateService.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public interface IUpdateService
+    {
+        Task CheckForUpdate(bool notifyNoUpdate = false);
+        Version GetCurrentVersion();
+        Task<Version> GetLatestVersionAsync();
+    }
+}

FluentTerminal.App.Services/Implementation/DefaultValueProvider.cs

@@ -0,0 +1,642 @@
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using System;
+using System.Collections.Generic;
+using Windows.Foundation.Metadata;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class DefaultValueProvider : IDefaultValueProvider
+    {
+        public ApplicationSettings GetDefaultApplicationSettings()
+        {
+            return new ApplicationSettings
+            {
+                ConfirmClosingTabs = false,
+                ConfirmClosingWindows = false,
+                UnderlineSelectedTab = false,
+                InactiveTabColorMode = InactiveTabColorMode.Background,
+                NewTerminalLocation = NewTerminalLocation.Tab,
+                TabsPosition = TabsPosition.Top,
+                CopyOnSelect = false,
+                MouseMiddleClickAction = MouseAction.None,
+                MouseRightClickAction = MouseAction.ContextMenu,
+                AlwaysShowTabs = false,
+                ShowNewOutputIndicator = false,
+                EnableTrayIcon = true,
+                ShowCustomTitleInTitlebar = true,
+                UseMoshByDefault = true,
+                AutoFallbackToWindowsUsernameInLinks = true,
+                UseQuickSshConnectByDefault = false,
+                RTrimCopiedLines = true,
+                MuteTerminalBeeps = true
+            };
+        }
+
+        public ICollection<KeyBinding> GetDefaultKeyBindings(Command command)
+        {
+            switch (command)
+            {
+                case Command.ToggleWindow:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ToggleWindow),
+                        Key = (int)ExtendedVirtualKey.Scroll
+                    }
+                };
+
+                case Command.NextTab:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.NextTab),
+                        Ctrl = true,
+                        Key = (int)ExtendedVirtualKey.Tab
+                    }
+                };
+
+                case Command.PreviousTab:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.PreviousTab),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.Tab
+                    }
+                };
+
+                case Command.SwitchToTerm1:
+                case Command.SwitchToTerm2:
+                case Command.SwitchToTerm3:
+                case Command.SwitchToTerm4:
+                case Command.SwitchToTerm5:
+                case Command.SwitchToTerm6:
+                case Command.SwitchToTerm7:
+                case Command.SwitchToTerm8:
+                case Command.SwitchToTerm9:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = command.ToString(),
+                        Alt = true,
+                        Key = (int)ExtendedVirtualKey.Number1 + (command - Command.SwitchToTerm1)
+                    }
+                };
+
+                case Command.NewTab:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.NewTab),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.T
+                    }
+                };
+
+                case Command.ConfigurableNewTab:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ConfigurableNewTab),
+                        Ctrl = true,
+                        Alt = true,
+                        Key = (int)ExtendedVirtualKey.T
+                    }
+                };
+
+                case Command.NewSshTab:
+                    return new List<KeyBinding>
+                    {
+                        new KeyBinding
+                        {
+                            Command = nameof(Command.NewSshTab),
+                            Ctrl = true,
+                            Shift = true,
+                            Key = (int)ExtendedVirtualKey.Y
+                        }
+                    };
+
+                case Command.NewSshWindow:
+                    return new List<KeyBinding>
+                    {
+                        new KeyBinding
+                        {
+                            Command = nameof(Command.NewSshWindow),
+                            Ctrl = true,
+                            Alt = true,
+                            Key = (int)ExtendedVirtualKey.Y
+                        }
+                    };
+
+                case Command.SavedSshNewTab:
+                    return new List<KeyBinding>
+                    {
+                        new KeyBinding
+                        {
+                            Command = nameof(Command.SavedSshNewTab),
+                            Ctrl = true,
+                            Shift = true,
+                            Key = (int)ExtendedVirtualKey.U
+                        }
+                    };
+
+                case Command.SavedSshNewWindow:
+                    return new List<KeyBinding>
+                    {
+                        new KeyBinding
+                        {
+                            Command = nameof(Command.SavedSshNewWindow),
+                            Ctrl = true,
+                            Alt = true,
+                            Key = (int)ExtendedVirtualKey.U
+                        }
+                    };
+
+
+                case Command.ChangeTabTitle:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ChangeTabTitle),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.R
+                    }
+                };
+
+                case Command.CloseTab:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.CloseTab),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.W
+                    }
+                };
+
+                case Command.NewWindow:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.NewWindow),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.N
+                    }
+                };
+
+                case Command.ConfigurableNewWindow:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ConfigurableNewWindow),
+                        Ctrl = true,
+                        Alt = true,
+                        Key = (int)ExtendedVirtualKey.N
+                    }
+                };
+
+                case Command.ShowSettings:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ShowSettings),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.Comma
+                    }
+                };
+
+                case Command.Copy:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.Copy),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.C
+                    }
+                };
+
+                case Command.Paste:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.Paste),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.V
+                    }
+                };
+
+
+                case Command.PasteWithoutNewlines:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.PasteWithoutNewlines),
+                        Ctrl = true,
+                        Alt = true,
+                        Key = (int)ExtendedVirtualKey.V
+                    }
+                };
+
+                case Command.Search:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.Search),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.F
+                    }
+                };
+
+                case Command.ToggleFullScreen:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ToggleFullScreen),
+                        Alt = true,
+                        Key = (int)ExtendedVirtualKey.Enter
+                    },
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.ToggleFullScreen),
+                        Key = (int)ExtendedVirtualKey.F11
+                    }
+                };
+
+                case Command.SelectAll:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.SelectAll),
+                        Ctrl = true,
+                        Shift = true,
+                        Key = (int)ExtendedVirtualKey.A
+                    }
+                };
+
+                case Command.Clear:
+                    return new List<KeyBinding>
+                {
+                    new KeyBinding
+                    {
+                        Command = nameof(Command.Clear),
+                        Ctrl = true,
+                        Alt = true,
+                        Key = (int)ExtendedVirtualKey.L
+                    }
+                };
+
+            }
+
+            return null;
+        }
+
+        public Guid GetDefaultShellProfileId()
+        {
+            return Guid.Parse("813f2298-210a-481a-bdbf-c17bc637a3e2");
+        }
+
+        public IEnumerable<TabTheme> GetDefaultTabThemes()
+        {
+            return new[]
+            {
+                new TabTheme
+                {
+                    Id = 0,
+                    Name = I18N.Translate("TabTheme.None"),
+                    BackgroundOpacity = double.NaN,
+                    BackgroundPointerOverOpacity = double.NaN,
+                    BackgroundPressedOpacity = double.NaN,
+                    BackgroundSelectedOpacity = double.NaN,
+                    BackgroundSelectedPointerOverOpacity = double.NaN,
+                    BackgroundSelectedPressedOpacity = double.NaN
+                },
+                new TabTheme
+                {
+                    Id = 1,
+                    Name = I18N.Translate("TabTheme.Red"),
+                    Color = "#E81123"
+                },
+                new TabTheme
+                {
+                    Id = 2,
+                    Name = I18N.Translate("TabTheme.Green"),
+                    Color = "#10893E"
+                },
+                new TabTheme
+                {
+                    Id = 3,
+                    Name = I18N.Translate("TabTheme.Blue"),
+                    Color = "#0078D7"
+                },
+                new TabTheme
+                {
+                    Id = 4,
+                    Name = I18N.Translate("TabTheme.Purple"),
+                    Color = "#881798"
+                },
+                new TabTheme
+                {
+                    Id = 5,
+                    Name = I18N.Translate("TabTheme.Orange"),
+                    Color = "#FF8C00"
+                },
+                new TabTheme
+                {
+                    Id = 6,
+                    Name = I18N.Translate("TabTheme.Teal"),
+                    Color = "#00B7C3"
+                }
+            };
+        }
+
+        public TerminalOptions GetDefaultTerminalOptions()
+        {
+            return new TerminalOptions
+            {
+                BellStyle = BellStyle.None,
+                CursorBlink = true,
+                CursorStyle = CursorStyle.Block,
+                ScrollBarStyle = ScrollBarStyle.Hidden,
+                FontFamily = "Consolas",
+                FontSize = 13,
+                BoldText = false,
+                BackgroundOpacity = 0.8,
+                Padding = 12,
+                ScrollBackLimit = 1000
+            };
+        }
+
+        public Guid GetDefaultThemeId()
+        {
+            return Guid.Parse("281e4352-bb50-47b7-a691-2b13830df95e");
+        }
+
+        public IEnumerable<ShellProfile> GetPreinstalledShellProfiles()
+        {
+            return new[]
+            {
+                new ShellProfile
+                {
+                    Id = GetDefaultShellProfileId(),
+                    Name = "Powershell",
+                    Arguments = string.Empty,
+                    Location = @"C:\windows\system32\WindowsPowerShell\v1.0\powershell.exe",
+                    PreInstalled = true,
+                    WorkingDirectory = string.Empty,
+                    LineEndingTranslation = LineEndingStyle.DoNotModify,
+                    UseConPty = ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 8), // Windows 10 1903+
+                    KeyBindings = new []
+                    {
+                        new KeyBinding
+                        {
+                            Command = GetDefaultShellProfileId().ToString(),
+                            Ctrl=true,
+                            Alt=true,
+                            Shift=false,
+                            Meta=false,
+                            Key=(int)ExtendedVirtualKey.Number1
+                        }
+                    }
+                },
+                new ShellProfile
+                {
+                    Id = Guid.Parse("ab942a61-7673-4755-9bd8-765aff91d9a3"),
+                    Name = "CMD",
+                    Arguments = string.Empty,
+                    Location = @"C:\Windows\System32\cmd.exe",
+                    PreInstalled = true,
+                    WorkingDirectory = string.Empty,
+                    LineEndingTranslation = LineEndingStyle.DoNotModify,
+                    UseConPty = ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 7), // Windows 10 1809+
+                    KeyBindings = new []
+                    {
+                        new KeyBinding
+                        {
+                            Command = "ab942a61-7673-4755-9bd8-765aff91d9a3",
+                            Ctrl=true,
+                            Alt=true,
+                            Shift=false,
+                            Meta=false,
+                            Key=(int)ExtendedVirtualKey.Number2
+                        }
+                    }
+                },
+                new ShellProfile
+                {
+                    Id= Guid.Parse("e5785ad6-584f-40cb-bdcd-d5b3b3953e7f"),
+                    Name = "WSL",
+                    Arguments = string.Empty,
+                    Location = @"C:\windows\system32\wsl.exe",
+                    PreInstalled = true,
+                    WorkingDirectory = string.Empty,
+                    LineEndingTranslation = LineEndingStyle.ToLF,
+                    UseConPty = ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 7), // Windows 10 1809+
+                    KeyBindings = new []
+                    {
+                        new KeyBinding
+                        {
+                            Command = "e5785ad6-584f-40cb-bdcd-d5b3b3953e7f",
+                            Ctrl=true,
+                            Alt=true,
+                            Shift=false,
+                            Meta=false,
+                            Key=(int)ExtendedVirtualKey.Number3
+                        }
+                    }
+                }
+            };
+        }
+
+        public IEnumerable<TerminalTheme> GetPreInstalledThemes()
+        {
+            var defaultXterm = new TerminalTheme
+            {
+                Id = GetDefaultThemeId(),
+                Author = "xterm.js",
+                Name = "Xterm.js Default",
+                PreInstalled = true,
+                Colors = new TerminalColors
+                {
+                    Black = "#2e3436",
+                    Red = "#cc0000",
+                    Green = "#4e9a06",
+                    Yellow = "#c4a000",
+                    Blue = "#3465a4",
+                    Magenta = "#75507b",
+                    Cyan = "#06989a",
+                    White = "#d3d7cf",
+                    BrightBlack = "#555753",
+                    BrightRed = "#ef2929",
+                    BrightGreen = "#8ae234",
+                    BrightYellow = "#fce94f",
+                    BrightBlue = "#729fcf",
+                    BrightMagenta = "#ad7fa8",
+                    BrightCyan = "#34e2e2",
+                    BrightWhite = "#eeeeec",
+                    Foreground = "#ffffff",
+                    Background = "#000000",
+                    Cursor = "#ffffff",
+                    CursorAccent = "#000000",
+                    Selection = "rgba(255, 255, 255, 0.3)"
+                }
+            };
+
+            var powerShell = new TerminalTheme
+            {
+                Id = Guid.Parse("3571ce1b-31ce-4cf7-ae15-e0bff70c3eea"),
+                Author = "Microsoft",
+                Name = "PowerShell",
+                PreInstalled = true,
+                Colors = new TerminalColors
+                {
+                    Black = "#000000",
+                    Red = "#800000",
+                    Green = "#008000",
+                    Yellow = "#EEEDF0",
+                    Blue = "#000080",
+                    Magenta = "#012456",
+                    Cyan = "#008080",
+                    White = "#c0c0c0",
+                    BrightBlack = "#808080",
+                    BrightRed = "#ff0000",
+                    BrightGreen = "#00ff00",
+                    BrightYellow = "#ffff00",
+                    BrightBlue = "#0000ff",
+                    BrightMagenta = "#ff00ff",
+                    BrightCyan = "#00ffff",
+                    BrightWhite = "#ffffff",
+                    Foreground = "#ffffff",
+                    Background = "#012456",
+                    Cursor = "#fedba9",
+                    CursorAccent = "#000000",
+                    Selection = "rgba(254, 219, 169, 0.3)"
+                }
+            };
+
+            var homebrew = new TerminalTheme
+            {
+                Id = Guid.Parse("5f034210-067b-40e2-b9c9-6a25eb6fb8e6"),
+                Author = "Hans Kokx",
+                Name = "Homebrew",
+                PreInstalled = true,
+                Colors = new TerminalColors
+                {
+                    Black = "#000000",
+                    Red = "#A0160B",
+                    Green = "#00AF21",
+                    Yellow = "#A1A222",
+                    Blue = "#192AB7",
+                    Magenta = "#AA2FAE",
+                    Cyan = "#12B1BC",
+                    White = "#BBB5AF",
+                    BrightBlack = "#747876",
+                    BrightRed = "#E52213",
+                    BrightGreen = "#00D92B",
+                    BrightYellow = "#E6E435",
+                    BrightBlue = "#283EF9",
+                    BrightMagenta = "#EB43E6",
+                    BrightCyan = "#15E7E8",
+                    BrightWhite = "#E9E9E9",
+                    Foreground = "#00D92B",
+                    Background = "#000000",
+                    Cursor = "#00D92B",
+                    CursorAccent = "#000000",
+                    Selection = "#4CFFFFFF"
+                }
+            };
+
+            var tomorrow = new TerminalTheme
+            {
+                Id = Guid.Parse("0cbbf805-fa86-4be5-ac51-75f3054dcc3a"),
+                Author = "Chris Kempson",
+                Name = "Tomorrow",
+                PreInstalled = true,
+                Colors = new TerminalColors
+                {
+                    Foreground = "#4D4D4C",
+                    Background = "#FFFFFF",
+                    Cursor = "#4D4D4C",
+                    CursorAccent = "#FFFFFF",
+                    Selection = "rgba(214, 214, 214, 0.5)",
+                    Black = "#000000",
+                    Red = "#C82829",
+                    Green = "#718C00",
+                    Yellow = "#EAB700",
+                    Blue = "#4271AE",
+                    Magenta = "#8959A8",
+                    Cyan = "#3E999F",
+                    White = "#FFFFFF",
+                    BrightBlack = "#000000",
+                    BrightRed = "#C82829",
+                    BrightGreen = "#718C00",
+                    BrightYellow = "#EAB700",
+                    BrightBlue = "#4271AE",
+                    BrightMagenta = "#8959A8",
+                    BrightCyan = "#3E999F",
+                    BrightWhite = "#FFFFFF"
+                }
+            };
+
+            var ubuntu = new TerminalTheme
+            {
+                Id = Guid.Parse("32519543-bf94-4db6-92a1-7bcec3966c82"),
+                Author = "Canonical",
+                Name = "Ubuntu Bash",
+                PreInstalled = true,
+                Colors = new TerminalColors
+                {
+                    Foreground = "#EEEEEE",
+                    Background = "#300A24",
+                    Cursor = "#CFF5DB",
+                    CursorAccent = "#000000",
+                    Selection = "#4DABEDC1",
+                    Black = "#300A24",
+                    Red = "#CC0000",
+                    Green = "#4E9A06",
+                    Yellow = "#C4A000",
+                    Blue = "#3465A4",
+                    Magenta = "#75507B",
+                    Cyan = "#06989A",
+                    White = "#D3D7CF",
+                    BrightBlack = "#554E53",
+                    BrightRed = "#EF2929",
+                    BrightGreen = "#8AE234",
+                    BrightYellow = "#FCE94F",
+                    BrightBlue = "#729FCF",
+                    BrightMagenta = "#AD7FA8",
+                    BrightCyan = "#34E2E2",
+                    BrightWhite = "#EEEEEE"
+                }
+            };
+
+            return new[] { defaultXterm, powerShell, homebrew, tomorrow, ubuntu };
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/DialogService.cs

@@ -0,0 +1,91 @@
+using FluentTerminal.App.Services.Dialogs;
+using FluentTerminal.Models;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class DialogService : IDialogService
+    {
+        private readonly Func<IShellProfileSelectionDialog> _shellProfileSelectionDialogFactory;
+        private readonly Func<IMessageDialog> _messageDialogFactory;
+        private readonly Func<ICreateKeyBindingDialog> _createKeyBindingDialogFactory;
+        private readonly Func<IInputDialog> _inputDialogFactory;
+        private readonly Func<ISshConnectionInfoDialog> _sshConnectionInfoDialogFactory;
+        private readonly Func<ISshProfileSelectionDialog> _sshProfileSelectionDialogFactory;
+
+        public DialogService(Func<IShellProfileSelectionDialog> shellProfileSelectionDialogFactory,
+            Func<IMessageDialog> messageDialogFactory, Func<ICreateKeyBindingDialog> createKeyBindingDialogFactory,
+            Func<IInputDialog> inputDialogFactory, Func<ISshConnectionInfoDialog> sshConnectionInfoDialogFactory,
+            Func<ISshProfileSelectionDialog> sshProfileSelectionDialogFactory)
+        {
+            _shellProfileSelectionDialogFactory = shellProfileSelectionDialogFactory;
+            _messageDialogFactory = messageDialogFactory;
+            _createKeyBindingDialogFactory = createKeyBindingDialogFactory;
+            _inputDialogFactory = inputDialogFactory;
+            _sshConnectionInfoDialogFactory = sshConnectionInfoDialogFactory;
+            _sshProfileSelectionDialogFactory = sshProfileSelectionDialogFactory;
+        }
+
+        public Task<KeyBinding> ShowCreateKeyBindingDialog()
+        {
+            var dialog = _createKeyBindingDialogFactory();
+
+            return dialog.CreateKeyBinding();
+        }
+
+        public Task<DialogButton> ShowMessageDialogAsnyc(string title, string content, params DialogButton[] buttons)
+        {
+            if (string.IsNullOrWhiteSpace(title))
+            {
+                throw new ArgumentNullException(nameof(title));
+            }
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                throw new ArgumentNullException(nameof(content));
+            }
+
+            if (buttons.Length == 0)
+            {
+                throw new ArgumentException("Must not be empty", nameof(buttons));
+            }
+
+            var dialog = _messageDialogFactory();
+            dialog.Content = content;
+            dialog.Title = title;
+
+            foreach (var button in buttons)
+            {
+                dialog.AddButton(button);
+            }
+
+            return dialog.ShowAsync();
+        }
+
+        public Task<string> ShowInputDialogAsync(string title)
+        {
+            var dialog = _inputDialogFactory.Invoke();
+            dialog.SetTitle(title);
+
+            return dialog.GetInput();
+        }
+
+        public Task<ShellProfile> ShowProfileSelectionDialogAsync()
+        {
+            var dialog = _shellProfileSelectionDialogFactory();
+
+            return dialog.SelectProfile();
+        }
+
+        public Task<SshProfile> ShowSshConnectionInfoDialogAsync(SshProfile input = null) =>
+            _sshConnectionInfoDialogFactory().GetSshConnectionInfoAsync(input);
+
+        public Task<SshProfile> ShowSshProfileSelectionDialogAsync()
+        {
+            var dialog = _sshProfileSelectionDialogFactory();
+
+            return dialog.SelectProfile();
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/FluentTerminalThemeParser.cs

@@ -0,0 +1,38 @@
+using FluentTerminal.Models;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class FluentTerminalThemeParser : IThemeParser
+    {
+        public IEnumerable<string> SupportedFileTypes { get; } = new string[] { ".flutecolors" };
+
+        public async Task<TerminalTheme> Parse(string fileName, Stream fileContent)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                throw new ArgumentNullException(nameof(fileName));
+            }
+
+            if (fileContent == null)
+            {
+                throw new ArgumentNullException(nameof(fileContent));
+            }
+
+            using (var streamReader = new StreamReader(fileContent))
+            {
+                var content = await streamReader.ReadToEndAsync();
+                var theme = JsonConvert.DeserializeObject<TerminalTheme>(content);
+
+                theme.PreInstalled = false;
+                theme.Id = Guid.NewGuid();
+
+                return theme;
+            }
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/ITermThemeParser.cs

@@ -0,0 +1,137 @@
+using FluentTerminal.App.Services.Exceptions;
+using FluentTerminal.Models;
+using PListNet;
+using PListNet.Nodes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class ITermThemeParser : IThemeParser
+    {
+        private const byte Opacity30Percent = 77;
+
+        public IEnumerable<string> SupportedFileTypes { get; } = new string[] { ".itermcolors" };
+
+        private static class ITermThemeKeys
+        {
+            public const string Ansi0Color = "Ansi 0 Color";
+            public const string Ansi1Color = "Ansi 1 Color";
+            public const string Ansi2Color = "Ansi 2 Color";
+            public const string Ansi3Color = "Ansi 3 Color";
+            public const string Ansi4Color = "Ansi 4 Color";
+            public const string Ansi5Color = "Ansi 5 Color";
+            public const string Ansi6Color = "Ansi 6 Color";
+            public const string Ansi7Color = "Ansi 7 Color";
+            public const string Ansi8Color = "Ansi 8 Color";
+            public const string Ansi9Color = "Ansi 9 Color";
+            public const string Ansi10Color = "Ansi 10 Color";
+            public const string Ansi11Color = "Ansi 11 Color";
+            public const string Ansi12Color = "Ansi 12 Color";
+            public const string Ansi13Color = "Ansi 13 Color";
+            public const string Ansi14Color = "Ansi 14 Color";
+            public const string Ansi15Color = "Ansi 15 Color";
+
+            public const string BackgroundColor = "Background Color";
+            public const string BoldColor = "Bold Color";
+            public const string CursorColor = "Cursor Color";
+            public const string CursorTextColor = "Cursor Text Color";
+            public const string ForegroundColor = "Foreground Color";
+            public const string SelectedTextColor = "Selected Text Color";
+            public const string SelectionColor = "Selection Color";
+        }
+
+        private static class ITermThemeColorKeys
+        {
+            public const string BlueComponent = "Blue Component";
+            public const string GreenComponent = "Green Component";
+            public const string RedComponent = "Red Component";
+        }
+
+        public async Task<TerminalTheme> Parse(string fileName, Stream fileContent)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                throw new ArgumentNullException(nameof(fileName));
+            }
+
+            if (fileContent == null)
+            {
+                throw new ArgumentNullException(nameof(fileContent));
+            }
+
+            var node = PList.Load(fileContent) as DictionaryNode ?? throw new ParseThemeException("Root node was not a dictionary.");
+
+            return new TerminalTheme
+            {
+                Name = Path.GetFileNameWithoutExtension(fileName),
+                Colors = GetColors(node),
+                Id = Guid.NewGuid(),
+                PreInstalled = false
+            };
+        }
+
+        private TerminalColors GetColors(DictionaryNode themeDictionary)
+        {
+            return new TerminalColors
+            {
+                Background = GetColorString(themeDictionary[ITermThemeKeys.BackgroundColor]),
+                Foreground = GetColorString(themeDictionary[ITermThemeKeys.ForegroundColor]),
+                Cursor = GetColorString(themeDictionary[ITermThemeKeys.CursorColor]),
+                CursorAccent = GetColorString(themeDictionary[ITermThemeKeys.CursorTextColor]),
+                Selection = GetColorString(themeDictionary[ITermThemeKeys.SelectionColor], Opacity30Percent),
+                Black = GetColorString(themeDictionary[ITermThemeKeys.Ansi0Color]),
+                Red = GetColorString(themeDictionary[ITermThemeKeys.Ansi1Color]),
+                Green = GetColorString(themeDictionary[ITermThemeKeys.Ansi2Color]),
+                Yellow = GetColorString(themeDictionary[ITermThemeKeys.Ansi3Color]),
+                Blue = GetColorString(themeDictionary[ITermThemeKeys.Ansi4Color]),
+                Magenta = GetColorString(themeDictionary[ITermThemeKeys.Ansi5Color]),
+                Cyan = GetColorString(themeDictionary[ITermThemeKeys.Ansi6Color]),
+                White = GetColorString(themeDictionary[ITermThemeKeys.Ansi7Color]),
+                BrightBlack = GetColorString(themeDictionary[ITermThemeKeys.Ansi8Color]),
+                BrightRed = GetColorString(themeDictionary[ITermThemeKeys.Ansi9Color]),
+                BrightGreen = GetColorString(themeDictionary[ITermThemeKeys.Ansi10Color]),
+                BrightYellow = GetColorString(themeDictionary[ITermThemeKeys.Ansi11Color]),
+                BrightBlue = GetColorString(themeDictionary[ITermThemeKeys.Ansi12Color]),
+                BrightMagenta = GetColorString(themeDictionary[ITermThemeKeys.Ansi13Color]),
+                BrightCyan = GetColorString(themeDictionary[ITermThemeKeys.Ansi14Color]),
+                BrightWhite = GetColorString(themeDictionary[ITermThemeKeys.Ansi15Color]),
+            };
+        }
+
+        private string GetColorString(PNode colorNode, byte alpha = Byte.MaxValue)
+        {
+            var dictionaryNode = colorNode as DictionaryNode ?? throw new ParseThemeException("Color node was not a dictionary");
+
+            var red = dictionaryNode[ITermThemeColorKeys.RedComponent] as RealNode ?? throw new ParseThemeException("Red node value was not a real number");
+            var green = dictionaryNode[ITermThemeColorKeys.GreenComponent] as RealNode ?? throw new ParseThemeException("Green node value was not a real number");
+            var blue = dictionaryNode[ITermThemeColorKeys.BlueComponent] as RealNode ?? throw new ParseThemeException("Blue node value was not a real number");
+
+            var color = $"#{alpha:X2}{GetByteValue(red):X2}{GetByteValue(green):X2}{GetByteValue(blue):X2}";
+
+            if (alpha == byte.MaxValue)
+            {
+                return $"#{GetByteValue(red):X2}{GetByteValue(green):X2}{GetByteValue(blue):X2}";
+            }
+            else
+            {
+                return $"rgba({GetByteValue(red):G}, {GetByteValue(green):G}, {GetByteValue(blue):G}, {ToDoubleString(alpha)})";
+            }
+        }
+
+        private byte GetByteValue(RealNode node)
+        {
+            var doubleValue = node.Value * Byte.MaxValue;
+
+            return Convert.ToByte(doubleValue);
+        }
+
+        private static string ToDoubleString(byte alpha)
+        {
+            return (alpha / 256.0).ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/KeyboardCommandService.cs

@@ -0,0 +1,46 @@
+using FluentTerminal.Models.Enums;
+using System;
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class KeyboardCommandService : IKeyboardCommandService
+    {
+        private readonly Dictionary<string, Action> _commandHandlers = new Dictionary<string, Action>();
+
+        public void RegisterCommandHandler(string command, Action handler)
+        {
+            if (_commandHandlers.ContainsKey(command))
+            {
+                throw new InvalidOperationException("command already registered");
+            }
+
+            _commandHandlers[command] = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public void DeregisterCommandHandler(string command)
+        {
+            if (_commandHandlers.ContainsKey(command))
+            {
+                _commandHandlers.Remove(command);
+            }
+        }
+
+        public void SendCommand(string command)
+        {
+            if (_commandHandlers.TryGetValue(command, out Action handler))
+            {
+                handler.Invoke();
+                return;
+            }
+
+            // already registered by SystemTray's ToggleWindowService
+            if (command == nameof(Command.ToggleWindow))
+            {
+                return;
+            }
+
+            throw new KeyNotFoundException($"No handler registered for command: {command}");
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/NotificationService.cs

@@ -0,0 +1,31 @@
+using System.Diagnostics;
+using Windows.Data.Xml.Dom;
+using Windows.UI.Notifications;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class NotificationService : INotificationService
+    {
+        public void ShowNotification(string title, string content, string url = null)
+        {
+            string xml = $@"<toast>
+                            <visual>
+                                <binding template='ToastGeneric'>
+                                    <text>{title}</text>
+                                    <text>{content}</text>
+                                </binding>
+                            </visual>
+                        </toast>";
+
+            var doc = new XmlDocument();
+            doc.LoadXml(xml);
+
+            var toast = new ToastNotification(doc);
+            if (url != null)
+            {
+                toast.Activated += (n, o) => Process.Start(url);
+            }
+            ToastNotificationManager.CreateToastNotifier().Show(toast);
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/SettingsService.cs

@@ -0,0 +1,401 @@
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class SettingsService : ISettingsService
+    {
+        public const string CurrentThemeKey = "CurrentTheme";
+        public const string DefaultShellProfileKey = "DefaultShellProfile";
+        public const string DefaultSshProfileKey = "DefaultSshProfile";
+
+        private readonly IDefaultValueProvider _defaultValueProvider;
+        private readonly IApplicationDataContainer _keyBindings;
+        private readonly IApplicationDataContainer _localSettings;
+        private readonly IApplicationDataContainer _roamingSettings;
+        private readonly IApplicationDataContainer _shellProfiles;
+        private readonly IApplicationDataContainer _sshProfiles;
+        private readonly IApplicationDataContainer _themes;
+
+        public SettingsService(IDefaultValueProvider defaultValueProvider, ApplicationDataContainers containers)
+        {
+            _defaultValueProvider = defaultValueProvider;
+            _localSettings = containers.LocalSettings;
+            _roamingSettings = containers.RoamingSettings;
+
+            _themes = containers.Themes;
+            _keyBindings = containers.KeyBindings;
+            _shellProfiles = containers.ShellProfiles;
+            _sshProfiles = containers.SshProfiles;
+
+
+            foreach (var theme in _defaultValueProvider.GetPreInstalledThemes())
+            {
+                if (GetTheme(theme.Id) == null)
+                {
+                    _themes.WriteValueAsJson(theme.Id.ToString(), theme);
+                }
+            }
+
+            foreach (var shellProfile in _defaultValueProvider.GetPreinstalledShellProfiles())
+            {
+                if (GetShellProfile(shellProfile.Id) == null)
+                {
+                    _shellProfiles.WriteValueAsJson(shellProfile.Id.ToString(), shellProfile);
+                }
+            }
+        }
+
+        public string ExportSettings()
+        {
+            var config = new
+            {
+                App = GetApplicationSettings(),
+                KeyBindings = GetCommandKeyBindings(),
+                TerminalOptions = GetTerminalOptions(),
+                Themes = new List<TerminalTheme>(),
+                Profiles = new List<ShellProfile>(),
+                SshProfiles = new List<SshProfile>()
+            };
+
+            foreach (var theme in GetThemes().Where(x => !x.PreInstalled))
+            {
+                config.Themes.Add(theme);
+            }
+
+            foreach (var profile in GetShellProfiles().Where(x => !x.PreInstalled))
+            {
+                config.Profiles.Add(profile);
+            }
+
+            foreach (var profile in GetSshProfiles())
+            {
+                config.SshProfiles.Add(profile);
+            }
+
+            return JsonConvert.SerializeObject(config);
+        }
+
+        public void ImportSettings(string serializedSettings)
+        {
+            var config = new
+            {
+                App = GetApplicationSettings(),
+                KeyBindings = new Dictionary<string, ICollection<KeyBinding>>(),
+                Themes = new List<TerminalTheme>(),
+                Profiles = new List<ShellProfile>(),
+                SshProfiles = new List<SshProfile>(),
+                TerminalOptions = GetTerminalOptions()
+            };
+
+            JsonConvert.PopulateObject(serializedSettings, config);
+
+            SaveApplicationSettings(config.App);
+
+            // Since we set each command sepaartely, we don't need all existing settings
+            foreach (var pair in config.KeyBindings)
+            {
+                SaveKeyBindings(pair.Key, pair.Value);
+            }
+
+            // Can't create/modify pre-installed themes
+            foreach (var theme in config.Themes.Where(x => !x.PreInstalled))
+            {
+                var existingTheme = GetTheme(theme.Id);
+                if (existingTheme?.PreInstalled == true)
+                {
+                    continue;
+                }
+                SaveTheme(theme, existingTheme != null);
+            }
+
+            // Can't create pre-installed profiles
+            foreach (var profile in config.Profiles.Where(x => !x.PreInstalled))
+            {
+                var existingProfile = GetShellProfile(profile.Id);
+                var isNew = existingProfile.EqualTo(default);
+
+                // You can only edit certain parts of preinstalled profiles
+                if (!isNew && existingProfile.PreInstalled)
+                {
+                    existingProfile.WorkingDirectory = profile.WorkingDirectory;
+                    existingProfile.Arguments = profile.Arguments;
+                    existingProfile.TabThemeId = profile.TabThemeId;
+                    existingProfile.TerminalThemeId = profile.TerminalThemeId;
+                    existingProfile.LineEndingTranslation = profile.LineEndingTranslation;
+                    existingProfile.KeyBindings = profile.KeyBindings;
+                    SaveShellProfile(profile, isNew);
+                    continue;
+                }
+                SaveShellProfile(profile, isNew);
+            }
+
+            foreach (var profile in config.SshProfiles)
+            {
+                var existingProfile = GetSshProfile(profile.Id);
+                var isNew = existingProfile.EqualTo(default(SshProfile));
+
+                SaveSshProfile(profile, isNew);
+            }
+
+            SaveTerminalOptions(config.TerminalOptions);
+        }
+
+        public event EventHandler<ApplicationSettings> ApplicationSettingsChanged;
+
+        public event EventHandler<TerminalTheme> ThemeAdded;
+        public event EventHandler<Guid> CurrentThemeChanged;
+        public event EventHandler<Guid> ThemeDeleted;
+
+        public event EventHandler KeyBindingsChanged;
+
+        public event EventHandler<ShellProfile> ShellProfileAdded;
+        public event EventHandler<Guid> ShellProfileDeleted;
+
+        public event EventHandler<SshProfile> SshProfileAdded;
+        public event EventHandler<Guid> SshProfileDeleted;
+
+        public event EventHandler<TerminalOptions> TerminalOptionsChanged;
+
+        public void DeleteShellProfile(Guid id)
+        {
+            _shellProfiles.Delete(id.ToString());
+            ShellProfileDeleted?.Invoke(this, id);
+        }
+
+        public void DeleteSshProfile(Guid id)
+        {
+            _sshProfiles.Delete(id.ToString());
+            SshProfileDeleted?.Invoke(this, id);
+            KeyBindingsChanged?.Invoke(this, System.EventArgs.Empty);
+        }
+
+
+        public void DeleteTheme(Guid id)
+        {
+            _themes.Delete(id.ToString());
+
+            foreach (var profile in GetShellProfiles())
+            {
+                if (profile.TerminalThemeId == id)
+                {
+                    profile.TerminalThemeId = Guid.Empty;
+                    SaveShellProfile(profile);
+                }
+            }
+
+            ThemeDeleted?.Invoke(this, id);
+        }
+
+        public ApplicationSettings GetApplicationSettings()
+        {
+            return _roamingSettings.ReadValueFromJson(nameof(ApplicationSettings), _defaultValueProvider.GetDefaultApplicationSettings());
+        }
+
+        public TerminalTheme GetCurrentTheme()
+        {
+            var id = GetCurrentThemeId();
+            var theme = GetTheme(id);
+            if (theme == null)
+            {
+                id = _defaultValueProvider.GetDefaultThemeId();
+                SaveCurrentThemeId(id);
+                theme = GetTheme(id);
+            }
+            return theme;
+        }
+
+        public Guid GetCurrentThemeId()
+        {
+            if (_roamingSettings.TryGetValue(CurrentThemeKey, out object value))
+            {
+                return (Guid)value;
+            }
+            return _defaultValueProvider.GetDefaultThemeId();
+        }
+
+        public ShellProfile GetDefaultShellProfile()
+        {
+            var id = GetDefaultShellProfileId();
+            var profile = _shellProfiles.ReadValueFromJson(id.ToString(), default(ShellProfile));
+            if (profile == null)
+            {
+                id = _defaultValueProvider.GetDefaultShellProfileId();
+                SaveDefaultShellProfileId(id);
+                profile = _shellProfiles.ReadValueFromJson(id.ToString(), default(ShellProfile));
+            }
+            return profile;
+        }
+        public SshProfile GetDefaultSshProfile()
+        {
+            var id = GetDefaultSshProfileId();
+            var profile = _sshProfiles.ReadValueFromJson(id.ToString(), default(SshProfile));
+
+            return profile;
+        }
+
+        public ShellProfile GetShellProfile(Guid id)
+        {
+            return _shellProfiles.ReadValueFromJson(id.ToString(), default(ShellProfile));
+        }
+        public SshProfile GetSshProfile(Guid id)
+        {
+            return _sshProfiles.ReadValueFromJson(id.ToString(), default(SshProfile));
+        }
+
+        public Guid GetDefaultShellProfileId()
+        {
+            if (_localSettings.TryGetValue(DefaultShellProfileKey, out object value))
+            {
+                return (Guid)value;
+            }
+            return _defaultValueProvider.GetDefaultShellProfileId();
+        }
+        public Guid GetDefaultSshProfileId()
+        {
+            if (_localSettings.TryGetValue(DefaultSshProfileKey, out object value))
+            {
+                return (Guid)value;
+            }
+            return System.Guid.Empty;
+        }
+
+        public IDictionary<string, ICollection<KeyBinding>> GetCommandKeyBindings()
+        {
+            var keyBindings = new Dictionary<string, ICollection<KeyBinding>>();
+
+            foreach (Command command in Enum.GetValues(typeof(Command)))
+            {
+                keyBindings.Add(command.ToString(), _keyBindings.ReadValueFromJson<Collection<KeyBinding>>(command.ToString(), null) ?? _defaultValueProvider.GetDefaultKeyBindings(command));
+            }
+            return keyBindings;
+        }
+
+        public IEnumerable<ShellProfile> GetShellProfiles()
+        {
+            return _shellProfiles.GetAll().Select(x => JsonConvert.DeserializeObject<ShellProfile>((string)x)).ToList();
+        }
+        public IEnumerable<SshProfile> GetSshProfiles()
+        {
+            if (_sshProfiles == null)
+                return new List<SshProfile>();
+            else
+                return _sshProfiles.GetAll()
+                    .Select(x => JsonConvert.DeserializeObject<SshProfile>((string) x)).ToList();
+        }
+
+        public IEnumerable<TabTheme> GetTabThemes()
+        {
+            return _defaultValueProvider.GetDefaultTabThemes();
+        }
+
+        public TerminalOptions GetTerminalOptions()
+        {
+            return _roamingSettings.ReadValueFromJson(nameof(TerminalOptions), _defaultValueProvider.GetDefaultTerminalOptions());
+        }
+
+        public TerminalTheme GetTheme(Guid id)
+        {
+            return _themes.ReadValueFromJson(id.ToString(), default(TerminalTheme));
+        }
+
+        public IEnumerable<TerminalTheme> GetThemes()
+        {
+            return _themes.GetAll().Select(x => JsonConvert.DeserializeObject<TerminalTheme>((string)x)).ToList();
+        }
+
+        public void ResetKeyBindings()
+        {
+            foreach (Command command in Enum.GetValues(typeof(Command)))
+            {
+                _keyBindings.WriteValueAsJson(command.ToString(), _defaultValueProvider.GetDefaultKeyBindings(command));
+            }
+
+            KeyBindingsChanged?.Invoke(this, System.EventArgs.Empty);
+        }
+
+        public void SaveApplicationSettings(ApplicationSettings applicationSettings)
+        {
+            _roamingSettings.WriteValueAsJson(nameof(ApplicationSettings), applicationSettings);
+            ApplicationSettingsChanged?.Invoke(this, applicationSettings);
+        }
+
+        public void SaveCurrentThemeId(Guid id)
+        {
+            _roamingSettings.SetValue(CurrentThemeKey, id);
+
+            CurrentThemeChanged?.Invoke(this, id);
+        }
+
+        public void SaveDefaultShellProfileId(Guid id)
+        {
+            _localSettings.SetValue(DefaultShellProfileKey, id);
+        }
+        public void SaveDefaultSshProfileId(Guid id)
+        {
+            _localSettings.SetValue(DefaultSshProfileKey, id);
+        }
+
+        public void SaveKeyBindings(string command, ICollection<KeyBinding> keyBindings)
+        {
+            if (!Enum.TryParse<Command>(command, true, out var enumValue))
+            {
+                throw new InvalidOperationException();
+            }
+
+            _keyBindings.WriteValueAsJson(enumValue.ToString(), keyBindings);
+            KeyBindingsChanged?.Invoke(this, System.EventArgs.Empty);
+        }
+
+        public void SaveShellProfile(ShellProfile shellProfile, bool newShell = false)
+        {
+            _shellProfiles.WriteValueAsJson(shellProfile.Id.ToString(), shellProfile);
+
+            // When saving the shell profile, we also need to update keybindings for everywhere.
+            KeyBindingsChanged?.Invoke(this, System.EventArgs.Empty);
+
+            if (newShell)
+            {
+                ShellProfileAdded?.Invoke(this, shellProfile);
+            }
+        }
+        public void SaveSshProfile(SshProfile sshProfile, bool newShell = false)
+        {
+            _sshProfiles.WriteValueAsJson(sshProfile.Id.ToString(), sshProfile);
+
+            // When saving the shell profile, we also need to update keybindings for everywhere.
+            KeyBindingsChanged?.Invoke(this, System.EventArgs.Empty);
+
+            if (newShell)
+            {
+                SshProfileAdded?.Invoke(this, sshProfile);
+            }
+        }
+
+        public void SaveTerminalOptions(TerminalOptions terminalOptions)
+        {
+            _roamingSettings.WriteValueAsJson(nameof(TerminalOptions), terminalOptions);
+            TerminalOptionsChanged?.Invoke(this, terminalOptions);
+        }
+
+        public void SaveTheme(TerminalTheme theme, bool newTheme = false)
+        {
+            _themes.WriteValueAsJson(theme.Id.ToString(), theme);
+
+            if (theme.Id == GetCurrentThemeId())
+            {
+                CurrentThemeChanged?.Invoke(this, theme.Id);
+            }
+
+            if (newTheme)
+            {
+                ThemeAdded?.Invoke(this, theme);
+            }
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/ThemeParserFactory.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class ThemeParserFactory : IThemeParserFactory
+    {
+        private IEnumerable<IThemeParser> _parsers;
+
+        public IEnumerable<string> SupportedFileTypes { get; }
+
+        public ThemeParserFactory(IEnumerable<IThemeParser> parsers)
+        {
+            _parsers = parsers;
+            SupportedFileTypes = _parsers.SelectMany(p => p.SupportedFileTypes);
+        }
+
+        public IThemeParser GetParser(string fileType)
+        {
+            return _parsers.FirstOrDefault(p => p.SupportedFileTypes.Contains(fileType));
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/TrayProcessCommunicationService.cs

@@ -0,0 +1,261 @@
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using FluentTerminal.Models.Requests;
+using FluentTerminal.Models.Responses;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Windows.Foundation.Collections;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class TrayProcessCommunicationService : ITrayProcessCommunicationService
+    {
+        private readonly ISettingsService _settingsService;
+        private IAppServiceConnection _appServiceConnection;
+        private readonly Dictionary<byte, Action<byte[]>> _terminalOutputHandlers;
+        private byte _nextTerminalId = 0;
+
+        public event EventHandler<TerminalExitStatus> TerminalExited;
+
+        public TrayProcessCommunicationService(ISettingsService settingsService)
+        {
+            _settingsService = settingsService;
+            _terminalOutputHandlers = new Dictionary<byte, Action<byte[]>>();
+        }
+
+        public byte GetNextTerminalId()
+        {
+            return _nextTerminalId++;
+        }
+
+        public async Task<GetAvailablePortResponse> GetAvailablePort()
+        {
+            var request = new GetAvailablePortRequest();
+
+            var responseMessage = await _appServiceConnection.SendMessageAsync(CreateMessage(request));
+            var response = JsonConvert.DeserializeObject<GetAvailablePortResponse>((string)responseMessage[MessageKeys.Content]);
+
+            Logger.Instance.Debug("Received GetAvailablePortResponse: {@response}", response);
+
+            return response;
+        }
+
+        private string _userName;
+
+        public async Task<string> GetUserName()
+        {
+            if (!string.IsNullOrEmpty(_userName))
+            {
+                // Returning the username from cache
+                return _userName;
+            }
+
+            GetUserNameResponse response;
+
+            // No need to crash for username, so try/catch
+            try
+            {
+                var responseMessage = await _appServiceConnection.SendMessageAsync(CreateMessage(new GetUserNameRequest()));
+                response = JsonConvert.DeserializeObject<GetUserNameResponse>((string)responseMessage[MessageKeys.Content]);
+            }
+            catch (Exception e)
+            {
+                Logger.Instance.Error(e, "Error while trying to get username.");
+
+                return null;
+            }
+
+            Logger.Instance.Debug("Received GetUserNameResponse: {@response}", response);
+
+            _userName = response.UserName;
+
+            return _userName;
+        }
+
+        public async Task SaveTextFileAsync(string path, string content)
+        {
+            var responseMessage = await _appServiceConnection.SendMessageAsync(CreateMessage(new SaveTextFileRequest {Path = path, Content = content}));
+
+            var response = JsonConvert.DeserializeObject<CommonResponse>((string)responseMessage[MessageKeys.Content]);
+
+            if (!response.Success)
+            {
+                throw new Exception(string.IsNullOrEmpty(response.Error) ? "Failed to save the file." : response.Error);
+            }
+        }
+
+        private static string _sshConfigDir;
+
+        public async Task<string> GetSshConfigDirAsync()
+        {
+            if (string.IsNullOrEmpty(_sshConfigDir))
+            {
+                var response = await GetSshConfigFolderAsync(false);
+
+                if (response?.Success ?? false)
+                {
+                    _sshConfigDir = response.Path;
+                }
+            }
+
+            return _sshConfigDir;
+        }
+
+        public async Task<string[]> GetFilesFromSshConfigDirAsync()
+        {
+            var response = await GetSshConfigFolderAsync(false);
+
+            if (response == null || !response.Success)
+            {
+                return null;
+            }
+
+            if (string.IsNullOrEmpty(_sshConfigDir))
+            {
+                _sshConfigDir = response.Path;
+            }
+
+            return response.Files;
+        }
+
+        private async Task<GetSshConfigFolderResponse> GetSshConfigFolderAsync(bool includeContent)
+        {
+            var responseMessage =
+                await _appServiceConnection.SendMessageAsync(CreateMessage(new GetSshConfigFolderRequest
+                    {IncludeContent = includeContent}));
+
+            return JsonConvert.DeserializeObject<GetSshConfigFolderResponse>(
+                (string) responseMessage[MessageKeys.Content]);
+        }
+
+        public async Task<bool> CheckFileExistsAsync(string path)
+        {
+            var responseMessage =
+                await _appServiceConnection.SendMessageAsync(CreateMessage(new CheckFileExistsRequest {Path = path}));
+
+            return JsonConvert.DeserializeObject<CommonResponse>((string) responseMessage[MessageKeys.Content]).Success;
+        }
+
+        public void MuteTerminal(bool mute)
+        {
+            _appServiceConnection.SendMessageAsync(CreateMessage(new MuteTerminalRequest { Mute = mute }));
+        }
+
+        public async Task<CreateTerminalResponse> CreateTerminal(byte id, TerminalSize size, ShellProfile shellProfile, SessionType sessionType)
+        {
+            var request = new CreateTerminalRequest
+            {
+                Id = id,
+                Size = size,
+                Profile = shellProfile,
+                SessionType = sessionType
+            };
+
+            Logger.Instance.Debug("Sending CreateTerminalRequest: {@request}", request);
+
+            var responseMessage = await _appServiceConnection.SendMessageAsync(CreateMessage(request));
+            var response = JsonConvert.DeserializeObject<CreateTerminalResponse>((string)responseMessage[MessageKeys.Content]);
+
+            Logger.Instance.Debug("Received CreateTerminalResponse: {@response}", response);
+
+            return response;
+        }
+
+        public void Initialize(IAppServiceConnection appServiceConnection)
+        {
+            _appServiceConnection = appServiceConnection;
+            _appServiceConnection.MessageReceived += OnMessageReceived;
+        }
+
+        private void OnMessageReceived(object sender, IDictionary<string, object> e)
+        {
+            var messageType = (byte)e[MessageKeys.Type];
+            var messageContent = e[MessageKeys.Content];
+
+            switch (messageType)
+            {
+                case Constants.TerminalBufferRequestIdentifier:
+                    var terminalId = (byte)e[MessageKeys.TerminalId];
+
+                    if (_terminalOutputHandlers.ContainsKey(terminalId))
+                    {
+                        _terminalOutputHandlers[terminalId].Invoke((byte[])messageContent);
+                    }
+                    else
+                    {
+                        Logger.Instance.Error("Received output for unknown terminal Id {id}", terminalId);
+                    }
+                    break;
+                case TerminalExitedRequest.Identifier:
+                    var request = JsonConvert.DeserializeObject<TerminalExitedRequest>((string)messageContent);
+                    Logger.Instance.Debug("Received TerminalExitedRequest: {@request}", request);
+
+                    TerminalExited?.Invoke(this, request.ToStatus());
+                    break;
+                default:
+                    Logger.Instance.Error("Received unknown message type: {messageType}", messageType);
+                    break;
+            }
+        }
+
+        public Task ResizeTerminal(byte id, TerminalSize size)
+        {
+            var request = new ResizeTerminalRequest
+            {
+                TerminalId = id,
+                NewSize = size
+            };
+
+            return _appServiceConnection.SendMessageAsync(CreateMessage(request));
+        }
+
+        public void SubscribeForTerminalOutput(byte terminalId, Action<byte[]> callback)
+        {
+            _terminalOutputHandlers[terminalId] = callback;
+        }
+
+        public Task UpdateToggleWindowKeyBindings()
+        {
+            var keyBindings = _settingsService.GetCommandKeyBindings()[nameof(Command.ToggleWindow)];
+
+            var request = new SetToggleWindowKeyBindingsRequest
+            {
+                KeyBindings = keyBindings
+            };
+
+            return _appServiceConnection.SendMessageAsync(CreateMessage(request));
+        }
+
+        public Task Write(byte id, byte[] data)
+        {
+            var message = new ValueSet
+            {
+                [MessageKeys.Type] = Constants.TerminalBufferRequestIdentifier,
+                [MessageKeys.TerminalId] = id,
+                [MessageKeys.Content] = data
+            };
+
+            return _appServiceConnection.SendMessageAsync(message);
+        }
+
+        public Task CloseTerminal(byte terminalId)
+        {
+            var request = new TerminalExitedRequest(terminalId, -1);
+
+            Logger.Instance.Debug("Sending TerminalExitedRequest: {@request}", request);
+
+            return _appServiceConnection.SendMessageAsync(CreateMessage(request));
+        }
+
+        private ValueSet CreateMessage(IMessage content)
+        {
+            return new ValueSet
+            {
+                [MessageKeys.Type] = content.Identifier,
+                [MessageKeys.Content] = JsonConvert.SerializeObject(content)
+            };
+        }
+    }
+}

FluentTerminal.App.Services/Implementation/UpdateService.cs

@@ -0,0 +1,56 @@
+using System;
+using Windows.ApplicationModel;
+using Newtonsoft.Json;
+using RestSharp;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services.Implementation
+{
+    public class UpdateService : IUpdateService
+    {
+        private const string apiEndpoint = "https://api.github.com";
+
+        private readonly INotificationService _notificationService;
+
+        public UpdateService(INotificationService notificationService)
+        {
+            _notificationService = notificationService;
+        }
+
+        public async Task CheckForUpdate(bool notifyNoUpdate = false)
+        {
+            var latest = await GetLatestVersionAsync();
+            if (latest > GetCurrentVersion())
+            {
+                _notificationService.ShowNotification("Update available",
+                    "Click to open the releases page.", "https://github.com/felixse/FluentTerminal/releases");
+            }
+            else if (notifyNoUpdate)
+            {
+                _notificationService.ShowNotification("No update available", "You're up to date!");
+            }
+        }
+
+        public Version GetCurrentVersion()
+        {
+            var currentVersion = Package.Current.Id.Version;
+            return new Version(currentVersion.Major, currentVersion.Minor, currentVersion.Build, currentVersion.Revision);
+        }
+
+        public async Task<Version> GetLatestVersionAsync()
+        {
+            var restClient = new RestClient(apiEndpoint);
+            var restRequest = new RestRequest("/repos/felixse/fluentterminal/releases", Method.GET);
+
+            var restResponse = await restClient.ExecuteTaskAsync(restRequest);
+            if (restResponse.IsSuccessful)
+            {
+                dynamic restResponseData = JsonConvert.DeserializeObject(restResponse.Content);
+                string tag = restResponseData[0].tag_name;
+                var latestVersion = new Version(tag);
+                return new Version(latestVersion.Major, latestVersion.Minor, latestVersion.Build, latestVersion.Revision);
+            }
+            return new Version(0, 0, 0, 0);
+        }
+    }
+}

FluentTerminal.App.Services/Logger.cs

@@ -0,0 +1,68 @@
+using Serilog;
+using Serilog.Events;
+using System;
+
+namespace FluentTerminal.App.Services
+{
+    public sealed class Logger
+    {
+        public enum LogLevel
+        {
+            Verbose = 0,
+            Debug = 1,
+            Information = 2,
+            Warning = 3,
+            Error = 4,
+            Fatal = 5
+        }
+
+        public class Configuration
+        {
+            public LogLevel LogLevel { get; set; } = LogLevel.Error;
+        }
+
+        public static Logger Instance { get; } = new Logger();
+
+        private Logger()
+        {
+
+        }
+
+        public void Initialize(string filePath, Configuration configuration)
+        {
+            Log.Logger = new LoggerConfiguration()
+            .WriteTo.Async(a => a.File(filePath, rollingInterval: RollingInterval.Day, retainedFileCountLimit: 7))
+            .MinimumLevel.Is((LogEventLevel)configuration.LogLevel)
+            .CreateLogger();
+
+            // Log file is not created during unhandled exception processing.
+            // Force log file creation with the highest severity initialization record.
+            Log.Fatal("Initialized");
+        }
+
+        public void Debug(string text, params object[] propertyValues)
+        {
+            Log.Debug(text, propertyValues, propertyValues);
+        }
+
+        public void Information(string text, params object[] propertyValues)
+        {
+            Log.Information(text, propertyValues);
+        }
+
+        public void Warning(string text, params object[] propertyValues)
+        {
+            Log.Warning(text, propertyValues);
+        }
+
+        public void Error(string text, params object[] propertyValues)
+        {
+            Log.Error(text, propertyValues);
+        }
+
+        public void Error(Exception exception, string text, params object[] propertyValues)
+        {
+            Log.Error(exception, text, propertyValues);
+        }
+    }
+}

FluentTerminal.App.Services/Terminal.cs

@@ -0,0 +1,162 @@
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using FluentTerminal.Models.Responses;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.Services
+{
+    public class Terminal
+    {
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+        private Func<Task<string>> _selectedTextCallback;
+        private bool _closingFromUI = false;
+        private bool _exited = false;
+
+        public Terminal(ITrayProcessCommunicationService trayProcessCommunicationService)
+        {
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+            _trayProcessCommunicationService.TerminalExited += OnTerminalExited;
+            Id = _trayProcessCommunicationService.GetNextTerminalId();
+        }
+
+        private void OnTerminalExited(object sender, TerminalExitStatus status)
+        {
+            if (status.TerminalId != Id)
+            {
+                return;
+            }
+
+            _exited = true;
+            Exited?.Invoke(this, status.ExitCode);
+
+            if (_closingFromUI == true || status.ExitCode <= 0)
+            {
+                Closed?.Invoke(this, System.EventArgs.Empty);
+            }
+        }
+
+        public event EventHandler<int> Exited;
+
+        /// <summary>
+        /// To be observed by both view and viewmodel
+        /// </summary>
+        public event EventHandler Closed;
+
+        /// <summary>
+        /// to be observed by viewmodel
+        /// </summary>
+        public event EventHandler<string> KeyboardCommandReceived;
+
+        /// <summary>
+        /// to be observed by view
+        /// </summary>
+        public event EventHandler<byte[]> OutputReceived;
+
+        /// <summary>
+        /// to be observed by viewmodel
+        /// </summary>
+        public event EventHandler<TerminalSize> SizeChanged;
+
+        /// <summary>
+        /// to be observed by viewmodel
+        /// </summary>
+        public event EventHandler<string> TitleChanged;
+
+        public string FallbackTitle { get; private set; }
+
+        public byte Id { get; }
+
+        /// <summary>
+        /// To be called by either view or viewmodel
+        /// </summary>
+        public async Task Close()
+        {
+            if (_exited)
+            {
+                Closed?.Invoke(this, System.EventArgs.Empty);
+                return;
+            }
+            _closingFromUI = true;
+            await _trayProcessCommunicationService.CloseTerminal(Id).ConfigureAwait(true);
+        }
+
+        /// <summary>
+        /// to be called by viewmodel
+        /// </summary>
+        /// <returns></returns>
+        public Task<string> GetSelectedText()
+        {
+            return _selectedTextCallback();
+        }
+
+        /// <summary>
+        /// to be called by view
+        /// </summary>
+        public void ProcessKeyboardCommand(string command)
+        {
+            KeyboardCommandReceived?.Invoke(this, command);
+        }
+
+        /// <summary>
+        /// To be set by view
+        /// </summary>
+        public void RegisterSelectedTextCallback(Func<Task<string>> selectedTextCallback)
+        {
+            _selectedTextCallback = selectedTextCallback;
+        }
+
+        /// <summary>
+        /// To be called by view
+        /// </summary>
+        public async Task SetSize(TerminalSize size)
+        {
+            await _trayProcessCommunicationService.ResizeTerminal(Id, size);
+            SizeChanged?.Invoke(this, size);
+        }
+
+        /// <summary>
+        /// to be called by view
+        /// </summary>
+        public void SetTitle(string title)
+        {
+            if (string.IsNullOrWhiteSpace(title))
+            {
+                title = FallbackTitle;
+            }
+            TitleChanged?.Invoke(this, title);
+        }
+
+        /// <summary>
+        /// to be called by view when ready
+        /// </summary>
+        /// <param name="shellProfile"></param>
+        /// <param name="size"></param>
+        /// <param name="sessionType"></param>
+        public async Task<CreateTerminalResponse> StartShellProcess(ShellProfile shellProfile, TerminalSize size, SessionType sessionType)
+        {
+            _trayProcessCommunicationService.SubscribeForTerminalOutput(Id, t => OutputReceived?.Invoke(this, t));
+            var response = await _trayProcessCommunicationService.CreateTerminal(Id, size, shellProfile, sessionType).ConfigureAwait(true);
+
+            if (response.Success)
+            {
+                FallbackTitle = response.ShellExecutableName;
+                SetTitle(FallbackTitle);
+            }
+            return response;
+        }
+
+        public Task Write(byte[] data)
+        {
+            return _trayProcessCommunicationService.Write(Id, data);
+        }
+
+        /// <summary>
+        /// Tells the ViewModel that this view failed to launch and can be closed.
+        /// </summary>
+        public void ReportLauchFailed()
+        {
+            Closed?.Invoke(this, System.EventArgs.Empty);
+        }
+    }
+}

FluentTerminal.App.Services/Utilities/EnumHelper.cs

@@ -0,0 +1,21 @@
+using System;
+using System.ComponentModel;
+
+namespace FluentTerminal.App.Services.Utilities
+{
+    public static class EnumHelper
+    {
+        public static string GetEnumDescription(Enum value)
+        {
+            var fieldInfo = value.GetType().GetField(value.ToString());
+
+            var attributes = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
+
+            if (attributes?.Length > 0)
+            {
+                return attributes[0].Description;
+            }
+            return value.ToString();
+        }
+    }
+}

FluentTerminal.App.Services/Utilities/I18N.cs

@@ -0,0 +1,17 @@
+using Windows.ApplicationModel.Resources;
+
+namespace FluentTerminal.App.Services.Utilities
+{
+    /// <summary>
+    /// Get strings in different languages.
+    /// Author: Zuozishi
+    /// </summary>
+    public static class I18N
+    {
+        public static string Translate(string resource)
+        {
+            var resourceLoader = ResourceLoader.GetForCurrentView();
+            return resourceLoader.GetString(resource.Replace('.', '/'));
+        }
+    }
+}

FluentTerminal.App.Services/Utilities/TerminalThemeContractResolver.cs

@@ -0,0 +1,27 @@
+using FluentTerminal.Models;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using System.Reflection;
+
+namespace FluentTerminal.App.Services.Utilities
+{
+    public class TerminalThemeContractResolver : DefaultContractResolver
+    {
+        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
+        {
+            JsonProperty property = base.CreateProperty(member, memberSerialization);
+
+            if (property.DeclaringType == typeof(TerminalTheme) && property.PropertyName == nameof(TerminalTheme.PreInstalled))
+            {
+                property.ShouldSerialize = (_) => false;
+            }
+
+            if (property.DeclaringType == typeof(TerminalTheme) && property.PropertyName == nameof(TerminalTheme.Id))
+            {
+                property.ShouldSerialize = (_) => false;
+            }
+
+            return property;
+        }
+    }
+}

FluentTerminal.App.ViewModels/FluentTerminal.App.ViewModels.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Fleck" Version="1.1.0" />
+    <PackageReference Include="MvvmLightLibs" Version="5.4.1.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\FluentTerminal.App.Services\FluentTerminal.App.Services.csproj" />
+    <ProjectReference Include="..\FluentTerminal.Models\FluentTerminal.Models.csproj" />
+  </ItemGroup>
+
+</Project>

FluentTerminal.App.ViewModels/Infrastructure/AsyncCommand.cs

@@ -0,0 +1,124 @@
+using FluentTerminal.App.ViewModels.Utilities;
+using System;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace FluentTerminal.App.ViewModels.Infrastructure
+{
+    public class AsyncCommand : IAsyncCommand
+    {
+        public event EventHandler CanExecuteChanged;
+
+        private bool _isExecuting;
+        private readonly Func<Task> _execute;
+        private readonly Func<bool> _canExecute;
+        private readonly IErrorHandler _errorHandler;
+
+        public AsyncCommand(
+            Func<Task> execute,
+            Func<bool> canExecute = null,
+            IErrorHandler errorHandler = null)
+        {
+            _execute = execute;
+            _canExecute = canExecute;
+            _errorHandler = errorHandler;
+        }
+
+        public bool CanExecute()
+        {
+            return !_isExecuting && (_canExecute?.Invoke() ?? true);
+        }
+
+        public async Task ExecuteAsync()
+        {
+            if (CanExecute())
+            {
+                try
+                {
+                    _isExecuting = true;
+                    await _execute();
+                }
+                finally
+                {
+                    _isExecuting = false;
+                }
+            }
+
+            RaiseCanExecuteChanged();
+        }
+
+        public void RaiseCanExecuteChanged()
+        {
+            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        #region Explicit implementations
+        bool ICommand.CanExecute(object parameter)
+        {
+            return CanExecute();
+        }
+
+        void ICommand.Execute(object parameter)
+        {
+            ExecuteAsync().FireAndForgetSafeAsync(_errorHandler);
+        }
+        #endregion
+    }
+
+    public class AsyncCommand<T> : IAsyncCommand<T>
+    {
+        public event EventHandler CanExecuteChanged;
+
+        private bool _isExecuting;
+        private readonly Func<T, Task> _execute;
+        private readonly Func<T, bool> _canExecute;
+        private readonly IErrorHandler _errorHandler;
+
+        public AsyncCommand(Func<T, Task> execute, Func<T, bool> canExecute = null, IErrorHandler errorHandler = null)
+        {
+            _execute = execute;
+            _canExecute = canExecute;
+            _errorHandler = errorHandler;
+        }
+
+        public bool CanExecute(T parameter)
+        {
+            return !_isExecuting && (_canExecute?.Invoke(parameter) ?? true);
+        }
+
+        public async Task ExecuteAsync(T parameter)
+        {
+            if (CanExecute(parameter))
+            {
+                try
+                {
+                    _isExecuting = true;
+                    await _execute(parameter);
+                }
+                finally
+                {
+                    _isExecuting = false;
+                }
+            }
+
+            RaiseCanExecuteChanged();
+        }
+
+        public void RaiseCanExecuteChanged()
+        {
+            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        #region Explicit implementations
+        bool ICommand.CanExecute(object parameter)
+        {
+            return CanExecute((T)parameter);
+        }
+
+        void ICommand.Execute(object parameter)
+        {
+            ExecuteAsync((T)parameter).FireAndForgetSafeAsync(_errorHandler);
+        }
+        #endregion
+    }
+}

FluentTerminal.App.ViewModels/Infrastructure/IAsyncCommand.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace FluentTerminal.App.ViewModels.Infrastructure
+{
+    /// <summary>
+    /// based on: https://github.com/johnthiriet/AsyncVoid
+    /// </summary>
+    public interface IAsyncCommand : ICommand
+    {
+        Task ExecuteAsync();
+        bool CanExecute();
+    }
+
+    public interface IAsyncCommand<T> : ICommand
+    {
+        Task ExecuteAsync(T parameter);
+        bool CanExecute(T parameter);
+    }
+}

FluentTerminal.App.ViewModels/Infrastructure/IErrorHandler.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace FluentTerminal.App.ViewModels.Infrastructure
+{
+    public interface IErrorHandler
+    {
+        void HandleError(Exception ex);
+    }
+}

FluentTerminal.App.ViewModels/MainViewModel.cs

@@ -0,0 +1,502 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.EventArgs;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels
+{
+    public class MainViewModel : ViewModelBase
+    {
+        private readonly IClipboardService _clipboardService;
+        private readonly IDialogService _dialogService;
+        private readonly IDispatcherTimer _dispatcherTimer;
+        private readonly IKeyboardCommandService _keyboardCommandService;
+        private readonly ISettingsService _settingsService;
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+        private ApplicationSettings _applicationSettings;
+        private string _background;
+        private double _backgroundOpacity;
+        private TerminalViewModel _selectedTerminal;
+        private TabsPosition _tabsPosition;
+        private string _windowTitle;
+
+        public MainViewModel(ISettingsService settingsService, ITrayProcessCommunicationService trayProcessCommunicationService, IDialogService dialogService, IKeyboardCommandService keyboardCommandService,
+            IApplicationView applicationView, IDispatcherTimer dispatcherTimer, IClipboardService clipboardService)
+        {
+            _settingsService = settingsService;
+            _settingsService.CurrentThemeChanged += OnCurrentThemeChanged;
+            _settingsService.ApplicationSettingsChanged += OnApplicationSettingsChanged;
+            _settingsService.TerminalOptionsChanged += OnTerminalOptionsChanged;
+            _settingsService.ShellProfileAdded += OnShellProfileAdded;
+            _settingsService.ShellProfileDeleted += OnShellProfileDeleted;
+            _settingsService.SshProfileAdded += OnSshProfileAdded;
+            _settingsService.SshProfileDeleted += OnSshProfileDeleted;
+
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+            _dialogService = dialogService;
+            ApplicationView = applicationView;
+            _dispatcherTimer = dispatcherTimer;
+            _clipboardService = clipboardService;
+            _keyboardCommandService = keyboardCommandService;
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.NewTab), async () => await AddLocalTabAsync());
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.NewSshTab), async () => await AddSshTabAsync());
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.ConfigurableNewTab), async () => await AddConfigurableTerminal());
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.ChangeTabTitle), async () => await SelectedTerminal.EditTitle());
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.CloseTab), CloseCurrentTab);
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.SavedSshNewTab), async () => await AddSavedSshTerminalAsync());
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.SavedSshNewWindow), () => NewWindow(NewWindowAction.ShowSshProfileSelection));
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.NewSshWindow), () => NewWindow(NewWindowAction.ShowSshInfoDialog));
+
+            // Add all of the commands for switching to a tab of a given ID, if there's one open there
+            for (int i = 0; i < 9; i++)
+            {
+                var switchCmd = Command.SwitchToTerm1 + i;
+                int tabNumber = i;
+                // ReSharper disable once InconsistentNaming
+                void handler() => SelectTabNumber(tabNumber);
+                _keyboardCommandService.RegisterCommandHandler(switchCmd.ToString(), handler);
+            }
+
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.NextTab), SelectNextTab);
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.PreviousTab), SelectPreviousTab);
+
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.NewWindow), () => NewWindow(NewWindowAction.StartDefaultLocalTerminal));
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.ConfigurableNewWindow), () => NewWindow(NewWindowAction.ShowProfileSelection));
+
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.ShowSettings), ShowSettings);
+            _keyboardCommandService.RegisterCommandHandler(nameof(Command.ToggleFullScreen), ToggleFullScreen);
+
+            foreach (ShellProfile profile in _settingsService.GetShellProfiles())
+            {
+                _keyboardCommandService.RegisterCommandHandler(profile.Id.ToString(), async () => await AddLocalTabOrWindowAsync(profile.Id));
+            }
+
+            foreach (SshProfile profile in _settingsService.GetSshProfiles())
+            {
+                _keyboardCommandService.RegisterCommandHandler(profile.Id.ToString(), async () => await AddSshTabOrWindowAsync(profile.Id));
+            }
+
+            var currentTheme = _settingsService.GetCurrentTheme();
+            var options = _settingsService.GetTerminalOptions();
+            Background = currentTheme.Colors.Background;
+            BackgroundOpacity = options.BackgroundOpacity;
+            _applicationSettings = _settingsService.GetApplicationSettings();
+            TabsPosition = _applicationSettings.TabsPosition;
+
+            AddLocalShellCommand = new RelayCommand(async () => await AddLocalTabAsync());
+            AddRemoteShellCommand = new RelayCommand(async () => await AddSshTabAsync());
+            ShowAboutCommand = new RelayCommand(ShowAbout);
+            ShowSettingsCommand = new RelayCommand(ShowSettings);
+
+            ApplicationView.CloseRequested += OnCloseRequest;
+            ApplicationView.Closed += OnClosed;
+            Terminals.CollectionChanged += OnTerminalsCollectionChanged;
+        }
+
+        private void OnClosed(object sender, EventArgs e)
+        {
+            Closed?.Invoke(this, e);
+        }
+
+        private void OnShellProfileDeleted(object sender, Guid e)
+        {
+            _keyboardCommandService.DeregisterCommandHandler(e.ToString());
+        }
+
+        private void OnShellProfileAdded(object sender, ShellProfile e)
+        {
+            _keyboardCommandService.RegisterCommandHandler(e.Id.ToString(), () => AddLocalTabOrWindowAsync(e.Id));
+        }
+
+        private void OnSshProfileAdded(object sender, ShellProfile e)
+        {
+            _keyboardCommandService.RegisterCommandHandler(e.Id.ToString(), () => AddSshTabOrWindowAsync(e.Id));
+        }
+        private void OnSshProfileDeleted(object sender, Guid e)
+        {
+            _keyboardCommandService.DeregisterCommandHandler(e.ToString());
+        }
+        
+        private void OnTerminalsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            RaisePropertyChanged(nameof(ShowTabsOnTop));
+            RaisePropertyChanged(nameof(ShowTabsOnBottom));
+        }
+
+        public event EventHandler Closed;
+
+        public event EventHandler<NewWindowRequestedEventArgs> NewWindowRequested;
+
+        public event EventHandler ShowSettingsRequested;
+
+        public event EventHandler ShowAboutRequested;
+
+        public event EventHandler ActivatedMv;
+
+        public void FocusWindow()
+        {
+            ActivatedMv?.Invoke(this, EventArgs.Empty);
+        }
+
+        public RelayCommand AddLocalShellCommand { get; }
+        public RelayCommand AddRemoteShellCommand { get; }
+
+        public string WindowTitle
+        {
+            get => _windowTitle;
+            set
+            {
+                if (Set(ref _windowTitle, value))
+                {
+                    ApplicationView.Title = value;
+                }
+            }
+        }
+
+        public bool ShowTabsOnTop
+        {
+            get => TabsPosition == TabsPosition.Top && (Terminals.Count > 1 || _applicationSettings.AlwaysShowTabs);
+        }
+
+        public bool ShowTabsOnBottom
+        {
+            get => TabsPosition == TabsPosition.Bottom && (Terminals.Count > 1 || _applicationSettings.AlwaysShowTabs);
+        }
+
+        public string Background
+        {
+            get => _background;
+            set => Set(ref _background, value);
+        }
+
+        public double BackgroundOpacity
+        {
+            get => _backgroundOpacity;
+            set => Set(ref _backgroundOpacity, value);
+        }
+
+        public TerminalViewModel SelectedTerminal
+        {
+            get => _selectedTerminal;
+            set
+            {
+                if (SelectedTerminal != null)
+                {
+                    _selectedTerminal.IsSelected = false;
+                }
+                if (Set(ref _selectedTerminal, value))
+                {
+                    SelectedTerminal?.FocusTerminal();
+                    if (SelectedTerminal != null)
+                    {
+                        SelectedTerminal.IsSelected = true;
+                        if (_applicationSettings.ShowCustomTitleInTitlebar)
+                        {
+                            WindowTitle = SelectedTerminal.TabTitle;
+                        }
+                        else
+                        {
+                            WindowTitle = SelectedTerminal.ShellTitle;
+                        }
+                    }
+                }
+            }
+        }
+
+        public RelayCommand ShowAboutCommand { get; }
+
+        public RelayCommand ShowSettingsCommand { get; }
+
+        public TabsPosition TabsPosition
+        {
+            get => _tabsPosition;
+            set => Set(ref _tabsPosition, value);
+        }
+
+        public ObservableCollection<TerminalViewModel> Terminals { get; } = new ObservableCollection<TerminalViewModel>();
+
+        public IApplicationView ApplicationView { get; }
+
+        public async Task AddConfigurableTerminal()
+        {
+            var profile = await _dialogService.ShowProfileSelectionDialogAsync();
+
+            if (profile == null)
+            {
+                if (Terminals.Count == 0)
+                {
+                    await ApplicationView.TryClose();
+                }
+
+                return;
+            }
+
+            await AddTerminalAsync(profile);
+        }
+
+        public async Task AddSshTabAsync()
+        {
+            SshProfile profile = await _dialogService.ShowSshConnectionInfoDialogAsync();
+            if (profile == null)
+            {
+                // User selected "Cancel"
+                if (Terminals.Count == 0)
+                {
+                    await ApplicationView.TryClose();
+                }
+            }
+            else
+            {
+                await AddTerminalAsync(profile);
+            }
+        }
+
+        public Task AddSshTabOrWindowAsync(Guid shellProfileId)
+        {
+            switch (_applicationSettings.NewTerminalLocation)
+            {
+                case NewTerminalLocation.Tab:
+                    var profile = _settingsService.GetSshProfile(shellProfileId);
+                    return AddTerminalAsync(profile);
+                case NewTerminalLocation.Window:
+                    NewWindow(NewWindowAction.StartSshTerminal, shellProfileId);
+                    return Task.FromResult(0);
+                default:
+                    throw new ArgumentException("unknown NewTerminalLocation");
+            }
+        }
+
+        public async Task AddSavedSshTerminalAsync()
+        {
+            ShellProfile profile = await _dialogService.ShowSshProfileSelectionDialogAsync();
+
+            if (profile == null)
+            {
+                // User selected "Cancel"
+                if (Terminals.Count == 0)
+                {
+                    await ApplicationView.TryClose();
+                }
+            }
+            else
+            {
+                await AddTerminalAsync(profile);
+            }
+        }
+
+        public Task AddLocalTabAsync()
+        {
+            var profile = _settingsService.GetDefaultShellProfile();
+            return AddTerminalAsync(profile);
+        }
+
+        public Task AddLocalTabOrWindowAsync(Guid shellProfileId)
+        {
+            switch (_applicationSettings.NewTerminalLocation)
+            {
+                case NewTerminalLocation.Tab:
+                    var profile = _settingsService.GetShellProfile(shellProfileId);
+                    return AddTerminalAsync(profile);
+                case NewTerminalLocation.Window:
+                    NewWindow(NewWindowAction.StartLocalTerminal, shellProfileId);
+                    return Task.FromResult(0);
+                default:
+                    throw new ArgumentException("unknown NewTerminalLocation");
+            }
+        }
+
+        public Task AddTerminalAsync(ShellProfile profile)
+        {
+            return ApplicationView.RunOnDispatcherThread(() =>
+            {
+                var terminal = new TerminalViewModel(_settingsService, _trayProcessCommunicationService, _dialogService, _keyboardCommandService,
+                    _applicationSettings, profile, ApplicationView, _dispatcherTimer, _clipboardService);
+
+                terminal.Closed += OnTerminalClosed;
+                terminal.ShellTitleChanged += Terminal_ShellTitleChanged;
+                terminal.CustomTitleChanged += Terminal_CustomTitleChanged;
+                Terminals.Add(terminal);
+
+                SelectedTerminal = terminal;
+            });
+        }
+
+        private void Terminal_CustomTitleChanged(object sender, string e)
+        {
+            if (sender is TerminalViewModel terminal)
+            {
+                if (terminal.IsSelected && _applicationSettings.ShowCustomTitleInTitlebar)
+                {
+                    if (string.IsNullOrWhiteSpace(e))
+                    {
+                        WindowTitle = terminal.ShellTitle;
+                    }
+                    else
+                    {
+                        WindowTitle = e;
+                    }
+                }
+            }
+        }
+
+        private void Terminal_ShellTitleChanged(object sender, string e)
+        {
+            if (sender is TerminalViewModel terminal && terminal.IsSelected && !_applicationSettings.ShowCustomTitleInTitlebar)
+            {
+                WindowTitle = e;
+            }
+        }
+
+        public async Task CloseAllTerminals()
+        {
+            foreach (var terminal in Terminals)
+            {
+                terminal.Closed -= OnTerminalClosed;
+                terminal.ShellTitleChanged -= Terminal_ShellTitleChanged;
+                terminal.CustomTitleChanged -= Terminal_CustomTitleChanged;
+                await terminal.Close();
+            }
+        }
+
+        private void CloseCurrentTab()
+        {
+            SelectedTerminal?.CloseCommand.Execute(null);
+        }
+
+        private void NewWindow(NewWindowAction showSelection)
+        {
+            NewWindow(showSelection, Guid.Empty);
+        }
+
+        private void NewWindow(NewWindowAction showSelection, Guid profileId)
+        {
+            var args = new NewWindowRequestedEventArgs
+            {
+                Action = showSelection,
+                ProfileId = profileId
+            };
+            NewWindowRequested?.Invoke(this, args);
+        }
+
+        private async void OnApplicationSettingsChanged(object sender, ApplicationSettings e)
+        {
+            await ApplicationView.RunOnDispatcherThread(() =>
+            {
+                _applicationSettings = e;
+                TabsPosition = e.TabsPosition;
+                RaisePropertyChanged(nameof(ShowTabsOnTop));
+                RaisePropertyChanged(nameof(ShowTabsOnBottom));
+
+                if (e.ShowCustomTitleInTitlebar)
+                {
+                    WindowTitle = SelectedTerminal?.TabTitle;
+                }
+                else
+                {
+                    WindowTitle = SelectedTerminal?.ShellTitle;
+                }
+            });
+        }
+
+        private async Task OnCloseRequest(object sender, CancelableEventArgs e)
+        {
+            if (_applicationSettings.ConfirmClosingWindows)
+            {
+                var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmCloseWindow"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(false);
+
+                if (result == DialogButton.OK)
+                {
+                    await CloseAllTerminals();
+                }
+                else
+                {
+                    e.Cancelled = true;
+                }
+            }
+            else
+            {
+                await CloseAllTerminals();
+            }
+        }
+
+        private async void OnCurrentThemeChanged(object sender, Guid e)
+        {
+            await ApplicationView.RunOnDispatcherThread(() =>
+             {
+                 var currentTheme = _settingsService.GetTheme(e);
+                 Background = currentTheme.Colors.Background;
+             });
+        }
+
+        private async void OnTerminalClosed(object sender, EventArgs e)
+        {
+            if (sender is TerminalViewModel terminal)
+            {
+                if (SelectedTerminal == terminal)
+                {
+                    SelectedTerminal = Terminals.LastOrDefault(t => t != terminal);
+                }
+                Logger.Instance.Debug("Terminal with Id: {@id} closed.", terminal.Terminal.Id);
+                Terminals.Remove(terminal);
+
+                if (Terminals.Count == 0)
+                {
+                    await ApplicationView.TryClose();
+                }
+            }
+        }
+
+        private async void OnTerminalOptionsChanged(object sender, TerminalOptions e)
+        {
+            await ApplicationView.RunOnDispatcherThread(() =>
+            {
+                BackgroundOpacity = e.BackgroundOpacity;
+            });
+        }
+
+        private void SelectTabNumber(int tabNumber)
+        {
+            if (tabNumber < Terminals.Count)
+            {
+                SelectedTerminal = Terminals[tabNumber];
+            }
+        }
+
+        private void SelectNextTab()
+        {
+            var currentIndex = Terminals.IndexOf(SelectedTerminal);
+            var nextIndex = (currentIndex + 1) % Terminals.Count;
+            SelectedTerminal = Terminals[nextIndex];
+        }
+
+        private void SelectPreviousTab()
+        {
+            var currentIndex = Terminals.IndexOf(SelectedTerminal);
+            var previousIndex = (currentIndex - 1 + Terminals.Count) % Terminals.Count;
+            SelectedTerminal = Terminals[previousIndex];
+        }
+
+        private void ShowAbout()
+        {
+            ShowAboutRequested?.Invoke(this, EventArgs.Empty);
+        }
+
+        private void ShowSettings()
+        {
+            ShowSettingsRequested?.Invoke(this, EventArgs.Empty);
+        }
+
+        private void ToggleFullScreen()
+        {
+            ApplicationView.ToggleFullScreen();
+        }
+    }
+}

FluentTerminal.App.ViewModels/OverlayViewModel.cs

@@ -0,0 +1,51 @@
+using FluentTerminal.App.Services;
+using GalaSoft.MvvmLight;
+using System;
+
+namespace FluentTerminal.App.ViewModels
+{
+    public class OverlayViewModel : ViewModelBase
+    {
+        private readonly IDispatcherTimer _overlayTimer;
+        private bool _showOverlay;
+        private string _overlayContent;
+
+        public OverlayViewModel(IDispatcherTimer dispatcherTimer)
+        {
+            _overlayTimer = dispatcherTimer;
+            _overlayTimer.Interval = new TimeSpan(0, 0, 2);
+            _overlayTimer.Tick += OnResizeOverlayTimerFinished;
+        }
+
+        public bool ShowOverlay
+        {
+            get => _showOverlay;
+            set => Set(ref _showOverlay, value);
+        }
+
+        public string OverlayContent
+        {
+            get => _overlayContent;
+            set => Set(ref _overlayContent, value);
+        }
+
+        public void Show(string message)
+        {
+            OverlayContent = message; 
+            ShowOverlay = true;
+
+            if (_overlayTimer.IsEnabled)
+            {
+                _overlayTimer.Stop();
+            }
+            _overlayTimer.Start();
+        }
+
+        private void OnResizeOverlayTimerFinished(object sender, object e)
+        {
+            _overlayTimer.Stop();
+            ShowOverlay = false;
+        }
+
+    }
+}

FluentTerminal.App.ViewModels/Profiles/CommandHistory.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+namespace FluentTerminal.App.ViewModels.Profiles
+{
+    public class ExecutedCommand
+    {
+        public string Command { get; set; }
+
+        public string Args { get; set; }
+
+        public DateTime LastExecution { get; set; }
+
+        public int ExecutionCount { get; set; }
+    }
+
+    public class ExecutedCommandHistory
+    {
+        public List<ExecutedCommand> ExecutedCommands { get; set; }
+    }
+}

FluentTerminal.App.ViewModels/Profiles/CommonProfileProviderViewModel.cs

@@ -0,0 +1,146 @@
+using System.Threading.Tasks;
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using FluentTerminal.Models;
+
+namespace FluentTerminal.App.ViewModels.Profiles
+{
+    /// <summary>
+    /// Used for common profiles (PowerShell, CMD, WSL).
+    /// </summary>
+    public class CommonProfileProviderViewModel : ProfileProviderViewModelBase
+    {
+        #region Fields
+
+        private readonly IFileSystemService _fileSystemService;
+
+        #endregion Fields
+
+        #region Properties
+
+        public bool PreInstalled { get; private set; }
+
+        private string _location;
+
+        public string Location
+        {
+            get => _location;
+            set => Set(ref _location, value);
+        }
+
+        private string _workingDirectory;
+
+        public string WorkingDirectory
+        {
+            get => _workingDirectory;
+            set => Set(ref _workingDirectory, value);
+        }
+
+        private string _arguments;
+
+        public string Arguments
+        {
+            get => _arguments;
+            set => Set(ref _arguments, value);
+        }
+
+        #endregion Properties
+
+        #region Commands
+
+        public IAsyncCommand BrowseForCustomShellCommand { get; }
+
+        public IAsyncCommand BrowseForWorkingDirectoryCommand { get; }
+
+        #endregion Commands
+
+        #region Constructor
+
+        public CommonProfileProviderViewModel(ISettingsService settingsService, IApplicationView applicationView,
+            IFileSystemService fileSystemService, ShellProfile original = null) : base(settingsService, applicationView,
+            original)
+        {
+            _fileSystemService = fileSystemService;
+
+            BrowseForCustomShellCommand = new AsyncCommand(BrowseForCustomShell);
+            BrowseForWorkingDirectoryCommand = new AsyncCommand(BrowseForWorkingDirectory);
+
+            Initialize(Model);
+        }
+
+        #endregion Constructor
+
+        #region Methods
+
+        private void Initialize(ShellProfile profile)
+        {
+            PreInstalled = profile.PreInstalled;
+            Location = profile.Location;
+            Arguments = profile.Arguments;
+            WorkingDirectory = profile.WorkingDirectory;
+        }
+
+        protected override void LoadFromProfile(ShellProfile profile)
+        {
+            base.LoadFromProfile(profile);
+
+            Initialize(profile);
+        }
+
+        protected override void CopyToProfile(ShellProfile profile)
+        {
+            base.CopyToProfile(profile);
+
+            profile.Location = _location;
+            profile.Arguments = _arguments;
+            profile.WorkingDirectory = _workingDirectory;
+        }
+
+        public override async Task<string> ValidateAsync()
+        {
+            var error = await base.ValidateAsync();
+
+            if (!string.IsNullOrEmpty(error))
+            {
+                return error;
+            }
+
+            if (!string.IsNullOrEmpty(_location))
+            {
+                return null;
+            }
+
+            error = I18N.Translate("LocationCantBeEmpty");
+
+            return string.IsNullOrEmpty(error) ? "Location cannot be empty." : error;
+        }
+
+        public override bool HasChanges()
+        {
+            return base.HasChanges() || !Model.Location.NullableEqualTo(_location) ||
+                   !Model.WorkingDirectory.NullableEqualTo(_workingDirectory) ||
+                   !Model.Arguments.NullableEqualTo(_arguments);
+        }
+
+        private async Task BrowseForCustomShell()
+        {
+            var file = await _fileSystemService.OpenFile(new[] { ".exe" }).ConfigureAwait(true);
+            if (file != null)
+            {
+                Location = file.Path;
+            }
+        }
+
+        private async Task BrowseForWorkingDirectory()
+        {
+            var directory = await _fileSystemService.BrowseForDirectory().ConfigureAwait(true);
+            if (directory != null)
+            {
+                WorkingDirectory = directory;
+            }
+        }
+
+        #endregion Methods
+    }
+}

FluentTerminal.App.ViewModels/Profiles/ProfileProviderViewModelBase.cs

@@ -0,0 +1,396 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Web;
+using FluentTerminal.App.Services;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+
+namespace FluentTerminal.App.ViewModels.Profiles
+{
+    /// <summary>
+    /// Base class for all profile view model classes. It contains properties shared by all other view models
+    /// (theme-related properties, line-ending translation, and WinPTY/ConPTY selection).
+    /// </summary>
+    public abstract class ProfileProviderViewModelBase : ViewModelBase
+    {
+        #region Static
+
+        private static readonly LineEndingStyle[] LineEndingStylesArray =
+            Enum.GetValues(typeof(LineEndingStyle)).Cast<LineEndingStyle>().ToArray();
+
+        #endregion Static
+
+        #region Fields
+
+        protected readonly ISettingsService SettingsService;
+        protected readonly IApplicationView ApplicationView;
+
+        #endregion Fields
+
+        #region Properties
+
+        private ShellProfile _model;
+
+        public ShellProfile Model
+        {
+            get => _model;
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException();
+                }
+
+                if (ReferenceEquals(_model, value))
+                {
+                    return;
+                }
+
+                if (_model != null && _model.GetType() != value.GetType())
+                {
+                    throw new ArgumentException($"The value has to be of type {_model.GetType().Name}.");
+                }
+
+                _model = value;
+
+                LoadFromProfile(value);
+            }
+        }
+        public ObservableCollection<TabTheme> TabThemes { get; }
+
+        public ObservableCollection<TerminalTheme> TerminalThemes { get; }
+
+        public ObservableCollection<LineEndingStyle> LineEndingStyles { get; } =
+            new ObservableCollection<LineEndingStyle>(LineEndingStylesArray);
+
+        private LineEndingStyle _lineEndingTranslation;
+
+        public LineEndingStyle LineEndingTranslation
+        {
+            get => _lineEndingTranslation;
+            set => Set(ref _lineEndingTranslation, value);
+        }
+
+        private TabTheme _selectedTabTheme;
+
+        public TabTheme SelectedTabTheme
+        {
+            get => _selectedTabTheme ?? (_selectedTabTheme = TabThemes.FirstOrDefault(t => t.Id.Equals(_tabThemeId)));
+            set
+            {
+                if (value == null)
+                {
+                    // Ignore attempt setting null.
+                    return;
+                }
+
+                // Ensure that it's from the list
+                var theme = TabThemes.Contains(value)
+                    ? value
+                    : TabThemes.FirstOrDefault(t => t.Id == value.Id) ?? TabThemes.First();
+
+                if (Set(ref _selectedTabTheme, theme))
+                {
+                    _tabThemeId = theme.Id;
+                }
+            }
+        }
+
+        private int _tabThemeId;
+
+        public int TabThemeId
+        {
+            get => _tabThemeId;
+            set
+            {
+                if (Set(ref _tabThemeId, value))
+                {
+                    SelectedTabTheme = TabThemes.FirstOrDefault(t => t.Id.Equals(value));
+                }
+            }
+        }
+
+        private TerminalTheme _selectedTerminalTheme;
+
+        public TerminalTheme SelectedTerminalTheme
+        {
+            get => _selectedTerminalTheme ??
+                   (_selectedTerminalTheme = TerminalThemes.FirstOrDefault(t => t.Id.Equals(_terminalThemeId)));
+            set
+            {
+                TerminalTheme theme = value;
+
+                if (theme == null)
+                {
+                    // How to handle attempt to setting null theme?
+                    // 1) Throw an exception:
+                    //throw new ArgumentNullException();
+                    // 2) Ignore the attempt:
+                    //return;
+                    // 3) Use default theme (probably the best):
+                    theme = TerminalThemes.First();
+                }
+                else if (!TerminalThemes.Contains(theme))
+                {
+                    // Ensure that it's from the list
+                    theme = TerminalThemes.FirstOrDefault(t => t.Id.Equals(theme.Id)) ?? TerminalThemes.First();
+                }
+
+                if (Set(ref _selectedTerminalTheme, theme))
+                {
+                    _terminalThemeId = theme.Id;
+                }
+            }
+        }
+
+        private Guid _terminalThemeId;
+
+        public Guid TerminalThemeId
+        {
+            get => _terminalThemeId;
+            set
+            {
+                if (Set(ref _terminalThemeId, value))
+                {
+                    SelectedTerminalTheme = TerminalThemes.FirstOrDefault(t => t.Id.Equals(value));
+                }
+            }
+        }
+
+        private bool _useConPty;
+
+        public bool UseConPty
+        {
+            get => _useConPty;
+            set => Set(ref _useConPty, value);
+        }
+
+        #endregion Properties
+
+        #region Constructor
+
+        protected ProfileProviderViewModelBase(ISettingsService settingsService, IApplicationView applicationView,
+            ShellProfile original = null)
+        {
+            SettingsService = settingsService;
+            ApplicationView = applicationView;
+
+            _model = original ?? new ShellProfile();
+
+            TabThemes = new ObservableCollection<TabTheme>(settingsService.GetTabThemes());
+
+            SelectedTabTheme = TabThemes.First();
+
+            TerminalThemes = new ObservableCollection<TerminalTheme>(settingsService.GetThemes());
+
+            TerminalThemes.Insert(0, new TerminalTheme { Id = Guid.Empty, Name = "Default" });
+
+            SelectedTerminalTheme = TerminalThemes.First();
+
+            settingsService.ThemeAdded += OnThemeAdded;
+            settingsService.ThemeDeleted += OnThemeDeleted;
+
+            Initialize(Model);
+        }
+
+        #endregion Constructor
+
+        #region Methods
+
+        private void OnThemeDeleted(object sender, Guid e)
+        {
+            ApplicationView.RunOnDispatcherThread(() =>
+            {
+                var theme = TerminalThemes.FirstOrDefault(t => t.Id.Equals(e));
+
+                if (theme == null)
+                {
+                    return;
+                }
+
+                TerminalThemes.Remove(theme);
+
+                if (_terminalThemeId.Equals(e))
+                {
+                    SelectedTerminalTheme = TerminalThemes.First();
+                }
+            }, false);
+        }
+
+        private void OnThemeAdded(object sender, TerminalTheme e)
+        {
+            ApplicationView.RunOnDispatcherThread(() => TerminalThemes.Add(e), false);
+        }
+
+        private void Initialize(ShellProfile profile)
+        {
+            LineEndingTranslation = profile.LineEndingTranslation;
+            UseConPty = profile.UseConPty;
+            TerminalThemeId = profile.TerminalThemeId;
+            TabThemeId = profile.TabThemeId;
+        }
+
+        protected virtual void LoadFromProfile(ShellProfile profile)
+        {
+            Initialize(profile);
+        }
+
+        protected virtual void CopyToProfile(ShellProfile profile)
+        {
+            profile.LineEndingTranslation = _lineEndingTranslation;
+            profile.UseConPty = _useConPty;
+            profile.TerminalThemeId = _terminalThemeId;
+            profile.TabThemeId = _tabThemeId;
+        }
+
+        public virtual Task<string> ValidateAsync()
+        {
+            return Task.FromResult<string>(null);
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> if view model values aren't equal to the corresponding values of the
+        /// underlying <see cref="ShellProfile"/>.
+        /// </summary>
+        public virtual bool HasChanges()
+        {
+            return Model.LineEndingTranslation != _lineEndingTranslation ||
+                   Model.UseConPty != _useConPty ||
+                   !Model.TerminalThemeId.Equals(_terminalThemeId) ||
+                   Model.TabThemeId != _tabThemeId;
+        }
+
+        /// <summary>
+        /// Copies values from the view model to the underlying <see cref="ShellProfile"/>.
+        /// </summary>
+        /// <param name="acceptIfInvalid">Defines what will happen if the view model data is invalid (if
+        /// <see cref="ValidateAsync"/> returns non-empty string). If this parameter is set to <c>true</c>, the
+        /// data will be copied to the underlying <see cref="ShellProfile"/> anyway. If it's set to <c>false</c>,
+        /// (default) the underlying <see cref="ShellProfile"/> won't be changed at all.</param>
+        /// <returns><c>null</c> or empty string if the operation was successful (the data is valid), or an error
+        /// message returned by <see cref="ValidateAsync"/> method.</returns>
+        public async Task<string> AcceptChangesAsync(bool acceptIfInvalid = false)
+        {
+            var error = await ValidateAsync();
+
+            if (acceptIfInvalid || string.IsNullOrEmpty(error))
+            {
+                CopyToProfile(Model);
+            }
+
+            return error;
+        }
+
+        public void RejectChanges()
+        {
+            ApplicationView.RunOnDispatcherThread(() => LoadFromProfile(Model), false);
+        }
+
+        #endregion Methods
+
+        #region Links/shortcuts related
+
+        private const string UseConPtyQueryStringName = "conpty";
+        private const string LineEndingQueryStringName = "lineending";
+        private const string TerminalThemeIdQueryStringName = "theme";
+        private const string TabThemeIdQueryStringName = "tab";
+
+        private const string ShortcutFileFormat = @"[{{000214A0-0000-0000-C000-000000000046}}]
+Prop3=19,0
+[InternetShortcut]
+IDList=
+URL={0}
+";
+
+        public static string GetShortcutFileContent(string url) => string.Format(ShortcutFileFormat, url);
+
+        public static IEnumerable<Tuple<string, string>> ParseParams(string uriOpts, char separator) =>
+            uriOpts.Split(separator).Select(ParseSshOptionFromUri).Where(p => p != null);
+
+        private static Tuple<string, string> ParseSshOptionFromUri(string option)
+        {
+            string[] nv = option.Split('=');
+
+            if (nv.Length != 2 || string.IsNullOrEmpty(nv[0]))
+            {
+                // For now simply ignore invalid options
+                return null;
+                //throw new FormatException($"Invalid SSH option '{option}'.");
+            }
+
+            return Tuple.Create(HttpUtility.UrlDecode(nv[0]), HttpUtility.UrlDecode(nv[1]));
+        }
+
+        /// <summary>
+        /// Generates URL.
+        /// </summary>
+        /// <returns><see cref="Tuple"/> whose first item represents success. If the first item is <c>true</c>,
+        /// the second contains the URL. If the first item is <c>false</c>, the second contains error message.</returns>
+        public virtual Task<Tuple<bool, string>> GetUrlAsync() =>
+            Task.FromResult(Tuple.Create(false, "Not supported."));
+
+        public string GetBaseQueryString()
+        {
+            var queryString =
+                $"{UseConPtyQueryStringName}={_useConPty}&{LineEndingQueryStringName}={_lineEndingTranslation}";
+
+            if (_tabThemeId != TabThemes.First().Id)
+            {
+                queryString += $"&{TabThemeIdQueryStringName}={_tabThemeId:##########}";
+            }
+
+            if (!_terminalThemeId.Equals(TerminalThemes.First().Id))
+            {
+                queryString += $"&{TerminalThemeIdQueryStringName}={_terminalThemeId}";
+            }
+
+            return queryString;
+        }
+
+        public void LoadBaseFromQueryString(IList<Tuple<string, string>> queryStringParams)
+        {
+            if (queryStringParams == null)
+            {
+                return;
+            }
+
+            var keyValue = queryStringParams.FirstOrDefault(t =>
+                UseConPtyQueryStringName.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
+
+            if (!string.IsNullOrEmpty(keyValue?.Item2) && bool.TryParse(keyValue.Item2?.ToLower(), out bool useConPty))
+            {
+                UseConPty = useConPty;
+            }
+
+            keyValue = queryStringParams.FirstOrDefault(t =>
+                LineEndingQueryStringName.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
+
+            if (!string.IsNullOrEmpty(keyValue?.Item2) && Enum.TryParse(keyValue.Item2, true, out LineEndingStyle lineEndingTranslation))
+            {
+                LineEndingTranslation = lineEndingTranslation;
+            }
+
+            keyValue = queryStringParams.FirstOrDefault(t =>
+                TabThemeIdQueryStringName.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
+
+            if (!string.IsNullOrEmpty(keyValue?.Item2) && int.TryParse(keyValue.Item2, out int tabThemeId))
+            {
+                TabThemeId = tabThemeId;
+            }
+
+            keyValue = queryStringParams.FirstOrDefault(t =>
+                TerminalThemeIdQueryStringName.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
+
+            if (!string.IsNullOrEmpty(keyValue?.Item2) && Guid.TryParse(keyValue.Item2, out Guid terminalThemeId))
+            {
+                TerminalThemeId = terminalThemeId;
+            }
+        }
+
+        #endregion Links/shortcuts related
+    }
+}

FluentTerminal.App.ViewModels/Profiles/SshConnectViewModel.cs

@@ -0,0 +1,860 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web;
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using FluentTerminal.Models;
+
+namespace FluentTerminal.App.ViewModels.Profiles
+{
+    /// <summary>
+    /// View-model for rich-UI based SSH profiles.
+    /// </summary>
+    public class SshConnectViewModel : ProfileProviderViewModelBase
+    {
+        #region Static
+
+        private static readonly Regex CommandValidationRx = new Regex(@"^(?<cmd>[^\s\.]+)(\.exe)?(\s+(?<args>\S.*))?$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        private static readonly string[] AcceptableCommands = { Constants.SshCommandName };
+
+        public static string GetErrorString(SshConnectionInfoValidationResult result, string separator = "; ") =>
+            string.Join(separator, GetErrors(result));
+
+        public static IEnumerable<string> GetErrors(SshConnectionInfoValidationResult result)
+        {
+            if (result == SshConnectionInfoValidationResult.Valid)
+            {
+                yield break;
+            }
+
+            foreach (var value in Enum.GetValues(typeof(SshConnectionInfoValidationResult))
+                .Cast<SshConnectionInfoValidationResult>().Where(r => r != SshConnectionInfoValidationResult.Valid))
+            {
+                if ((value & result) == value)
+                {
+                    yield return I18N.Translate($"{nameof(SshConnectionInfoValidationResult)}.{value}");
+                }
+            }
+        }
+
+        #endregion Static
+
+        #region Fields
+
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+        private readonly IFileSystemService _fileSystemService;
+        private readonly IApplicationDataContainer _historyContainer;
+
+        private bool _commandInputOriginal;
+
+        // To prevent validating the existence of the same file multiple times because it's kinda expensive
+        private string _validatedIdentityFile;
+
+        #endregion Fields
+
+        #region Properties
+
+        private bool _commandInput;
+
+        public bool CommandInput
+        {
+            get => _commandInput;
+            set
+            {
+                if (Set(ref _commandInput, value) && _useMosh)
+                {
+                    RaisePropertyChanged(nameof(MoshVisible));
+                }
+            }
+        }
+
+        #region Quick SSH properties
+
+        private string _command;
+
+        public string Command
+        {
+            get => _command;
+            set => Set(ref _command, value);
+        }
+
+        #endregion Quick SSH properties
+
+        #region Full UI properties
+
+        private string _host;
+
+        public string Host
+        {
+            get => _host;
+            set => Set(ref _host, value);
+        }
+
+        private ushort _sshPort;
+
+        public ushort SshPort
+        {
+            get => _sshPort;
+            set => Set(ref _sshPort, value);
+        }
+
+        private string _username;
+
+        public string Username
+        {
+            get => _username;
+            set => Set(ref _username, value);
+        }
+
+        private string _identityFile;
+
+        public string IdentityFile
+        {
+            get => _identityFile;
+            set => Set(ref _identityFile, value);
+        }
+
+        private bool _useMosh;
+
+        public bool UseMosh
+        {
+            get => _useMosh;
+            set
+            {
+                if (Set(ref _useMosh, value) && !_commandInput)
+                {
+                    RaisePropertyChanged(nameof(MoshVisible));
+                }
+            }
+        }
+
+        private ushort _moshPortFrom;
+
+        public ushort MoshPortFrom
+        {
+            get => _moshPortFrom;
+            set => Set(ref _moshPortFrom, value);
+        }
+
+        private ushort _moshPortTo;
+
+        public ushort MoshPortTo
+        {
+            get => _moshPortTo;
+            set => Set(ref _moshPortTo, value);
+        }
+
+        #endregion Full UI properties
+
+        public bool MoshVisible => _useMosh && !_commandInput;
+
+        public ObservableCollection<string> CommandHistory { get; private set; }
+
+        #endregion Properties
+
+        #region Commands
+
+        public IAsyncCommand BrowseForIdentityFileCommand { get; }
+
+        #endregion Commands
+
+        #region Constructors
+
+        public SshConnectViewModel(ISettingsService settingsService, IApplicationView applicationView,
+            ITrayProcessCommunicationService trayProcessCommunicationService, IFileSystemService fileSystemService,
+            IApplicationDataContainer historyContainer, SshProfile original = null) : base(settingsService, applicationView,
+            original ?? new SshProfile { UseMosh = settingsService.GetApplicationSettings().UseMoshByDefault })
+        {
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+            _fileSystemService = fileSystemService;
+            _historyContainer = historyContainer;
+
+            if (string.IsNullOrEmpty(Model.Location))
+            {
+                _commandInput = settingsService.GetApplicationSettings().UseQuickSshConnectByDefault;
+            }
+            else if (string.IsNullOrEmpty(((SshProfile)Model).Host))
+            {
+                _commandInput = true;
+            }
+            else
+            {
+                _commandInput = false;
+            }
+
+            _commandInputOriginal = _commandInput;
+
+            FillCommandHistory();
+
+            Initialize((SshProfile)Model);
+
+            BrowseForIdentityFileCommand = new AsyncCommand(BrowseForIdentityFile);
+        }
+
+        private SshConnectViewModel(ISettingsService settingsService, IApplicationView applicationView,
+            ITrayProcessCommunicationService trayProcessCommunicationService, IFileSystemService fileSystemService,
+            IApplicationDataContainer historyContainer, bool useCommandInput) : base(settingsService, applicationView,
+            new SshProfile { UseMosh = settingsService.GetApplicationSettings().UseMoshByDefault })
+        {
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+            _fileSystemService = fileSystemService;
+            _historyContainer = historyContainer;
+            _commandInput = useCommandInput;
+            _commandInputOriginal = useCommandInput;
+
+            FillCommandHistory();
+
+            Initialize((SshProfile)Model);
+
+            BrowseForIdentityFileCommand = new AsyncCommand(BrowseForIdentityFile);
+        }
+
+        #endregion Constructors
+
+        #region Methods
+
+        // Fills the view model properties from the input sshProfile
+        private void Initialize(SshProfile sshProfile)
+        {
+            Command = string.IsNullOrEmpty(sshProfile.Location) ? string.Empty : $"{sshProfile.Location} {sshProfile.Arguments}";
+
+            Host = sshProfile.Host;
+            SshPort = sshProfile.SshPort;
+
+            Username = sshProfile.Username;
+
+            if (string.IsNullOrEmpty(Username))
+            {
+                _trayProcessCommunicationService.GetUserName().ContinueWith(t =>
+                {
+                    var username = t.Result;
+
+                    if (string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(username))
+                    {
+                        ApplicationView.RunOnDispatcherThread(() => Username = username, false);
+                    }
+                }, TaskContinuationOptions.OnlyOnRanToCompletion);
+            }
+
+            IdentityFile = sshProfile.IdentityFile;
+            UseMosh = sshProfile.UseMosh;
+            MoshPortFrom = sshProfile.MoshPortFrom;
+            MoshPortTo = sshProfile.MoshPortTo;
+        }
+
+        private async Task BrowseForIdentityFile()
+        {
+            var file = await _fileSystemService.OpenFile(new[] { "*" });
+            if (file != null)
+            {
+                IdentityFile = file.Path;
+            }
+        }
+
+        private string GetArgumentsString()
+        {
+            StringBuilder sb = new StringBuilder();
+
+            if (_sshPort != SshProfile.DefaultSshPort)
+                sb.Append($"-p {_sshPort:#####} ");
+
+            if (!string.IsNullOrEmpty(_identityFile))
+                sb.Append($"-i \"{_identityFile}\" ");
+
+            sb.Append($"{_username}@{_host}");
+
+            if (_useMosh)
+                sb.Append($" {_moshPortFrom}:{_moshPortTo}");
+
+            return sb.ToString();
+        }
+
+        protected override void LoadFromProfile(ShellProfile profile)
+        {
+            base.LoadFromProfile(profile);
+
+            CommandInput = _commandInputOriginal;
+
+            Initialize((SshProfile)profile);
+        }
+
+        protected override void CopyToProfile(ShellProfile profile)
+        {
+            base.CopyToProfile(profile);
+
+            _commandInputOriginal = _commandInput;
+
+            if (_commandInput)
+            {
+                CopyToProfileQuick((SshProfile)profile);
+            }
+            else
+            {
+                CopyToProfileFull((SshProfile)profile);
+            }
+        }
+
+        private void CopyToProfileFull(SshProfile sshProfile)
+        {
+            sshProfile.Location = _useMosh ? Constants.MoshCommandName : Constants.SshCommandName;
+            sshProfile.Arguments = GetArgumentsString();
+
+            sshProfile.WorkingDirectory = null;
+
+            sshProfile.Host = _host;
+            sshProfile.SshPort = _sshPort;
+            sshProfile.Username = _username;
+            sshProfile.IdentityFile = _identityFile;
+            sshProfile.UseMosh = _useMosh;
+            sshProfile.MoshPortFrom = _moshPortFrom;
+            sshProfile.MoshPortTo = _moshPortTo;
+        }
+
+        private void CopyToProfileQuick(SshProfile sshProfile)
+        {
+            var command = _command?.Trim();
+
+            if (string.IsNullOrEmpty(command))
+            {
+                sshProfile.Location = null;
+                sshProfile.Arguments = null;
+
+                return;
+            }
+
+            var match = CommandValidationRx.Match(command);
+
+            if (!match.Success)
+            {
+                // Should not happen ever because this method gets called only if validation succeeds.
+                throw new Exception("Invalid command.");
+            }
+
+            sshProfile.Location = match.Groups["cmd"].Value;
+            sshProfile.Arguments = match.Groups["args"].Success ? match.Groups["args"].Value.Trim() : null;
+
+            sshProfile.WorkingDirectory = null;
+
+            sshProfile.Host = null;
+            sshProfile.SshPort = 0;
+            sshProfile.Username = null;
+            sshProfile.IdentityFile = null;
+            sshProfile.UseMosh = false;
+            sshProfile.MoshPortFrom = 0;
+            sshProfile.MoshPortTo = 0;
+        }
+
+        public override Task<string> ValidateAsync()
+        {
+            return _commandInput ? ValidateQuickAsync() : ValidateFullAsync();
+        }
+
+        private async Task<string> ValidateFullAsync()
+        {
+            var error = await base.ValidateAsync();
+
+            if (!string.IsNullOrEmpty(error))
+            {
+                return error;
+            }
+
+            var result = await GetSshInfoValidationResultAsync();
+
+            if (result == SshConnectionInfoValidationResult.Valid)
+            {
+                return null;
+            }
+
+            error = GetErrorString(result, Environment.NewLine);
+
+            if (string.IsNullOrEmpty(error))
+            {
+                error = "Invalid input.";
+            }
+
+            return error;
+        }
+
+        private async Task<string> ValidateQuickAsync()
+        {
+            var error = await base.ValidateAsync();
+
+            if (!string.IsNullOrEmpty(error))
+            {
+                return error;
+            }
+
+            var match = CommandValidationRx.Match(_command?.Trim() ?? string.Empty);
+
+            if (!match.Success)
+            {
+                error = I18N.Translate("InvalidCommand");
+
+                return string.IsNullOrEmpty(error) ? "Invalid command." : error;
+            }
+
+            if (!AcceptableCommands.Any(c => c.Equals(match.Groups["cmd"].Value, StringComparison.OrdinalIgnoreCase)))
+            {
+                error = I18N.Translate("UnsupportedCommand");
+
+                return string.IsNullOrEmpty(error)
+                    ? $"Unsupported command: {match.Groups["cmd"]}."
+                    : $"{error} {match.Groups["cmd"]}";
+            }
+
+            if (!match.Groups["args"].Success)
+            {
+                error = I18N.Translate("CommandArgumentsMandatory");
+
+                return string.IsNullOrEmpty(error) ? "Command arguments are missing." : error;
+            }
+
+            return null;
+        }
+
+        public override bool HasChanges()
+        {
+            // ReSharper disable once ArrangeRedundantParentheses
+            if (base.HasChanges() || (_commandInput != _commandInputOriginal))
+            {
+                return true;
+            }
+
+            if (_commandInput)
+            {
+                return !_command.NullableEqualTo($"{Model.Location} {Model.Arguments}");
+            }
+
+            var original = (SshProfile)Model;
+
+            return base.HasChanges() || !original.Host.NullableEqualTo(_host) || original.SshPort != _sshPort ||
+                   !original.Username.NullableEqualTo(_username) ||
+                   !original.IdentityFile.NullableEqualTo(_identityFile) || original.UseMosh != _useMosh ||
+                   original.MoshPortFrom != _moshPortFrom || original.MoshPortTo != _moshPortTo;
+        }
+
+        public async Task<SshConnectionInfoValidationResult> GetSshInfoValidationResultAsync()
+        {
+            var result = SshConnectionInfoValidationResult.Valid;
+
+            if (string.IsNullOrEmpty(_username))
+            {
+                result |= SshConnectionInfoValidationResult.UsernameEmpty;
+            }
+
+            if (string.IsNullOrEmpty(_host))
+            {
+                result |= SshConnectionInfoValidationResult.HostEmpty;
+            }
+
+            if (_sshPort < 1)
+            {
+                result |= SshConnectionInfoValidationResult.SshPortZeroOrNegative;
+            }
+
+            if (!await CheckIdentityFileExistsAsync())
+            {
+                result |= SshConnectionInfoValidationResult.IdentityFileDoesNotExist;
+            }
+
+            if (!_useMosh)
+            {
+                return result;
+            }
+
+            if (_moshPortFrom < 1)
+            {
+                result |= SshConnectionInfoValidationResult.MoshPortZeroOrNegative;
+            }
+
+            if (_moshPortFrom > _moshPortTo)
+            {
+                result |= SshConnectionInfoValidationResult.MoshPortRangeInvalid;
+            }
+
+            return result;
+        }
+
+        private async Task<bool> CheckIdentityFileExistsAsync()
+        {
+            var identityFile = _identityFile;
+
+            if (string.IsNullOrEmpty(identityFile) ||
+                identityFile.Equals(_validatedIdentityFile, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            // Here we need to take into account that files from ssh config dir can be provided by name, without full path.
+            string fullPath;
+
+            if (Path.IsPathRooted(identityFile))
+            {
+                fullPath = identityFile;
+            }
+            else
+            {
+                var sshConfigDir = await _trayProcessCommunicationService.GetSshConfigDirAsync();
+
+                if (string.IsNullOrEmpty(sshConfigDir))
+                {
+                    return false;
+                }
+
+                fullPath = Path.Combine(sshConfigDir, identityFile);
+            }
+
+            if (await _trayProcessCommunicationService.CheckFileExistsAsync(fullPath))
+            {
+                _validatedIdentityFile = identityFile;
+
+                IdentityFile = fullPath;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public void SetValidatedIdentityFile(string identityFile)
+        {
+            _validatedIdentityFile = identityFile;
+            IdentityFile = identityFile;
+        }
+
+        #endregion Methods
+
+        #region Command history
+
+        private const string ExecutedCommandsKey = "ExecutedCommands";
+        private const int CommandHistoryLimit = 20;
+
+        private void FillCommandHistory()
+        {
+            var commands = _historyContainer.ReadValueFromJson<ExecutedCommandHistory>(ExecutedCommandsKey, null)
+                ?.ExecutedCommands;
+
+            CommandHistory = commands == null
+                ? new ObservableCollection<string>()
+                : new ObservableCollection<string>(commands.Select(c => $"{c.Command} {c.Args}"));
+        }
+
+        public void SaveCommand(string cmd, string args)
+        {
+            cmd = cmd?.Trim();
+
+            if (string.IsNullOrEmpty(cmd))
+            {
+                throw new ArgumentNullException(nameof(cmd));
+            }
+
+            var commandHistory =
+                _historyContainer.ReadValueFromJson<ExecutedCommandHistory>(ExecutedCommandsKey, null) ??
+                new ExecutedCommandHistory { ExecutedCommands = new List<ExecutedCommand>() };
+
+            var command = commandHistory.ExecutedCommands.FirstOrDefault(c =>
+                string.Equals(cmd, c.Command, StringComparison.Ordinal) && args.NullableEqualTo(c.Args));
+
+            if (command == null)
+            {
+                command = new ExecutedCommand
+                { Command = cmd, Args = args, ExecutionCount = 1, LastExecution = DateTime.UtcNow };
+            }
+            else
+            {
+                command.ExecutionCount++;
+
+                command.LastExecution = DateTime.UtcNow;
+
+                commandHistory.ExecutedCommands.Remove(command);
+            }
+
+            commandHistory.ExecutedCommands.Insert(0, command);
+
+            while (commandHistory.ExecutedCommands.Count > CommandHistoryLimit)
+            {
+                commandHistory.ExecutedCommands.RemoveAt(CommandHistoryLimit);
+            }
+
+            _historyContainer.WriteValueAsJson(ExecutedCommandsKey, commandHistory);
+        }
+
+        #endregion Command history
+
+        #region Links/shortcuts related
+
+        // Resources:
+        // https://tools.ietf.org/html/draft-ietf-secsh-scp-sftp-ssh-uri-04#section-3
+        // https://man.openbsd.org/ssh
+
+        private const string SshUriScheme = "ssh";
+        private const string MoshUriScheme = "mosh";
+
+        private const string CustomSshUriScheme = "sshft";
+        private const string CustomUriHost = "fluent.terminal";
+        private const string CustomCommandQueryStringName = "cmd";
+        private const string CustomArgumentsQueryStringName = "args";
+
+        // Constant derived from https://man.openbsd.org/ssh
+        private const string IdentityFileOptionName = "IdentityFile";
+
+        private static readonly string[] ValidMoshPortsNames = { "mosh_ports", "mosh-ports" };
+
+        private static readonly Regex MoshRangeRx =
+            new Regex(@"^(?<from>\d{1,5})[:-](?<to>\d{1,5})$", RegexOptions.Compiled);
+
+        public static bool CheckScheme(Uri uri) => CheckSchemeStandard(uri) || CheckSchemeCustom(uri);
+
+        private static bool CheckSchemeStandard(Uri uri) =>
+            SshUriScheme.Equals(uri?.Scheme, StringComparison.OrdinalIgnoreCase) ||
+            MoshUriScheme.Equals(uri?.Scheme, StringComparison.OrdinalIgnoreCase);
+
+        private static bool CheckSchemeCustom(Uri uri) =>
+            CustomSshUriScheme.Equals(uri?.Scheme, StringComparison.OrdinalIgnoreCase);
+
+        public static SshConnectViewModel ParseUri(Uri uri, ISettingsService settingsService,
+            IApplicationView applicationView, ITrayProcessCommunicationService trayProcessCommunicationService,
+            IFileSystemService fileSystemService, IApplicationDataContainer historyContainer)
+        {
+            if (CheckSchemeStandard(uri))
+            {
+                return ParseUriStandard(uri, settingsService, applicationView, trayProcessCommunicationService,
+                    fileSystemService, historyContainer);
+            }
+
+            if (CheckSchemeCustom(uri))
+            {
+                return ParseUriCustom(uri, settingsService, applicationView, trayProcessCommunicationService,
+                    fileSystemService, historyContainer);
+            }
+
+            // Won't happen ever
+            throw new Exception($"Unsupported URI scheme: {uri.Scheme}");
+        }
+
+        private static SshConnectViewModel ParseUriStandard(Uri uri, ISettingsService settingsService,
+            IApplicationView applicationView, ITrayProcessCommunicationService trayProcessCommunicationService,
+            IFileSystemService fileSystemService, IApplicationDataContainer historyContainer)
+        {
+            var vm = new SshConnectViewModel(settingsService, applicationView, trayProcessCommunicationService,
+                fileSystemService, historyContainer, false)
+            {
+                Host = uri.Host,
+                UseMosh = MoshUriScheme.Equals(uri.Scheme, StringComparison.OrdinalIgnoreCase)
+            };
+
+            if (uri.Port >= 0)
+                vm.SshPort = (ushort)uri.Port;
+
+            if (!string.IsNullOrEmpty(uri.UserInfo))
+            {
+                string[] parts = uri.UserInfo.Split(';');
+
+                if (parts.Length > 2)
+                    throw new FormatException($"UserInfo part contains {parts.Length} elements.");
+
+                vm.Username = HttpUtility.UrlDecode(parts[0]);
+
+                if (parts.Length > 1)
+                {
+                    // For now we are only interested in IdentityFile option
+                    Tuple<string, string> identityFileOption = ParseParams(parts[1], ',').FirstOrDefault(p =>
+                        string.Equals(p.Item1, IdentityFileOptionName, StringComparison.OrdinalIgnoreCase));
+
+                    vm.IdentityFile = identityFileOption?.Item2;
+                }
+            }
+
+            // ReSharper disable once ConstantConditionalAccessQualifier
+            string queryString = uri.Query?.Trim();
+
+            if (string.IsNullOrEmpty(queryString))
+            {
+                return vm;
+            }
+
+            if (queryString.StartsWith("?", StringComparison.Ordinal))
+            {
+                queryString = queryString.Substring(1);
+            }
+
+            var queryStringParams = ParseParams(queryString, '&').ToList();
+
+            var moshPorts = queryStringParams.FirstOrDefault(p =>
+                ValidMoshPortsNames.Any(n => string.Equals(p.Item1, n, StringComparison.OrdinalIgnoreCase)));
+
+            if (moshPorts != null)
+            {
+                Match match = MoshRangeRx.Match(moshPorts.Item2);
+
+                if (match.Success)
+                {
+                    vm.MoshPortFrom = ushort.Parse(match.Groups["from"].Value);
+                    vm.MoshPortTo = ushort.Parse(match.Groups["to"].Value);
+                }
+            }
+
+            vm.LoadBaseFromQueryString(queryStringParams);
+
+            return vm;
+        }
+
+        private static SshConnectViewModel ParseUriCustom(Uri uri, ISettingsService settingsService,
+            IApplicationView applicationView, ITrayProcessCommunicationService trayProcessCommunicationService,
+            IFileSystemService fileSystemService, IApplicationDataContainer historyContainer)
+        {
+            var vm = new SshConnectViewModel(settingsService, applicationView, trayProcessCommunicationService,
+                fileSystemService, historyContainer, true);
+
+            // ReSharper disable once ConstantConditionalAccessQualifier
+            string queryString = uri.Query?.Trim();
+
+            if (string.IsNullOrEmpty(queryString))
+            {
+                return vm;
+            }
+
+            if (queryString.StartsWith("?", StringComparison.Ordinal))
+            {
+                queryString = queryString.Substring(1);
+            }
+
+            var queryStringParams = ParseParams(queryString, '&').ToList();
+
+            var cmdParam = queryStringParams.FirstOrDefault(t =>
+                CustomCommandQueryStringName.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
+
+            var argsParam = queryStringParams.FirstOrDefault(t =>
+                CustomArgumentsQueryStringName.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
+
+            vm._command =
+                $"{(string.IsNullOrEmpty(cmdParam?.Item2) ? Constants.SshCommandName : cmdParam.Item2)} {argsParam?.Item2}"
+                    .Trim();
+
+            vm.LoadBaseFromQueryString(queryStringParams);
+
+            return vm;
+        }
+
+        public override Task<Tuple<bool, string>> GetUrlAsync()
+        {
+            return _commandInput ? GetUrlQuickAsync() : GetUrlFullAsync();
+        }
+
+        private async Task<Tuple<bool, string>> GetUrlFullAsync()
+        {
+            var error = await base.ValidateAsync();
+
+            if (!string.IsNullOrEmpty(error))
+            {
+                return Tuple.Create(false, error);
+            }
+
+            var result = await GetSshInfoValidationResultAsync();
+
+            if (result != SshConnectionInfoValidationResult.Valid &&
+                // For links we can ignore missing username
+                result != SshConnectionInfoValidationResult.UsernameEmpty)
+            {
+
+                error = GetErrorString(result, Environment.NewLine);
+
+                if (string.IsNullOrEmpty(error))
+                {
+                    error = "Invalid input.";
+                }
+
+                return Tuple.Create(false, error);
+            }
+
+            StringBuilder sb = new StringBuilder(_useMosh ? MoshUriScheme : SshUriScheme);
+
+            sb.Append("://");
+
+            bool containsUserInfo = false;
+
+            if (!string.IsNullOrEmpty(_username))
+            {
+                sb.Append(HttpUtility.UrlEncode(_username));
+
+                containsUserInfo = true;
+            }
+
+            if (!string.IsNullOrEmpty(_identityFile))
+            {
+                sb.Append(";");
+
+                if (!string.IsNullOrEmpty(_identityFile))
+                {
+                    sb.Append($"{IdentityFileOptionName}={HttpUtility.UrlEncode(_identityFile)}");
+                }
+
+                containsUserInfo = true;
+            }
+
+            if (containsUserInfo)
+                sb.Append("@");
+
+            sb.Append(_host);
+
+            if (_sshPort != SshProfile.DefaultSshPort)
+            {
+                sb.Append($":{_sshPort:#####}");
+            }
+
+            sb.Append("/");
+
+            bool queryStringAdded = false;
+
+            if (_useMosh)
+            {
+                sb.Append(
+                    $"?{ValidMoshPortsNames[0]}={_moshPortFrom:#####}-{_moshPortTo:#####}");
+
+                queryStringAdded = true;
+            }
+
+            var terminalInfoQueryString = GetBaseQueryString();
+
+            if (!string.IsNullOrEmpty(terminalInfoQueryString))
+            {
+                sb.Append($"{(queryStringAdded ? "&" : "?")}{terminalInfoQueryString}");
+            }
+
+            return Tuple.Create(true, sb.ToString());
+        }
+
+        private async Task<Tuple<bool, string>> GetUrlQuickAsync()
+        {
+            var error = await base.ValidateAsync();
+
+            if (!string.IsNullOrEmpty(error))
+            {
+                return Tuple.Create(false, error);
+            }
+
+            var match = CommandValidationRx.Match(_command);
+
+            if (!match.Success)
+            {
+                error = I18N.Translate("InvalidCommand");
+
+                return Tuple.Create(false, string.IsNullOrEmpty(error) ? "Invalid command." : error);
+            }
+
+            return Tuple.Create(true,
+                $"{CustomSshUriScheme}://{CustomUriHost}/?{CustomCommandQueryStringName}={Constants.SshCommandName}&{CustomArgumentsQueryStringName}={HttpUtility.UrlEncode(match.Groups["args"].Value.Trim())}&{GetBaseQueryString()}");
+        }
+
+        #endregion Links/shortcuts related
+    }
+}

FluentTerminal.App.ViewModels/Profiles/SshConnectionInfoValidationResult.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace FluentTerminal.App.ViewModels.Profiles
+{
+    [Flags]
+    public enum SshConnectionInfoValidationResult
+    {
+        Valid = 0, 
+        UsernameEmpty = 1,
+        HostEmpty = 2,
+        SshPortZeroOrNegative = 4,
+        MoshPortZeroOrNegative = 8,
+        MoshPortRangeInvalid = 16, 
+        IdentityFileDoesNotExist = 32
+    }
+}

FluentTerminal.App.ViewModels/Settings/AboutPageViewModel.cs

@@ -0,0 +1,79 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using GalaSoft.MvvmLight;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class AboutPageViewModel : ViewModelBase
+    {
+        private const string BaseUrl = "https://github.com/felixse/FluentTerminal/releases/tag/";
+        private readonly ISettingsService _settingsService;
+        private readonly IUpdateService _updateService;
+        private string _latestVersion;
+        private readonly IApplicationView _applicationView;
+
+        public AboutPageViewModel(ISettingsService settingsService, IUpdateService updateService, IApplicationView applicationView)
+        {
+            _settingsService = settingsService;
+            _updateService = updateService;
+            _applicationView = applicationView;
+
+            CheckForUpdatesCommand = new AsyncCommand(() => CheckForUpdate(true));
+        }
+
+        public IAsyncCommand CheckForUpdatesCommand { get; }
+
+        public string CurrentVersion
+        {
+            get
+            {
+                var version = _updateService.GetCurrentVersion();
+                return ConvertVersionToString(version);
+            }
+        }
+
+        public string CurrentVersionReleaseNotesURL => BaseUrl + CurrentVersion;
+
+        public string LatestVersion
+        {
+            get => _latestVersion;
+            set
+            {
+                if (Set(ref _latestVersion, value))
+                {
+                    RaisePropertyChanged(nameof(LatestVersionFound));
+                    RaisePropertyChanged(nameof(LatestVersionLoading));
+                    RaisePropertyChanged(nameof(LatestVersionNotFound));
+                    RaisePropertyChanged(nameof(LatestVersionReleaseNotesURL));
+                }
+            }
+        }
+
+        public bool LatestVersionFound => !LatestVersionNotFound && !LatestVersionLoading;
+
+        public bool LatestVersionLoading => LatestVersion == null;
+
+        public bool LatestVersionNotFound => LatestVersion == "0.0.0.0";
+
+        public string LatestVersionReleaseNotesURL => BaseUrl + LatestVersion;
+
+        public Task OnNavigatedTo()
+        {
+            return CheckForUpdate(false);
+        }
+
+        public async Task CheckForUpdate(bool notifyNoUpdate)
+        {
+            var version = ConvertVersionToString(await _updateService.GetLatestVersionAsync());
+            await _applicationView.RunOnDispatcherThread(() => LatestVersion = version);
+            await _updateService.CheckForUpdate(notifyNoUpdate);
+        }
+
+        private string ConvertVersionToString(Version version)
+        {
+            return string.Format("{0}.{1}.{2}.{3}", version.Major, version.Minor, version.Build, version.Revision);
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/GeneralPageViewModel.cs

@@ -0,0 +1,419 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class GeneralPageViewModel : ViewModelBase
+    {
+        private readonly ApplicationSettings _applicationSettings;
+        private readonly IDefaultValueProvider _defaultValueProvider;
+        private readonly IDialogService _dialogService;
+        private readonly ISettingsService _settingsService;
+        private readonly IStartupTaskService _startupTaskService;
+        private bool _canEnableStartupTask;
+        private bool _startupTaskEnabled;
+        private bool _shouldRestartForTrayMessage;
+        private string _startupTaskErrorMessage;
+        private bool _needsToRestart;
+        private readonly IApplicationLanguageService _applicationLanguageService;
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+
+        public GeneralPageViewModel(ISettingsService settingsService, IDialogService dialogService, IDefaultValueProvider defaultValueProvider,
+            IStartupTaskService startupTaskService, IApplicationLanguageService applicationLanguageService, ITrayProcessCommunicationService trayProcessCommunicationService)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _defaultValueProvider = defaultValueProvider;
+            _startupTaskService = startupTaskService;
+            _applicationLanguageService = applicationLanguageService;
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+
+            _applicationSettings = _settingsService.GetApplicationSettings();
+
+            RestoreDefaultsCommand = new RelayCommand(async () => await RestoreDefaults().ConfigureAwait(false));
+        }
+
+        public IEnumerable<string> Languages => _applicationLanguageService.Languages;
+
+        public bool NeedsToRestart
+        {
+            get => _needsToRestart;
+            set => Set(ref _needsToRestart, value);
+        }
+
+        public string SelectedLanguage
+        {
+            get => _applicationLanguageService.GetCurrentLanguage();
+            set
+            {
+                _applicationLanguageService.SetLanguage(value);
+                NeedsToRestart = true;
+            }
+        }
+
+        public async Task OnNavigatedTo()
+        {
+            var startupTaskStatus = await _startupTaskService.GetStatus();
+            SetStartupTaskPropertiesForStatus(startupTaskStatus);
+        }
+
+        public bool AlwaysShowTabs
+        {
+            get => _applicationSettings.AlwaysShowTabs;
+            set
+            {
+                if (_applicationSettings.AlwaysShowTabs != value)
+                {
+                    _applicationSettings.AlwaysShowTabs = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool ShowCustomTitleInTitlebar
+        {
+            get => _applicationSettings.ShowCustomTitleInTitlebar;
+            set
+            {
+                if (_applicationSettings.ShowCustomTitleInTitlebar != value)
+                {
+                    _applicationSettings.ShowCustomTitleInTitlebar = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool EnableTrayIcon
+        {
+            get => _applicationSettings.EnableTrayIcon;
+            set
+            {
+                if (_applicationSettings.EnableTrayIcon != value)
+                {
+                    _applicationSettings.EnableTrayIcon = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+
+                    // Toggle message telling user to restart the program
+                    ShouldRestartForTrayMessage = !ShouldRestartForTrayMessage;
+                }
+            }
+        }
+
+        public bool ShouldRestartForTrayMessage
+        {
+            get => _shouldRestartForTrayMessage;
+            set => Set(ref _shouldRestartForTrayMessage, value);
+        }
+
+        public bool ShowNewOutputIndicator
+        {
+            get => _applicationSettings.ShowNewOutputIndicator;
+            set
+            {
+                if (_applicationSettings.ShowNewOutputIndicator != value)
+                {
+                    _applicationSettings.ShowNewOutputIndicator = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool UseMoshByDefault
+        {
+            get => _applicationSettings.UseMoshByDefault;
+            set
+            {
+                if (_applicationSettings.UseMoshByDefault != value)
+                {
+                    _applicationSettings.UseMoshByDefault = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool AutoFallbackToWindowsUsernameInLinks
+        {
+            get => _applicationSettings.AutoFallbackToWindowsUsernameInLinks;
+            set
+            {
+                if (_applicationSettings.AutoFallbackToWindowsUsernameInLinks != value)
+                {
+                    _applicationSettings.AutoFallbackToWindowsUsernameInLinks = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool UseQuickSshConnectByDefault
+        {
+            get => _applicationSettings.UseQuickSshConnectByDefault;
+            set
+            {
+                if (_applicationSettings.UseQuickSshConnectByDefault != value)
+                {
+                    _applicationSettings.UseQuickSshConnectByDefault = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool RTrimCopiedLines
+        {
+            get => _applicationSettings.RTrimCopiedLines;
+            set
+            {
+                if (_applicationSettings.RTrimCopiedLines != value)
+                {
+                    _applicationSettings.RTrimCopiedLines = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool MuteTerminalBeeps
+        {
+            get => _applicationSettings.MuteTerminalBeeps;
+            set
+            {
+                if (_applicationSettings.MuteTerminalBeeps != value)
+                {
+                    _applicationSettings.MuteTerminalBeeps = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+
+                    _trayProcessCommunicationService.MuteTerminal(value);
+                }
+            }
+        }
+
+        public bool BottomIsSelected
+        {
+            get => TabsPosition == TabsPosition.Bottom;
+            set { if (value) TabsPosition = TabsPosition.Bottom; }
+        }
+
+        public bool CanEnableStartupTask
+        {
+            get => _canEnableStartupTask;
+            set => Set(ref _canEnableStartupTask, value);
+        }
+
+        public bool ConfirmClosingTabs
+        {
+            get => _applicationSettings.ConfirmClosingTabs;
+            set
+            {
+                if (_applicationSettings.ConfirmClosingTabs != value)
+                {
+                    _applicationSettings.ConfirmClosingTabs = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool ConfirmClosingWindows
+        {
+            get => _applicationSettings.ConfirmClosingWindows;
+            set
+            {
+                if (_applicationSettings.ConfirmClosingWindows != value)
+                {
+                    _applicationSettings.ConfirmClosingWindows = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public NewTerminalLocation NewTerminalLocation
+        {
+            get => _applicationSettings.NewTerminalLocation;
+            set
+            {
+                if (_applicationSettings.NewTerminalLocation != value)
+                {
+                    _applicationSettings.NewTerminalLocation = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public RelayCommand RestoreDefaultsCommand { get; }
+
+        public bool StartupTaskEnabled
+        {
+            get => _startupTaskEnabled;
+            set
+            {
+                if (_startupTaskEnabled != value)
+                {
+                    _startupTaskEnabled = value;
+                    RaisePropertyChanged(nameof(StartupTaskEnabled));
+                    SetStartupTaskState(value);
+                }
+            }
+        }
+
+        public string StartupTaskErrorMessage
+        {
+            get => _startupTaskErrorMessage;
+            set => Set(ref _startupTaskErrorMessage, value);
+        }
+
+        public bool TabIsSelected
+        {
+            get => NewTerminalLocation == NewTerminalLocation.Tab;
+            set { if (value) NewTerminalLocation = NewTerminalLocation.Tab; }
+        }
+
+        public TabsPosition TabsPosition
+        {
+            get => _applicationSettings.TabsPosition;
+            set
+            {
+                if (_applicationSettings.TabsPosition != value)
+                {
+                    _applicationSettings.TabsPosition = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool TopIsSelected
+        {
+            get => TabsPosition == TabsPosition.Top;
+            set { if (value) TabsPosition = TabsPosition.Top; }
+        }
+
+        public bool UnderlineSelectedTab
+        {
+            get => _applicationSettings.UnderlineSelectedTab;
+            set
+            {
+                if (_applicationSettings.UnderlineSelectedTab != value)
+                {
+                    _applicationSettings.UnderlineSelectedTab = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool BackgroundIsSelected
+        {
+            get => InactiveTabColorMode == InactiveTabColorMode.Background;
+            set { if (value) InactiveTabColorMode = InactiveTabColorMode.Background; }
+        }
+
+        public bool UnderlinedIsSelected
+        {
+            get => InactiveTabColorMode == InactiveTabColorMode.Underlined;
+            set { if (value) InactiveTabColorMode = InactiveTabColorMode.Underlined; }
+        }
+
+        public InactiveTabColorMode InactiveTabColorMode
+        {
+            get => _applicationSettings.InactiveTabColorMode;
+            set
+            {
+                if (_applicationSettings.InactiveTabColorMode != value)
+                {
+                    _applicationSettings.InactiveTabColorMode = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool WindowIsSelected
+        {
+            get => NewTerminalLocation == NewTerminalLocation.Window;
+            set { if (value) NewTerminalLocation = NewTerminalLocation.Window; }
+        }
+
+        private async Task RestoreDefaults()
+        {
+            var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmRestoreGeneralSettings"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                var defaults = _defaultValueProvider.GetDefaultApplicationSettings();
+                ConfirmClosingWindows = defaults.ConfirmClosingWindows;
+                ConfirmClosingTabs = defaults.ConfirmClosingTabs;
+                UnderlineSelectedTab = defaults.UnderlineSelectedTab;
+                InactiveTabColorMode = defaults.InactiveTabColorMode;
+                NewTerminalLocation = defaults.NewTerminalLocation;
+                AlwaysShowTabs = defaults.AlwaysShowTabs;
+                ShowNewOutputIndicator = defaults.ShowNewOutputIndicator;
+                EnableTrayIcon = defaults.EnableTrayIcon;
+                ShowCustomTitleInTitlebar = defaults.ShowCustomTitleInTitlebar;
+                UseMoshByDefault = defaults.UseMoshByDefault;
+                AutoFallbackToWindowsUsernameInLinks = defaults.AutoFallbackToWindowsUsernameInLinks;
+                RTrimCopiedLines = defaults.RTrimCopiedLines;
+                MuteTerminalBeeps = defaults.MuteTerminalBeeps;
+            }
+        }
+
+        private void SetStartupTaskPropertiesForStatus(StartupTaskStatus startupTaskStatus)
+        {
+            switch (startupTaskStatus)
+            {
+                case StartupTaskStatus.Enabled:
+                    StartupTaskEnabled = true;
+                    StartupTaskErrorMessage = string.Empty;
+                    CanEnableStartupTask = true;
+                    break;
+
+                case StartupTaskStatus.Disabled:
+                    StartupTaskEnabled = false;
+                    StartupTaskErrorMessage = string.Empty;
+                    CanEnableStartupTask = true;
+                    break;
+
+                case StartupTaskStatus.DisabledByUser:
+                    StartupTaskEnabled = false;
+                    StartupTaskErrorMessage = I18N.Translate("DisabledByUser");
+                    CanEnableStartupTask = false;
+                    break;
+
+                case StartupTaskStatus.DisabledByPolicy:
+                    StartupTaskEnabled = false;
+                    StartupTaskErrorMessage = I18N.Translate("DisabledByPolicy");
+                    CanEnableStartupTask = false;
+                    break;
+            }
+        }
+
+        private async Task SetStartupTaskState(bool enabled)
+        {
+            StartupTaskStatus status;
+            if (enabled)
+            {
+                status = await _startupTaskService.EnableStartupTask();
+            }
+            else
+            {
+                await _startupTaskService.DisableStartupTask();
+                status = await _startupTaskService.GetStatus();
+            }
+            SetStartupTaskPropertiesForStatus(status);
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/KeyBindingViewModel.cs

@@ -0,0 +1,130 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class KeyBindingViewModel : ViewModelBase
+    {
+        private readonly IDialogService _dialogService;
+
+        public KeyBindingViewModel(KeyBinding keyBinding, IDialogService dialogService, KeyBindingsViewModel parent)
+        {
+            Model = keyBinding;
+            Parent = parent;
+            _dialogService = dialogService;
+            EditCommand = new AsyncCommand(Edit);
+            DeleteCommand = new AsyncCommand(Delete);
+        }
+
+        public event EventHandler Deleted;
+
+        public event EventHandler Edited;
+
+        public KeyBindingsViewModel Parent { get; }
+
+        public bool Meta
+        {
+            get => Model.Meta;
+            set
+            {
+                if (Model.Meta != value)
+                {
+                    Model.Meta = value;
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool Alt
+        {
+            get => Model.Alt;
+            set
+            {
+                if (Model.Alt != value)
+                {
+                    Model.Alt = value;
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool Ctrl
+        {
+            get => Model.Ctrl;
+            set
+            {
+                if (Model.Ctrl != value)
+                {
+                    Model.Ctrl = value;
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public IAsyncCommand DeleteCommand { get; }
+        public IAsyncCommand EditCommand { get; }
+
+        public int Key
+        {
+            get => Model.Key;
+            set
+            {
+                if (Model.Key != value)
+                {
+                    Model.Key = value;
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public KeyBinding Model { get; }
+
+        public bool Shift
+        {
+            get => Model.Shift;
+            set
+            {
+                if (Model.Shift != value)
+                {
+                    Model.Shift = value;
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public async Task<bool> Edit()
+        {
+            var keyBinding = await _dialogService.ShowCreateKeyBindingDialog().ConfigureAwait(true);
+
+            if (keyBinding != null)
+            {
+                Alt = keyBinding.Alt;
+                Ctrl = keyBinding.Ctrl;
+                Shift = keyBinding.Shift;
+                Meta = keyBinding.Meta;
+                Key = keyBinding.Key;
+
+                Edited?.Invoke(this, EventArgs.Empty);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private async Task Delete()
+        {
+            var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmDeleteKeybindings"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                Deleted?.Invoke(this, EventArgs.Empty);
+            }
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/KeyBindingsPageViewModel.cs

@@ -0,0 +1,91 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class KeyBindingsPageViewModel : ViewModelBase
+    {
+        private readonly IDefaultValueProvider _defaultValueProvider;
+        private readonly IDialogService _dialogService;
+        private readonly ISettingsService _settingsService;
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+        private IDictionary<string, ICollection<KeyBinding>> _keyBindings;
+
+        public KeyBindingsPageViewModel(ISettingsService settingsService, IDialogService dialogService, IDefaultValueProvider defaultValueProvider, ITrayProcessCommunicationService trayProcessCommunicationService)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _defaultValueProvider = defaultValueProvider;
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+            RestoreDefaultsCommand = new RelayCommand(async () => await RestoreDefaults().ConfigureAwait(false));
+            AddCommand = new RelayCommand<string>(async command => await Add(command).ConfigureAwait(false));
+
+            Initialize(_settingsService.GetCommandKeyBindings());
+        }
+
+        public RelayCommand<string> AddCommand { get; }
+        public ObservableCollection<KeyBindingsViewModel> KeyBindings { get; } = new ObservableCollection<KeyBindingsViewModel>();
+        public RelayCommand RestoreDefaultsCommand { get; }
+
+        private async Task Add(string command)
+        {
+            var keyBinding = KeyBindings.FirstOrDefault(k => k.Command == command);
+            await keyBinding?.ShowAddKeyBindingDialog();
+        }
+
+        private void ClearKeyBindings()
+        {
+            foreach (var keyBinding in KeyBindings)
+            {
+                keyBinding.Edited -= OnEdited;
+            }
+
+            KeyBindings.Clear();
+        }
+
+        private void Initialize(IDictionary<string, ICollection<KeyBinding>> keyBindings)
+        {
+            _keyBindings = keyBindings;
+
+            ClearKeyBindings();
+
+            foreach (var value in Enum.GetValues(typeof(Command)))
+            {
+                var command = (Command)value;
+                var viewModel = new KeyBindingsViewModel(command.ToString(), _dialogService, I18N.Translate($"{nameof(Command)}.{command}"), true);
+                foreach (var keyBinding in _keyBindings[command.ToString()])
+                {
+                    viewModel.Add(keyBinding);
+                }
+                viewModel.Edited += OnEdited;
+                KeyBindings.Add(viewModel);
+            }
+        }
+
+        private void OnEdited(string command, ICollection<KeyBinding> keyBindings)
+        {
+            _settingsService.SaveKeyBindings(command, keyBindings);
+            _trayProcessCommunicationService.UpdateToggleWindowKeyBindings();
+        }
+
+        private async Task RestoreDefaults()
+        {
+            var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmRestoreKeybindings"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                _settingsService.ResetKeyBindings();
+                Initialize(_settingsService.GetCommandKeyBindings());
+            }
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/KeyBindingsViewModel.cs

@@ -0,0 +1,84 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class KeyBindingsViewModel : ViewModelBase
+    {
+        private readonly IDialogService _dialogService;
+        private bool _editable;
+
+        public KeyBindingsViewModel(string command, IDialogService dialogService, string commandName, bool editable)
+        {
+            _dialogService = dialogService;
+
+            Command = command;
+            CommandName = commandName;
+            Editable = editable;
+        }
+
+        public delegate void EditedEvent(string command, ICollection<KeyBinding> keyBindings);
+
+        public event EditedEvent Edited;
+
+        public string Command { get; }
+
+        public string CommandName { get; }
+
+        /// <summary>
+        ///  Whether or not the "Edit" and "Delete" links appear next to the key binding list.
+        /// </summary>
+        public bool Editable
+        {
+            get => _editable;
+            set => Set(ref _editable, value);
+        }
+
+        public ObservableCollection<KeyBindingViewModel> KeyBindings { get; } = new ObservableCollection<KeyBindingViewModel>();
+
+        public async Task ShowAddKeyBindingDialog()
+        {
+            var newKeyBinding = new KeyBindingViewModel(new KeyBinding { Command = Command }, _dialogService, this);
+
+            if (await newKeyBinding.Edit().ConfigureAwait(true))
+            {
+                Add(newKeyBinding.Model);
+            }
+        }
+
+        public void Clear()
+        {
+            KeyBindings.Clear();
+        }
+
+        public void Add(KeyBinding keyBinding)
+        {
+            var viewModel = new KeyBindingViewModel(keyBinding, _dialogService, this);
+
+            viewModel.Deleted += ViewModel_Deleted;
+            viewModel.Edited += ViewModel_Edited;
+            KeyBindings.Add(viewModel);
+            Edited?.Invoke(Command, KeyBindings.Select(x => x.Model).ToList());
+        }
+
+        private void ViewModel_Deleted(object sender, EventArgs e)
+        {
+            if (sender is KeyBindingViewModel keyBinding)
+            {
+                KeyBindings.Remove(keyBinding);
+                Edited?.Invoke(Command, KeyBindings.Select(x => x.Model).ToList());
+            }
+        }
+
+        private void ViewModel_Edited(object sender, EventArgs e)
+        {
+            Edited?.Invoke(Command, KeyBindings.Select(x => x.Model).ToList());
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/MousePageViewModel.cs

@@ -0,0 +1,121 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class MousePageViewModel : ViewModelBase
+    {
+        private readonly ISettingsService _settingsService;
+        private readonly IDialogService _dialogService;
+        private readonly IDefaultValueProvider _defaultValueProvider;
+        private readonly ApplicationSettings _applicationSettings;
+
+        public MousePageViewModel(ISettingsService settingsService, IDialogService dialogService, IDefaultValueProvider defaultValueProvider)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _defaultValueProvider = defaultValueProvider;
+            _applicationSettings = _settingsService.GetApplicationSettings();
+
+            RestoreDefaultsCommand = new RelayCommand(async () => await RestoreDefaults().ConfigureAwait(false));
+        }
+
+        public bool CopyOnSelect
+        {
+            get => _applicationSettings.CopyOnSelect;
+            set
+            {
+                if (_applicationSettings.CopyOnSelect != value)
+                {
+                    _applicationSettings.CopyOnSelect = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public MouseAction MouseRightClickAction
+        {
+            get => _applicationSettings.MouseRightClickAction;
+            set
+            {
+                if (_applicationSettings.MouseRightClickAction != value)
+                {
+                    _applicationSettings.MouseRightClickAction = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool MouseRightClickNoneIsSelected
+        {
+            get => MouseRightClickAction == MouseAction.None;
+            set { if (value) MouseRightClickAction = MouseAction.None; }
+        }
+
+        public bool MouseRightClickContextMenuIsSelected
+        {
+            get => MouseRightClickAction == MouseAction.ContextMenu;
+            set { if (value) MouseRightClickAction = MouseAction.ContextMenu; }
+        }
+
+        public bool MouseRightClickPasteIsSelected
+        {
+            get => MouseRightClickAction == MouseAction.Paste;
+            set { if (value) MouseRightClickAction = MouseAction.Paste; }
+        }
+
+        public MouseAction MouseMiddleClickAction
+        {
+            get => _applicationSettings.MouseMiddleClickAction;
+            set
+            {
+                if (_applicationSettings.MouseMiddleClickAction != value)
+                {
+                    _applicationSettings.MouseMiddleClickAction = value;
+                    _settingsService.SaveApplicationSettings(_applicationSettings);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool MouseMiddleClickNoneIsSelected
+        {
+            get => MouseMiddleClickAction == MouseAction.None;
+            set { if (value) MouseMiddleClickAction = MouseAction.None; }
+        }
+
+        public bool MouseMiddleClickContextMenuIsSelected
+        {
+            get => MouseMiddleClickAction == MouseAction.ContextMenu;
+            set { if (value) MouseMiddleClickAction = MouseAction.ContextMenu; }
+        }
+
+        public bool MouseMiddleClickPasteIsSelected
+        {
+            get => MouseMiddleClickAction == MouseAction.Paste;
+            set { if (value) MouseMiddleClickAction = MouseAction.Paste; }
+        }
+
+        public RelayCommand RestoreDefaultsCommand { get; }
+
+        private async Task RestoreDefaults()
+        {
+            var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmRestoreMouseSettings"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                var defaults = _defaultValueProvider.GetDefaultApplicationSettings();
+                CopyOnSelect = defaults.CopyOnSelect;
+                MouseMiddleClickAction = defaults.MouseMiddleClickAction;
+                MouseRightClickAction = defaults.MouseRightClickAction;
+            }
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/ProfilesPageViewModel.cs

@@ -0,0 +1,128 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class ProfilesPageViewModel : ViewModelBase
+    {
+        private readonly IDefaultValueProvider _defaultValueProvider;
+        private readonly IDialogService _dialogService;
+        private readonly ISettingsService _settingsService;
+        private readonly IFileSystemService _fileSystemService;
+        private ShellProfileViewModel _selectedShellProfile;
+        private readonly IApplicationView _applicationView;
+
+        public ProfilesPageViewModel(ISettingsService settingsService, IDialogService dialogService, IDefaultValueProvider defaultValueProvider, IFileSystemService fileSystemService, IApplicationView applicationView)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _defaultValueProvider = defaultValueProvider;
+            _fileSystemService = fileSystemService;
+            _applicationView = applicationView;
+
+            CreateShellProfileCommand = new RelayCommand(CreateShellProfile);
+            CloneCommand = new RelayCommand<ShellProfileViewModel>(Clone);
+
+            var defaultShellProfileId = _settingsService.GetDefaultShellProfileId();
+            foreach (var shellProfile in _settingsService.GetShellProfiles())
+            {
+                var viewModel = new ShellProfileViewModel(shellProfile, settingsService, dialogService, fileSystemService, applicationView, defaultValueProvider, false);
+                viewModel.Deleted += OnShellProfileDeleted;
+                viewModel.SetAsDefault += OnShellProfileSetAsDefault;
+
+                if (shellProfile.Id == defaultShellProfileId)
+                {
+                    viewModel.IsDefault = true;
+                }
+                ShellProfiles.Add(viewModel);
+            }
+
+            SelectedShellProfile = ShellProfiles.First(p => p.IsDefault);
+            
+        }
+
+        private void OnShellProfileSetAsDefault(object sender, EventArgs e)
+        {
+            if (sender is ShellProfileViewModel defaultShellProfile)
+            {
+                _settingsService.SaveDefaultShellProfileId(defaultShellProfile.Id);
+
+                foreach (var shellProfile in ShellProfiles)
+                {
+                    shellProfile.IsDefault = shellProfile.Id == defaultShellProfile.Id;
+                }
+            }
+        }
+
+        private void OnShellProfileDeleted(object sender, EventArgs e)
+        {
+            if (sender is ShellProfileViewModel shellProfile)
+            {
+                if (SelectedShellProfile == shellProfile)
+                {
+                    SelectedShellProfile = ShellProfiles.First();
+                }
+                ShellProfiles.Remove(shellProfile);
+
+                if (shellProfile.IsDefault)
+                {
+                    ShellProfiles.First().IsDefault = true;
+                    _settingsService.SaveDefaultShellProfileId(ShellProfiles.First().Id);
+                }
+                _settingsService.DeleteShellProfile(shellProfile.Id);
+            }
+        }
+
+        public RelayCommand CreateShellProfileCommand { get; }
+
+        public RelayCommand<ShellProfileViewModel> CloneCommand { get; }
+
+        private void CreateShellProfile()
+        {
+            var shellProfile = new ShellProfile
+            {
+                Id = Guid.NewGuid(),
+                PreInstalled = false,
+                Name = "New profile",
+                KeyBindings = new List<KeyBinding>()
+            };
+
+            AddShellProfile(shellProfile);
+        }
+
+        private void Clone(ShellProfileViewModel shellProfile)
+        {
+            var cloned = shellProfile.ProfileVm.Model.Clone();
+
+            cloned.Id = Guid.NewGuid();
+            cloned.PreInstalled = false;
+            cloned.Name = $"Copy of {shellProfile.Name}";
+
+            AddShellProfile(cloned);
+        }
+
+        private void AddShellProfile(ShellProfile shellProfile)
+        {
+            var viewModel = new ShellProfileViewModel(shellProfile, _settingsService, _dialogService, _fileSystemService, _applicationView, _defaultValueProvider, true);
+            viewModel.EditCommand.Execute(null);
+            viewModel.SetAsDefault += OnShellProfileSetAsDefault;
+            viewModel.Deleted += OnShellProfileDeleted;
+            ShellProfiles.Add(viewModel);
+            SelectedShellProfile = viewModel;
+        }
+
+        public ShellProfileViewModel SelectedShellProfile
+        {
+            get => _selectedShellProfile;
+            set => Set(ref _selectedShellProfile, value);
+        }
+
+        public ObservableCollection<ShellProfileViewModel> ShellProfiles { get; } = new ObservableCollection<ShellProfileViewModel>();
+    }
+}

FluentTerminal.App.ViewModels/Settings/SshProfilesPageViewModel.cs

@@ -0,0 +1,118 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class SshProfilesPageViewModel: ViewModelBase
+    {
+        private readonly IDialogService _dialogService;
+        private readonly ISettingsService _settingsService;
+        private readonly IFileSystemService _fileSystemService;
+        private SshProfileViewModel _selectedShellProfile;
+        private readonly IApplicationView _applicationView;
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+        private readonly IApplicationDataContainer _historyContainer;
+
+        public SshProfilesPageViewModel(ISettingsService settingsService, IDialogService dialogService,
+            IFileSystemService fileSystemService, IApplicationView applicationView,
+            ITrayProcessCommunicationService trayProcessCommunicationService,
+            IApplicationDataContainer historyContainer)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _fileSystemService = fileSystemService;
+            _applicationView = applicationView;
+            _trayProcessCommunicationService = trayProcessCommunicationService;
+            _historyContainer = historyContainer;
+
+            CreateSshProfileCommand = new RelayCommand(CreateSshProfile);
+            CloneCommand = new RelayCommand<SshProfileViewModel>(Clone);
+
+            foreach (var sshProfile in _settingsService.GetSshProfiles())
+            {
+                var viewModel = new SshProfileViewModel(sshProfile, settingsService, dialogService, fileSystemService,
+                    applicationView, _trayProcessCommunicationService, historyContainer, false);
+                viewModel.Deleted += OnSshProfileDeleted;
+                SshProfiles.Add(viewModel);
+            }
+
+            if (SshProfiles.Count == 0)
+            {
+                CreateSshProfile();
+            }
+
+            SelectedSshProfile = SshProfiles.First();
+        }
+
+        private void OnSshProfileDeleted(object sender, EventArgs e)
+        {
+            if (sender is SshProfileViewModel shellProfile)
+            {
+                if (SelectedSshProfile == shellProfile)
+                {
+                    SelectedSshProfile = SshProfiles.First();
+                }
+                SshProfiles.Remove(shellProfile);
+                _settingsService.DeleteSshProfile(shellProfile.Id);
+            }
+        }
+
+        public RelayCommand CreateSshProfileCommand { get; }
+
+        public RelayCommand<SshProfileViewModel> CloneCommand { get; }
+
+        public void CreateSshProfile()
+        {
+            var shellProfile = new SshProfile
+            {
+                Id = Guid.NewGuid(),
+                PreInstalled = false,
+                Name = "New SSH profile",
+                KeyBindings = new List<KeyBinding>(),
+                UseMosh = _settingsService.GetApplicationSettings().UseMoshByDefault
+            };
+
+            AddSshProfile(shellProfile);
+        }
+
+        private void Clone(SshProfileViewModel shellProfile)
+        {
+            var cloned = (SshProfile) shellProfile.ProfileVm.Model.Clone();
+
+            cloned.Id = Guid.NewGuid();
+            cloned.PreInstalled = false;
+            cloned.Name = $"Copy of {shellProfile.Name}";
+
+            foreach (KeyBinding keyBinding in cloned.KeyBindings)
+            {
+                keyBinding.Command = cloned.Id.ToString();
+            }
+            AddSshProfile(cloned);
+        }
+
+        private void AddSshProfile(SshProfile sshProfile)
+        {
+            var viewModel = new SshProfileViewModel(sshProfile, _settingsService, _dialogService, _fileSystemService,
+                _applicationView, _trayProcessCommunicationService, _historyContainer, true);
+
+            viewModel.EditCommand.Execute(null);
+            viewModel.Deleted += OnSshProfileDeleted;
+            SshProfiles.Add(viewModel);
+            SelectedSshProfile = viewModel;
+        }
+
+        public SshProfileViewModel SelectedSshProfile
+        {
+            get => _selectedShellProfile;
+            set => Set(ref _selectedShellProfile, value);
+        }
+
+        public ObservableCollection<SshProfileViewModel> SshProfiles { get; } = new ObservableCollection<SshProfileViewModel>();
+    }
+}

FluentTerminal.App.ViewModels/Settings/TerminalPageViewModel.cs

@@ -0,0 +1,247 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class TerminalPageViewModel : ViewModelBase
+    {
+        private readonly TerminalOptions _terminalOptions;
+        private readonly ISettingsService _settingsService;
+        private readonly IDialogService _dialogService;
+        private readonly IDefaultValueProvider _defaultValueProvider;
+
+        public bool BarIsSelected
+        {
+            get => CursorStyle == CursorStyle.Bar;
+            set { if (value) CursorStyle = CursorStyle.Bar; }
+        }
+
+        public bool BlockIsSelected
+        {
+            get => CursorStyle == CursorStyle.Block;
+            set { if (value) CursorStyle = CursorStyle.Block; }
+        }
+
+        public bool UnderlineIsSelected
+        {
+            get => CursorStyle == CursorStyle.Underline;
+            set { if (value) CursorStyle = CursorStyle.Underline; }
+        }
+
+        public bool HiddenIsSelected
+        {
+            get => ScrollBarStyle == ScrollBarStyle.Hidden;
+            set { if (value) ScrollBarStyle = ScrollBarStyle.Hidden; }
+        }
+
+        public bool AutoHidingIsSelected
+        {
+            get => ScrollBarStyle == ScrollBarStyle.AutoHiding;
+            set { if (value) ScrollBarStyle = ScrollBarStyle.AutoHiding; }
+        }
+
+        public bool VisibleIsSelected
+        {
+            get => ScrollBarStyle == ScrollBarStyle.Visible;
+            set { if (value) ScrollBarStyle = ScrollBarStyle.Visible; }
+        }
+
+        public bool CursorBlink
+        {
+            get => _terminalOptions.CursorBlink;
+            set
+            {
+                if (_terminalOptions.CursorBlink != value)
+                {
+                    _terminalOptions.CursorBlink = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public string FontFamily
+        {
+            get => _terminalOptions.FontFamily;
+            set
+            {
+                if (_terminalOptions.FontFamily != value)
+                {
+                    _terminalOptions.FontFamily = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public double BackgroundOpacity
+        {
+            get => _terminalOptions.BackgroundOpacity;
+            set
+            {
+                if (_terminalOptions.BackgroundOpacity != value)
+                {
+                    _terminalOptions.BackgroundOpacity = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public int Padding
+        {
+            get => _terminalOptions.Padding;
+            set
+            {
+                if (_terminalOptions.Padding != value)
+                {
+                    _terminalOptions.Padding = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public string ScrollBackLimit
+        {
+            get => _terminalOptions.ScrollBackLimit.ToString();
+            set
+            {
+                var oldValue = _terminalOptions.ScrollBackLimit;
+                if (uint.TryParse(value, out uint intValue))
+                {
+                    if (intValue == uint.MinValue)
+                    {
+                        intValue = uint.MaxValue;
+                    }
+                    if (_terminalOptions.ScrollBackLimit != intValue)
+                    {
+                        _terminalOptions.ScrollBackLimit = intValue;
+                        _settingsService.SaveTerminalOptions(_terminalOptions);
+                        RaisePropertyChanged();
+                    }
+                }
+                else
+                {
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool BoldText
+        {
+            get => _terminalOptions.BoldText;
+            set
+            {
+                if (_terminalOptions.BoldText != value)
+                {
+                    _terminalOptions.BoldText = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public bool ShowTextCopied
+        {
+            get => _terminalOptions.ShowTextCopied;
+            set
+            {
+                if (_terminalOptions.ShowTextCopied != value)
+                {
+                    _terminalOptions.ShowTextCopied = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public IEnumerable<FontInfo> Fonts { get; }
+
+        public int FontSize
+        {
+            get => _terminalOptions.FontSize;
+            set
+            {
+                if (_terminalOptions.FontSize != value)
+                {
+                    _terminalOptions.FontSize = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        public IEnumerable<int> Sizes { get; }
+
+        public RelayCommand RestoreDefaultsCommand { get; }
+
+        private CursorStyle CursorStyle
+        {
+            get => _terminalOptions.CursorStyle;
+            set
+            {
+                if (_terminalOptions.CursorStyle != value)
+                {
+                    _terminalOptions.CursorStyle = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        private ScrollBarStyle ScrollBarStyle
+        {
+            get => _terminalOptions.ScrollBarStyle;
+            set
+            {
+                if (_terminalOptions.ScrollBarStyle != value)
+                {
+                    _terminalOptions.ScrollBarStyle = value;
+                    _settingsService.SaveTerminalOptions(_terminalOptions);
+                    RaisePropertyChanged();
+                }
+            }
+        }
+
+        private async Task RestoreDefaults()
+        {
+            var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmRestoreTerminalOptions"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                var defaults = _defaultValueProvider.GetDefaultTerminalOptions();
+                CursorBlink = defaults.CursorBlink;
+                CursorStyle = defaults.CursorStyle;
+                ScrollBarStyle = defaults.ScrollBarStyle;
+                FontFamily = defaults.FontFamily;
+                FontSize = defaults.FontSize;
+                BoldText = defaults.BoldText;
+                BackgroundOpacity = defaults.BackgroundOpacity;
+                ScrollBackLimit = defaults.ScrollBackLimit.ToString();
+                ShowTextCopied = defaults.ShowTextCopied;
+            }
+        }
+
+        public TerminalPageViewModel(ISettingsService settingsService, IDialogService dialogService, IDefaultValueProvider defaultValueProvider, ISystemFontService systemFontService)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _defaultValueProvider = defaultValueProvider;
+
+            RestoreDefaultsCommand = new RelayCommand(async () => await RestoreDefaults().ConfigureAwait(false));
+
+            Fonts = systemFontService.GetSystemFontFamilies().OrderBy(s => s.Name);
+            Sizes = Enumerable.Range(1, 72);
+
+            _terminalOptions = _settingsService.GetTerminalOptions();
+        }
+    }
+}

FluentTerminal.App.ViewModels/Settings/ThemesPageViewModel.cs

@@ -0,0 +1,193 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace FluentTerminal.App.ViewModels.Settings
+{
+    public class ThemesPageViewModel : ViewModelBase
+    {
+        private readonly IDefaultValueProvider _defaultValueProvider;
+        private readonly IDialogService _dialogService;
+        private readonly ISettingsService _settingsService;
+        private ThemeViewModel _selectedTheme;
+        private double _backgroundOpacity;
+        private readonly IThemeParserFactory _themeParserFactory;
+        private readonly IFileSystemService _fileSystemService;
+
+        public event EventHandler<string> SelectedThemeBackgroundColorChanged;
+
+        public ThemesPageViewModel(ISettingsService settingsService, IDialogService dialogService, IDefaultValueProvider defaultValueProvider,
+            IThemeParserFactory themeParserFactory, IFileSystemService fileSystemService)
+        {
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _defaultValueProvider = defaultValueProvider;
+            _themeParserFactory = themeParserFactory;
+            _fileSystemService = fileSystemService;
+
+            CreateThemeCommand = new RelayCommand(CreateTheme);
+            ImportThemeCommand = new RelayCommand(ImportTheme);
+            CloneCommand = new RelayCommand<ThemeViewModel>(CloneTheme);
+
+            _settingsService.TerminalOptionsChanged += OnTerminalOptionsChanged;
+
+            BackgroundOpacity = _settingsService.GetTerminalOptions().BackgroundOpacity;
+
+            var activeThemeId = _settingsService.GetCurrentThemeId();
+            foreach (var theme in _settingsService.GetThemes())
+            {
+                var viewModel = new ThemeViewModel(theme, _settingsService, _dialogService, fileSystemService, false);
+                viewModel.Activated += OnThemeActivated;
+                viewModel.Deleted += OnThemeDeleted;
+
+                if (theme.Id == activeThemeId)
+                {
+                    viewModel.IsActive = true;
+                }
+                Themes.Add(viewModel);
+            }
+
+            SelectedTheme = Themes.First(t => t.IsActive);
+        }
+
+        public RelayCommand CreateThemeCommand { get; }
+        public RelayCommand ImportThemeCommand { get; }
+        public RelayCommand<ThemeViewModel> CloneCommand { get; set; }
+
+        public double BackgroundOpacity
+        {
+            get => _backgroundOpacity;
+            set => Set(ref _backgroundOpacity, value);
+        }
+
+        public ThemeViewModel SelectedTheme
+        {
+            get => _selectedTheme;
+            set
+            {
+                if (_selectedTheme != null)
+                {
+                    _selectedTheme.BackgroundChanged -= OnSelectedThemeBackgroundChanged;
+                }
+                Set(ref _selectedTheme, value);
+                if (value != null)
+                {
+                    value.BackgroundChanged += OnSelectedThemeBackgroundChanged;
+                }
+            }
+        }
+
+        public ObservableCollection<ThemeViewModel> Themes { get; } = new ObservableCollection<ThemeViewModel>();
+
+        private void CloneTheme(ThemeViewModel theme)
+        {
+            var cloned = new TerminalTheme(theme.Model)
+            {
+                Id = Guid.NewGuid(),
+                PreInstalled = false,
+                Name = $"Copy of {theme.Name}"
+            };
+
+            AddTheme(cloned);
+        }
+
+        private void CreateTheme()
+        {
+            var defaultTheme = _settingsService.GetTheme(_defaultValueProvider.GetDefaultThemeId());
+            var theme = new TerminalTheme
+            {
+                Id = Guid.NewGuid(),
+                PreInstalled = false,
+                Name = "New Theme",
+                Colors = new TerminalColors(defaultTheme.Colors)
+            };
+
+            AddTheme(theme);
+        }
+
+        private async void ImportTheme()
+        {
+            var file = await _fileSystemService.OpenFile(_themeParserFactory.SupportedFileTypes).ConfigureAwait(true);
+            if (file != null)
+            {
+                var parser = _themeParserFactory.GetParser(file.FileType);
+
+                if (parser == null)
+                {
+                    await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("ImportThemeFailed"), I18N.Translate("NoSuitableParserFound"), DialogButton.OK).ConfigureAwait(false);
+                    return;
+                }
+
+                try
+                {
+                    var theme = await parser.Parse(file.Name, file.Content).ConfigureAwait(true);
+
+                    AddTheme(theme);
+                }
+                catch (Exception exception)
+                {
+                    await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("ImportThemeFailed"), exception.Message, DialogButton.OK).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private void AddTheme(TerminalTheme theme)
+        {
+            _settingsService.SaveTheme(theme, true);
+
+            var viewModel = new ThemeViewModel(theme, _settingsService, _dialogService, _fileSystemService, true);
+            viewModel.EditCommand.Execute(null);
+            viewModel.Activated += OnThemeActivated;
+            viewModel.Deleted += OnThemeDeleted;
+            Themes.Add(viewModel);
+            SelectedTheme = viewModel;
+        }
+
+        private void OnThemeActivated(object sender, EventArgs e)
+        {
+            if (sender is ThemeViewModel activatedTheme)
+            {
+                _settingsService.SaveCurrentThemeId(activatedTheme.Id);
+
+                foreach (var theme in Themes)
+                {
+                    theme.IsActive = theme.Id == activatedTheme.Id;
+                }
+            }
+        }
+
+        private void OnThemeDeleted(object sender, EventArgs e)
+        {
+            if (sender is ThemeViewModel theme)
+            {
+                if (SelectedTheme == theme)
+                {
+                    SelectedTheme = Themes.First();
+                }
+                Themes.Remove(theme);
+
+                if (theme.IsActive)
+                {
+                    Themes.First().IsActive = true;
+                    _settingsService.SaveCurrentThemeId(Themes.First().Id);
+                }
+                _settingsService.DeleteTheme(theme.Id);
+            }
+        }
+
+        private void OnTerminalOptionsChanged(object sender, TerminalOptions e)
+        {
+            BackgroundOpacity = e.BackgroundOpacity;
+        }
+
+        private void OnSelectedThemeBackgroundChanged(object sender, string e)
+        {
+            SelectedThemeBackgroundColorChanged?.Invoke(this, e);
+        }
+    }
+}

FluentTerminal.App.ViewModels/SettingsViewModel.cs

@@ -0,0 +1,48 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.ViewModels.Settings;
+using GalaSoft.MvvmLight;
+using System;
+
+namespace FluentTerminal.App.ViewModels
+{
+    public class SettingsViewModel : ViewModelBase
+    {
+        public SettingsViewModel(ISettingsService settingsService, IDefaultValueProvider defaultValueProvider, IDialogService dialogService,
+            ITrayProcessCommunicationService trayProcessCommunicationService, IThemeParserFactory themeParserFactory, ISystemFontService systemFontService,
+            IFileSystemService fileSystemService, IStartupTaskService startupTaskService, IUpdateService updateService, IApplicationView applicationView, 
+            IApplicationLanguageService applicationLanguageService, ApplicationDataContainers containers)
+        {
+            About = new AboutPageViewModel(settingsService, updateService, applicationView);
+            KeyBindings = new KeyBindingsPageViewModel(settingsService, dialogService, defaultValueProvider, trayProcessCommunicationService);
+            General = new GeneralPageViewModel(settingsService, dialogService, defaultValueProvider, startupTaskService, applicationLanguageService, trayProcessCommunicationService);
+            Profiles = new ProfilesPageViewModel(settingsService, dialogService, defaultValueProvider, fileSystemService, applicationView);
+            Terminal = new TerminalPageViewModel(settingsService, dialogService, defaultValueProvider, systemFontService);
+            Themes = new ThemesPageViewModel(settingsService, dialogService, defaultValueProvider, themeParserFactory, fileSystemService);
+            Mouse = new MousePageViewModel(settingsService, dialogService, defaultValueProvider);
+            SshProfiles = new SshProfilesPageViewModel(settingsService, dialogService, fileSystemService,
+                applicationView, trayProcessCommunicationService, containers.HistoryContainer);
+        }
+
+        public event EventHandler Closed;
+        public event EventHandler AboutPageRequested;
+
+        public GeneralPageViewModel General { get; }
+        public KeyBindingsPageViewModel KeyBindings { get; }
+        public ProfilesPageViewModel Profiles { get; }
+        public TerminalPageViewModel Terminal { get; }
+        public ThemesPageViewModel Themes { get; }
+        public MousePageViewModel Mouse { get; }
+        public AboutPageViewModel About { get; }
+        public SshProfilesPageViewModel SshProfiles { get; }
+
+        public void NavigateToAboutPage()
+        {
+            AboutPageRequested?.Invoke(this, EventArgs.Empty);
+        }
+
+        public void Close()
+        {
+            Closed?.Invoke(this, EventArgs.Empty);
+        }
+    }
+}

FluentTerminal.App.ViewModels/ShellProfileViewModel.cs

@@ -0,0 +1,109 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using FluentTerminal.App.ViewModels.Profiles;
+
+namespace FluentTerminal.App.ViewModels
+{
+    /// <summary>
+    /// Extends <see cref="ShellProfileViewModelBase{T}"/>, and implements only "Set as default" logic.
+    /// </summary>
+    public class ShellProfileViewModel : ShellProfileViewModelBase<CommonProfileProviderViewModel>
+    {
+        #region Fields
+
+        private readonly IDefaultValueProvider _defaultValueProvider;
+
+        #endregion Fields
+
+        #region Properties
+
+        private bool _isDefault;
+
+        public bool IsDefault
+        {
+            get => _isDefault;
+            set => Set(ref _isDefault, value);
+        }
+
+        #endregion Properties
+
+        #region Events
+
+        public event EventHandler SetAsDefault;
+
+        #endregion Events
+
+        #region Commands
+
+        public RelayCommand SetDefaultCommand { get; }
+
+        public IAsyncCommand RestoreDefaultsCommand { get; }
+
+        #endregion Commands
+
+        #region Constrcutor
+
+        public ShellProfileViewModel(ShellProfile shellProfile, ISettingsService settingsService,
+            IDialogService dialogService, IFileSystemService fileSystemService, IApplicationView applicationView,
+            IDefaultValueProvider defaultValueProvider, bool isNew) : base(shellProfile, settingsService, dialogService,
+            isNew)
+        {
+            _defaultValueProvider = defaultValueProvider;
+
+            ProfileVm = new CommonProfileProviderViewModel(settingsService, applicationView, fileSystemService,
+                shellProfile);
+
+            SetDefaultCommand = new RelayCommand(SetDefault);
+            RestoreDefaultsCommand = new AsyncCommand(RestoreDefaults);
+        }
+
+        #endregion Constrcutor
+
+        #region Methods
+
+        private async Task RestoreDefaults()
+        {
+            if (InEditMode || !ProfileVm.PreInstalled)
+            {
+                throw new InvalidOperationException();
+            }
+
+            var result = await DialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"),
+                I18N.Translate("ConfirmRestoreProfile"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                var profile = _defaultValueProvider.GetPreinstalledShellProfiles().FirstOrDefault(x => x.Id.Equals(Id));
+
+                if (profile == null)
+                {
+                    // Should not happen ever, but...
+                    return;
+                }
+
+                ProfileVm.Model = profile;
+                Initialize(profile);
+
+                SettingsService.SaveShellProfile(profile);
+            }
+        }
+
+        protected override bool CanDelete()
+        {
+            return !ProfileVm.PreInstalled;
+        }
+
+        private void SetDefault()
+        {
+            SetAsDefault?.Invoke(this, EventArgs.Empty);
+        }
+
+        #endregion Methods
+    }
+}

FluentTerminal.App.ViewModels/ShellProfileViewModelBase.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using FluentTerminal.App.ViewModels.Profiles;
+using FluentTerminal.App.ViewModels.Settings;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+
+namespace FluentTerminal.App.ViewModels
+{
+    /// <summary>
+    /// Base class for all shell profile view models. Implements logic for saving, editing, resetting, etc.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class ShellProfileViewModelBase<T> : ViewModelBase where T : ProfileProviderViewModelBase
+    {
+        #region Fields
+
+        protected readonly IDialogService DialogService;
+        protected readonly ISettingsService SettingsService;
+
+        private List<KeyBinding> _bindingsBeforeEdit;
+        private string _nameBeforeEdit;
+
+        #endregion Fields
+
+        #region Properties
+
+        protected bool IsNew { get; private set; }
+
+        public Guid Id { get; private set; }
+
+        private bool _inEditMode;
+
+        public bool InEditMode
+        {
+            get => _inEditMode;
+            set => Set(ref _inEditMode, value);
+        }
+
+        private string _name;
+
+        public string Name
+        {
+            get => _name;
+            set => Set(ref _name, value);
+        }
+
+        public KeyBindingsViewModel KeyBindings { get; }
+
+        public T ProfileVm { get; protected set; }
+
+        #endregion Properties
+
+        #region Events
+
+        public event EventHandler Deleted;
+
+        #endregion Events
+
+        #region Commands
+
+        public IAsyncCommand CancelEditCommand { get; }
+
+        public IAsyncCommand DeleteCommand { get; }
+
+        public RelayCommand EditCommand { get; }
+
+        public IAsyncCommand SaveChangesCommand { get; }
+
+        public IAsyncCommand AddKeyboardShortcutCommand { get; }
+
+        #endregion Commands
+
+        #region Constructor
+
+        protected ShellProfileViewModelBase(ShellProfile shellProfile, ISettingsService settingsService, IDialogService dialogService, bool isNew)
+        {
+            SettingsService = settingsService;
+            DialogService = dialogService;
+            IsNew = isNew;
+
+            KeyBindings = new KeyBindingsViewModel(shellProfile.Id.ToString(), dialogService, string.Empty, false);
+
+            Initialize(shellProfile);
+
+            DeleteCommand = new AsyncCommand(Delete, CanDelete);
+            EditCommand = new RelayCommand(Edit);
+            CancelEditCommand = new AsyncCommand(CancelEdit);
+            SaveChangesCommand = new AsyncCommand(SaveChangesAsync);
+            AddKeyboardShortcutCommand = new AsyncCommand(AddKeyboardShortcut);
+        }
+
+        #endregion Constructor
+
+        #region Methods
+
+        // Loads view model properties from the input shellProfile
+        protected void Initialize(ShellProfile shellProfile)
+        {
+            Id = shellProfile.Id;
+            Name = shellProfile.Name;
+
+            KeyBindings.Clear();
+            foreach (var keyBinding in shellProfile.KeyBindings.Select(x => new KeyBinding(x)).ToList())
+            {
+                KeyBindings.Add(keyBinding);
+            }
+        }
+
+        protected virtual bool HasChanges()
+        {
+            return ProfileVm.HasChanges() || !_nameBeforeEdit.NullableEqualTo(_name) ||
+                   !(_bindingsBeforeEdit?.SequenceEqual(KeyBindings.KeyBindings.Select(x => x.Model).ToList()) ??
+                     false);
+        }
+
+        private async Task Delete()
+        {
+            var result = await DialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"),
+                I18N.Translate("ConfirmDeleteProfile"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                Deleted?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        protected abstract bool CanDelete();
+
+        private void Edit()
+        {
+            if (InEditMode)
+            {
+                return;
+            }
+
+            _bindingsBeforeEdit = KeyBindings.KeyBindings.Select(x => x.Model).ToList();
+            _nameBeforeEdit = _name;
+
+            KeyBindings.Editable = true;
+            InEditMode = true;
+        }
+
+        private async Task CancelEdit()
+        {
+            if (IsNew)
+            {
+                await Delete();
+            }
+            else
+            {
+                if (HasChanges())
+                {
+                    var result = await DialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"),
+                            I18N.Translate("ConfirmDiscardChanges"), DialogButton.OK, DialogButton.Cancel)
+                        .ConfigureAwait(true);
+
+                    if (result == DialogButton.OK)
+                    {
+                        // Cancelled, so rollback
+                        ProfileVm.RejectChanges();
+
+                        KeyBindings.Editable = false;
+                        InEditMode = false;
+                    }
+                }
+                else
+                {
+                    KeyBindings.Editable = false;
+                    InEditMode = false;
+                }
+            }
+        }
+
+        public virtual async Task SaveChangesAsync()
+        {
+            var error = await ProfileVm.AcceptChangesAsync();
+
+            if (!string.IsNullOrEmpty(error))
+            {
+                await DialogService.ShowMessageDialogAsnyc(I18N.Translate("InvalidInput"), error, DialogButton.OK);
+
+                return;
+            }
+
+            var profile = ProfileVm.Model;
+
+            profile.Id = Id;
+            profile.Name = _name;
+            profile.KeyBindings = KeyBindings.KeyBindings.Select(x => x.Model).ToList();
+
+            if (profile is SshProfile sshProfile)
+            {
+                SettingsService.SaveSshProfile(sshProfile, IsNew);
+            }
+            else
+            {
+                SettingsService.SaveShellProfile(profile, IsNew);
+            }
+
+            KeyBindings.Editable = false;
+            InEditMode = false;
+            IsNew = false;
+        }
+
+        public Task AddKeyboardShortcut()
+        {
+            return KeyBindings.ShowAddKeyBindingDialog();
+        }
+
+        #endregion Methods
+    }
+}

FluentTerminal.App.ViewModels/SshProfileViewModel.cs

@@ -0,0 +1,36 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.ViewModels.Profiles;
+using FluentTerminal.Models;
+
+namespace FluentTerminal.App.ViewModels
+{
+    /// <summary>
+    /// Extends <see cref="ShellProfileViewModelBase{T}"/>, and doesn't implement any additional logic because in
+    /// case of SSH profiles no additional logic is needed.
+    /// </summary>
+    public class SshProfileViewModel : ShellProfileViewModelBase<SshConnectViewModel>
+    {
+        #region Constructor
+
+        public SshProfileViewModel(SshProfile sshProfile, ISettingsService settingsService,
+            IDialogService dialogService, IFileSystemService fileSystemService, IApplicationView applicationView,
+            ITrayProcessCommunicationService trayProcessCommunicationService,
+            IApplicationDataContainer historyContainer, bool isNew) : base(sshProfile, settingsService, dialogService,
+            isNew)
+        {
+            ProfileVm = new SshConnectViewModel(settingsService, applicationView, trayProcessCommunicationService,
+                fileSystemService, historyContainer, sshProfile);
+        }
+
+        #endregion Constructor
+
+        #region Methods
+
+        protected override bool CanDelete()
+        {
+            return true;
+        }
+
+        #endregion Methods
+    }
+}

FluentTerminal.App.ViewModels/TerminalViewModel.cs

@@ -0,0 +1,436 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Infrastructure;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels
+{
+    public class TerminalViewModel : ViewModelBase
+    {
+        #region Static
+
+        private static readonly Regex SshTitleRx = new Regex(@"^\w+@\S+:", RegexOptions.Compiled);
+
+        #endregion Static
+
+        private readonly IKeyboardCommandService _keyboardCommandService;
+        private bool _isSelected;
+        private bool _hasNewOutput;
+        private bool _hasExitedWithError;
+        private string _searchText;
+        private bool _showSearchPanel;
+        private TabTheme _tabTheme;
+        private TerminalTheme _terminalTheme;
+        private TerminalOptions _terminalOptions;
+        private string _tabTitle;
+        private string _shellTitle;
+        private bool _hasCustomTitle;
+
+        public TerminalViewModel(ISettingsService settingsService, ITrayProcessCommunicationService trayProcessCommunicationService, IDialogService dialogService,
+            IKeyboardCommandService keyboardCommandService, ApplicationSettings applicationSettings, ShellProfile shellProfile,
+            IApplicationView applicationView, IDispatcherTimer dispatcherTimer, IClipboardService clipboardService)
+        {
+            SettingsService = settingsService;
+            SettingsService.CurrentThemeChanged += OnCurrentThemeChanged;
+            SettingsService.TerminalOptionsChanged += OnTerminalOptionsChanged;
+            SettingsService.ApplicationSettingsChanged += OnApplicationSettingsChanged;
+            SettingsService.KeyBindingsChanged += OnKeyBindingsChanged;
+
+            _terminalOptions = SettingsService.GetTerminalOptions();
+
+            TrayProcessCommunicationService = trayProcessCommunicationService;
+
+            DialogService = dialogService;
+            _keyboardCommandService = keyboardCommandService;
+            ApplicationSettings = applicationSettings;
+            ApplicationView = applicationView;
+            ClipboardService = clipboardService;
+
+            ShellProfile = shellProfile;
+            TerminalTheme = shellProfile.TerminalThemeId == Guid.Empty ? SettingsService.GetCurrentTheme() : SettingsService.GetTheme(shellProfile.TerminalThemeId);
+
+            TabThemes = new ObservableCollection<TabTheme>(SettingsService.GetTabThemes());
+            TabTheme = TabThemes.FirstOrDefault(t => t.Id == ShellProfile.TabThemeId);
+
+            CloseCommand = new RelayCommand(async () => await TryClose().ConfigureAwait(false));
+            FindNextCommand = new RelayCommand(FindNext);
+            FindPreviousCommand = new RelayCommand(FindPrevious);
+            CloseSearchPanelCommand = new RelayCommand(CloseSearchPanel);
+            SelectTabThemeCommand = new RelayCommand<string>(SelectTabTheme);
+            EditTitleCommand = new AsyncCommand(EditTitle);
+
+            Terminal = new Terminal(TrayProcessCommunicationService);
+            Terminal.KeyboardCommandReceived += Terminal_KeyboardCommandReceived;
+            Terminal.OutputReceived += Terminal_OutputReceived;
+            Terminal.SizeChanged += Terminal_SizeChanged;
+            Terminal.TitleChanged += Terminal_TitleChanged;
+            Terminal.Exited += Terminal_Exited;
+            Terminal.Closed += Terminal_Closed;
+
+            Overlay = new OverlayViewModel(dispatcherTimer);
+
+        }
+
+        public event EventHandler Activated;
+        public event EventHandler Closed;
+        public event EventHandler<string> FindNextRequested;
+        public event EventHandler<string> FindPreviousRequested;
+        public event EventHandler KeyBindingsChanged;
+        public event EventHandler<TerminalOptions> OptionsChanged;
+        public event EventHandler SearchStarted;
+        public event EventHandler<TerminalTheme> ThemeChanged;
+        public event EventHandler<string> ShellTitleChanged;
+        public event EventHandler<string> CustomTitleChanged;
+
+        public ApplicationSettings ApplicationSettings { get; private set; }
+
+        public IApplicationView ApplicationView { get; }
+
+        public TabTheme BackgroundTabTheme
+        {
+            // The effective background theme depends on whether it is selected (use the theme), or if it is inactive
+            // (if we're set to underline inactive tabs, use the null theme).
+            get => IsSelected || (!IsSelected && ApplicationSettings.InactiveTabColorMode == InactiveTabColorMode.Background) ?
+                _tabTheme :
+                SettingsService.GetTabThemes().FirstOrDefault(t => t.Color == null);
+        }
+
+        public IClipboardService ClipboardService { get; }
+
+        public RelayCommand CloseCommand { get; }
+
+        public RelayCommand CloseSearchPanelCommand { get; }
+
+        public IDialogService DialogService { get; }
+
+        public IAsyncCommand EditTitleCommand { get; }
+
+        public RelayCommand FindNextCommand { get; }
+
+        public RelayCommand FindPreviousCommand { get; }
+
+        public bool IsSelected
+        {
+            get => _isSelected;
+            set
+            {
+                if (Set(ref _isSelected, value))
+                {
+                    if (IsSelected)
+                    {
+                        HasNewOutput = false;
+                    }
+                    RaisePropertyChanged(nameof(IsUnderlined));
+                    RaisePropertyChanged(nameof(BackgroundTabTheme));
+                }
+            }
+        }
+
+        public bool IsUnderlined => (IsSelected && ApplicationSettings.UnderlineSelectedTab) ||
+            (!IsSelected && ApplicationSettings.InactiveTabColorMode == InactiveTabColorMode.Underlined && TabTheme.Color != null);
+
+        public bool HasNewOutput
+        {
+            get => _hasNewOutput;
+            set => Set(ref _hasNewOutput, value);
+        }
+
+        public bool HasExitedWithError
+        {
+            get => _hasExitedWithError;
+            set
+            {
+                if (Set(ref _hasExitedWithError, value) && value)
+                {
+                    HasNewOutput = false;
+                }
+            }
+        }
+
+        public string SearchText
+        {
+            get => _searchText;
+            set => Set(ref _searchText, value);
+        }
+
+        public RelayCommand<string> SelectTabThemeCommand { get; }
+
+        public ISettingsService SettingsService { get; }
+
+        public ShellProfile ShellProfile { get; }
+
+        public bool ShowSearchPanel
+        {
+            get => _showSearchPanel;
+            set => Set(ref _showSearchPanel, value);
+        }
+
+        public TabTheme TabTheme
+        {
+            get => _tabTheme;
+            set
+            {
+                Set(ref _tabTheme, value);
+                RaisePropertyChanged(nameof(IsUnderlined));
+                RaisePropertyChanged(nameof(BackgroundTabTheme));
+            }
+        }
+
+        public ObservableCollection<TabTheme> TabThemes { get; }
+
+        public Terminal Terminal { get; private set; }
+
+        public OverlayViewModel Overlay { get; private set; }
+
+        public TerminalTheme TerminalTheme
+        {
+            get => _terminalTheme;
+            set => Set(ref _terminalTheme, value);
+        }
+
+        public string TabTitle
+        {
+            get => _tabTitle;
+            set
+            {
+                var title = value?.Trim() ?? string.Empty;
+
+                if (ShellProfile is SshProfile)
+                {
+                    // For SshProfile we are adjusting title.
+                    if (title.Equals("ssh", StringComparison.OrdinalIgnoreCase) ||
+                        title.EndsWith("\\ssh.exe", StringComparison.OrdinalIgnoreCase))
+                    {
+                        title = $"[ssh] {I18N.Translate("Authenticate")}";
+                    }
+                    else if (title.Equals("mosh", StringComparison.OrdinalIgnoreCase) ||
+                             title.EndsWith("\\mosh.exe", StringComparison.OrdinalIgnoreCase))
+                    {
+                        title = $"[mosh] {I18N.Translate("Authenticate")}";
+                    }
+                    else if (SshTitleRx.IsMatch(title))
+                    {
+                        title = $"[ssh] {title}";
+                    }
+                }
+
+                if (Set(ref _tabTitle, title))
+                {
+                    CustomTitleChanged?.Invoke(this, title);
+                }
+            }
+        }
+
+        public string ShellTitle
+        {
+            get => _shellTitle;
+            set
+            {
+                if (Set(ref _shellTitle, value) && !_hasCustomTitle)
+                {
+                    TabTitle = value;
+                }
+            }
+        }
+
+        public ITrayProcessCommunicationService TrayProcessCommunicationService { get; }
+
+        public Task Close()
+        {
+            SettingsService.CurrentThemeChanged -= OnCurrentThemeChanged;
+            SettingsService.TerminalOptionsChanged -= OnTerminalOptionsChanged;
+            SettingsService.ApplicationSettingsChanged -= OnApplicationSettingsChanged;
+            SettingsService.KeyBindingsChanged -= OnKeyBindingsChanged;
+            return Terminal.Close();
+        }
+
+        public void CopyText(string text)
+        {
+            ClipboardService.SetText(text);
+        }
+
+        public async Task EditTitle()
+        {
+            var result = await DialogService.ShowInputDialogAsync(I18N.Translate("EditTitleString"));
+            if (result != null)
+            {
+                if (string.IsNullOrWhiteSpace(result))
+                {
+                    _hasCustomTitle = false;
+                    TabTitle = ShellTitle;
+                }
+                else
+                {
+                    _hasCustomTitle = true;
+                    TabTitle = result;
+                }
+            }
+        }
+
+        public void FocusTerminal()
+        {
+            Activated?.Invoke(this, EventArgs.Empty);
+        }
+
+        private void CloseSearchPanel()
+        {
+            SearchText = string.Empty;
+            ShowSearchPanel = false;
+            FocusTerminal();
+        }
+
+        private void FindNext()
+        {
+            FindNextRequested?.Invoke(this, SearchText);
+        }
+
+        private void FindPrevious()
+        {
+            FindPreviousRequested?.Invoke(this, SearchText);
+        }
+
+        private async void OnApplicationSettingsChanged(object sender, ApplicationSettings e)
+        {
+            await ApplicationView.RunOnDispatcherThread(() =>
+            {
+                ApplicationSettings = e;
+                RaisePropertyChanged(nameof(IsUnderlined));
+                RaisePropertyChanged(nameof(BackgroundTabTheme));
+            });
+        }
+
+        private async void OnCurrentThemeChanged(object sender, Guid e)
+        {
+            await ApplicationView.RunOnDispatcherThread(() =>
+            {
+                // only change theme if not overwritten by profile
+                if (ShellProfile.TerminalThemeId == Guid.Empty)
+                {
+                    var currentTheme = SettingsService.GetTheme(e);
+                    TerminalTheme = currentTheme;
+                    ThemeChanged?.Invoke(this, currentTheme);
+                }
+            });
+        }
+
+        private async void OnKeyBindingsChanged(object sender, EventArgs e)
+        {
+            await ApplicationView.RunOnDispatcherThread(() => KeyBindingsChanged?.Invoke(this, EventArgs.Empty));
+        }
+
+        private async void OnTerminalOptionsChanged(object sender, TerminalOptions e)
+        {
+            _terminalOptions = e;
+            await ApplicationView.RunOnDispatcherThread(() => OptionsChanged?.Invoke(this, e));
+        }
+
+        private void SelectTabTheme(string id)
+        {
+            TabTheme = TabThemes.FirstOrDefault(t => t.Id == int.Parse(id));
+        }
+
+        private void Terminal_Exited(object sender, int exitCode)
+        {
+            ApplicationView.RunOnDispatcherThread(() => HasExitedWithError = exitCode > 0);
+        }
+
+        private void Terminal_Closed(object sender, EventArgs e)
+        {
+            ApplicationView.RunOnDispatcherThread(() => Closed?.Invoke(this, EventArgs.Empty));
+        }
+
+        private async void Terminal_KeyboardCommandReceived(object sender, string e)
+        {
+            switch (e)
+            {
+                case nameof(Command.Copy):
+                    {
+                        var selection = await Terminal.GetSelectedText().ConfigureAwait(true);
+                        ClipboardService.SetText(selection);
+                        if(_terminalOptions.ShowTextCopied)
+                        {
+                            Overlay.Show(I18N.Translate("TextCopied"));
+                        }
+                        break;
+                    }
+                case nameof(Command.Paste):
+                    {
+                        string content = await ClipboardService.GetText().ConfigureAwait(true);
+                        if (content != null)
+                        {
+                            content = ShellProfile.TranslateLineEndings(content);
+                            await Terminal.Write(Encoding.UTF8.GetBytes(content)).ConfigureAwait(true);
+                        }
+                        break;
+                    }
+                case nameof(Command.PasteWithoutNewlines):
+                    {
+                        string content = await ClipboardService.GetText().ConfigureAwait(true);
+                        if (content != null)
+                        {
+                            content = ShellProfile.NewlinePattern.Replace(content, string.Empty);
+                            await Terminal.Write(Encoding.UTF8.GetBytes(content)).ConfigureAwait(true);
+                        }
+                        break;
+                    }
+                case nameof(Command.Search):
+                    {
+                        ShowSearchPanel = !ShowSearchPanel;
+                        if (ShowSearchPanel)
+                        {
+                            SearchStarted?.Invoke(this, EventArgs.Empty);
+                        }
+                        break;
+                    }
+                default:
+                    {
+                        _keyboardCommandService.SendCommand(e);
+                        break;
+                    }
+            }
+        }
+
+        private void Terminal_OutputReceived(object sender, byte[] e)
+        {
+            if (!IsSelected && ApplicationSettings.ShowNewOutputIndicator)
+            {
+                ApplicationView.RunOnDispatcherThread(() => HasNewOutput = true);
+            }
+        }
+
+        private void Terminal_SizeChanged(object sender, TerminalSize e)
+        {
+            Overlay.Show($"{e.Columns} x {e.Rows}");
+        }
+
+        private void Terminal_TitleChanged(object sender, string e)
+        {
+            ShellTitle = e;
+            ShellTitleChanged?.Invoke(this, e);
+        }
+
+        private async Task TryClose()
+        {
+            if (ApplicationSettings.ConfirmClosingTabs)
+            {
+                var result = await DialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmCloseTab"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+                if (result == DialogButton.Cancel)
+                {
+                    return;
+                }
+            }
+
+            await Close().ConfigureAwait(true);
+        }
+    }
+}

FluentTerminal.App.ViewModels/ThemeViewModel.cs

@@ -0,0 +1,420 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.Models;
+using GalaSoft.MvvmLight;
+using GalaSoft.MvvmLight.Command;
+using Newtonsoft.Json;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels
+{
+    public class ThemeViewModel : ViewModelBase
+    {
+        private readonly IDialogService _dialogService;
+        private readonly ISettingsService _settingsService;
+        private string _author;
+        private string _background;
+        private double _backgroundOpacity;
+        private string _black;
+        private string _blue;
+        private string _brightBlack;
+        private string _brightBlue;
+        private string _brightCyan;
+        private string _brightGreen;
+        private string _brightMagenta;
+        private string _brightRed;
+        private string _brightWhite;
+        private string _brightYellow;
+        private string _cursor;
+        private string _cursorAccent;
+        private string _cyan;
+        private TerminalTheme _fallbackTheme;
+        private string _foreground;
+        private string _green;
+        private bool _inEditMode;
+        private bool _isActive;
+        private string _magenta;
+        private string _name;
+        private bool _isNew;
+        private string _red;
+        private string _selection;
+        private string _white;
+        private string _yellow;
+        private readonly IFileSystemService _fileSystemService;
+
+        public event EventHandler<string> BackgroundChanged;
+
+        public ThemeViewModel(TerminalTheme theme, ISettingsService settingsService, IDialogService dialogService, IFileSystemService fileSystemService, bool isNew)
+        {
+            Model = theme;
+            _settingsService = settingsService;
+            _dialogService = dialogService;
+            _fileSystemService = fileSystemService;
+            _isNew = isNew;
+
+            Name = Model.Name;
+            Author = Model.Author;
+            Id = Model.Id;
+
+            Black = Model.Colors.Black;
+            Red = Model.Colors.Red;
+            Green = Model.Colors.Green;
+            Yellow = Model.Colors.Yellow;
+            Blue = Model.Colors.Blue;
+            Magenta = Model.Colors.Magenta;
+            Cyan = Model.Colors.Cyan;
+            White = Model.Colors.White;
+
+            BrightBlack = Model.Colors.BrightBlack;
+            BrightRed = Model.Colors.BrightRed;
+            BrightGreen = Model.Colors.BrightGreen;
+            BrightYellow = Model.Colors.BrightYellow;
+            BrightBlue = Model.Colors.BrightBlue;
+            BrightMagenta = Model.Colors.BrightMagenta;
+            BrightCyan = Model.Colors.BrightCyan;
+            BrightWhite = Model.Colors.BrightWhite;
+
+            Background = Model.Colors.Background;
+            Foreground = Model.Colors.Foreground;
+            Cursor = Model.Colors.Cursor;
+            CursorAccent = Model.Colors.CursorAccent;
+            Selection = Model.Colors.Selection;
+
+            SetActiveCommand = new RelayCommand(SetActive);
+            DeleteCommand = new RelayCommand(async () => await Delete().ConfigureAwait(false), NotPreInstalled);
+            EditCommand = new RelayCommand(Edit, NotPreInstalled);
+            CancelEditCommand = new RelayCommand(async () => await CancelEdit().ConfigureAwait(false));
+            SaveChangesCommand = new RelayCommand(SaveChanges);
+            ExportCommand = new RelayCommand(async () => await Export().ConfigureAwait(false), NotPreInstalled);
+        }
+
+        public event EventHandler Activated;
+
+        public event EventHandler Deleted;
+
+        public TerminalTheme Model { get; }
+
+        public string Author
+        {
+            get => _author;
+            set => Set(ref _author, value);
+        }
+
+        public string Background
+        {
+            get => _background;
+            set
+            {
+                Set(ref _background, value);
+                BackgroundChanged?.Invoke(this, value);
+            }
+        }
+
+        public double BackgroundOpacity
+        {
+            get => _backgroundOpacity;
+            set => Set(ref _backgroundOpacity, value);
+        }
+
+        public string Black
+        {
+            get => _black;
+            set => Set(ref _black, value);
+        }
+
+        public string Blue
+        {
+            get => _blue;
+            set => Set(ref _blue, value);
+        }
+
+        public string BrightBlack
+        {
+            get => _brightBlack;
+            set => Set(ref _brightBlack, value);
+        }
+
+        public string BrightBlue
+        {
+            get => _brightBlue;
+            set => Set(ref _brightBlue, value);
+        }
+
+        public string BrightCyan
+        {
+            get => _brightCyan;
+            set => Set(ref _brightCyan, value);
+        }
+
+        public string BrightGreen
+        {
+            get => _brightGreen;
+            set => Set(ref _brightGreen, value);
+        }
+
+        public string BrightMagenta
+        {
+            get => _brightMagenta;
+            set => Set(ref _brightMagenta, value);
+        }
+
+        public string BrightRed
+        {
+            get => _brightRed;
+            set => Set(ref _brightRed, value);
+        }
+
+        public string BrightWhite
+        {
+            get => _brightWhite;
+            set => Set(ref _brightWhite, value);
+        }
+
+        public string BrightYellow
+        {
+            get => _brightYellow;
+            set => Set(ref _brightYellow, value);
+        }
+
+        public RelayCommand CancelEditCommand { get; }
+
+        public string Cursor
+        {
+            get => _cursor;
+            set => Set(ref _cursor, value);
+        }
+
+        public string CursorAccent
+        {
+            get => _cursorAccent;
+            set => Set(ref _cursorAccent, value);
+        }
+
+        public string Cyan
+        {
+            get => _cyan;
+            set => Set(ref _cyan, value);
+        }
+
+        public RelayCommand DeleteCommand { get; }
+        public RelayCommand EditCommand { get; }
+        public RelayCommand ExportCommand { get; }
+
+        public string Foreground
+        {
+            get => _foreground;
+            set => Set(ref _foreground, value);
+        }
+
+        public string Green
+        {
+            get => _green;
+            set => Set(ref _green, value);
+        }
+
+        public Guid Id { get; }
+
+        public bool InEditMode
+        {
+            get => _inEditMode;
+            set => Set(ref _inEditMode, value);
+        }
+
+        public bool IsActive
+        {
+            get => _isActive;
+            set => Set(ref _isActive, value);
+        }
+
+        public string Magenta
+        {
+            get => _magenta;
+            set => Set(ref _magenta, value);
+        }
+
+        public string Name
+        {
+            get => _name;
+            set => Set(ref _name, value);
+        }
+
+        public string Red
+        {
+            get => _red;
+            set => Set(ref _red, value);
+        }
+
+        public RelayCommand SaveChangesCommand { get; }
+
+        public string Selection
+        {
+            get => _selection;
+            set => Set(ref _selection, value);
+        }
+
+        public RelayCommand SetActiveCommand { get; }
+
+        public string White
+        {
+            get => _white;
+            set => Set(ref _white, value);
+        }
+
+        public string Yellow
+        {
+            get => _yellow;
+            set => Set(ref _yellow, value);
+        }
+
+        public void SaveChanges()
+        {
+            Model.Name = Name;
+            Model.Author = Author;
+
+            Model.Colors.Black = Black;
+            Model.Colors.Red = Red;
+            Model.Colors.Green = Green;
+            Model.Colors.Yellow = Yellow;
+            Model.Colors.Blue = Blue;
+            Model.Colors.Magenta = Magenta;
+            Model.Colors.Cyan = Cyan;
+            Model.Colors.White = White;
+
+            Model.Colors.BrightBlack = BrightBlack;
+            Model.Colors.BrightRed = BrightRed;
+            Model.Colors.BrightGreen = BrightGreen;
+            Model.Colors.BrightYellow = BrightYellow;
+            Model.Colors.BrightBlue = BrightBlue;
+            Model.Colors.BrightMagenta = BrightMagenta;
+            Model.Colors.BrightCyan = BrightCyan;
+            Model.Colors.BrightWhite = BrightWhite;
+
+            Model.Colors.Background = Background;
+            Model.Colors.Foreground = Foreground;
+            Model.Colors.Cursor = Cursor;
+            Model.Colors.CursorAccent = CursorAccent;
+            Model.Colors.Selection = Selection;
+
+            _settingsService.SaveTheme(Model);
+
+            InEditMode = false;
+            _isNew = false;
+        }
+
+        private async Task CancelEdit()
+        {
+            if (_isNew)
+            {
+                await Delete();
+            }
+            else
+            {
+                TerminalTheme changedTheme = new TerminalTheme()
+                {
+                    Name = Name,
+                    Author = Author,
+                    Colors = new TerminalColors()
+                    {
+                        Black = Black,
+                        Red = Red,
+                        Green = Green,
+                        Yellow = Yellow,
+                        Blue = Blue,
+                        Magenta = Magenta,
+                        Cyan = Cyan,
+                        White = White,
+
+                        BrightBlack = BrightBlack,
+                        BrightRed = BrightRed,
+                        BrightGreen = BrightGreen,
+                        BrightYellow = BrightYellow,
+                        BrightBlue = BrightBlue,
+                        BrightMagenta = BrightMagenta,
+                        BrightCyan = BrightCyan,
+                        BrightWhite = BrightWhite,
+
+                        Background = Background,
+                        Foreground = Foreground,
+                        Cursor = Cursor,
+                        CursorAccent = CursorAccent,
+                        Selection = Selection
+                    }
+                };
+
+                if (!_fallbackTheme.Equals(changedTheme))
+                {
+                    var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmDiscardChanges"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+                    if (result == DialogButton.OK)
+                    {
+                        Black = _fallbackTheme.Colors.Black;
+                        Red = _fallbackTheme.Colors.Red;
+                        Green = _fallbackTheme.Colors.Green;
+                        Yellow = _fallbackTheme.Colors.Yellow;
+                        Blue = _fallbackTheme.Colors.Blue;
+                        Magenta = _fallbackTheme.Colors.Magenta;
+                        Cyan = _fallbackTheme.Colors.Cyan;
+                        White = _fallbackTheme.Colors.White;
+
+                        BrightBlack = _fallbackTheme.Colors.BrightBlack;
+                        BrightRed = _fallbackTheme.Colors.BrightRed;
+                        BrightGreen = _fallbackTheme.Colors.BrightGreen;
+                        BrightYellow = _fallbackTheme.Colors.BrightYellow;
+                        BrightBlue = _fallbackTheme.Colors.BrightBlue;
+                        BrightMagenta = _fallbackTheme.Colors.BrightMagenta;
+                        BrightCyan = _fallbackTheme.Colors.BrightCyan;
+                        BrightWhite = _fallbackTheme.Colors.BrightWhite;
+
+                        Background = _fallbackTheme.Colors.Background;
+                        Foreground = _fallbackTheme.Colors.Foreground;
+                        Cursor = _fallbackTheme.Colors.Cursor;
+                        CursorAccent = _fallbackTheme.Colors.CursorAccent;
+                        Selection = _fallbackTheme.Colors.Selection;
+
+                        Name = _fallbackTheme.Name;
+                        Author = _fallbackTheme.Author;
+
+                        InEditMode = false;
+                    }
+                }
+                else
+                {
+                    InEditMode = false;
+                }
+            }
+        }
+
+        private bool NotPreInstalled()
+        {
+            return !Model.PreInstalled;
+        }
+
+        private async Task Delete()
+        {
+            var result = await _dialogService.ShowMessageDialogAsnyc(I18N.Translate("PleaseConfirm"), I18N.Translate("ConfirmDeleteTheme"), DialogButton.OK, DialogButton.Cancel).ConfigureAwait(true);
+
+            if (result == DialogButton.OK)
+            {
+                Deleted?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        private void Edit()
+        {
+            _fallbackTheme = new TerminalTheme(Model);
+            InEditMode = true;
+        }
+
+        private void SetActive()
+        {
+            Activated?.Invoke(this, EventArgs.Empty);
+        }
+
+        private Task Export()
+        {
+            var content = JsonConvert.SerializeObject(Model, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new TerminalThemeContractResolver() });
+            return _fileSystemService.SaveTextFile(Name, "Fluent Terminal Theme", ".flutecolors", content);
+        }
+    }
+}

FluentTerminal.App.ViewModels/Utilities/TaskUtilities.cs

@@ -0,0 +1,23 @@
+using FluentTerminal.App.ViewModels.Infrastructure;
+using System;
+using System.Threading.Tasks;
+
+namespace FluentTerminal.App.ViewModels.Utilities
+{
+    public static class TaskUtilities
+    {
+        #pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
+        public static async void FireAndForgetSafeAsync(this Task task, IErrorHandler handler = null)
+        #pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void
+        {
+            try
+            {
+                await task;
+            }
+            catch (Exception ex)
+            {
+                handler?.HandleError(ex);
+            }
+        }
+    }
+}

FluentTerminal.App/Adapters/AppServiceConnectionAdapter.cs

@@ -0,0 +1,39 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.Models;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.AppService;
+using Windows.Foundation.Collections;
+
+namespace FluentTerminal.App.Adapters
+{
+    public class AppServiceConnectionAdapter : IAppServiceConnection
+    {
+        private readonly AppServiceConnection _appServiceConnection;
+
+        public event EventHandler<ValueSet> MessageReceived;
+
+        public AppServiceConnectionAdapter(AppServiceConnection appServiceConnection)
+        {
+            _appServiceConnection = appServiceConnection;
+            _appServiceConnection.RequestReceived += OnRequestReceived;
+        }
+
+        private void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
+        {
+            MessageReceived?.Invoke(this, args.Request.Message);
+        }
+
+        public async Task<ValueSet> SendMessageAsync(ValueSet message)
+        {
+            var response = await _appServiceConnection.SendMessageAsync(message).AsTask();
+
+            if (response.Status == AppServiceResponseStatus.Success)
+            {
+                return response.Message;
+            }
+            return null;
+        }
+    }
+}

FluentTerminal.App/Adapters/ApplicationViewAdapter.cs

@@ -0,0 +1,108 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.EventArgs;
+using System;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.Foundation.Metadata;
+using Windows.UI.Core;
+using Windows.UI.Core.Preview;
+using Windows.UI.ViewManagement;
+
+namespace FluentTerminal.App.Adapters
+{
+    public class ApplicationViewAdapter : IApplicationView
+    {
+        private readonly ApplicationView _applicationView;
+        private readonly CoreDispatcher _dispatcher;
+        private bool _closed;
+
+        public event CloseRequestedHandler CloseRequested;
+        public event EventHandler Closed;
+
+        public ApplicationViewAdapter()
+        {
+            _applicationView = ApplicationView.GetForCurrentView();
+            _applicationView.Consolidated += _applicationView_Consolidated;
+            _dispatcher = CoreApplication.GetCurrentView().Dispatcher;
+            SystemNavigationManagerPreview.GetForCurrentView().CloseRequested += OnCloseRequest;
+
+            Logger.Instance.Debug("Created ApplicationViewAdapter for ApplicationView with Id: {Id}", _applicationView.Id);
+        }
+
+        private void _applicationView_Consolidated(ApplicationView sender, ApplicationViewConsolidatedEventArgs args)
+        {
+            Closed?.Invoke(this, EventArgs.Empty);
+        }
+
+        public int Id => _applicationView.Id;
+
+        public string Title
+        {
+            get => _applicationView.Title;
+            set => _applicationView.Title = value ?? string.Empty;
+        }
+
+        public bool IsApiContractPresent(string api, ushort version)
+        {
+            return ApiInformation.IsApiContractPresent(api, version);
+        }
+
+        public Task RunOnDispatcherThread(Action action, bool enforceNewSchedule = true)
+        {
+            if (!enforceNewSchedule && _dispatcher.HasThreadAccess)
+            {
+                action();
+
+                return Task.CompletedTask;
+            }
+
+            return _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => action()).AsTask();
+        }
+
+        public async Task<bool> TryClose()
+        {
+            if (_closed)
+            {
+                Logger.Instance.Debug("ApplicationViewAdapter.TryClose was called, but was already closed. ApplicationView.Id: {Id}", _applicationView.Id);
+                return true;
+            }
+            Logger.Instance.Debug("TryClose ApplicationView with Id: {Id}", _applicationView.Id);
+            _closed = await _applicationView.TryConsolidateAsync().AsTask();
+            return _closed;
+        }
+
+        public bool ToggleFullScreen()
+        {
+            if (_applicationView.IsFullScreenMode)
+            {
+                _applicationView.ExitFullScreenMode();
+                return true;
+            }
+            else
+            {
+                return _applicationView.TryEnterFullScreenMode();
+            }
+        }
+
+        private async void OnCloseRequest(object sender, SystemNavigationCloseRequestedPreviewEventArgs e)
+        {
+            var deferral = e.GetDeferral();
+
+            var args = new CancelableEventArgs();
+
+            if (CloseRequested != null)
+            {
+                await CloseRequested.Invoke(this, args);
+            }
+
+            e.Handled = args.Cancelled;
+
+            if (!e.Handled)
+            {
+                SystemNavigationManagerPreview.GetForCurrentView().CloseRequested -= OnCloseRequest;
+            }
+
+            deferral.Complete();
+        }
+    }
+}

FluentTerminal.App/Adapters/DispatcherTimerAdapter.cs

@@ -0,0 +1,42 @@
+using FluentTerminal.App.Services;
+using System;
+using Windows.UI.Xaml;
+
+namespace FluentTerminal.App.Adapters
+{
+    public class DispatcherTimerAdapter : IDispatcherTimer
+    {
+        private readonly DispatcherTimer _dispatcherTimer;
+
+        public DispatcherTimerAdapter()
+        {
+            _dispatcherTimer = new DispatcherTimer();
+            _dispatcherTimer.Tick += OnDispatcherTimerTick;
+        }
+
+        private void OnDispatcherTimerTick(object sender, object e)
+        {
+            Tick?.Invoke(this, null);
+        }
+
+        public TimeSpan Interval
+        {
+            get => _dispatcherTimer.Interval;
+            set => _dispatcherTimer.Interval = value;
+        }
+
+        public bool IsEnabled => _dispatcherTimer.IsEnabled;
+
+        public event EventHandler<object> Tick;
+
+        public void Start()
+        {
+            _dispatcherTimer.Start();
+        }
+
+        public void Stop()
+        {
+            _dispatcherTimer.Stop();
+        }
+    }
+}

FluentTerminal.App/Adapters/MessageDialogAdapter.cs

@@ -0,0 +1,48 @@
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Dialogs;
+using FluentTerminal.App.Services.Utilities;
+using System;
+using System.Threading.Tasks;
+using Windows.UI.Popups;
+
+namespace FluentTerminal.App.Adapters
+{
+    public class MessageDialogAdapter : IMessageDialog
+    {
+        private readonly MessageDialog _messageDialog;
+
+        public MessageDialogAdapter()
+        {
+            _messageDialog = new MessageDialog(string.Empty);
+        }
+
+        public string Title
+        {
+            get => _messageDialog.Title;
+            set => _messageDialog.Title = value;
+        }
+
+        public string Content
+        {
+            get => _messageDialog.Content;
+            set => _messageDialog.Content = value;
+        }
+
+        public void AddButton(DialogButton button)
+        {
+            var command = new UICommand
+            {
+                Label = I18N.Translate(button.ToString()),
+                Id = button
+            };
+            _messageDialog.Commands.Add(command);
+        }
+
+        public async Task<DialogButton> ShowAsync()
+        {
+            var result = await _messageDialog.ShowAsync();
+
+            return (DialogButton)result.Id;
+        }
+    }
+}

FluentTerminal.App/App.xaml

@@ -1,12 +1,44 @@
 <Application
     x:Class="FluentTerminal.App.App"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:converters="using:FluentTerminal.App.Converters">
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
                 <ResourceDictionary Source="Styles\Custom.xaml" />
             </ResourceDictionary.MergedDictionaries>
+            <LinearGradientBrush x:Key="MissingColorSelectionBrush" StartPoint="0,0" EndPoint="1,1">
+                <GradientStop Offset="0" Color="Black" />
+                <GradientStop Offset="1.0" Color="White" />
+            </LinearGradientBrush>
+            <converters:IntToVisibilityConverter
+                x:Key="OneToVisibleConverter"
+                Else="Collapsed"
+                If="1"
+                Then="Visible" />
+            <converters:IntToVisibilityConverter
+                x:Key="OneToCollapsedConverter"
+                Else="Visible"
+                If="1"
+                Then="Collapsed" />
+            <converters:NegateConverter x:Key="NegateConverter" />
+            <converters:FalseToVisibleConverter x:Key="FalseToVisibleConverter" />
+            <converters:TrueToVisibleConverter x:Key="TrueToVisibleConverter" />
+            <converters:TabColorFallbackConverter x:Key="TabColorFallbackConverter" />
+            <converters:IntToVisibilityConverter
+                x:Key="ZeroToCollapsedConverter"
+                Else="Visible"
+                If="0"
+                Then="Collapsed" />
+            <converters:IntToExtendedVirtualKeyConverter x:Key="IntToExtendedVirtualKeyConverter" />
+            <converters:BackgroundToApplicationThemeConverter x:Key="BackgroundToApplicationThemeConverter" />
+            <converters:StringToColorConverter x:Key="StringToColorConverter" />
+            <converters:EnumValueToVisibiltyConverter x:Key="EnumValueToVisibiltyConverter" />
+            <converters:TabThemeSelectedConverter x:Key="TabThemeSelectedConverter" />
+            <converters:ColorResourceKeyFallbackConverter x:Key="ColorResourceKeyFallbackConverter" />
+            <converters:TrueToBoldConverter x:Key="TrueToBoldConverter" />
+            <converters:I18NConverter x:Key="I18NConverter" />
         </ResourceDictionary>
     </Application.Resources>
-</Application>
+</Application>

FluentTerminal.App/App.xaml.cs

@@ -1,134 +1,674 @@
-using FluentTerminal.App.Views;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Windows.ApplicationModel;
-using Windows.ApplicationModel.Activation;
-using Windows.ApplicationModel.AppService;
-using Windows.ApplicationModel.Background;
-using Windows.ApplicationModel.Core;
-using Windows.UI.Core;
-using Windows.UI.ViewManagement;
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Navigation;
-
-namespace FluentTerminal.App
-{
-    sealed partial class App : Application
-    {
-        public App()
-        {
-            InitializeComponent();
-            Instance = this;
-        }
-
-        public static BackgroundTaskDeferral AppServiceDeferral = null;
-        public static AppServiceConnection Connection = null;
-        public static App Instance;
-        int? _settingsWindowId;
-        int idCreate = 0;
-        List<int> idSaved = new List<int>();
-
-        protected override async void OnLaunched(LaunchActivatedEventArgs e)
-        {
-            var launch = FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync().AsTask();
-            var clearCache = WebView.ClearTemporaryWebDataAsync().AsTask();
-
-            await Task.WhenAll(launch, clearCache);
-
-            Frame rootFrame = Window.Current.Content as Frame;
-            if (rootFrame == null)
-            {
-                rootFrame = new Frame();
-                rootFrame.NavigationFailed += OnNavigationFailed;
-                Window.Current.Content = rootFrame;
-            }
-
-            if (rootFrame.Content == null)
-            {
-                CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = true;
-                rootFrame.Navigate(typeof(MainPage), e.Arguments);
-                idSaved.Add(ApplicationView.GetForCurrentView().Id);
-            }
-            else if (false) //todo: add option to create new windows on launch
-            {
-                await CreateNewWindow(typeof(MainPage), true);
-            }
-            Window.Current.Activate();
-        }
-
-        protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
-        {
-            // connection established from the fulltrust process
-            base.OnBackgroundActivated(args);
-            if (args.TaskInstance.TriggerDetails is AppServiceTriggerDetails details)
-            {
-                AppServiceDeferral = args.TaskInstance.GetDeferral();
-                args.TaskInstance.Canceled += OnTaskCanceled;
-                Connection = details.AppServiceConnection;
-                Connection.RequestReceived += OnRequestReceived;
-            }
-        }
-
-        private void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
-        {
-            if (args.Request.Message.ContainsKey("exit"))
-            {
-                App.Current.Exit();
-            }
-        }
-
-        private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
-        {
-            if (AppServiceDeferral != null)
-            {
-                AppServiceDeferral.Complete();
-            }
-        }
-
-        public async Task<int> CreateNewWindow(Type pageType, bool ExtendViewIntoTitleBar)
-        {
-            var create = CoreApplication.CreateNewView();
-            await create.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
-            {
-                CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = ExtendViewIntoTitleBar;
-                var frame = new Frame();
-                frame.Navigate(pageType, null);
-                Window.Current.Content = frame;
-                Window.Current.Activate();
-
-                idCreate = ApplicationView.GetForCurrentView().Id;
-            });
-
-            for (int i = idSaved.Count - 1; i >= 0; i--)
-                if (await ApplicationViewSwitcher.TryShowAsStandaloneAsync(
-                        idCreate, ViewSizePreference.Default,
-                        idSaved[i], ViewSizePreference.Default)
-                   ) break;
-
-            idSaved.Add(idCreate);
-            return idCreate;
-        }
-
-        public async Task ShowNew()
-        {
-            var id = await CreateNewWindow(typeof(MainPage), true);
-            bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(id);
-        }
-
-        public async Task ShowSettings()
-        {
-            if (_settingsWindowId == null)
-            {
-                _settingsWindowId = await CreateNewWindow(typeof(Views.SettingsPage), false);
-            }
-            bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(_settingsWindowId.Value);
-        }
-
-        void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
-        {
-            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
-        }
-    }
-}
+using Autofac;
+using CommandLine;
+using FluentTerminal.App.Adapters;
+using FluentTerminal.App.CommandLineArguments;
+using FluentTerminal.App.Dialogs;
+using FluentTerminal.App.Services;
+using FluentTerminal.App.Services.Adapters;
+using FluentTerminal.App.Services.Dialogs;
+using FluentTerminal.App.Services.EventArgs;
+using FluentTerminal.App.Services.Implementation;
+using FluentTerminal.App.ViewModels;
+using FluentTerminal.App.Views;
+using FluentTerminal.Models;
+using FluentTerminal.Models.Enums;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.AppService;
+using Windows.ApplicationModel.Background;
+using Windows.ApplicationModel.Core;
+using Windows.Storage;
+using Windows.UI.Core;
+using Windows.UI.Popups;
+using Windows.UI.ViewManagement;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using FluentTerminal.App.Utilities;
+using IContainer = Autofac.IContainer;
+using FluentTerminal.App.Services.Utilities;
+using FluentTerminal.App.ViewModels.Profiles;
+
+namespace FluentTerminal.App
+{
+    // ReSharper disable once RedundantExtendsListEntry
+    public sealed partial class App : Application
+    {
+        private readonly TaskCompletionSource<int> _trayReady = new TaskCompletionSource<int>();
+        private readonly ISettingsService _settingsService;
+        private readonly ITrayProcessCommunicationService _trayProcessCommunicationService;
+        private readonly IDialogService _dialogService;
+        private bool _alreadyLaunched;
+        private bool _isLaunching;
+        private ApplicationSettings _applicationSettings;
+        private readonly IContainer _container;
+        private readonly List<MainViewModel> _mainViewModels;
+        private SettingsViewModel _settingsViewModel;
+        private int? _settingsWindowId;
+        private IAppServiceConnection _appServiceConnection;
+        private BackgroundTaskDeferral _appServiceDeferral;
+        private Parser _commandLineParser;
+        private int? _activeWindowId;
+
+        public App()
+        {
+            _mainViewModels = new List<MainViewModel>();
+
+            InitializeComponent();
+
+            UnhandledException += OnUnhandledException;
+
+            var applicationDataContainers = new ApplicationDataContainers
+            {
+                LocalSettings = new ApplicationDataContainerAdapter(ApplicationData.Current.LocalSettings),
+                RoamingSettings = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings),
+                KeyBindings = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings.CreateContainer(Constants.KeyBindingsContainerName, ApplicationDataCreateDisposition.Always)),
+                ShellProfiles = new ApplicationDataContainerAdapter(ApplicationData.Current.LocalSettings.CreateContainer(Constants.ShellProfilesContainerName, ApplicationDataCreateDisposition.Always)),
+                Themes = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings.CreateContainer(Constants.ThemesContainerName, ApplicationDataCreateDisposition.Always)),
+                SshProfiles = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings.CreateContainer(Constants.SshProfilesContainerName, ApplicationDataCreateDisposition.Always)), 
+                HistoryContainer = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings.CreateContainer(Constants.ExecutedCommandsContainerName, ApplicationDataCreateDisposition.Always))
+            };
+            var builder = new ContainerBuilder();
+            builder.RegisterType<SettingsService>().As<ISettingsService>().SingleInstance();
+            builder.RegisterType<DefaultValueProvider>().As<IDefaultValueProvider>().SingleInstance();
+            builder.RegisterType<TrayProcessCommunicationService>().As<ITrayProcessCommunicationService>().SingleInstance();
+            builder.RegisterType<DialogService>().As<IDialogService>().SingleInstance();
+            builder.RegisterType<KeyboardCommandService>().As<IKeyboardCommandService>().InstancePerDependency();
+            builder.RegisterType<NotificationService>().As<INotificationService>().InstancePerDependency();
+            builder.RegisterType<UpdateService>().As<IUpdateService>().InstancePerDependency();
+            builder.RegisterType<MainViewModel>().InstancePerDependency();
+            builder.RegisterType<SettingsViewModel>().InstancePerDependency();
+            builder.RegisterType<ThemeParserFactory>().As<IThemeParserFactory>().SingleInstance();
+            builder.RegisterType<ITermThemeParser>().As<IThemeParser>().SingleInstance();
+            builder.RegisterType<FluentTerminalThemeParser>().As<IThemeParser>().SingleInstance();
+            builder.RegisterType<ClipboardService>().As<IClipboardService>().SingleInstance();
+            builder.RegisterType<FileSystemService>().As<IFileSystemService>().SingleInstance();
+            builder.RegisterType<SystemFontService>().As<ISystemFontService>().SingleInstance();
+            builder.RegisterType<ShellProfileSelectionDialog>().As<IShellProfileSelectionDialog>().InstancePerDependency();
+            builder.RegisterType<SshProfileSelectionDialog>().As<ISshProfileSelectionDialog>().InstancePerDependency();
+            builder.RegisterType<CreateKeyBindingDialog>().As<ICreateKeyBindingDialog>().InstancePerDependency();
+            builder.RegisterType<InputDialog>().As<IInputDialog>().InstancePerDependency();
+            builder.RegisterType<MessageDialogAdapter>().As<IMessageDialog>().InstancePerDependency();
+            builder.RegisterType<SshInfoDialog>().As<ISshConnectionInfoDialog>().InstancePerDependency();
+            builder.RegisterType<ApplicationViewAdapter>().As<IApplicationView>().InstancePerDependency();
+            builder.RegisterType<DispatcherTimerAdapter>().As<IDispatcherTimer>().InstancePerDependency();
+            builder.RegisterType<StartupTaskService>().As<IStartupTaskService>().SingleInstance();
+            builder.RegisterType<ApplicationLanguageService>().As<IApplicationLanguageService>().SingleInstance();
+            builder.RegisterInstance(applicationDataContainers);
+
+            _container = builder.Build();
+
+            _settingsService = _container.Resolve<ISettingsService>();
+            _settingsService.ApplicationSettingsChanged += OnApplicationSettingsChanged;
+
+            _trayProcessCommunicationService = _container.Resolve<ITrayProcessCommunicationService>();
+
+            _dialogService = _container.Resolve<IDialogService>();
+
+            _applicationSettings = _settingsService.GetApplicationSettings();
+
+            JsonConvert.DefaultSettings = () =>
+            {
+                var settings = new JsonSerializerSettings
+                {
+                    ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                };
+                settings.Converters.Add(new StringEnumConverter(typeof(CamelCaseNamingStrategy)));
+
+                return settings;
+            };
+
+            _commandLineParser = new Parser(settings =>
+            {
+                settings.CaseSensitive = false;
+                settings.CaseInsensitiveEnumValues = true;
+            });
+        }
+
+        private void OnUnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e)
+        {
+            Logger.Instance.Error(e.Exception, "Unhandled Exception");
+        }
+
+        private static IEnumerable<string> SplitArguments(string arguments)
+        {
+            var chars = arguments.ToCharArray();
+            var inQuote = false;
+
+            for (var i = 0; i < chars.Length; i++)
+            {
+                if (chars[i] == '"')
+                {
+                    inQuote = !inQuote;
+                }
+
+                if (!inQuote && chars[i] == ' ')
+                {
+                    chars[i] = '\n';
+                }
+            }
+
+            foreach (var value in new string(chars).Split('\n'))
+            {
+                yield return value.Trim('"');
+            }
+        }
+
+        protected override async void OnActivated(IActivatedEventArgs args)
+        {
+            if (args is ProtocolActivatedEventArgs protocolActivated)
+            {
+                MainViewModel mainViewModel = null;
+                // IApplicationView to use for creating view models
+                IApplicationView applicationView;
+
+                if (_alreadyLaunched)
+                {
+                    applicationView =
+                        (_mainViewModels.FirstOrDefault(o => o.ApplicationView.Id == _activeWindowId) ??
+                         _mainViewModels.Last()).ApplicationView;
+                }
+                else
+                {
+                    // App wasn't launched before double clicking a shortcut, so we have to create a window
+                    // in order to be able to communicate with user.
+                    mainViewModel = _container.Resolve<MainViewModel>();
+
+                    await CreateMainView(typeof(MainPage), mainViewModel, true);
+
+                    applicationView = mainViewModel.ApplicationView;
+                }
+
+                bool isSsh;
+
+                try
+                {
+                    isSsh = SshConnectViewModel.CheckScheme(protocolActivated.Uri);
+                }
+                catch (Exception ex)
+                {
+                    await new MessageDialog($"Invalid link: {ex.Message}", "Invalid Link").ShowAsync();
+
+                    mainViewModel?.ApplicationView.TryClose();
+
+                    return;
+                }
+
+                if (isSsh)
+                {
+                    SshConnectViewModel vm;
+
+                    try
+                    {
+                        vm = SshConnectViewModel.ParseUri(protocolActivated.Uri, _settingsService, applicationView,
+                            _trayProcessCommunicationService, _container.Resolve<IFileSystemService>(),
+                            _container.Resolve<ApplicationDataContainers>().HistoryContainer);
+                    }
+                    catch (Exception ex)
+                    {
+                        await new MessageDialog($"Invalid link: {ex.Message}", "Invalid Link").ShowAsync();
+
+                        mainViewModel?.ApplicationView.TryClose();
+
+                        return;
+                    }
+
+                    if (!vm.CommandInput && _applicationSettings.AutoFallbackToWindowsUsernameInLinks &&
+                        string.IsNullOrEmpty(vm.Username))
+                    {
+                        vm.Username = await _trayProcessCommunicationService.GetUserName();
+                    }
+
+                    var error = await vm.AcceptChangesAsync(true);
+
+                    SshProfile profile = (SshProfile) vm.Model;
+
+                    if (!string.IsNullOrEmpty(error))
+                    {
+                        // Link is valid, but incomplete (i.e. username missing), so we need to show dialog.
+                        profile = await _dialogService.ShowSshConnectionInfoDialogAsync(profile);
+
+                        if (profile == null)
+                        {
+                            // User clicked "Cancel" in the dialog.
+                            mainViewModel?.ApplicationView.TryClose();
+
+                            return;
+                        }
+                    }
+
+                    if (mainViewModel == null)
+                        await CreateTerminal(profile, _applicationSettings.NewTerminalLocation);
+                    else
+                        await mainViewModel.AddTerminalAsync(profile);
+
+                    return;
+                }
+
+                await new MessageDialog($"Invalid link: {protocolActivated.Uri}", "Invalid Link").ShowAsync();
+
+                mainViewModel?.ApplicationView.TryClose();
+
+                return;
+            }
+
+            if (args is CommandLineActivatedEventArgs commandLineActivated)
+            {
+                if (string.IsNullOrWhiteSpace(commandLineActivated.Operation.Arguments))
+                {
+                    return;
+                }
+
+                _commandLineParser.ParseArguments(SplitArguments(commandLineActivated.Operation.Arguments), typeof(NewVerb), typeof(RunVerb), typeof(SettingsVerb)).WithParsed(async verb =>
+                {
+                    if (verb is SettingsVerb settingsVerb)
+                    {
+                        if (!settingsVerb.Import && !settingsVerb.Export)
+                        {
+                            await ShowSettings().ConfigureAwait(true);
+                        }
+                        else if (settingsVerb.Export)
+                        {
+                            var exportFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("config.json", CreationCollisionOption.OpenIfExists);
+
+                            var settings = _settingsService.ExportSettings();
+                            await FileIO.WriteTextAsync(exportFile, settings);
+                            await new MessageDialog($"{I18N.Translate("SettingsExported")} {exportFile.Path}").ShowAsync();
+                        }
+                        else if (settingsVerb.Import)
+                        {
+                            var file = await ApplicationData.Current.LocalFolder.GetFileAsync("config.json");
+                            var content = await FileIO.ReadTextAsync(file);
+                            _settingsService.ImportSettings(content);
+                            await new MessageDialog($"{I18N.Translate("SettingsImported")} {file.Path}").ShowAsync();
+                        }
+                    }
+                    else if (verb is NewVerb newVerb)
+                    {
+                        var profile = default(ShellProfile);
+                        if (!string.IsNullOrWhiteSpace(newVerb.Profile))
+                        {
+                            profile = _settingsService.GetShellProfiles().FirstOrDefault(x => x.Name.Equals(newVerb.Profile, StringComparison.CurrentCultureIgnoreCase));
+                        }
+
+                        if (profile == null)
+                        {
+                            profile = _settingsService.GetDefaultShellProfile();
+                        }
+
+                        if (!string.IsNullOrWhiteSpace(newVerb.Directory))
+                        {
+                            profile.WorkingDirectory = newVerb.Directory;
+                        }
+
+                        var location = newVerb.Target == Target.Default ? _applicationSettings.NewTerminalLocation
+                            : newVerb.Target == Target.Tab ? NewTerminalLocation.Tab
+                            : NewTerminalLocation.Window;
+
+                        await CreateTerminal(profile, location).ConfigureAwait(true);
+                    }
+                    else if (verb is RunVerb runVerb)
+                    {
+                        var profile = new ShellProfile
+                        {
+                            Id = Guid.Empty,
+                            Location = null,
+                            Arguments = runVerb.Command,
+                            WorkingDirectory = runVerb.Directory
+                        };
+
+                        if (!string.IsNullOrWhiteSpace(runVerb.Theme))
+                        {
+                            var theme = _settingsService.GetThemes().FirstOrDefault(x => x.Name.Equals(runVerb.Theme, StringComparison.CurrentCultureIgnoreCase));
+                            if (theme != null)
+                            {
+                                profile.TerminalThemeId = theme.Id;
+                            }
+                        }
+
+                        if (string.IsNullOrWhiteSpace(profile.WorkingDirectory))
+                        {
+                            profile.WorkingDirectory = commandLineActivated.Operation.CurrentDirectoryPath;
+                        }
+
+                        var location = runVerb.Target == Target.Default ? _applicationSettings.NewTerminalLocation
+                            : runVerb.Target == Target.Tab ? NewTerminalLocation.Tab
+                            : NewTerminalLocation.Window;
+
+                        await CreateTerminal(profile, location).ConfigureAwait(true);
+                    }
+                });
+            }
+        }
+
+        protected override async void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            if (_isLaunching)
+            {
+                return;
+            }
+
+            _isLaunching = true;
+            if (!_alreadyLaunched)
+            {
+                await InitializeLogger();
+
+                // TODO: Check the reason for such strange using of tasks!
+                Task.Run(async () => await JumpListHelper.Update(_settingsService.GetShellProfiles()));
+
+                var viewModel = _container.Resolve<MainViewModel>();
+                if (args.Arguments.StartsWith(JumpListHelper.ShellProfileFlag))
+                {
+                    await viewModel.AddLocalTabOrWindowAsync(Guid.Parse(args.Arguments.Replace(JumpListHelper.ShellProfileFlag, string.Empty)));
+                }
+                else
+                {
+                    await viewModel.AddLocalTabAsync();
+                }
+                await CreateMainView(typeof(MainPage), viewModel, true).ConfigureAwait(true);
+                Window.Current.Activate();
+            }
+            else if (_mainViewModels.Count == 0)
+            {
+                await CreateSecondaryView<MainViewModel>(typeof(MainPage), true).ConfigureAwait(true);
+            }
+            else if (args.Arguments.StartsWith(JumpListHelper.ShellProfileFlag))
+            {
+                var location = _applicationSettings.NewTerminalLocation;
+                var profile = _settingsService.GetShellProfile(Guid.Parse(args.Arguments.Replace(JumpListHelper.ShellProfileFlag, string.Empty)));
+                await CreateTerminal(profile, location).ConfigureAwait(true);
+            }
+            _isLaunching = false;
+        }
+
+        private static async Task InitializeLogger()
+        {
+            var logDirectory = await ApplicationData.Current.LocalCacheFolder.CreateFolderAsync("Logs", CreationCollisionOption.OpenIfExists);
+            var logFile = Path.Combine(logDirectory.Path, "fluentterminal.app.log");
+            var configFile = await logDirectory.CreateFileAsync("config.json", CreationCollisionOption.OpenIfExists);
+            var configContent = await FileIO.ReadTextAsync(configFile);
+
+
+            if (string.IsNullOrWhiteSpace(configContent))
+            {
+                configContent = JsonConvert.SerializeObject(new Logger.Configuration());
+                await FileIO.WriteTextAsync(configFile, configContent);
+            }
+
+            var config = JsonConvert.DeserializeObject<Logger.Configuration>(configContent) ?? new Logger.Configuration();
+
+            Logger.Instance.Initialize(logFile, config);
+        }
+
+        protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
+        {
+            base.OnBackgroundActivated(args);
+
+            if (args.TaskInstance.TriggerDetails is AppServiceTriggerDetails details)
+            {
+                if (details.CallerPackageFamilyName == Package.Current.Id.FamilyName)
+                {
+                    _appServiceDeferral = args.TaskInstance.GetDeferral();
+                    args.TaskInstance.Canceled += OnTaskCanceled;
+
+                    _appServiceConnection = new AppServiceConnectionAdapter(details.AppServiceConnection);
+
+                    _trayReady.SetResult(0);
+                }
+            }
+        }
+
+        private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
+        {
+            _appServiceDeferral?.Complete();
+            _appServiceDeferral = null;
+            _appServiceConnection = null;
+
+            // ReSharper disable once ArrangeStaticMemberQualifier
+            Application.Current.Exit();
+        }
+
+        private async Task CreateMainView(Type pageType, INotifyPropertyChanged viewModel, bool extendViewIntoTitleBar)
+        {
+            await StartSystemTray().ConfigureAwait(true);
+
+            if (!(Window.Current.Content is Frame rootFrame))
+            {
+                rootFrame = new Frame();
+                Window.Current.Content = rootFrame;
+            }
+
+            if (rootFrame.Content == null)
+            {
+                CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = extendViewIntoTitleBar;
+
+                if (viewModel is MainViewModel mainViewModel)
+                {
+                    mainViewModel.Closed += OnMainViewModelClosed;
+                    mainViewModel.NewWindowRequested += OnNewWindowRequested;
+                    mainViewModel.ShowSettingsRequested += OnShowSettingsRequested;
+                    mainViewModel.ShowAboutRequested += OnShowAboutRequested;
+                    mainViewModel.ActivatedMv += OnMainViewActivated;
+                    _mainViewModels.Add(mainViewModel);
+                }
+
+                rootFrame.Navigate(pageType, viewModel);
+            }
+            _alreadyLaunched = true;
+            Window.Current.Activate();
+        }
+
+        private async Task<MainViewModel> CreateNewTerminalWindow()
+        {
+            var viewModel = await CreateSecondaryView<MainViewModel>(typeof(MainPage), true).ConfigureAwait(true);
+            viewModel.Closed += OnMainViewModelClosed;
+            viewModel.NewWindowRequested += OnNewWindowRequested;
+            viewModel.ShowSettingsRequested += OnShowSettingsRequested;
+            viewModel.ShowAboutRequested += OnShowAboutRequested;
+            viewModel.ActivatedMv += OnMainViewActivated;
+            _mainViewModels.Add(viewModel);
+
+            return viewModel;
+        }
+
+        private async Task<TViewModel> CreateSecondaryView<TViewModel>(Type pageType, bool extendViewIntoTitleBar)
+        {
+            int windowId = 0;
+            TViewModel viewModel = default;
+            await CoreApplication.CreateNewView().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
+            {
+                viewModel = _container.Resolve<TViewModel>();
+
+                CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = extendViewIntoTitleBar;
+                var frame = new Frame();
+                frame.Navigate(pageType, viewModel);
+                Window.Current.Content = frame;
+                Window.Current.Activate();
+
+                windowId = ApplicationView.GetForCurrentView().Id;
+            });
+
+            if (viewModel is SettingsViewModel settingsViewModel)
+            {
+                _settingsViewModel = settingsViewModel;
+                _settingsViewModel.Closed += OnSettingsClosed;
+                _settingsWindowId = windowId;
+            }
+
+            await ApplicationViewSwitcher.TryShowAsStandaloneAsync(windowId);
+
+            return viewModel;
+        }
+
+        private void OnApplicationSettingsChanged(object sender, ApplicationSettings e)
+        {
+            _applicationSettings = e;
+        }
+
+        private void OnMainViewModelClosed(object sender, EventArgs e)
+        {
+            if (sender is MainViewModel viewModel)
+            {
+                Logger.Instance.Debug("MainViewModel with ApplicationView Id: {@id} closed.", viewModel.ApplicationView.Id);
+
+                viewModel.Closed -= OnMainViewModelClosed;
+                viewModel.NewWindowRequested -= OnNewWindowRequested;
+                viewModel.ShowSettingsRequested -= OnShowSettingsRequested;
+                viewModel.ShowAboutRequested -= OnShowAboutRequested;
+                viewModel.ActivatedMv -= OnMainViewActivated;
+                if (_activeWindowId == viewModel.ApplicationView.Id)
+                {
+                    _activeWindowId = 0;
+                }
+
+                _mainViewModels.Remove(viewModel);
+            }
+        }
+
+        private void OnMainViewActivated(object sender, EventArgs e)
+        {
+            if (sender is MainViewModel viewModel)
+            {
+                Logger.Instance.Debug("MainViewModel with ApplicationView Id: {@id} activated.", viewModel.ApplicationView.Id);
+                _activeWindowId = viewModel.ApplicationView.Id;
+            }
+        }
+
+        private async void OnNewWindowRequested(object sender, NewWindowRequestedEventArgs e)
+        {
+            ShellProfile profile = null;
+            switch (e.Action)
+            {
+                case NewWindowAction.StartDefaultLocalTerminal:
+                    break;
+                case NewWindowAction.ShowProfileSelection:
+                    profile = await _dialogService.ShowProfileSelectionDialogAsync();
+                    if (profile == null)
+                    {
+                        // Nothing to do if user cancels.
+                        return;
+                    }
+                    break;
+                case NewWindowAction.ShowSshProfileSelection:
+                    profile = await _dialogService.ShowSshProfileSelectionDialogAsync();
+                    if (profile == null)
+                    {
+                        // Nothing to do if user cancels.
+                        return;
+                    }
+                    break;
+                case NewWindowAction.ShowSshInfoDialog:
+                    profile = await _dialogService.ShowSshConnectionInfoDialogAsync();
+                    if (profile == null)
+                    {
+                        // Nothing to do if user cancels.
+                        return;
+                    }
+                    break;
+                case NewWindowAction.StartLocalTerminal:
+                    profile = _settingsService.GetShellProfile(e.ProfileId);
+                    break;
+                case NewWindowAction.StartSshTerminal:
+                    profile = _settingsService.GetSshProfile(e.ProfileId);
+                    break;
+                default:
+                    throw new NotImplementedException("this ProfileSelection not implemented yet");
+            }
+
+            var viewModel = await CreateNewTerminalWindow().ConfigureAwait(true);
+
+            if (profile == null)
+            {
+                await viewModel.AddLocalTabAsync();
+            }
+            else
+            {
+                await viewModel.AddTerminalAsync(profile);
+            }
+        }
+
+        private void OnSettingsClosed(object sender, EventArgs e)
+        {
+            Task.Run(async () => await JumpListHelper.Update(_settingsService.GetShellProfiles()));
+            _settingsViewModel.Closed -= OnSettingsClosed;
+            _settingsViewModel = null;
+            _settingsWindowId = null;
+        }
+
+        private void OnShowAboutRequested(object sender, EventArgs e)
+        {
+            ShowAbout().ConfigureAwait(true);
+        }
+
+        private async void OnShowSettingsRequested(object sender, EventArgs e)
+        {
+            await ShowSettings().ConfigureAwait(true);
+        }
+
+        private async Task ShowAbout()
+        {
+            await ShowSettings().ConfigureAwait(true);
+            _settingsViewModel.NavigateToAboutPage();
+        }
+
+        private async Task CreateTerminal(ShellProfile profile, NewTerminalLocation location)
+        {
+            if (!_alreadyLaunched)
+            {
+                var viewModel = _container.Resolve<MainViewModel>();
+                await viewModel.AddTerminalAsync(profile);
+                await CreateMainView(typeof(MainPage), viewModel, true).ConfigureAwait(true);
+            }
+            else if (location == NewTerminalLocation.Tab && _mainViewModels.Count > 0)
+            {
+
+                MainViewModel item = _mainViewModels.FirstOrDefault(o => o.ApplicationView.Id == _activeWindowId);
+                if (item != null)
+                {
+                    await item.AddTerminalAsync(profile);
+                }
+                else
+                {
+                    await _mainViewModels.Last().AddTerminalAsync(profile);
+                }
+            }
+            else
+            {
+                var viewModel = await CreateNewTerminalWindow().ConfigureAwait(true);
+                await viewModel.AddTerminalAsync(profile);
+            }
+        }
+
+        private async Task ShowSettings()
+        {
+            if (!_alreadyLaunched)
+            {
+                var viewModel = _container.Resolve<SettingsViewModel>();
+                await CreateMainView(typeof(SettingsPage), viewModel, true).ConfigureAwait(true);
+            }
+            else if (_settingsViewModel == null)
+            {
+                await CreateSecondaryView<SettingsViewModel>(typeof(SettingsPage), true).ConfigureAwait(true);
+            }
+            else
+            {
+                await ApplicationViewSwitcher.TryShowAsStandaloneAsync(_settingsWindowId.Value);
+            }
+        }
+
+        private async Task StartSystemTray()
+        {
+            var launch = FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync("AppLaunchedParameterGroup").AsTask();
+            await Task.WhenAll(launch, _trayReady.Task).ConfigureAwait(true);
+            _trayProcessCommunicationService.Initialize(_appServiceConnection);
+        }
+    }
+}